யூனிட் சோதனை (Unit Testing)

யூனிட் சோதனை என்பது வலை மேம்பாட்டில் ஒரு அடிப்படை நடைமுறையாகும். தனிப்பட்ட கூறுகள் (components) அல்லது செயல்பாடுகள் (functions) எதிர்பார்த்தபடி இயங்குவதை உறுதிப்படுத்த அவற்றைச் சோதிப்பதை இது உள்ளடக்குகிறது. இந்த நடைமுறையானது சோதனை உந்துதல் மேம்பாடு (test-driven development - TDD) எனப்படும் மென்பொருள் மேம்பாட்டு அணுகுமுறையில் (software development approach) சேர்க்கப்பட்டுள்ளது, இது மென்பொருள் தேவைகளிலிருந்து முதலில் யூனிட் சோதனைகளை எழுதுவதையும் பின்னர் குறியீட்டை எழுதுவதையும் கொண்டுள்ளது. யூனிட் சோதனைகளை நாம் ஏன் எழுத வேண்டும் என்பதை இப்போது பார்ப்போம்.

யூனிட் சோதனைகளை ஏன் எழுத வேண்டும்?

பின்வரும் காரணங்களால் யூனிட் சோதனை பரவலாகப் பயன்படுத்தப்படுகிறது:

• TDD இல், மென்பொருள் தேவைகள் (software requirements) குறிப்பிட்ட சோதனை வழக்குகளாக (test cases) மாற்றப்படுகின்றன. புதிய சோதனைகளில் தேர்ச்சி பெற மென்பொருள் பின்னர் மேம்படுத்தப்படுகிறது.
• குறியீட்டுத் தளத்தின் (codebase) தனிப்பட்ட பகுதிகள் சரியாகச் செயல்படுகின்றனவா என்பதைச் சரிபார்க்கும் பொருட்டு.
• பிற யூனிட்கள் அல்லது மென்பொருளின் செயல்பாட்டைப் பாதிக்காமல் குறியீட்டு மாற்றத்தை (code modification) இது அனுமதிக்கிறது.
• ரீஃபாக்டரிங் (refactoring) அல்லது மாற்றங்களைச் செய்யும்போது இது ஒரு பாதுகாப்பு வலையை (safety net) வழங்குகிறது.
• செயல்பாடுகள் மற்றும் கூறுகளின் (components) எதிர்பார்க்கப்படும் நடத்தையை ஆவணப்படுத்த (document) இது உதவுகிறது.
• ஒவ்வொரு மாட்யூலுக்கும் (module) அதன் சொந்தப் பொறுப்பு இருப்பதால் மாட்யூல்களின் மறுநிகழ்வு (repetition) இல்லாமல் இருக்க இது உதவுகிறது.

யூனிட் சோதனைகளின் நன்மைகள் (Benefits of Unit Tests)

யூனிட் சோதனைகளின் முக்கிய நன்மை அவற்றின் லேசர்-கூர்மையான (laser-sharp) கவனம் ஆகும். அவர்கள் ஒற்றைச் செயல்பாட்டைச் சோதிப்பதால், அவை துல்லியமான பின்னூட்டத்தை (feedback) அளிக்கின்றன. ஒரு யூனிட் சோதனை தோல்வியுற்றால், பெரும்பாலான சந்தர்ப்பங்களில், சோதிக்கப்படும் குறிப்பிட்ட செயல்பாடே பிரச்சனை என்பதை நீங்கள் உறுதியாக நம்பலாம்.

• பிழைகளை (bugs) விரைவாகவும் எளிதாகவும் கண்டறிந்து சரிசெய்ய யூனிட் சோதனைகள் உதவுகின்றன.
• யூனிட் சோதனைகள் உயர்ந்த குறியீடு தரத்திற்கு (code quality) பங்களிக்கின்றன.
• சிறந்த பயன்பாட்டுக் கட்டமைப்புக்கு (application architecture) யூனிட் சோதனைகள் பங்களிக்கின்றன.
• யூனிட் சோதனைகள் ஆவணங்களாகச் (documentation) செயல்படுகின்றன.

யூனிட் சோதனைகளை உருவாக்குவதற்கான சிறந்த நடைமுறைகள் (Best Practices for creating Unit Tests)

உங்களிடம் நல்ல யூனிட் சோதனைகள் இருப்பதை உறுதிசெய்ய இந்தச் சிறந்த நடைமுறைகளைப் பின்பற்றவும்:

• மேம்பாட்டின் (development) போது சோதனைகளை எழுதுங்கள், அதற்குப் பிறகு அல்ல
• சோதனை வழக்குகள் (Test cases) செயல்படுத்தும் தர்க்கத்தை (implementation logic) நகலெடுக்கக் (duplicate) கூடாது.
• சோதனை வழக்குகள் அவற்றின் குறியீடு மாறாத வரை ஒரே நடத்தையை (behavior) வெளிப்படுத்த வேண்டும்.
• சோதனை வழக்குகளுக்கு நிலையான பெயரிடும் மாநாட்டைப் (naming convention) பயன்படுத்தவும்
• யூனிட் சோதனைகளில் நிபந்தனைக்குட்பட்ட தர்க்க வெளிப்பாடுகளைப் (conditional logic expressions) பயன்படுத்துவதைத் தவிர்க்கவும்
• முடிந்தால் யூனிட் சோதனைகளைத் தானியங்குபடுத்தவும் (automate)

சோதனைக் கட்டமைப்புகள் (Testing Frameworks)

சோதனைக் கட்டமைப்புகள் சோதனைகளை எழுதுதல் மற்றும் இயக்கும் செயல்முறையை ஒழுங்குபடுத்துகின்றன. ஜாவாஸ்கிரிப்டில் Jest மற்றும் Mocha ஆகிய இரண்டும் பிரபலமான கட்டமைப்புகளாகும்.

Jest

Jest என்பது பூஜ்ஜிய உள்ளமைவு (zero-config), ஆல்-இன்-ஒன் (all-in-one) பிரபலமான சோதனைக் கட்டமைப்பாகும். இது யூனிட் மற்றும் ஒருங்கிணைப்பு சோதனை (integration testing) ஆகிய இரண்டிற்கும் ஏற்றது. Jest உடன் எவ்வாறு தொடங்குவது என்று பார்ப்போம்.

npm அல்லது yarn ஐப் பயன்படுத்தி Jest ஐ நிறுவவும்:

npm install --save-dev jest

நீங்கள் சோதிக்க விரும்பும் செயல்பாட்டிற்கான ஒரு சோதனைக் கோப்பை (எ.கா., myFunction.test.js) உருவாக்கவும்.

Jest இன் சோதனைச் செயல்பாட்டைப் (test function) பயன்படுத்தி ஒரு சோதனை வழக்கை எழுதவும்:

const myFunction = require('./myFunction');

test('should return the sum of two numbers', () => {
  expect(myFunction(2, 3)).toBe(5);
});

jest கட்டளையைப் பயன்படுத்திச் சோதனைகளை இயக்கவும்:

npx jest

Mocha

Mocha ஒரு நெகிழ்வான சோதனைக் கட்டமைப்பாகும். இது சோதனைகளை இயக்குவதற்கான கட்டமைப்பை வழங்குகிறது, ஆனால் வலியுறுத்தல்கள் (assertions) மற்றும் கேலி (mocking) செய்யக் கூடுதல் நூலகங்கள் தேவை.

Mocha உடன் தொடங்குதல் (Getting Started with Mocha)

Mocha மற்றும் Chai போன்ற வலியுறுத்தல் நூலகத்தை நிறுவவும்:

npm install --save-dev mocha chai

ஒரு test கோப்பகத்தை (directory) உருவாக்கி உங்கள் சோதனைக் கோப்புகளைச் சேர்க்கவும்.

Mocha இன் describe மற்றும் it செயல்பாடுகள் மற்றும் Chai இன் வலியுறுத்தல் செயல்பாடுகளைப் பயன்படுத்தி உங்கள் சோதனை வழக்குகளை எழுதுங்கள்.

const chai = require('chai');
const expect = chai.expect;
const myFunction = require('./myFunction');

describe('myFunction', () => {
  it('should return the sum of two numbers', () => {
    expect(myFunction(2, 3)).to.equal(5);
  });
});

வலை மேம்பாட்டில் சோதனையின் அடிப்படைகளை நாங்கள் ஆராய்ந்தோம் மற்றும் எந்த வலை டெவலப்பருக்கும் இன்றியமையாத யூனிட் சோதனை மற்றும் பிற சோதனைக் கட்டமைப்புகள் மற்றும் கருவிகளின் முக்கியத்துவத்தைப் பற்றி விவாதித்தோம். நிலையான பயிற்சி மற்றும் சரியான கருவிகளின் தொகுப்பிற்கான அணுகல் மூலம், ஒருவர் நம்பகமான குறியீட்டை எழுதலாம் மற்றும் பயன்பாடுகள் உகந்ததாகச் செயல்படுவதை உறுதிசெய்யலாம்.