Création de tests simples avec Mocha et Chai

Construire un test de base en utilisant Mocha et Chai

Pour créer un test de base à l'aide Mocha de et Chai, vous pouvez suivre ces étapes :

1. Installez Mocha et Chai: Utilisez npm(Node Package Manager) pour installer Mocha et Chai dans votre projet Node.js. Exécutez la commande suivante dans le répertoire de votre projet :

npm install mocha chai --save-dev

2. Créez un fichier de test: Créez un nouveau fichier, par exemple test.js, et importez les déclarations suivantes à utiliser Mocha et 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. Exécutez le test : ouvrez le terminal et exécutez la mocha  commande pour exécuter les tests. Si tout se passe bien, vous verrez les résultats affichés dans le terminal.

Ce test de base utilise Mocha et Chai pour vérifier un calcul simple. Dans l'exemple ci-dessus, nous vérifions que le résultat de l' 2 + 2 opération doit être égal à 4. Si le résultat est correct, le test réussira.

En ajoutant describe  et it  des blocs, vous pouvez créer des tests plus complexes et vérifier différentes parties de votre code source.

Notez que vous pouvez également utiliser d'autres méthodes d'assertion fournies par Chai, telles que assert ou should, pour les tests. L'utilisation spécifique dépend de votre choix et de la manière dont vous souhaitez organiser votre code de test.

 

Utiliser des assertions et des requêtes pour vérifier les résultats de la fonction

Lorsque vous utilisez Mocha et Chai pour les tests, vous pouvez utiliser des assertions et des requêtes pour vérifier les résultats des fonctions. Voici quelques exemples d'utilisation d'assertions et de requêtes pour vérifier les résultats d'une fonction :

1. Utilisez l' expect assertion et la to.equal requête pour vérifier le résultat d'une fonction qui renvoie une valeur spécifique :

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

2. Utilisez l'assertion `expect` et la requête to.be.true or to.be.false pour vérifier le résultat d'une fonction qui renvoie une valeur booléenne :

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

3. Utilisez l'assertion `expect` et la to.be.null requête or to.be.undefined pour vérifier le résultat d'une fonction qui renvoie une valeur nulle ou indéfinie :

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

4. Utilisez l' expect assertion et la to.include requête pour vérifier si une valeur est incluse dans un tableau ou une chaîne :

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

5. Utilisez l' expect assertion et la to.have.lengthOf requête pour vérifier la longueur d'un tableau ou d'une chaîne :

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

Ces exemples ne sont que quelques-unes des nombreuses façons d'utiliser des assertions et des requêtes Mocha et Chai de vérifier les résultats de fonctions. Vous pouvez personnaliser et utiliser les assertions et requêtes appropriées en fonction des besoins de test de votre projet.

 

Créer des cas de test réussis et échoués

Lors de l'écriture de scénarios de test avec Mocha et Chai, il est important de couvrir à la fois les scénarios de réussite et d'échec. Voici des exemples de création de cas de test pour des scénarios de réussite et d'échec :

1. Scénario de test réussi :

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. Cas de test d'échec :

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

Dans le scénario de test réussi, vous définissez l'entrée pour la fonction et le résultat attendu. Ensuite, vous appelez la fonction avec l'entrée et affirmez que le résultat correspond à la valeur attendue.

Dans le cas de test d'échec, vous fournissez une entrée non valide à la fonction et affirmez qu'elle génère une erreur. Cela garantit que la fonction gère correctement les conditions d'entrée ou d'erreur non valides.

En couvrant à la fois les scénarios de réussite et d'échec dans vos cas de test, vous pouvez vous assurer que votre code est testé de manière approfondie et gère les différentes situations de manière appropriée.