Mocha est un outil de test largement adopté pour JavaScript, fonctionnant aussi bien dans les navigateurs que sous Node.js.

Installation de Mocha

Pour commencer, installez Mocha localemant dans votre projet :

$ npm install mocha --save-dev

Pour une utilisation en ligne de commande globale :

$ npm install --global mocha

Création d'un script de test

Les fichiers de test portent généralement l'extension .test.js ou .spec.js. Voici un module simple à tester :

// calcul.js
function soustraction(a, b) {
  return a - b;
}
module.exports = soustraction;

Le script de test correspondant :

// calcul.test.js
const soustraction = require('./calcul');
const { expect } = require('chai');

describe('Tests de la fonction soustraction', function() {
  it('devrait retourner 2 pour 5 moins 3', function() {
    expect(soustraction(5, 3)).to.equal(2);
  });
  it('devrait gérer les nombres négatifs', function() {
    expect(soustraction(1, 4)).to.equal(-3);
  });
});

Chaque suite de tests est définie avec describe, et chaque cas de test avec it.

Utilisation des assertions avec Chai

Chai offre plusieurs styles d'assertions. Avec le style expect :

expect(10).to.be.above(5);
expect('hello').to.have.lengthOf(5);
expect([1, 2]).to.be.an('array').that.does.not.include(3);

Une assertion échoue si la condition n'est pas satisfaite, générant une erreur.

Exécution des tests

Lancez les tests avec la commande :

$ mocha calcul.test.js

Mocha recherche par défaut dans le dossier test. Pour inclure les sous-dossiers récursivement :

$ mocha --recursive

Options de ligne de commande

Diverses options permettent de personnaliser l'exécution :

• --reporter : change le format du rapport (ex. : tap, dot).
• --timeout ou -t : ajuste le délai d'attente par test.
• --grep : filtre les tests par expression régulière sur leur description.
• --watch ou -w : relance les tests à chaque modification.

Exemple :

$ mocha --reporter min --timeout 3000

Configuration avec mocha.opts

Créez un fichier mocha.opts dans le répretoire test pour centraliser les options :

--reporter spec
--recursive
--timeout 5000

Mocha lira automatiquement ce fichier à l'exécution.

Tests avec des syntaxes modernes (ES6+)

Pour utiliser des modules ES6, configurez Babel :

$ npm install @babel/core @babel/preset-env --save-dev

Dans .babelrc :

{
  "presets": ["@babel/preset-env"]
}

Exécutez les tests avec :

$ mocha --require @babel/register

Gestion des tests asynchrones

Pour les opérations asynchrones, utilisez des callbacks ou des promesses. Avec callback :

it('test asynchrone avec callback', function(done) {
  setTimeout(() => {
    expect(true).to.be.true;
    done();
  }, 200);
});

Avec promesse :

it('test asynchrone avec promesse', function() {
  return new Promise(resolve => {
    setTimeout(() => {
      expect(42).to.equal(42);
      resolve();
    }, 300);
  });
});

Le délai d'attente peut être ajusté par test :

it('test long', function() {
  this.timeout(10000);
  // ...
});

Cycles de vie des tests (hooks)

Les hooks permettent d'exécuter du code avant/après les tests :

describe('Suite avec hooks', function() {
  before(function() { /* exécuté une fois avant tous les tests */ });
  after(function() { /* exécuté une fois après tous les tests */ });
  beforeEach(function() { /* exécuté avant chaque test */ });
  afterEach(function() { /* exécuté après chaque test */ });
  // tests ici
});

Sélection et saut de tests

Utilisez .only pour exécuter un test spécifique et .skip pour en ignorer :

it.only('test exclusif', function() {
  // seul ce test sera exécuté
});
it.skip('test ignoré', function() {
  // ce test ne sera pas exécuté
});

Tests dans le navigateur

Générez un fichier HTML de base avec mocha init. Incluez Mocha, Chai et vos scripts de test dans le HTML pour les exécuter côté client.

Export des résultats

Générez des rapports au format Markdown ou HTML :

$ mocha --recursive --reporter markdown > spec.md
$ mocha --recursive --reporter doc > spec.html