Afprøvning af funktioner og metoder med Chai

 Test af funktioner til at kaste de korrekte undtagelser

For at teste for undtagelser kan vi bruge throw påstanden fra Chai. Denne påstand giver os mulighed for at specificere den type undtagelse, der skal kastes, og eventuelle yderligere detaljer, vi ønsker at validere. Ved at inkludere denne påstand i vores testcases kan vi sikre, at vores funktioner opfører sig som forventet og håndterer fejltilstande korrekt.

Lad os overveje et eksempel, hvor vi har en funktion, der deler to tal. Vi vil sikre, at funktionen kaster en undtagelse, når den divideres med nul. Vi kan skrive en testcase ved at bruge Chai 's throw påstand til at kontrollere, om funktionen korrekt kaster a, DivideByZeroError når den divideres med nul.

const { expect } = require('chai');  
  
function divide(a, b) {  
  if(b === 0) {  
    throw new Error('DivideByZeroError');  
  }  
  return a / b;  
}  
  
describe('divide',() => {  
  it('should throw DivideByZeroError when dividing by zero',() => {  
    expect(() => divide(10, 0)).to.throw('DivideByZeroError');  
  });  
  
  it('should return the correct result when dividing two numbers',() => {  
    expect(divide(10, 5)).to.equal(2);  
  });  
});  

I ovenstående eksempel bruger vi to.throw påstanden til at verificere, at divide funktionen kaster a DivideByZeroError, når den divideres med nul. Påstanden er pakket ind i en funktion, så den kan fange undtagelsen og udføre de nødvendige kontroller.

Ved at inkludere tests for korrekt afgivelse af undtagelser kan vi sikre, at vores funktioner håndterer fejltilstande korrekt og giver meningsfuld feedback, når uventede situationer opstår. Dette hjælper med at forbedre den overordnede kvalitet og pålidelighed af vores kode.

Afslutningsvis er testfunktioner, der giver undtagelser, et vigtigt aspekt af softwaretest. Med Chai 's throw påstand kan vi nemt verificere, at vores funktioner giver de forventede undtagelser, når det er nødvendigt. Ved at inkorporere disse tests i vores teststrategi kan vi forbedre robustheden af ​​vores applikationer og give en bedre brugeroplevelse.

I den tredje artikel i "Node.js, Mocha, and Chai "-serien vil vi undersøge, hvordan man tester funktioner og metoder ved hjælp af Chai. Chai er et kraftfuldt påstandsbibliotek til test af værdier og resultater i JavaScript kode.

 

Afprøvning af objektmetoder og deres adfærd

For at verificere metoderne for et objekt kan vi bruge påstande fra testrammer som Mocha og Chai. Disse påstande giver os mulighed for at fremsætte påstande om genstandes egenskaber og adfærd.

Lad os overveje et eksempel, hvor vi har et objekt kaldet calculator med metoder til addition, subtraktion, multiplikation og division. Vi ønsker at sikre, at disse metoder giver de korrekte resultater. Vi kan skrive testcases ved hjælp af Chai 's påstande for at verificere adfærden af ​​disse metoder.

const { expect } = require('chai');  
  
const calculator = {  
  add:(a, b) => a + b,  
  subtract:(a, b) => a- b,  
  multiply:(a, b) => a * b,  
  divide:(a, b) => a / b,  
};  
  
describe('calculator',() => {  
  it('should return the correct sum when adding two numbers',() => {  
    expect(calculator.add(5, 3)).to.equal(8);  
  });  
  
  it('should return the correct difference when subtracting two numbers',() => {  
    expect(calculator.subtract(5, 3)).to.equal(2);  
  });  
  
  it('should return the correct product when multiplying two numbers',() => {  
    expect(calculator.multiply(5, 3)).to.equal(15);  
  });  
  
  it('should return the correct quotient when dividing two numbers',() => {  
    expect(calculator.divide(6, 3)).to.equal(2);  
  });  
});  

I eksemplet ovenfor bruger vi Chai 's expect assertion til at verificere, at objektets metoder calculator returnerer de forventede resultater. Hver testcase fokuserer på en bestemt metode og kontrollerer, om den returnerer det korrekte output for et givet input.

Ved at køre disse testcases kan vi sikre, at objektets metoder calculator opfører sig som forventet og giver nøjagtige resultater.

Ud over at kontrollere metodernes returværdier, kan vi også bruge påstande til at verificere andre egenskaber og opførsel af objekter. Chai giver en bred vifte af påstande, der giver os mulighed for at fremsætte forskellige slags påstande om objekter, såsom kontrol af egenskabsværdier, verificering af metodeankaldelser og mere.

Ved at teste et objekts metoder grundigt, kan vi sikre deres rigtighed og pålidelighed, hvilket bidrager til den overordnede kvalitet af vores kodebase.