Testing av funksjoner og metoder med Chai

 Teste funksjoner for å kaste de riktige unntakene

For å teste for unntak kan vi bruke throwpåstanden gitt av Chai. Denne påstanden lar oss spesifisere typen unntak som skal kastes og eventuelle tilleggsdetaljer vi ønsker å validere. Ved å inkludere denne påstanden i testsakene våre kan vi sikre at funksjonene våre oppfører seg som forventet og håndterer feiltilstander på riktig måte.

La oss se på et eksempel hvor vi har en funksjon som deler to tall. Vi ønsker å sikre at funksjonen kaster et unntak ved deling på null. Vi kan skrive et testtilfelle ved å bruke Chais throwpåstand for å sjekke om funksjonen kaster a riktig DivideByZeroErrornår den deler på null.

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 eksemplet ovenfor bruker vi to.throwpåstanden for å bekrefte at dividefunksjonen kaster a DivideByZeroErrornår den deler på null. Påstanden er pakket inn i en funksjon slik at den kan fange opp unntaket og utføre de nødvendige kontrollene.

Ved å inkludere tester for korrekt unntakskasting, kan vi sikre at funksjonene våre håndterer feiltilstander på riktig måte og gir meningsfull tilbakemelding når uventede situasjoner oppstår. Dette bidrar til å forbedre den generelle kvaliteten og påliteligheten til koden vår.

Avslutningsvis er testing av funksjoner som gir unntak et viktig aspekt ved programvaretesting. Med Chais throwpåstand kan vi enkelt verifisere at funksjonene våre gir de forventede unntakene når det er nødvendig. Ved å inkludere disse testene i teststrategien vår, kan vi forbedre robustheten til applikasjonene våre og gi en bedre brukeropplevelse.

I den tredje artikkelen i "Node.js, Mocha, and Chai"-serien vil vi utforske hvordan du kan teste funksjoner og metoder ved hjelp av Chai. Chai er et kraftig påstandsbibliotek for testing av verdier og resultater i JavaScript-kode.

Testing av objektmetoder og deres atferd

For å verifisere metodene til et objekt, kan vi bruke påstander gitt ved å teste rammeverk som Mocha og Chai. Disse påstandene lar oss komme med påstander om egenskapene og oppførselen til objekter.

La oss se på et eksempel hvor vi har et objekt kalt calculatormed metoder for addisjon, subtraksjon, multiplikasjon og divisjon. Vi ønsker å sikre at disse metodene gir de riktige resultatene. Vi kan skrive testsaker ved å bruke Chais påstander for å verifisere oppførselen til disse metodene.

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 bruker vi Chais expectpåstand for å verifisere at metodene til calculatorobjektet gir de forventede resultatene. Hver testcase fokuserer på en spesifikk metode og sjekker om den returnerer riktig utgang for en gitt inngang.

Ved å kjøre disse testsakene kan vi sikre at metodene til objektet calculatoroppfører seg som forventet og gir nøyaktige resultater.

I tillegg til å sjekke returverdiene til metoder, kan vi også bruke påstander for å verifisere andre egenskaper og oppførsel til objekter. Chai tilbyr et bredt spekter av påstander som lar oss gjøre ulike typer påstander om objekter, for eksempel å sjekke egenskapsverdier, verifisere metodeanrop og mer.

Ved å teste metodene til et objekt grundig, kan vi sikre korrekthet og pålitelighet, noe som bidrar til den generelle kvaliteten på kodebasen vår.