close

Eenvoudige tests maken met Mocha en Chai

Een basistest bouwen met Mocha en Chai

Om een ​​basistest te bouwen met Mocha en Chai, kunt u deze stappen volgen:

1. Installeer Mocha en Chai: gebruik npm(Node Package Manager) om te installeren Mocha en Chai in uw Node.js-project. Voer de volgende opdracht uit in uw projectdirectory:

npm install mocha chai --save-dev

2. Maak een testbestand: maak een nieuw bestand aan, bijvoorbeeld test.js, en importeer de volgende declaraties om te gebruiken Mocha en 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. Voer de test uit: Open de terminal en voer de mocha  opdracht uit om de tests uit te voeren. Als alles goed gaat, ziet u de resultaten in de terminal.

Deze basistest gebruikt Mocha en Chai om een ​​eenvoudige berekening te controleren. In het bovenstaande voorbeeld controleren we of het resultaat van de 2 + 2 bewerking gelijk moet zijn aan 4. Als het resultaat correct is, zal de test slagen.

Door blokken describe  en it  blokken toe te voegen, kunt u complexere tests bouwen en verschillende delen van uw broncode controleren.

Houd er rekening mee dat u ook andere beweringsmethoden kunt gebruiken die worden geleverd door Chai, zoals assert of should, om te testen. Het specifieke gebruik hangt af van uw keuze en hoe u uw testcode wilt organiseren.

 

Beweringen en query's gebruiken om functieresultaten te verifiëren

Wanneer u Mocha en Chai voor testen gebruikt, kunt u beweringen en query's gebruiken om de resultaten van functies te controleren. Hier zijn enkele voorbeelden van het gebruik van beweringen en query's om functieresultaten te controleren:

1. Gebruik de expect assertion en de to.equal query om het resultaat te controleren van een functie die een specifieke waarde retourneert:

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

2. Gebruik de `expect`-bevestiging en de to.be.true of- to.be.false query om het resultaat te controleren van een functie die een booleaanse waarde retourneert:

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

3. Gebruik de `expect`-bevestiging en de to.be.null query or to.be.undefined om het resultaat te controleren van een functie die een null- of ongedefinieerde waarde retourneert:

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

4. Gebruik de expect assertion en de to.include query om te controleren of een waarde is opgenomen in een array of string:

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

5. Gebruik de expect assertion en de to.have.lengthOf query om de lengte van een array of string te controleren:

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

Deze voorbeelden zijn slechts enkele van de vele manieren om beweringen en query's te gebruiken in Mocha en Chai om functieresultaten te controleren. U kunt de juiste beweringen en query's aanpassen en gebruiken op basis van de testbehoeften van uw project.

 

Succesvolle en mislukte testcases maken

Bij het schrijven van testgevallen met Mocha en Chai is het belangrijk om zowel geslaagde als mislukte scenario's te behandelen. Hier zijn voorbeelden van het maken van testgevallen voor zowel succesvolle als mislukte scenario's:

1. Succesvolle testcase:

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. Mislukte testcase:

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

In de succesvolle testcase definieert u de invoer voor de functie en het verwachte resultaat. Vervolgens roept u de functie aan met de invoer en bevestigt u dat het resultaat overeenkomt met de verwachte waarde.

In de fouttestcase geeft u ongeldige invoer aan de functie en beweert u dat deze een fout genereert. Dit zorgt ervoor dat de functie correct omgaat met ongeldige invoer of foutcondities.

Door zowel succesvolle als mislukte scenario's in uw testcases te behandelen, kunt u ervoor zorgen dat uw code grondig wordt getest en verschillende situaties op de juiste manier afhandelt.