À propos de ce cours
Objectifs de la leçon
- Remplacer une dépendance par une doublure avec useValue.
- Simuler un repository TypeORM avec getRepositoryToken.
- Programmer et vérifier des fonctions simulées (jest.fn).
- Observer une vraie méthode avec jest.spyOn et maîtriser le temps.
Pourquoi simuler ?
Le service ci-dessous enregistre en base, envoie un e-mail et lit la configuration. Pour le tester « pour de vrai », il faudrait une base MySQL, un serveur SMTP et une date limite réelle. Le test serait lent, fragile (le serveur SMTP est en panne ?) et ne pourrait pas reproduire facilement certains cas (que se passe-t-il si l'e-mail échoue ?). On remplace donc les dépendances par des doublures dont on contrôle exactement le comportement.
📄 src/inscriptions/inscriptions.service.ts
import { ConflictException, Injectable, Logger, UnprocessableEntityException } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Inscription } from './inscription.entity';
import { MailService } from './mail.service';
@Injectable()
export class InscriptionsService {
private readonly logger = new Logger(InscriptionsService.name);
constructor(
@InjectRepository(Inscription) private readonly depot: Repository<Inscription>,
private readonly mail: MailService,
private readonly config: ConfigService,
) {}
async inscrire(email: string, formation: string) {
// Inscriptions closes après la date limite (configuration)
const limite = new Date(this.config.getOrThrow<string>('DATE_LIMITE_INSCRIPTION'));
if (new Date() > limite) throw new UnprocessableEntityException('Les inscriptions sont closes');
if (await this.depot.existsBy({ email, formation })) throw new ConflictException('Déjà inscrit à cette formation');
const inscription = await this.depot.save(this.depot.create({ email, formation }));
try {
await this.mail.envoyer(email, `Inscription à ${formation} confirmée`);
} catch (e) {
this.logger.warn(`E-mail non envoyé à ${email} : ${(e as Error).message}`); // l'inscription reste valide
}
return inscription;
}
}
La classe testée est réelle ; ses dépendances sont des doublures fournies avec useValue.
Les tests
📄 src/inscriptions/inscriptions.service.spec.ts
import { ConflictException, Logger, UnprocessableEntityException } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { Test } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { Inscription } from './inscription.entity';
import { InscriptionsService } from './inscriptions.service';
import { MailService } from './mail.service';
describe('InscriptionsService', () => {
let service: InscriptionsService;
// Les doublures (mocks) : des objets qui n'ont que les méthodes utilisées, toutes simulées par jest.fn()
const depot = {
existsBy: jest.fn(),
create: jest.fn((donnees) => donnees),
save: jest.fn(async (i) => ({ id: 1, creeLe: new Date('2026-09-01'), ...i })),
};
const mail = { envoyer: jest.fn() };
const config = { getOrThrow: jest.fn().mockReturnValue('2026-09-30') };
beforeEach(async () => {
jest.clearAllMocks(); // remet à zéro les compteurs d'appels entre deux tests
jest.useFakeTimers().setSystemTime(new Date('2026-09-15T10:00:00Z')); // « aujourd'hui » maîtrisé
const module = await Test.createTestingModule({
providers: [
InscriptionsService,
{ provide: getRepositoryToken(Inscription), useValue: depot },
{ provide: MailService, useValue: mail },
{ provide: ConfigService, useValue: config },
],
}).compile();
service = module.get(InscriptionsService);
});
afterEach(() => jest.useRealTimers());
it('enregistre l\'inscription et envoie un e-mail', async () => {
depot.existsBy.mockResolvedValue(false);
mail.envoyer.mockResolvedValue('<id-message>');
const r = await service.inscrire('sami@exemple.tn', 'NestJS');
expect(r).toMatchObject({ id: 1, email: 'sami@exemple.tn', formation: 'NestJS' });
expect(depot.save).toHaveBeenCalledTimes(1);
expect(mail.envoyer).toHaveBeenCalledWith('sami@exemple.tn', expect.stringContaining('NestJS'));
});
it('refuse un doublon sans rien enregistrer ni envoyer', async () => {
depot.existsBy.mockResolvedValue(true);
await expect(service.inscrire('sami@exemple.tn', 'NestJS')).rejects.toThrow(ConflictException);
expect(depot.save).not.toHaveBeenCalled();
expect(mail.envoyer).not.toHaveBeenCalled();
});
it('refuse après la date limite', async () => {
jest.setSystemTime(new Date('2026-10-01T08:00:00Z'));
await expect(service.inscrire('ines@exemple.tn', 'SQL')).rejects.toThrow(UnprocessableEntityException);
expect(depot.existsBy).not.toHaveBeenCalled();
});
it('garde l\'inscription si l\'e-mail échoue, et journalise l\'erreur', async () => {
depot.existsBy.mockResolvedValue(false);
mail.envoyer.mockRejectedValue(new Error('SMTP indisponible'));
const espion = jest.spyOn(Logger.prototype, 'warn').mockImplementation(() => undefined); // spy : observe sans afficher
await expect(service.inscrire('omar@exemple.tn', 'SQL')).resolves.toMatchObject({ id: 1 });
expect(espion).toHaveBeenCalledWith(expect.stringContaining('SMTP indisponible'));
espion.mockRestore();
});
});
{ provide: MailService, useValue: mail }: quand NestJS doit injecterMailService, il fournit notre objet (leçon 7.4). Pour un repository injecté par@InjectRepository(Inscription), le jeton estgetRepositoryToken(Inscription).jest.fn()crée une fonction simulée qui mémorise ses appels. On programme sa réponse :mockReturnValue,mockResolvedValue(promesse résolue),mockRejectedValue(promesse rejetée), ou une implémentationjest.fn((x) => …).- On vérifie les effets:
toHaveBeenCalledTimes(1),toHaveBeenCalledWith(…),not.toHaveBeenCalled(), avec des correspondances souples (expect.stringContaining,expect.objectContaining,expect.any(Date)). jest.clearAllMocks()efface les appels mémorisés entre deux tests ; sinontoHaveBeenCalledTimes(1)compterait aussi les appels des tests précédents.jest.spyOn(objet, 'methode')espionne une vraie méthode ;mockImplementationen remplace le contenu (ici : pas d'affichage du journal pendant les tests) ;mockRestore()rétablit l'original.jest.useFakeTimers().setSystemTime(…)fixe la date du jour : la règle « inscriptions closes après le 30 septembre » se teste n'importe quel jour de l'année.
Résultat réellement obtenu :
$ npm test -- inscriptions --verbose
PASS src/inscriptions/inscriptions.service.spec.ts
InscriptionsService
✓ enregistre l'inscription et envoie un e-mail (107 ms)
✓ refuse un doublon sans rien enregistrer ni envoyer (19 ms)
✓ refuse après la date limite (8 ms)
✓ garde l'inscription si l'e-mail échoue, et journalise l'erreur (4 ms)
Test Suites: 1 passed, 1 total
Tests: 4 passed, 4 total
Snapshots: 0 total
Time: 0.82 s
Ran all test suites matching inscriptions.
Une dépendance oubliée
Si le module de test ne fournit pas toutes les dépendances, la compilation du module échoue avec un message précis :
📄 src/inscriptions/inscriptions.service.spec.ts (incomplet)
import { Test } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { Inscription } from './inscription.entity';
import { InscriptionsService } from './inscriptions.service';
describe('InscriptionsService (dépendances oubliées)', () => {
it('se compile', async () => {
const module = await Test.createTestingModule({
providers: [InscriptionsService, { provide: getRepositoryToken(Inscription), useValue: {} }],
}).compile();
expect(module.get(InscriptionsService)).toBeDefined();
});
});
Résultat réellement obtenu :
$ npm test -- inscriptions
FAIL src/inscriptions/inscriptions.service.spec.ts
InscriptionsService (dépendances oubliées)
✕ se compile (13 ms)
● InscriptionsService (dépendances oubliées) › se compile
Nest can't resolve dependencies of the InscriptionsService (InscriptionRepository, ?, ConfigService). Please make sure that the argument MailService at index [1] is available in the RootTestModule module.
Potential solutions:
- Is RootTestModule a valid NestJS module?
- If MailService is a provider, is it part of the current RootTestModule?
- If MailService is exported from a separate @Module, is that module imported within RootTestModule?
@Module({
imports: [ /* the Module containing MailService */ ]
})
For more common dependency resolution issues, see: https://docs.nestjs.com/faq/common-errors
at TestingInjector.lookupComponentInParentModules (../node_modules/@nestjs/core/injector/injector.js:471:19)
Test Suites: 1 failed, 1 total
Tests: 1 failed, 1 total
Snapshots: 0 total
Time: 0.782 s
Ran all test suites matching inscriptions.
Le point d'interrogation montre la dépendance manquante (index 1 : MailService). C'est la même erreur qu'au chapitre 07 pour un module mal configuré.
Remplacer un provider d'un vrai module
Quand on importe un module entier, overrideProvider remplace un seul de ses providers. C'est la technique des tests e2e (leçon 17.4) :
const module = await Test.createTestingModule({ imports: [InscriptionsModule] })
.overrideProvider(MailService).useValue({ envoyer: jest.fn().mockResolvedValue('ok') })
.compile();
Les règles d'un bon mock: ne simulez que les frontières (base, réseau, e-mail, horloge, hasard), jamais la classe que vous testez ; donnez au mock seulement les méthodes utilisées ; ne testez pas les détails internes (« find a été appelé avec telles options ») sauf s'ils font partie du comportement attendu (« aucun e-mail n'est envoyé en cas de doublon »). Trop de mocks rendent les tests fragiles : ils échouent à chaque réorganisation du code alors que le comportement n'a pas changé.
Activités
Activité 1 Un cas supplémentaire
Ajoutez un test : si DATE_LIMITE_INSCRIPTION est absente, getOrThrow lève une erreur et rien n'est enregistré. Programmez le mock de configuration pour ce seul test.
Voir le corrigé
it('échoue si la configuration est absente', async () => {
config.getOrThrow.mockImplementationOnce(() => { throw new TypeError('Configuration key "DATE_LIMITE_INSCRIPTION" does not exist'); });
await expect(service.inscrire('a@b.tn', 'SQL')).rejects.toThrow('DATE_LIMITE_INSCRIPTION');
expect(depot.save).not.toHaveBeenCalled();
});
mockImplementationOnce ne vaut que pour le prochain appel : les autres tests gardent le comportement par défaut (mockReturnValue('2026-09-30')).
Activité 2 Simuler le service du TP 8
Écrivez les tests unitaires de AuthService.connecter (TP 8) en simulant le repository des utilisateurs et JwtService. Pour bcrypt, utilisez un vrai hachage calculé une fois dans beforeAll. Testez : succès, mot de passe faux, compte inconnu, compte désactivé.
Voir le corrigé
Doublures : { provide: getRepositoryToken(Utilisateur), useValue: { createQueryBuilder: … } } ou, plus simple, simulez la méthode du service des utilisateurs qui renvoie le compte avec son mot de passe ; { provide: JwtService, useValue: { signAsync: jest.fn().mockResolvedValue('jeton') } }. Les quatre cas d'échec doivent lever UnauthorizedException avec le même message (leçon 13.3), et signAsync ne doit pas être appelé.
Activité 3 Spy ou mock ?
Pour chaque besoin, jest.fn() en useValue ou jest.spyOn? (a) Remplacer l'envoi d'e-mails. (b) Vérifier qu'une méthode privée de calcul est appelée deux fois. (c) Faire échouer Math.random pour tester un tirage au sort. (d) Vérifier qu'un avertissement est journalisé.
Voir le corrigé
(a) Mock en useValue: c'est une dépendance injectée. (b) Ni l'un ni l'autre : c'est un détail interne ; testez le résultat. (c) jest.spyOn(Math, 'random').mockReturnValue(0.42), puis mockRestore(). (d) jest.spyOn(Logger.prototype, 'warn'), comme dans la leçon.
Activité 4 Repérer le problème
Ce fichier de test passe quand on lance ses tests un par un, mais l'un d'eux échoue quand on lance le fichier entier. Pourquoi ?
const mail = { envoyer: jest.fn() };
// … module construit dans beforeEach, SANS jest.clearAllMocks()
it('envoie un e-mail', async () => { /* … */ expect(mail.envoyer).toHaveBeenCalledTimes(1); });
it('envoie un e-mail à la seconde inscription aussi', async () => { /* … */ expect(mail.envoyer).toHaveBeenCalledTimes(1); });
Voir le corrigé
Le mock est créé une seule fois, au niveau du fichier : il garde le compte des appels du premier test, et le second voit 2 appels. Solution : jest.clearAllMocks() dans beforeEach (ou l'option clearMocks: true dans jest.config.ts), ou créer les mocks dans beforeEach.
À retenir
- Doublure : { provide: Dépendance, useValue: objetSimulé } ; repository : getRepositoryToken(Entité).
- jest.fn() + mockReturnValue / mockResolvedValue / mockRejectedValue / mockImplementationOnce.
- Vérifier les effets : toHaveBeenCalledWith, not.toHaveBeenCalled ; expect.objectContaining, stringContaining.
- jest.clearAllMocks() entre les tests ; jest.spyOn pour observer une vraie méthode ; useFakeTimers pour la date.
- Ne simuler que les frontières (base, réseau, e-mail, horloge), jamais la classe testée.
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 !