மோச்சா மற்றும் சாய் மூலம் எளிய சோதனைகளை உருவாக்குதல்

Mocha மற்றும் Chai ஐப் பயன்படுத்தி அடிப்படை சோதனையை உருவாக்குதல்

Mocha மற்றும் Chai ஐப் பயன்படுத்தி அடிப்படை சோதனையை உருவாக்க, நீங்கள் பின்வரும் படிகளைப் பின்பற்றலாம்:

1. Mocha மற்றும் Chai ஐ நிறுவவும்: உங்கள் Node.js திட்டத்தில் Mocha மற்றும் Chai ஐ நிறுவ npm (நோட் தொகுப்பு மேலாளர்) பயன்படுத்தவும். உங்கள் திட்ட கோப்பகத்தில் பின்வரும் கட்டளையை இயக்கவும்:

npm install mocha chai --save-dev

2. சோதனைக் கோப்பை உருவாக்கவும்: ஒரு புதிய கோப்பை உருவாக்கவும், உதாரணமாக test.js, Mocha மற்றும் Chai ஐப் பயன்படுத்த பின்வரும் அறிவிப்புகளை இறக்குமதி செய்யவும்:

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

describe('Example Test Suite', () => {
  it('should pass the test', () => {
    expect(2 + 2).to.equal(4);
  });
});

3. சோதனையை இயக்கவும்: டெர்மினலைத் திறந்து mocha சோதனைகளை இயக்க கட்டளையை இயக்கவும். எல்லாம் சீராக நடந்தால், டெர்மினலில் காட்டப்படும் முடிவுகளைக் காண்பீர்கள்.

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

சேர்ப்பது describe மற்றும் it தடுப்பதன் மூலம், நீங்கள் மிகவும் சிக்கலான சோதனைகளை உருவாக்கலாம் மற்றும் உங்கள் மூலக் குறியீட்டின் வெவ்வேறு பகுதிகளைச் சரிபார்க்கலாம்.

Chai வழங்கிய மற்ற உறுதியான முறைகளையும் நீங்கள் பயன்படுத்தலாம், அதாவது assert அல்லது should, சோதனைக்கு. குறிப்பிட்ட பயன்பாடு உங்கள் தேர்வு மற்றும் உங்கள் சோதனைக் குறியீட்டை எவ்வாறு ஒழுங்கமைக்க விரும்புகிறீர்கள் என்பதைப் பொறுத்தது.

செயல்பாட்டு முடிவுகளைச் சரிபார்க்க வலியுறுத்தல்கள் மற்றும் வினவல்களைப் பயன்படுத்துதல்

சோதனைக்கு Mocha மற்றும் Chai ஐப் பயன்படுத்தும் போது, ​​செயல்பாடுகளின் முடிவுகளைச் சரிபார்க்க, நீங்கள் வலியுறுத்தல்களையும் வினவல்களையும் பயன்படுத்தலாம். செயல்பாடு முடிவுகளைச் சரிபார்க்க வலியுறுத்தல் மற்றும் வினவல்களைப் பயன்படுத்துவதற்கான சில எடுத்துக்காட்டுகள் இங்கே:

1. ஒரு குறிப்பிட்ட மதிப்பை வழங்கும் செயல்பாட்டின் முடிவைச் சரிபார்க்க expectவலியுறுத்தல் மற்றும் வினவலைப் பயன்படுத்தவும் :to.equal

const result = myFunction();
expect(result).to.equal(expectedValue);

2. பூலியன் மதிப்பை வழங்கும் செயல்பாட்டின் முடிவைச் சரிபார்க்க `எதிர்பார்ப்பு` உறுதிமொழி மற்றும் வினவலைப் பயன்படுத்தவும் to.be.true: to.be.false

const result = myFunction();
expect(result).to.be.true; // or expect(result).to.be.false;

to.be.null3. பூஜ்ய அல்லது வரையறுக்கப்படாத மதிப்பை வழங்கும் செயல்பாட்டின் முடிவைச் சரிபார்க்க `எதிர்பார்ப்பு` வலியுறுத்தல் மற்றும் or to.be.undefined வினவல் ஆகியவற்றைப் பயன்படுத்தவும் :

const result = myFunction();
expect(result).to.be.null; // or expect(result).to.be.undefined;

4. ஒரு வரிசை அல்லது சரத்தில் மதிப்பு சேர்க்கப்பட்டுள்ளதா என்பதைச் சரிபார்க்க expectவலியுறுத்தல் மற்றும் வினவலைப் பயன்படுத்தவும் :to.include

const result = myFunction();
expect(result).to.include(expectedValue);

5. ஒரு வரிசை அல்லது சரத்தின் நீளத்தைச் சரிபார்க்க expectவலியுறுத்தல் மற்றும் வினவலைப் பயன்படுத்தவும் :to.have.lengthOf

const result = myFunction();
expect(result).to.have.lengthOf(expectedLength);

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

வெற்றிகரமான மற்றும் தோல்வியுற்ற சோதனை நிகழ்வுகளை உருவாக்குதல்

மோச்சா மற்றும் சாய் மூலம் சோதனை வழக்குகளை எழுதும் போது, ​​வெற்றிகரமான மற்றும் தோல்வி சூழ்நிலைகளை உள்ளடக்குவது முக்கியம். வெற்றிகரமான மற்றும் தோல்விக்கான சோதனை நிகழ்வுகளை உருவாக்குவதற்கான எடுத்துக்காட்டுகள் இங்கே:

1. வெற்றிகரமான சோதனை வழக்கு:

describe('myFunction', () => {
  it('should return the expected result', () => {
    // Arrange
    const input = // provide the input for the function
    const expected = // define the expected result

    // Act
    const result = myFunction(input);

    // Assert
    expect(result).to.equal(expected);
  });
});

2. தோல்வி சோதனை வழக்கு:

describe('myFunction', () => {
  it('should throw an error when invalid input is provided', () => {
    // Arrange
    const invalidInput = // provide invalid input for the function

    // Act and Assert
    expect(() => myFunction(invalidInput)).to.throw(Error);
  });
});

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

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

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