Testa funktioner och metoder med Chai

 Testa funktioner för att kasta rätt undantag

För att testa för undantag kan vi använda throwpåståendet från Chai. Detta påstående tillåts oss att specificera vilken typ av undantag som ska kastas och eventuella ytterligare detaljer som vi vill validera. Genom att inkludera detta påstående i våra testfall kan vi hantera att våra funktioner fungerar som förväntat och hanterar feltillstånd på lämpligt sätt.

Låt oss betrakta ett exempel där vi har en funktion som delar två tal. Vi vill veta att funktionen ger ett undantag den divideras med noll. Vi kan skriva ett testfall genom att använda Chais throwpåstående för att kontrollera om funktionen korrekt kastar DivideByZeroErrornär den delar med noll.

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 exemplet ovan använder vi to.throwpåståendet för att verifiera att dividefunktionen kastar a DivideByZeroErrornär den divideras med noll. Påståendet är insvept i en funktion så att det kan fånga undantaget och utföra nödvändiga kontroller.

Genom att inkludera tester för korrekt undantagskastning kan vi svara att våra funktioner hanterar feltillstånd på lämpligt sätt och ge meningsfulla oväntade situationer inträffar när feedback. Detta hjälper till att förbättra den övergripande kvaliteten och tillförlitligheten hos vår kod.

Sammanfattningsvis är att testa funktioner som ger undantag och viktiga aspekter av mjukvarutestning. Med Chais throwpåstående kan vi enkelt verifiera att våra funktioner ger de förväntade undantagen när det behövs. Genom att införliva dessa tester i vår teststrategi kan vi förbättra robustheten i våra applikationer och ge en bättre användarupplevelse.

I den tredje artikeln i "Node.js, Mocha, and Chai"-serien kommer vi att utforska hur man testar funktioner och metoder med Chai. Chai är ett kraftfullt påstående bibliotek för att testa värden och resultat i JavaScript-kod.

Testa objektmetoder och deras beteenden

För att verifiera metoder för ett objekt kan vi använda påståenden från testa ramverk som Mocha och Chai. Dessa påståenden tillåter oss att göra stående om objektens egenskaper och beteende.

Låt oss betrakta ett exempel där vi har ett objekt som kallas calculatormed metoder för addition, subtraktion, multiplikation och division. Vi vill garantera att dessa metoder ger rätt resultat. Vi kan skriva testfall med hjälp av Chais påståenden för att verifiera beteendet hos dessa 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 exemplet ovan använder vi Chais expectpåstående för att verifiera att metoder för calculatorobjektet ger de förväntade resultaten. Varje testfall görs på en specifik metod och kontrollerar om den återlämnande rätt utdata för en given ingång.

Genom att köra dessa testfall kan vi använda metoder för att calculatorbättre kunna förvänta oss och ge korrekta resultat.

Förutom att kontrollera returvärdena för metoder kan vi också använda påståenden för att verifiera andra egenskaper och beteende hos objekt. Chai tillhandahåller ett brett utbud av påståenden som gör att vi kan göra olika typer av påståenden om objekt, som att kontrollera egenskapsvärden, verifiera metodanrop och mer.

Genom att noggrant testa ett objekts metoder kan vi kodifiera deras korrekthet och tillförlitlighet, vilket bidrar till den övergripande kvaliteten på vår bas.