Skapa enkla tester med Mocha och Chai

Bygga ett grundläggande test med Mocha och Chai

För att bygga ett grundläggande test med Mocha och Chai kan du följa dessa steg:

1. Installera Mocha och Chai: Använd npm(Node Package Manager) för att installera Mocha och Chai i ditt Node.js-projekt. Kör följande kommando i din projektkatalog:

npm install mocha chai --save-dev

2. Skapa en testfil: Skapa en ny fil, till exempel test.js, och importera följande deklarationer för att använda Mocha och 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. Kör testet: Öppna terminalen och kör mocha  kommandot för att utföra testerna. Om allt går smidigt kommer du att se resultaten som visas i terminalen.

Detta grundläggande test använder Mocha och Chai för att kontrollera en enkel beräkning. I exemplet ovan kontrollerar vi att resultatet av operationen 2 + 2 ska vara lika med 4. Om resultatet är korrekt kommer testet att godkännas.

Genom att lägga till describe  och it  blockera kan du bygga mer komplexa tester och kontrollera olika delar av din källkod.

Observera att du även kan använda andra påståendemetoder som tillhandahålls av, Chai till exempel assert eller should, för testning. Den specifika användningen beror på ditt val och hur du vill organisera din testkod.

 

Använda påståenden och frågor för att verifiera funktionsresultat

När du använder Mocha och Chai för testning kan du använda påståenden och frågor för att kontrollera resultaten av funktioner. Här är några exempel på hur man använder påståenden och frågor för att kontrollera funktionsresultat:

1. Använd expect påståendet och to.equal frågan för att kontrollera resultatet av en funktion som returnerar ett specifikt värde:

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

2. Använd "förvänta" påståendet och frågan to.be.true eller to.be.false för att kontrollera resultatet av en funktion som returnerar ett booleskt värde:

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

3. Använd "expect"-påståendet och to.be.null eller to.be.undefined-frågan för att kontrollera resultatet av en funktion som returnerar ett null- eller odefinierat värde:

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

4. Använd expect påståendet och to.include frågan för att kontrollera om ett värde ingår i en matris eller sträng:

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

5. Använd expect påståendet och to.have.lengthOf frågan för att kontrollera längden på en array eller sträng:

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

Dessa exempel är bara några av många sätt att använda påståenden och frågor i Mocha och Chai för att kontrollera funktionsresultat. Du kan anpassa och använda lämpliga påståenden och frågor baserat på ditt projekts testbehov.

 

Skapa framgångsrika och misslyckade testfall

När du skriver testfall med Mocha och Chai är det viktigt att täcka både framgångsrika och misslyckade scenarier. Här är exempel på hur man skapar testfall för både framgångsrika och misslyckade scenarier:

1. Framgångsrikt testfall:

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. Testfall för fel:

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

I det framgångsrika testfallet definierar du ingången för funktionen och det förväntade resultatet. Sedan anropar du funktionen med ingången och hävdar att resultatet matchar det förväntade värdet.

I feltestfallet ger du ogiltig input till funktionen och hävdar att den ger ett fel. Detta säkerställer att funktionen korrekt hanterar ogiltiga indata eller feltillstånd.

Genom att täcka både framgångsrika och misslyckade scenarier i dina testfall kan du säkerställa att din kod testas grundligt och hanterar olika situationer på lämpligt sätt.