À propos de ce cours
Objectifs de la leçon
- Construire un module de test avec Test.createTestingModule.
- Tester un service : valeurs, objets, exceptions, code asynchrone.
- Tester un contrôleur avec son service.
- Garder des tests indépendants avec beforeEach.
Le service à tester
📄 src/notes/notes.service.ts
import { Injectable, NotFoundException } from '@nestjs/common';
import { mention, moyenne } from './calculs';
export interface Note { stagiaireId: number; matiere: string; valeur: number }
@Injectable()
export class NotesService {
private notes: Note[] = [];
ajouter(note: Note) {
if (note.valeur < 0 || note.valeur > 20) throw new RangeError('Une note est comprise entre 0 et 20');
this.notes.push(note);
return note;
}
bulletin(stagiaireId: number) {
const siennes = this.notes.filter((n) => n.stagiaireId === stagiaireId);
if (siennes.length === 0) throw new NotFoundException(`Aucune note pour le stagiaire ${stagiaireId}`);
const moy = moyenne(siennes.map((n) => n.valeur));
return { stagiaireId, notes: siennes.length, moyenne: moy, mention: mention(moy) };
}
async bulletinAsync(stagiaireId: number) {
await new Promise((r) => setTimeout(r, 10)); // comme une requête en base
return this.bulletin(stagiaireId);
}
}
Test.createTestingModule
Un service NestJS reçoit ses dépendances par injection. Plutôt que de faire new NotesService(…) à la main, on demande à NestJS de construire un petit module, exactement comme à l'exécution :
On déclare ce dont le test a besoin, NestJS construit et injecte.
📄 src/notes/notes.service.spec.ts
import { NotFoundException } from '@nestjs/common';
import { Test, TestingModule } from '@nestjs/testing';
import { NotesService } from './notes.service';
describe('NotesService', () => {
let service: NotesService;
// Avant CHAQUE test : un module neuf, donc un service neuf (aucune note héritée du test précédent)
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
providers: [NotesService],
}).compile();
service = module.get(NotesService);
});
it('est défini', () => {
expect(service).toBeDefined();
});
describe('bulletin()', () => {
it('calcule moyenne et mention à partir des notes du stagiaire', () => {
service.ajouter({ stagiaireId: 1, matiere: 'SQL', valeur: 16 });
service.ajouter({ stagiaireId: 1, matiere: 'NestJS', valeur: 13 });
service.ajouter({ stagiaireId: 2, matiere: 'SQL', valeur: 5 }); // un autre stagiaire
expect(service.bulletin(1)).toEqual({ stagiaireId: 1, notes: 2, moyenne: 14.5, mention: 'Bien' });
});
it('lève NotFoundException si le stagiaire n\'a aucune note', () => {
expect(() => service.bulletin(99)).toThrow(NotFoundException);
expect(() => service.bulletin(99)).toThrow('Aucune note pour le stagiaire 99');
});
it('fonctionne aussi en asynchrone', async () => {
service.ajouter({ stagiaireId: 3, matiere: 'SQL', valeur: 9 });
await expect(service.bulletinAsync(3)).resolves.toMatchObject({ mention: 'Insuffisant' });
await expect(service.bulletinAsync(4)).rejects.toThrow(NotFoundException);
});
});
describe('ajouter()', () => {
it.each([-1, 20.5, 25])('refuse la note %p', (valeur) => {
expect(() => service.ajouter({ stagiaireId: 1, matiere: 'SQL', valeur })).toThrow(RangeError);
});
it('accepte les bornes 0 et 20', () => {
expect(service.ajouter({ stagiaireId: 1, matiere: 'A', valeur: 0 })).toMatchObject({ valeur: 0 });
expect(service.ajouter({ stagiaireId: 1, matiere: 'B', valeur: 20 })).toMatchObject({ valeur: 20 });
});
});
});
Ce qu'il faut remarquer
beforeEachrecrée le module, donc un service neuf, avant chaque test : les notes ajoutées dans un test n'existent pas dans le suivant. Les tests peuvent s'exécuter dans n'importe quel ordre.toEqualcompare tout le contenu ;toMatchObjectseulement les propriétés indiquées (plus robuste quand l'objet contient des dates ou des identifiants).- Une exception synchrone se teste en passant une fonction à
expect:expect(() => service.bulletin(99)).toThrow(…). Sans la flèche, l'exception serait levée avantexpectet le test planterait. - Pour une promesse:
await expect(promesse).resolves…ou.rejects.toThrow(…). Oublierawaitfait passer le test même si la promesse échoue. toThrowaccepte une classe d'exception, un message ou une expression régulière.
Tester un contrôleur
📄 src/notes/notes.controller.ts
import { Body, Controller, Get, Param, ParseIntPipe, Post } from '@nestjs/common';
import { NotesService, type Note } from './notes.service';
@Controller('notes')
export class NotesController {
constructor(private readonly service: NotesService) {}
@Post()
ajouter(@Body() note: Note) {
return this.service.ajouter(note);
}
@Get('bulletin/:id')
bulletin(@Param('id', ParseIntPipe) id: number) {
return this.service.bulletin(id);
}
}
📄 src/notes/notes.controller.spec.ts
import { Test } from '@nestjs/testing';
import { NotesController } from './notes.controller';
import { NotesService } from './notes.service';
describe('NotesController', () => {
let controleur: NotesController;
beforeEach(async () => {
const module = await Test.createTestingModule({
controllers: [NotesController],
providers: [NotesService], // le vrai service : test d'intégration contrôleur + service
}).compile();
controleur = module.get(NotesController);
});
it('renvoie le bulletin après ajout de notes', () => {
controleur.ajouter({ stagiaireId: 7, matiere: 'SQL', valeur: 18 });
expect(controleur.bulletin(7).mention).toBe('Très bien');
});
});
Ici, le contrôleur est testé avec le vrai service : c'est un petit test d'intégration. Les décorateurs (@Get, ParseIntPipe…) ne sont pas exécutés : on appelle directement la méthode. Le routage, les pipes et les guards se testent en e2e (leçon 17.4).
Résultat réellement obtenu :
$ npm test -- notes --verbose
PASS src/notes/notes.service.spec.ts
NotesService
✓ est défini (152 ms)
bulletin()
✓ calcule moyenne et mention à partir des notes du stagiaire (6 ms)
✓ lève NotFoundException si le stagiaire n'a aucune note (34 ms)
✓ fonctionne aussi en asynchrone (25 ms)
ajouter()
✓ refuse la note -1 (7 ms)
✓ refuse la note 20.5 (7 ms)
✓ refuse la note 25 (4 ms)
✓ accepte les bornes 0 et 20 (4 ms)
PASS src/notes/notes.controller.spec.ts
NotesController
✓ renvoie le bulletin après ajout de notes (105 ms)
PASS 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 »
✓ mention(15.99) vaut « Bien »
✓ 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é »
Test Suites: 3 passed, 3 total
Tests: 19 passed, 19 total
Snapshots: 0 total
Time: 1.353 s
Ran all test suites matching notes.
Les fichiers générés et le mode watch
nest g service notes crée aussi notes.service.spec.ts, avec un seul test « should be defined ». C'est un point de départ : complétez-le, ou supprimez-le avec l'option --no-spec si vous préférez écrire vos tests vous-même.
npm test # tous les tests unitaires
npm test -- notes # seulement les fichiers dont le chemin contient « notes »
npm test -- -t "bulletin" # seulement les tests dont le nom contient « bulletin »
npm run test:watch # relance à chaque modification (touche a : tout, p : filtrer)
it.only(…) exécute uniquement ce test, it.skip(…) l'ignore : pratique pendant la mise au point, mais ne les commitez jamais (un only oublié désactive silencieusement tous les autres tests du fichier).
Activités
Activité 1 Compléter les tests
Ajoutez à NotesService une méthode supprimer(stagiaireId, matiere) qui lève NotFoundException si la note n'existe pas. Écrivez trois tests : suppression réussie (le bulletin ne la contient plus), note inexistante, et vérification que les notes des autres stagiaires sont intactes.
Voir le corrigé
describe('supprimer()', () => {
beforeEach(() => {
service.ajouter({ stagiaireId: 1, matiere: 'SQL', valeur: 12 });
service.ajouter({ stagiaireId: 1, matiere: 'JS', valeur: 16 });
service.ajouter({ stagiaireId: 2, matiere: 'SQL', valeur: 8 });
});
it('retire la note', () => {
service.supprimer(1, 'SQL');
expect(service.bulletin(1)).toMatchObject({ notes: 1, moyenne: 16 });
});
it('404 si la note n\'existe pas', () => {
expect(() => service.supprimer(1, 'Réseaux')).toThrow(NotFoundException);
});
it('ne touche pas aux autres stagiaires', () => {
service.supprimer(1, 'SQL');
expect(service.bulletin(2).moyenne).toBe(8);
});
});
Un beforeEach placé dans un describe ne s'applique qu'aux tests de ce bloc ; il s'exécute après celui du niveau supérieur.
Activité 2 Le piège du await
Ce test passe alors que bulletinAsync(4) échoue. Pourquoi ? Corrigez-le.
it('rejette pour un stagiaire sans note', () => {
expect(service.bulletinAsync(4)).rejects.toThrow(NotFoundException);
});
Voir le corrigé
Sans await (ni return), le test se termine avant que la promesse soit résolue : Jest considère qu'il a réussi. Correction : it('…', async () => { await expect(service.bulletinAsync(4)).rejects.toThrow(NotFoundException); });.
Activité 3 toEqual ou toMatchObject ?
Pour chaque vérification, quel matcher choisir ? (a) Le résultat de moyenne(); (b) une entité renvoyée par un service, avec id et creeLe générés ; (c) un tableau de messages d'erreur dont l'ordre peut varier ; (d) le bulletin complet de la leçon.
Voir le corrigé
(a) toBe (nombre). (b) toMatchObject({ email, formation }): on ne connaît pas la date exacte ; ou toEqual({ ..., creeLe: expect.any(Date) }). (c) toEqual(expect.arrayContaining([...])). (d) toEqual: on connaît toutes les valeurs, et une propriété en trop doit faire échouer le test.
Activité 4 Tester un service existant
Écrivez les tests unitaires de FormationsService du chapitre 06 (liste en mémoire : création, recherche, modification, suppression, 404). Visez au moins un test par chemin de chaque méthode.
Voir le corrigé
Structure attendue : un describe par méthode, un beforeEach qui crée le module, au moins un test « cas normal » et un test par exception (NotFoundException, conflit éventuel). Lancez npm test -- formations --verbose: le rapport doit se lire comme la spécification du service.
À retenir
- Test.createTestingModule({ providers, controllers }).compile() puis module.get(Classe).
- beforeEach : un module neuf par test, des tests indépendants.
- toBe, toEqual, toMatchObject, toThrow ; expect(() => …) pour une exception synchrone.
- await expect(promesse).resolves / .rejects : ne jamais oublier await.
- Tester un contrôleur = appeler ses méthodes ; routage, pipes et guards se testent en e2e.
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 !