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

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

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

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

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  சோதனைகளை இயக்க கட்டளையை இயக்கவும். எல்லாம் சீராக நடந்தால், டெர்மினலில் காட்டப்படும் முடிவுகளைக் காண்பீர்கள்.

இந்த அடிப்படை சோதனை ஒரு எளிய கணக்கீட்டைப் Mocha பயன்படுத்துகிறது. Chai மேலே உள்ள எடுத்துக்காட்டில், செயல்பாட்டின் முடிவு 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.null 3. பூஜ்ய அல்லது வரையறுக்கப்படாத மதிப்பை வழங்கும் செயல்பாட்டின் முடிவைச் சரிபார்க்க `எதிர்பார்ப்பு` வலியுறுத்தல் மற்றும் 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 உங்கள் திட்டத்தின் சோதனைத் தேவைகளின் அடிப்படையில் பொருத்தமான கூற்றுகள் மற்றும் வினவல்களைத் தனிப்பயனாக்கலாம் மற்றும் பயன்படுத்தலாம்.

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

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);  
  });  
});

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

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

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