21 juillet 2025Français

Maîtrisez les modèles de tests avancés de Jest pour créer des logiciels plus fiables et maintenables. Explorez le mocking, les tests de snapshots, et plus.

Jest : Modèles de tests avancés pour des logiciels robustes

Dans le paysage actuel du développement logiciel, qui évolue rapidement, il est primordial de garantir la fiabilité et la stabilité de votre base de code. Bien que Jest soit devenu la norme de facto pour les tests JavaScript, aller au-delà des tests unitaires de base débloque un nouveau niveau de confiance dans vos applications. Cet article explore les modèles de tests avancés de Jest qui sont essentiels pour construire des logiciels robustes, s'adressant à un public mondial de développeurs.

Pourquoi aller au-delà des tests unitaires de base ?

Les tests unitaires de base vérifient les composants individuels de manière isolée. Cependant, les applications du monde réel sont des systèmes complexes où les composants interagissent. Les modèles de tests avancés abordent ces complexités en nous permettant de :

Simuler des dépendances complexes.
Capturer les changements d'interface utilisateur de manière fiable.
Écrire des tests plus expressifs et maintenables.
Améliorer la couverture des tests et la confiance dans les points d'intégration.
Faciliter les flux de travail de Développement Piloté par les Tests (TDD) et de Développement Piloté par le Comportement (BDD).

Maîtriser le Mocking et les Spies

Le mocking est crucial pour isoler l'unité testée en remplaçant ses dépendances par des substituts contrôlés. Jest fournit des outils puissants pour cela :

`jest.fn()` : La base des Mocks et des Spies

jest.fn() crée une fonction mock. Vous pouvez suivre ses appels, ses arguments et ses valeurs de retour. C'est la pierre angulaire pour des stratégies de mocking plus sophistiquées.

Exemple : Suivi des appels de fonction

            // component.js
export const fetchData = () => {
  // Simule un appel API
  return Promise.resolve({ data: 'quelques données' });
};

export const processData = async (fetcher) => {
  const result = await fetcher();
  return `Traité : ${result.data}`;
};

// component.test.js
import { processData } from './component';

test('devrait traiter les données correctement', async () => {
  const mockFetcher = jest.fn().mockResolvedValue({ data: 'données mockées' });
  const result = await processData(mockFetcher);
  expect(result).toBe('Traité : données mockées');
  expect(mockFetcher).toHaveBeenCalledTimes(1);
  expect(mockFetcher).toHaveBeenCalledWith();
});

`jest.spyOn()` : Observer sans remplacer

jest.spyOn() vous permet d'observer les appels à une méthode sur un objet existant sans nécessairement remplacer son implémentation. Vous pouvez également mocker l'implémentation si nécessaire.

Exemple : Espionner une méthode de module

            // logger.js
export const logInfo = (message) => {
  console.log(`INFO: ${message}`);
};

// service.js
import { logInfo } from './logger';

export const performTask = (taskName) => {
  logInfo(`Démarrage de la tâche : ${taskName}`);
  // ... logique de la tâche ...
  logInfo(`Tâche ${taskName} terminée.`);
};

// service.test.js
import { performTask } from './service';
import * as logger from './logger';

test('devrait logger le début et la fin de la tâche', () => {
  const logSpy = jest.spyOn(logger, 'logInfo');

  performTask('sauvegarde');

  expect(logSpy).toHaveBeenCalledTimes(2);
  expect(logSpy).toHaveBeenCalledWith('Démarrage de la tâche : sauvegarde');
  expect(logSpy).toHaveBeenCalledWith('Tâche sauvegarde terminée.');

  logSpy.mockRestore(); // Important pour restaurer l'implémentation d'origine
});

Mocker les importations de modules

Les capacités de mocking de module de Jest sont étendues. Vous pouvez mocker des modules entiers ou des exportations spécifiques.

Exemple : Mocker un client d'API externe

            // api.js
import axios from 'axios';

export const getUser = async (userId) => {
  const response = await axios.get(`/api/users/${userId}`);
  return response.data;
};

// user-service.js
import { getUser } from './api';

export const getUserFullName = async (userId) => {
  const user = await getUser(userId);
  return `${user.firstName} ${user.lastName}`;
};

// user-service.test.js
import { getUserFullName } from './user-service';
import * as api from './api';

// Mocker le module api en entier
jest.mock('./api');

test('devrait obtenir le nom complet en utilisant une API mockée', async () => {
  // Mocker la fonction spécifique du module mocké
  api.getUser.mockResolvedValue({ id: 1, firstName: 'Ada', lastName: 'Lovelace' });

  const fullName = await getUserFullName(1);

  expect(fullName).toBe('Ada Lovelace');
  expect(api.getUser).toHaveBeenCalledTimes(1);
  expect(api.getUser).toHaveBeenCalledWith(1);
});

Mocking automatique vs. Mocking manuel

Jest mocke automatiquement les modules Node.js. Pour les modules ES ou les modules personnalisés, vous pourriez avoir besoin de jest.mock(). Pour plus de contrôle, vous pouvez créer des répertoires __mocks__.

Implémentations de mock

Vous pouvez fournir des implémentations personnalisées pour vos mocks.

Exemple : Mocking avec une implémentation personnalisée

            // math.js
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;

// calculator.js
import { add, subtract } from './math';

export const calculate = (operation, a, b) => {
  if (operation === 'add') {
    return add(a, b);
  } else if (operation === 'subtract') {
    return subtract(a, b);
  }
  return null;
};

// calculator.test.js
import { calculate } from './calculator';
import * as math from './math';

// Mocker le module math en entier
jest.mock('./math');

test('devrait effectuer une addition en utilisant la fonction mockée math.add', () => {
  // Fournir une implémentation de mock pour la fonction 'add'
  math.add.mockImplementation((a, b) => a + b + 10); // Ajoute 10 au résultat
  math.subtract.mockReturnValue(5); // Mocker aussi subtract

  const result = calculate('add', 5, 3);

  expect(math.add).toHaveBeenCalledWith(5, 3);
  expect(result).toBe(18); // 5 + 3 + 10

  const subResult = calculate('subtract', 10, 2);
  expect(math.subtract).toHaveBeenCalledWith(10, 2);
  expect(subResult).toBe(5);
});

Tests de snapshots : Préserver l'interface utilisateur et la configuration

Les tests de snapshots sont une fonctionnalité puissante pour capturer le rendu de vos composants ou de vos configurations. Ils sont particulièrement utiles pour les tests d'interface utilisateur ou pour vérifier des structures de données complexes.

Comment fonctionnent les tests de snapshots

La première fois qu'un test de snapshot est exécuté, Jest crée un fichier .snap contenant une représentation sérialisée de la valeur testée. Lors des exécutions suivantes, Jest compare le résultat actuel avec le snapshot stocké. S'ils diffèrent, le test échoue, vous alertant de changements inattendus. C'est inestimable pour détecter les régressions dans les composants d'interface utilisateur à travers différentes régions ou locales.

Exemple : Créer un snapshot d'un composant React

En supposant que vous ayez un composant React :

            // UserProfile.js
import React from 'react';

const UserProfile = ({ name, email, isActive }) => (
  <div>
    <h2>{name}</h2>
    <p><strong>E-mail :</strong> {email}</p>
    <p><strong>Statut :</strong> {isActive ? 'Actif' : 'Inactif'}</p>
  </div>
);

export default UserProfile;

// UserProfile.test.js
import React from 'react';
import renderer from 'react-test-renderer'; // Pour les snapshots de composants React
import UserProfile from './UserProfile';

test('affiche UserProfile correctement', () => {
  const user = {
    name: 'Jane Doe',
    email: 'jane.doe@example.com',
    isActive: true,
  };
  const component = renderer.create(
    <UserProfile {...user} />
  );
  const tree = component.toJSON();
  expect(tree).toMatchSnapshot();
});

test('affiche un UserProfile inactif correctement', () => {
  const user = {
    name: 'John Smith',
    email: 'john.smith@example.com',
    isActive: false,
  };
  const component = renderer.create(
    <UserProfile {...user} />
  );
  const tree = component.toJSON();
  expect(tree).toMatchSnapshot('profil utilisateur inactif'); // Snapshot nommé
});

Après avoir exécuté les tests, Jest créera un fichier UserProfile.test.js.snap. Lorsque vous mettrez à jour le composant, vous devrez examiner les changements et potentiellement mettre à jour le snapshot en exécutant Jest avec l'option --updateSnapshot ou -u.

Meilleures pratiques pour les tests de snapshots

Utiliser pour les composants d'interface utilisateur et les fichiers de configuration : Idéal pour s'assurer que les éléments de l'interface utilisateur s'affichent comme prévu et que la configuration ne change pas involontairement.
Examinez attentivement les snapshots : N'acceptez pas aveuglément les mises à jour de snapshots. Examinez toujours ce qui a changé pour vous assurer que les modifications sont intentionnelles.
Évitez les snapshots pour les données qui changent fréquemment : Si les données changent rapidement, les snapshots peuvent devenir fragiles et générer beaucoup de bruit.
Utilisez des snapshots nommés : Pour tester plusieurs états d'un composant, les snapshots nommés offrent une meilleure clarté.

Matchers personnalisés : Améliorer la lisibilité des tests

Les matchers intégrés de Jest sont nombreux, mais parfois vous devez affirmer des conditions spécifiques non couvertes. Les matchers personnalisés vous permettent de créer votre propre logique d'assertion, rendant vos tests plus expressifs et lisibles.

Créer des matchers personnalisés

Vous pouvez étendre l'objet expect de Jest avec vos propres matchers.

Exemple : Vérifier un format d'e-mail valide

Dans votre fichier de configuration Jest (par ex. jest.setup.js, configuré dans jest.config.js) :

            // jest.setup.js

expect.extend({
  toBeValidEmail(received) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    const pass = emailRegex.test(received);

    if (pass) {
      return {
        message: () => `s'attendait à ce que ${received} ne soit pas un e-mail valide`,
        pass: true,
      };
    } else {
      return {
        message: () => `s'attendait à ce que ${received} soit un e-mail valide`,
        pass: false,
      };
    }
  },
});

// Dans votre jest.config.js
// module.exports = { setupFilesAfterEnv: ['/jest.setup.js'] };

Dans votre fichier de test :

            // validation.test.js

test('devrait valider les formats d'e-mail', () => {
  expect('test@example.com').toBeValidEmail();
  expect('email-invalide').not.toBeValidEmail();
  expect('un.autre.test@sous.domaine.co.uk').toBeValidEmail();
});

Avantages des matchers personnalisés

Lisibilité améliorée : Les tests deviennent plus déclaratifs, indiquant *ce qui* est testé plutôt que *comment*.
Réutilisabilité du code : Évitez de répéter une logique d'assertion complexe dans plusieurs tests.
Assertions spécifiques au domaine : Adaptez les assertions aux exigences spécifiques du domaine de votre application.

Tester les opérations asynchrones

JavaScript est fortement asynchrone. Jest offre un excellent support pour tester les promesses et async/await.

Utiliser `async/await`

C'est la manière moderne et la plus lisible de tester du code asynchrone.

Exemple : Tester une fonction asynchrone

            // dataService.js
export const fetchUserData = async (userId) => {
  // Simule la récupération de données après un délai
  await new Promise(resolve => setTimeout(resolve, 50));
  if (userId === 1) {
    return { id: 1, name: 'Alice' };
  } else {
    throw new Error('Utilisateur non trouvé');
  }
};

// dataService.test.js
import { fetchUserData } from './dataService';

test('récupère les données utilisateur correctement', async () => {
  const user = await fetchUserData(1);
  expect(user).toEqual({ id: 1, name: 'Alice' });
});

test('lève une erreur pour un utilisateur inexistant', async () => {
  await expect(fetchUserData(2)).rejects.toThrow('Utilisateur non trouvé');
});

Utiliser `.resolves` et `.rejects`

Ces matchers simplifient les tests de résolutions et de rejets de promesses.

Exemple : Utiliser .resolves/.rejects

            // dataService.test.js (suite)

test('récupère les données utilisateur avec .resolves', () => {
  return expect(fetchUserData(1)).resolves.toEqual({ id: 1, name: 'Alice' });
});

test('lève une erreur pour un utilisateur inexistant avec .rejects', () => {
  return expect(fetchUserData(2)).rejects.toThrow('Utilisateur non trouvé');
});

Gérer les minuteurs (timers)

Pour les fonctions qui utilisent setTimeout ou setInterval, Jest permet de contrôler les minuteurs.

Exemple : Contrôler les minuteurs

            // delayedGreeter.js
export const greetAfterDelay = (name, callback) => {
  setTimeout(() => {
    callback(`Bonjour, ${name} !`);
  }, 1000);
};

// delayedGreeter.test.js
import { greetAfterDelay } from './delayedGreeter';

jest.useFakeTimers(); // Activer les minuteurs factices

test('salue après un délai', () => {
  const mockCallback = jest.fn();
  greetAfterDelay('Monde', mockCallback);

  // Avancer les minuteurs de 1000 ms
  jest.advanceTimersByTime(1000);

  expect(mockCallback).toHaveBeenCalledTimes(1);
  expect(mockCallback).toHaveBeenCalledWith('Bonjour, Monde !');
});

// Restaurer les minuteurs réels si nécessaire ailleurs
jest.useRealTimers();

Organisation et structure des tests

À mesure que votre suite de tests s'agrandit, l'organisation devient essentielle pour la maintenabilité.

Blocs `describe` et blocs `it`

Utilisez describe pour regrouper les tests connexes et it (ou test) pour les cas de test individuels. Cette structure reflète la modularité de l'application.

Exemple : Tests structurés

            describe('Service d\'authentification utilisateur', () => {
  let authService;

  beforeEach(() => {
    // Configurer les mocks ou les instances de service avant chaque test
    authService = require('./authService');
    jest.spyOn(authService, 'login').mockImplementation(() => Promise.resolve({ token: 'fake_token' }));
  });

  afterEach(() => {
    // Nettoyer les mocks
    jest.restoreAllMocks();
  });

  describe('fonctionnalité de connexion', () => {
    it('devrait connecter avec succès un utilisateur avec des identifiants valides', async () => {
      const result = await authService.login('user@example.com', 'password123');
      expect(result.token).toBeDefined();
      // ... plus d'assertions ...
    });

    it('devrait échouer la connexion avec des identifiants invalides', async () => {
      jest.spyOn(authService, 'login').mockRejectedValue(new Error('Identifiants invalides'));
      await expect(authService.login('user@example.com', 'wrong_password')).rejects.toThrow('Identifiants invalides');
    });
  });

  describe('fonctionnalité de déconnexion', () => {
    it('devrait vider la session utilisateur', async () => {
      // Tester la logique de déconnexion...
    });
  });
});

Hooks d'initialisation et de nettoyage

beforeAll : S'exécute une fois avant tous les tests dans un bloc describe.
afterAll : S'exécute une fois après tous les tests dans un bloc describe.
beforeEach : S'exécute avant chaque test dans un bloc describe.
afterEach : S'exécute après chaque test dans un bloc describe.

Ces hooks sont essentiels pour configurer des données mockées, des connexions à la base de données ou pour nettoyer les ressources entre les tests.

Tester pour un public mondial

Lors du développement d'applications pour un public mondial, les considérations de test s'élargissent :

Internationalisation (i18n) et localisation (l10n)

Assurez-vous que votre interface utilisateur et vos messages s'adaptent correctement aux différentes langues et formats régionaux.

Snapshot d'interface utilisateur localisée : Testez que les différentes versions linguistiques de votre interface utilisateur s'affichent correctement à l'aide de tests de snapshots.
Mocker les données de locale : Mockez des bibliothèques comme react-intl ou i18next pour tester le comportement des composants avec différents messages de locale.
Formatage des dates, heures et devises : Testez que ceux-ci sont gérés correctement à l'aide de matchers personnalisés ou en mockant des bibliothèques d'internationalisation. Par exemple, vérifier qu'une date formatée pour l'Allemagne (JJ.MM.AAAA) apparaît différemment de celle pour les États-Unis (MM/JJ/AAAA).

Exemple : Tester le formatage de date localisé

            // dateUtils.js
export const formatLocalizedDate = (date, locale) => {
  return new Intl.DateTimeFormat(locale, { year: 'numeric', month: 'numeric', day: 'numeric' }).format(date);
};

// dateUtils.test.js
import { formatLocalizedDate } from './dateUtils';

test('formate la date correctement pour la locale américaine', () => {
  const date = new Date(2023, 10, 15); // 15 novembre 2023
  expect(formatLocalizedDate(date, 'en-US')).toBe('11/15/2023');
});

test('formate la date correctement pour la locale allemande', () => {
  const date = new Date(2023, 10, 15);
  expect(formatLocalizedDate(date, 'de-DE')).toBe('15.11.2023');
});

Prise en compte des fuseaux horaires

Testez comment votre application gère différents fuseaux horaires, en particulier pour des fonctionnalités comme la planification ou les mises à jour en temps réel. Mocker l'horloge système ou utiliser des bibliothèques qui abstraient les fuseaux horaires peut être bénéfique.

Nuances culturelles dans les données

Considérez comment les nombres, les devises et autres représentations de données peuvent être perçus ou attendus différemment selon les cultures. Les matchers personnalisés peuvent être particulièrement utiles ici.

Techniques et stratégies avancées

Développement Piloté par les Tests (TDD) et Développement Piloté par le Comportement (BDD)

Jest s'aligne bien avec les méthodologies TDD (Rouge-Vert-Refactoriser) et BDD (Étant donné-Quand-Alors). Écrivez des tests qui décrivent le comportement souhaité avant d'écrire le code d'implémentation. Cela garantit que le code est écrit en gardant la testabilité à l'esprit dès le départ.

Tests d'intégration avec Jest

Bien que Jest excelle dans les tests unitaires, il peut également être utilisé pour les tests d'intégration. Mocker moins de dépendances ou utiliser des outils comme l'option runInBand de Jest peut aider.

Exemple : Tester l'interaction avec une API (simplifié)

            // apiService.js
import axios from 'axios';

const API_BASE_URL = 'https://api.example.com';

export const createProduct = async (productData) => {
  const response = await axios.post(`${API_BASE_URL}/products`, productData);
  return response.data;
};

// apiService.test.js (Test d'intégration)
import axios from 'axios';
import { createProduct } from './apiService';

// Mocker axios pour les tests d'intégration afin de contrôler la couche réseau
jest.mock('axios');

test('crée un produit via l\'API', async () => {
  const mockProduct = { id: 1, name: 'Gadget' };
  const responseData = { success: true, product: mockProduct };

  axios.post.mockResolvedValue({
    data: responseData,
    status: 201,
    headers: { 'content-type': 'application/json' },
  });

  const newProductData = { name: 'Gadget', price: 99.99 };
  const result = await createProduct(newProductData);

  expect(axios.post).toHaveBeenCalledWith(`${process.env.API_BASE_URL || 'https://api.example.com'}/products`, newProductData);
  expect(result).toEqual(responseData);
});

Parallélisme et configuration

Jest peut exécuter des tests en parallèle pour accélérer l'exécution. Configurez cela dans votre jest.config.js. Par exemple, le réglage maxWorkers contrôle le nombre de processus parallèles.

Rapports de couverture

Utilisez le rapport de couverture intégré de Jest pour identifier les parties de votre base de code qui ne sont pas testées. Exécutez les tests avec --coverage pour générer des rapports détaillés.

            jest --coverage

L'examen des rapports de couverture aide à garantir que vos modèles de tests avancés couvrent efficacement la logique critique, y compris les chemins de code d'internationalisation et de localisation.

Conclusion

Maîtriser les modèles de tests avancés de Jest est une étape importante vers la création de logiciels fiables, maintenables et de haute qualité pour un public mondial. En utilisant efficacement le mocking, les tests de snapshots, les matchers personnalisés et les techniques de test asynchrone, vous pouvez améliorer la robustesse de votre suite de tests et gagner une plus grande confiance dans le comportement de votre application à travers divers scénarios et régions. L'adoption de ces modèles permet aux équipes de développement du monde entier d'offrir des expériences utilisateur exceptionnelles.

Commencez à intégrer ces techniques avancées dans votre flux de travail dès aujourd'hui pour élever vos pratiques de test JavaScript.