Mocking dans Express.js : Simuler pour Mieux Tester

Mocking dans les Tests d'Applications Express.js : Simuler pour Mieux Tester

Par sbenothman, 21 mars 2025

---

Introduction

Dans le développement d'applications Express.js, il est essentiel de s'assurer que chaque composant fonctionne de manière fiable. Pour cela, les tests sont cruciaux. Mais que faire lorsque vos tests dépendent de services externes, comme une base de données ou des APIs externes ? La réponse est simple : utiliser le mocking.

Le mocking permet de simuler des dépendances externes, ce qui rend vos tests plus rapides, fiables et indépendants des systèmes réels. Dans cet article, nous explorerons le mocking dans les tests d'Express.js, en nous appuyant sur des outils comme Jest et @jest-mock/express.

---

1. Pourquoi utiliser le Mocking ?

Le mocking permet de créer des versions simulées de certaines parties du code, telles que les appels aux bases de données ou les services externes, afin de tester des composants isolés. Cela permet de :

• Isoler les tests pour éviter d'interagir avec des systèmes externes
• Tester plus rapidement et de manière prédictible
• Contrôler les réponses des dépendances (par exemple, simuler des erreurs ou des résultats vides)

Sans le mocking, vos tests risquent :

• De modifier des données réelles dans la base de données
• D'échouer si la connexion à une base de données ou à un service est perdue
• D'être incohérents si l'état de la base de données change entre les tests

Le mocking garantit que vos tests ne dépendent pas de services externes et qu'ils restent efficaces et reproductibles.

---

2. Comment faire du Mocking dans Express.js ?

2.1 Utilisation de Jest pour le Mocking

Jest est un outil puissant pour effectuer des tests unitaires et d'intégration en JavaScript. Il offre plusieurs méthodes pour effectuer du mocking, telles que jest.mock(), jest.fn() et jest.spyOn().

2.1.1 jest.mock()

jest.mock() permet de simuler un module entier. Cela est utile lorsqu'on travaille avec des modules complexes comme des bases de données ou des services externes. Par exemple, vous pouvez simuler un module de base de données qui retourne des données fictives.

Exemple de code :

// Mock de Mongoose pour simuler les requêtes à la base de données
jest.mock('mongoose', () => ({
  model: jest.fn(() => ({
    find: jest.fn().mockResolvedValue([{ name: 'Utilisateur' }])
  }))
}));

2.1.2 jest.fn()

jest.fn() crée une fonction simulée qui peut être utilisée pour suivre l'exécution des fonctions dans votre code. Cela permet de simuler des méthodes ou des requêtes, comme une requête à la base de données.

Exemple de code :

const maFonctionSimulee = jest.fn().mockReturnValue({ id: 1, name: 'Test' });

2.1.3 jest.spyOn()

jest.spyOn() permet de surveiller une fonction spécifique. Il est utile pour vérifier qu'une fonction est appelée correctement sans la modifier directement.

Exemple de code :

const espion = jest.spyOn(someModule, 'method').mockImplementation(() => 'valeur simulée');

2.2 Mocking des Requêtes et Réponses dans Express avec @jest-mock/express

@jest-mock/express est un package qui facilite le mocking des objets req et res d'Express. Cela permet de tester les contrôleurs et middleware sans dépendre d'un serveur réel.

Installation de @jest-mock/express

npm install --save-dev @jest-mock/express

Exemple d'utilisation pour tester un contrôleur

const { getMockReq, getMockRes } = require('@jest-mock/express');

describe('Test du contrôleur', () => {
  it('Étant donné une requête avec un paramètre id, lorsque la requête est effectuée, on obtient la réponse avec l'entité demandée', async () => {
    const { req, res, next } = getMockRes();

    const monControleur = {
      getEntity: (req, res, next) => {
        res.json({ id: req.params.id });
      }
    };

    const req = getMockReq({ params: { id: '123' } });

    await monControleur.getEntity(req, res, next);

    expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ id: '123' }));
  });
});

---

3. Tester des Services et Modèles avec Jest

Dans un projet Express.js, les services et modèles interagissent souvent avec une base de données ou d'autres ressources. Pour tester ces composants, il est essentiel de simuler les appels à ces services ou modèles.

Exemple de service utilisant un modèle pour interroger la base de données

class UserService {
  constructor(userModel) {
    this.userModel = userModel;
  }

  async utilisateurExiste(nomUtilisateur) {
    const utilisateur = await this.userModel.findOne({ nomUtilisateur });
    return !!utilisateur;
  }
}

module.exports = UserService;

Test avec Jest pour simuler la réponse d'un modèle :

const UserService = require('../services/UserService');
const { userModel } = require('../models/User');

jest.mock('../models/User'); // Mocker le modèle

describe('UserService', () => {
  it('Étant donné qu'un utilisateur existe, lorsque la requête est effectuée, on obtient ses informations', async () => {
    userModel.findOne.mockResolvedValue({ nomUtilisateur: 'utilisateurExistant' });
    
    const service = new UserService(userModel);
    const result = await service.utilisateurExiste('utilisateurExistant');
    
    expect(result).toBe(true);
  });

  it('Étant donné qu'un utilisateur n'existe pas, lorsque la requête est effectuée, on obtient une réponse indiquant que l'utilisateur n'existe pas', async () => {
    userModel.findOne.mockResolvedValue(null);

    const service = new UserService(userModel);
    const result = await service.utilisateurExiste('utilisateurInexistant');
    
    expect(result).toBe(false);
  });
});

---

4. Conclusion

Le mocking est une technique indispensable pour tester efficacement les applications Express.js. En utilisant des outils comme Jest et @jest-mock/express, vous pouvez simuler des dépendances externes telles que les bases de données et les services externes. Cela vous permet de tester vos composants de manière isolée, sans interférences provenant des systèmes externes.

En appliquant ces pratiques, vous assurerez des tests rapides, fiables et indépendants des environnements externes. Continuez à exploiter ces outils pour garantir la qualité de votre code et simplifier le processus de test.

---

Ressources

Pour approfondir vos connaissances sur le mocking et les tests dans Express.js, voici quelques articles utiles :

• Documentation de Express.js- Consulté le 20 Mars 2025
• A Simple Guide to Mocking in Node.js Tests with Jest- Consulté le 20 Mars 2025
• Advanced Testing Strategies for Express.js Applications: Mocking, Stubbing, and Beyond - Consulté le 20 Mars 2025