Tests en JavaScript : unit, integration, e2e de A à Z

Test en JavaScript : Unit, Integration, E2E — de A à Z

Le développement d'une application web moderne en JavaScript (notamment avec Node.js) est impossible sans des tests de qualité. Les tests non seulement détectent les bugs avant la mise en production, mais servent également de documentation vivante et permettent de refactoriser le code sans crainte de casser quelque chose. Dans cet article, nous allons analyser les trois niveaux principaux de la pyramide des tests : unit (tests unitaires), integration (tests d'intégration) et e2e (tests de bout en bout). Vous découvrirez leurs différences, les outils à utiliser et verrez des exemples concrets sur Node.js.

1. Tests unitaires : tester des modules isolés

Les tests unitaires constituent la base de la pyramide. Ils vérifient le fonctionnement de fonctions, classes ou composants individuels en isolation complète des dépendances externes (BDD, API, système de fichiers). L'objectif principal est de s'assurer que la logique du module fonctionne correctement pour toutes les données d'entrée.

Pour Node.js, le framework le plus populaire est Jest (de Facebook). Il ne nécessite pas de configuration complexe, dispose d'assertions intégrées, de mocks et de couverture de code.

Exemple : tester une fonction de tri de tableau

// utils.jsfunction sortNumbers(arr) {  if (!Array.isArray(arr)) {    throw new Error('Input must be an array');  }  return [...arr].sort((a, b) => a - b);}

module.exports = { sortNumbers };

// utils.test.jsconst { sortNumbers } = require('./utils');

describe('sortNumbers', () => {  test('should sort an array of numbers in ascending order', () => {    expect(sortNumbers([3, 1, 2])).toEqual([1, 2, 3]);  });

  test('should handle an empty array', () => {    expect(sortNumbers([])).toEqual([]);  });

  test('should throw error for non-array input', () => {    expect(() => sortNumbers('string')).toThrow('Input must be an array');  });});

Bonnes pratiques pour les tests unitaires :

• Un test = une vérification (une seule assertion).
• Utilisez describe pour regrouper les tests par fonction.
• Mockez les dépendances externes (avec jest.mock()).
• Écrivez les tests avant le code (TDD — Test-Driven Development).

2. Tests d'intégration : vérifier l'interaction des composants

Les tests d'intégration vérifient comment différents modules du système fonctionnent ensemble. Par exemple, comment votre contrôleur interagit avec la base de données ou une API externe. Contrairement aux tests unitaires, on ne mocke pas tout ici, mais on utilise des environnements réels (ou de test).

Pour tester les serveurs HTTP avec Express, la bibliothèque Supertest associée à Jest est parfaitement adaptée.

Exemple : tester un endpoint REST

// app.jsconst express = require('express');const app = express();

app.get('/api/hello', (req, res) => {  res.json({ message: 'Hello, World!' });});

app.post('/api/data', (req, res) => {  const { name } = req.body;  if (!name) {    return res.status(400).json({ error: 'Name is required' });  }  res.status(201).json({ received: name });});

module.exports = app;

// app.test.jsconst request = require('supertest');const app = require('./app');

describe('Integration tests for API', () => {  test('GET /api/hello should return a greeting', async () => {    const response = await request(app)      .get('/api/hello')      .expect(200);

    expect(response.body).toEqual({ message: 'Hello, World!' });  });

  test('POST /api/data with valid body should return 201', async () => {    const response = await request(app)      .post('/api/data')      .send({ name: 'Alice' })      .expect(201);

    expect(response.body).toEqual({ received: 'Alice' });  });

  test('POST /api/data without name should return 400', async () => {