Tester une Application Express.js : Tests Unitaires et Tests d'Intégration

Par sbenothman, 13 mars, 2025
test avec Express.js

Introduction

Dans notre précédent article, nous avons exploré les meilleures pratiques pour structurer une application Express.js, renforcer sa sécurité et gérer efficacement les erreurs. Cependant, une application robuste ne se limite pas à une bonne architecture ; elle doit être testée rigoureusement pour assurer sa fiabilité et prévenir les régressions.

Dans cet article, nous allons aborder :

  • Les tests unitaires pour vérifier le bon fonctionnement des composants individuels de l’application.
  • Les tests d’intégration pour tester l’interaction entre différents modules.
  • Les outils et bibliothèques recommandés pour automatiser ces tests.
  • Une stratégie efficace pour écrire et organiser les tests.

1. Pourquoi Tester son Application Express.js ?

Les tests permettent de :

  • Détecter les bogues avant la mise en production.
  • Améliorer la qualité et la maintenabilité du code.
  • Assurer que les modifications n’introduisent pas de régressions.
  • Automatiser le processus de vérification du bon fonctionnement de l’application.

2. Les Tests Unitaires dans Express.js

2.1 Qu’est-ce qu’un Test Unitaire ?

Un test unitaire vérifie le bon fonctionnement d’une unité de code isolée, comme une fonction ou un middleware. L’objectif est de s’assurer que chaque composant fonctionne correctement en dehors de tout contexte global.

2.2 Outils Recommandés

Avant de commencer, assure-toi d’installer les dépendances nécessaires avec npm :

npm install --save-dev mocha chai chai-http supertest
  • Mocha + Chai : Mocha est un framework de test flexible, souvent utilisé avec Chai pour les assertions.

2.3 Exemple de Test Unitaire

Prenons l’exemple d’un service qui génère un message de salutation :

Service de Salutation (GreetingService.js)

class ServiceDeSalutation {
  saluer(nom) {
    return `Bonjour, ${nom} !`;
  }
}

module.exports = ServiceDeSalutation;

Route utilisant ce service (routes.js)

const express = require('express');
const ServiceDeSalutation = require('./ServiceDeSalutation');

const routeur = express.Router();
const serviceSalutation = new ServiceDeSalutation();

routeur.get('/saluer/:nom', (req, res) => {
  const { nom } = req.params;
  const messageSalutation = serviceSalutation.saluer(nom);
  res.send({ message: messageSalutation });
});

module.exports = routeur;

Test Unitaire avec Mocha et Chai (test/routes.test.js)

const { expect } = require('chai');
const request = require('supertest');
const express = require('express');
const routes = require('../routes');

describe('Service de Salutation', () => {
  const app = express();
  app.use('/', routes);

  it('Étant donné un nom valide, lorsque l'utilisateur effectue une requête, on obtient un message de salutation', async () => {
    const response = await request(app).get('/saluer/Jean');
    expect(response.status).to.equal(200);
    expect(response.body).to.have.property('message');
    expect(response.body.message).to.equal('Bonjour, Jean !');
  });
});

3. Les Tests d’Intégration dans Express.js

3.1 Qu’est-ce qu’un Test d’Intégration ?

Un test d’intégration vérifie que plusieurs composants de l’application fonctionnent correctement ensemble, y compris l’intégration avec une base de données.

3.2 Exemple de Test d’Intégration avec Chai et Chai-HTTP

Test d’Intégration (test/integration.test.js)

const chai = require('chai');
const chaiHttp = require('chai-http');
const app = require('../app');

chai.use(chaiHttp);
const expect = chai.expect;

describe('Gestion des utilisateurs', () => {
  it('Étant donné qu'un utilisateur envoie des informations valides, lorsque la requête est effectuée, on obtient un nouvel utilisateur créé', (done) => {
    chai.request(app)
      .post('/api/utilisateurs')
      .send({ nomUtilisateur: 'chevalierbrave', motDePasse: 'secret' })
      .end((err, res) => {
        expect(res).to.have.status(201);
        expect(res.body).to.have.property('idUtilisateur');
        done();
      });
  });

  it('Étant donné qu'un utilisateur existe, lorsque la requête est effectuée, on obtient ses informations', (done) => {
    chai.request(app)
      .get('/api/utilisateurs/chevalierbrave')
      .end((err, res) => {
        expect(res).to.have.status(200);
        expect(res.body.nomUtilisateur).to.equal('chevalierbrave');
        done();
      });
  });
});

4. Stratégie et Organisation des Tests

Pour assurer une bonne couverture des tests :

  • Tests unitaires en premier : Valider les fonctions et middlewares de façon isolée.
  • Tests d’intégration ensuite : Vérifier les interactions entre les composants et la base de données.
  • Organisation des tests : Placer les tests dans un dossier tests/, et suivre la structure du projet.
  • Utilisation de CI/CD : Automatiser l’exécution des tests avec GitHub Actions, GitLab CI ou CircleCI.

Conclusion

Les tests sont essentiels pour garantir la robustesse d’une application Express.js. En combinant tests unitaires et tests d’intégration, on peut identifier rapidement les erreurs et s’assurer que l’application fonctionne correctement dans différents scénarios.

Avec Mocha, Chai et Chai-HTTP, tu as maintenant les outils nécessaires pour tester efficacement tes applications Express.js. Alors, intègre ces bonnes pratiques et assure-toi que ton code reste fiable et évolutif !

Ressources

Pour approfondir les tests dans Express.js, voici quelques articles utiles :

Étiquettes

Commentaires