À propos de ce cours
Objectifs de la leçon
- Expliquer à quoi servent les tests automatisés.
- Distinguer tests unitaires, d'intégration et end-to-end.
- Écrire et lancer un premier test avec Jest.
- Lire le rapport d'un test qui échoue.
Node.js 24 obligatoire pour les tests: depuis NestJS 12, les paquets @nestjs/* sont des modules ESM. Votre application CommonJS les charge sans problème avec Node.js 22, mais Jest ne sait le faire qu'à partir de Node.js 24.9. Avec Node.js 22, même le test généré par nest new échoue (« Must use import to load ES Module »). Vérifiez avec node -v; installez la version LTS 24 si besoin. Les projets NestJS 11 ne sont pas concernés.
Pourquoi tester ?
Jusqu'ici, nous avons vérifié nos API à la main : un fichier .http, des requêtes, un coup d'œil aux réponses. C'est utile, mais cela ne passe pas à l'échelle : après chaque modification, il faudrait tout revérifier. Un test automatisé est un programme qui vérifie un comportement attendu, et que l'on relance en quelques secondes, à chaque modification, avant chaque fusion de branche et chaque mise en production.
- Détecter les régressions: une modification casse une fonctionnalité qui marchait.
- Modifier sans crainte: on peut réorganiser le code (refactoriser), les tests disent si le comportement est conservé.
- Documenter: un test dit précisément ce que le code doit faire (« refuse un 4e emprunt »).
- Mieux concevoir: un code difficile à tester est souvent trop couplé (leçon 17.3).
La pyramide des tests
Beaucoup de tests unitaires rapides, moins de tests d'intégration, quelques tests end-to-end.
| Type | Ce qui est testé | Dans NestJS | Leçon |
|---|---|---|---|
| Unitaire | une fonction ou une classe seule ; ses dépendances sont simulées | src/**/*.spec.ts, npm test | 17.2, 17.3 |
| Intégration | plusieurs classes réelles ensemble (contrôleur + service, service + base) | Test.createTestingModule avec de vrais providers | 17.2 |
| End-to-end (e2e) | l'API entière par des requêtes HTTP, comme un vrai client | test/*.e2e-spec.ts, npm run test:e2e, Supertest | 17.4 |
Jest
nest new installe et configure Jest, le cadre de test le plus utilisé en JavaScript : jest.config.ts pour les tests unitaires (fichiers *.spec.ts de src/), test/jest-e2e.json pour les tests e2e, et les scripts test, test:watch, test:cov, test:e2e. ts-jest compile le TypeScript à la volée.
Le projet tel que créé par nest new, testé avec Node.js 22 puis 24 :
$ node -v && npm test (Node.js 22)
v22.23.4
FAIL src/app.controller.spec.ts
● Test suite failed to run
Must use import to load ES Module: node_modules/@nestjs/testing/index.js
The file contains ESM syntax (import/export) that could not be executed as CommonJS. Either:
- Configure a transform (e.g. babel-jest) that compiles this file to CommonJS (see https://jestjs.io/docs/code-transformation)
- If the file is in "node_modules", allow it to be transformed by adjusting "transformIgnorePatterns" (see https://jestjs.io/docs/configuration#transformignorepatterns-arraystring)
- Use Node v24.9+ where Jest supports require(esm) natively (see https://jestjs.io/docs/ecmascript-modules#require-of-esm)
> 1 | import { Test, TestingModule } from '@nestjs/testing';
| ^
$ node -v && npm test (Node.js 24)
v24.22.3
PASS src/app.controller.spec.ts
AppController
root
✓ should return "Hello World!" (102 ms)
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 total
Time: 0.624 s
Ran all test suites.
Un premier test
Commençons par le plus simple : une fonction pure, dont le résultat ne dépend que de ses paramètres.
📄 src/notes/calculs.ts
// Fonctions « pures » : même entrée → même sortie, aucun effet de bord. Les plus faciles à tester.
export function moyenne(notes: number[]): number | null {
if (notes.length === 0) return null;
const somme = notes.reduce((total, n) => total + n, 0);
return Math.round((somme / notes.length) * 100) / 100;
}
export function mention(moy: number | null): string {
if (moy === null) return 'Non évalué';
if (moy >= 16) return 'Très bien';
if (moy >= 14) return 'Bien';
if (moy >= 12) return 'Assez bien';
if (moy >= 10) return 'Passable';
return 'Insuffisant';
}
📄 src/notes/calculs.spec.ts
import { mention, moyenne } from './calculs';
describe('moyenne()', () => {
it('calcule la moyenne de plusieurs notes', () => {
// Préparer (Arrange)
const notes = [12, 15, 18];
// Agir (Act)
const resultat = moyenne(notes);
// Vérifier (Assert)
expect(resultat).toBe(15);
});
it('arrondit à deux décimales', () => {
expect(moyenne([10, 11, 11])).toBe(10.67);
});
it('renvoie null pour une liste vide', () => {
expect(moyenne([])).toBeNull();
});
});
describe('mention()', () => {
// Un test par ligne du tableau : idéal pour les valeurs limites
it.each([
[16, 'Très bien'],
[15.99, 'Bien'],
[14, 'Bien'],
[12, 'Assez bien'],
[10, 'Passable'],
[9.99, 'Insuffisant'],
[null, 'Non évalué'],
])('mention(%p) vaut « %s »', (moy, attendu) => {
expect(mention(moy)).toBe(attendu);
});
});
describe('…', () => { … })regroupe les tests d'un même sujet ;it('…', () => { … })(outest) décrit un comportement, en une phrase.- Chaque test suit le schéma Préparer → Agir → Vérifier (Arrange, Act, Assert).
expect(valeur)suivi d'un matcher:toBe(égalité stricte),toBeNull,toEqual(égalité de contenu d'objets),toThrow…it.eachexécute le même test pour chaque ligne d'un tableau : parfait pour les valeurs limites (16 et 15,99 ; 10 et 9,99), là où se cachent la plupart des erreurs.
Résultat réellement obtenu :
$ npm test -- --verbose
PASS src/notes/calculs.spec.ts
moyenne()
✓ calcule la moyenne de plusieurs notes (2 ms)
✓ arrondit à deux décimales
✓ renvoie null pour une liste vide
mention()
✓ mention(16) vaut « Très bien »
✓ mention(15.99) vaut « Bien »
✓ mention(14) vaut « Bien »
✓ mention(12) vaut « Assez bien »
✓ mention(10) vaut « Passable »
✓ mention(9.99) vaut « Insuffisant » (1 ms)
✓ mention(null) vaut « Non évalué »
Test Suites: 1 passed, 1 total
Tests: 10 passed, 10 total
Snapshots: 0 total
Time: 0.163 s
Ran all test suites.
Lire un échec
Introduisons une erreur volontaire : moy > 16 au lieu de moy >= 16.
Résultat réellement obtenu :
$ npm test (après avoir remplacé >= 16 par > 16)
FAIL src/notes/calculs.spec.ts
moyenne()
✓ calcule la moyenne de plusieurs notes (4 ms)
✓ arrondit à deux décimales (1 ms)
✓ renvoie null pour une liste vide (1 ms)
mention()
✕ mention(16) vaut « Très bien » (5 ms)
✓ mention(15.99) vaut « Bien » (1 ms)
✓ mention(14) vaut « Bien » (1 ms)
✓ mention(12) vaut « Assez bien » (1 ms)
✓ mention(10) vaut « Passable »
✓ mention(9.99) vaut « Insuffisant »
✓ mention(null) vaut « Non évalué »
● mention() › mention(16) vaut « Très bien »
expect(received).toBe(expected) // Object.is equality
Expected: "Très bien"
Received: "Bien"
31 | [null, 'Non évalué'],
32 | ])('mention(%p) vaut « %s »', (moy, attendu) => {
> 33 | expect(mention(moy)).toBe(attendu);
| ^
34 | });
35 | });
36 |
at src/notes/calculs.spec.ts:33:26
Test Suites: 1 failed, 1 total
Tests: 1 failed, 9 passed, 10 total
Snapshots: 0 total
Time: 0.309 s
Ran all test suites.
Jest indique le test en échec (mention(16) vaut « Très bien »), la valeur attendue et la valeur reçue, et la ligne concernée. Les 9 autres tests passent : seule la valeur limite 16 révèle l'erreur. Sans le test 16, le bug serait passé inaperçu.
Bonnes habitudes: un test = un comportement ; un nom qui décrit le comportement attendu (« refuse un doublon »), pas la méthode (« test inscrire 2 ») ; des tests indépendants les uns des autres ; lancer npm run test:watch pendant le développement : Jest relance les tests concernés à chaque enregistrement.
Activités
Activité 1 Quel type de test ?
Classez : (a) vérifier que moyenne([]) renvoie null; (b) vérifier que POST /api/livres sans jeton renvoie 401 ; (c) vérifier que NotesController.bulletin() renvoie la mention calculée par le vrai NotesService; (d) vérifier que deux emprunts simultanés du dernier exemplaire ne réussissent pas tous les deux.
Voir le corrigé
(a) Unitaire. (b) End-to-end : il faut l'application complète avec ses guards. (c) Intégration : deux classes réelles ensemble. (d) End-to-end avec une vraie base : seul un vrai serveur de base de données applique les verrous (TP 11).
Activité 2 Les valeurs limites
Écrivez les tests de estMajeur(dateNaissance: string, aujourdHui: string): boolean. Quelles dates choisir ? Écrivez la fonction ensuite et faites passer les tests.
Voir le corrigé
it.each([
['2008-11-15', '2026-11-15', true], // 18 ans aujourd'hui
['2008-11-16', '2026-11-15', false], // 18 ans demain
['2008-11-14', '2026-11-15', true],
['2008-02-29', '2026-02-28', false], // né un 29 février
['2008-02-29', '2026-03-01', true],
])('né le %s, le %s → %p', (naissance, jour, attendu) => {
expect(estMajeur(naissance, jour)).toBe(attendu);
});
Le jour anniversaire, la veille et le lendemain, puis le cas piège du 29 février. Écrire les tests avant le code (démarche TDD, Test-Driven Development) oblige à préciser le comportement attendu.
Activité 3 Corriger le test, pas le code ?
Un test échoue après une modification. Un collègue propose de modifier la valeur attendue dans le test « pour que ça passe ». Quand est-ce légitime, et quand est-ce une erreur ?
Voir le corrigé
Légitime si la règle a changé volontairement (la mention « Très bien » passe à 17 sur décision pédagogique) : le test doit suivre la nouvelle règle. Une erreur si la règle n'a pas changé : le test vient justement de détecter une régression, et c'est le code qu'il faut corriger. Avant de toucher un test, demandez-vous ce que le comportement doit être.
Activité 4 Moyenne pondérée
Ajoutez moyennePonderee(notes: { valeur: number; coefficient: number }[]) à calculs.ts, avec ses tests : cas normal, coefficient 0 ignoré, liste vide (null), coefficients tous nuls (null).
Voir le corrigé
export function moyennePonderee(notes: { valeur: number; coefficient: number }[]): number | null {
const total = notes.reduce((t, n) => t + n.coefficient, 0);
if (total === 0) return null;
return Math.round((notes.reduce((s, n) => s + n.valeur * n.coefficient, 0) / total) * 100) / 100;
}
it('pondère les notes', () => expect(moyennePonderee([{ valeur: 10, coefficient: 1 }, { valeur: 16, coefficient: 2 }])).toBe(14));
it('liste vide ou coefficients nuls → null', () => {
expect(moyennePonderee([])).toBeNull();
expect(moyennePonderee([{ valeur: 12, coefficient: 0 }])).toBeNull();
});
À retenir
- Un test automatisé vérifie un comportement en quelques millisecondes, à chaque modification.
- Pyramide : beaucoup d'unitaires, des tests d'intégration, quelques e2e.
- Jest est configuré par nest new : *.spec.ts (npm test), test/*.e2e-spec.ts (npm run test:e2e).
- describe / it / expect + matchers ; Préparer → Agir → Vérifier ; it.each pour les valeurs limites.
- NestJS 12 : Node.js 24.9 minimum pour lancer Jest.
Cet article vous a-t-il aidé ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !