À propos de ce cours
Ce TP ajoute une suite de tests complète au dépôt api-bibliotheque du TP 7, publiée sur GitHub. Les tests unitaires couvrent les dates avec une horloge simulée, le filtre d'erreurs TypeORM et LivresService avec ses quatre dépôts simulés. Ils couvrent aussi EmpruntsService avec une transaction simulée : limites, doublons, stock et retards. Les tests e2e utilisent une base MySQL dédiée, configurée par .env.test : validation, erreurs de contraintes, parcours d'emprunt, et deux emprunts simultanés du dernier exemplaire. La couverture est mesurée et analysée. Correction exécutée et grille sur 20.
Objectifs du TP
- Écrire les tests unitaires des règles métier d'une vraie API, en simulant dépôts et transactions.
- Écrire des tests e2e sur une base de données de test isolée.
- Vérifier ce que seuls les tests avec une vraie base peuvent vérifier : contraintes et verrous.
- Mesurer la couverture et l'analyser.
Durée: 6 h | Prérequis: TP 7 (dépôt api-bibliotheque), leçons 17.1 à 17.5, Node.js 24 | Livrable: le dépôt api-bibliotheque avec l'étiquette v1.1.0.
Les règles métier en tests unitaires rapides, l'intégration réelle en e2e.
Cahier des charges
- Unitaires (aucune base, aucun réseau) :
date.ts;TypeOrmErreursFilter(chaque code d'erreur) ;LivresService(création, auteur inexistant, catégories inconnues, modification du stock, suppression refusée) ;EmpruntsService(emprunt nominal avec verrou, 404, adhérent inactif, limite de 3, doublon, plus d'exemplaire, retour, retard, double retour). - E2e sur la base
bibliotheque_test, vidée et recréée à chaque exécution : recherche paginée, validation, ISBN en double (409), suppression d'un auteur qui a des livres (409), parcours d'emprunt et de retour, deux emprunts simultanés du dernier exemplaire (un seul doit réussir), statistiques. - Un garde-fou empêche les tests e2e de s'exécuter sur une autre base que la base de test.
- Couverture mesurée pour les deux suites, fichiers sans logique exclus.
Partie 1 Préparer le dépôt
- Vérifiez
node -v(24.9 minimum, leçon 17.1). Dansapi-bibliotheque, créez la branchetp11-tests. - Créez
src/configurer-app.ts(leçon 17.4) et utilisez-le dansmain.ts. - Dans
AppModule:ConfigModule.forRoot({ isGlobal: true, envFilePath: process.env.NODE_ENV === 'test' ? '.env.test' : '.env' }). Créez.env.testet la basebibliotheque_test(CREATE DATABASE bibliotheque_test;, droits pourapc_dev). - Supprimez les fichiers d'exemple générés (
app.controller.spec.ts,test/app.e2e-spec.ts) s'ils ne correspondent plus à votre code. Commit :test: configuration des tests.
Partie 2 Tests unitaires des utilitaires
date.spec.tsavecjest.useFakeTimers().setSystemTime(…): choisissez une date qui fait changer de mois et d'année.typeorm-erreurs.filter.spec.ts: unArgumentsHostsimulé, une réponse simulée (statusqui renvoiethis), unit.eachpar code d'erreur.- Commit :
test: utilitaires.
Partie 3 LivresService
- Quatre dépôts simulés avec
getRepositoryToken. - Pour chaque règle : un test du cas accepté et un test du cas refusé, en vérifiant aussi l'absence d'effet (
savenon appelé). - Commit :
test: LivresService.
Partie 4 EmpruntsService
- Un faux
EntityManageret une fausseDataSourcedonttransaction(rappel)appelle directement le rappel ; le jeton estgetDataSourceToken(). - Une fonction
casNominal()qui programme les réponses par défaut ; chaque test n'en modifie qu'une. - Vérifiez que le livre est lu avec le verrou
pessimistic_write, et la date de retour prévue avec l'horloge simulée. - Commit :
test: EmpruntsService.
Partie 5 Tests e2e
- Dans
beforeAll: application avecconfigurerApp, garde-fou sur le nom de la base,synchronize(true)(supprime et recrée les tables d'après les entités), données minimales. - Les scénarios du cahier des charges, dont les deux emprunts lancés en même temps avec
Promise.all. afterAll(() => app.close()). Commit :test: e2e de l'API.
Partie 6 Couverture et livraison
- Exclusions dans
jest.config.tset danstest/jest-e2e.json(racine du projet, comme à la leçon 17.5). Ajoutezcoverage/etcoverage-e2e/à.gitignore. - Dans le README : comment lancer les tests, la base de test à créer, et un tableau des taux de couverture obtenus avec votre analyse (ce qui n'est pas couvert, et pourquoi).
- Fusion, push, étiquette
v1.1.0.
Résultat attendu
Les trois commandes exécutées avec la correction (Node.js 24, base MariaDB de test) :
$ npm test -- --verbose
PASS src/emprunts/emprunts.service.spec.ts
EmpruntsService
emprunter()
✓ enregistre l'emprunt pour 14 jours et décrémente les disponibles (132 ms)
✓ 404 si le livre est introuvable (16 ms)
✓ 422 si l'adhérent est inactif (5 ms)
✓ 422 au-delà de 3 emprunts en cours (4 ms)
✓ 409 si le même livre est déjà emprunté par l'adhérent (5 ms)
✓ 409 s'il ne reste aucun exemplaire, sans rien modifier (5 ms)
rendre()
✓ enregistre le retour, incrémente les disponibles et signale le retard (4 ms)
✓ 409 si l'emprunt est déjà rendu (4 ms)
PASS src/livres/livres.service.spec.ts
LivresService
create()
✓ crée le livre avec autant d'exemplaires disponibles que d'exemplaires (82 ms)
✓ refuse un auteur inexistant (404) sans rien enregistrer (8 ms)
✓ refuse des catégories inconnues (400) (3 ms)
update()
✓ recalcule les disponibles quand le nombre d'exemplaires change (3 ms)
✓ refuse de descendre sous le nombre d'exemplaires empruntés (409) (2 ms)
✓ 404 si le livre n'existe pas (1 ms)
remove()
✓ refuse la suppression si des emprunts sont en cours (409) (2 ms)
✓ supprime sinon (2 ms)
PASS src/common/typeorm-erreurs.filter.spec.ts
TypeOrmErreursFilter
✓ ER_DUP_ENTRY → 409 (4 ms)
✓ ER_ROW_IS_REFERENCED_2 → 409 (1 ms)
✓ ER_NO_REFERENCED_ROW_2 → 400
✓ ER_INCONNUE → 500
✓ undefined → 500 (1 ms)
PASS src/common/date.spec.ts
dates
✓ aujourdHui() renvoie la date du jour au format AAAA-MM-JJ (3 ms)
✓ dansNJours() passe correctement au mois et à l'année suivants (2 ms)
Test Suites: 4 passed, 4 total
Tests: 23 passed, 23 total
Snapshots: 0 total
Time: 1.74 s
Ran all test suites.
$ npm run test:cov
----------------------------|---------|----------|---------|---------|-------------------
File | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
----------------------------|---------|----------|---------|---------|-------------------
All files | 47.66 | 38.88 | 32.55 | 49.43 |
src | 0 | 100 | 0 | 0 |
configurer-app.ts | 0 | 100 | 0 | 0 | 1-7
src/adherents | 0 | 0 | 0 | 0 |
adherents.controller.ts | 0 | 0 | 0 | 0 | 1-24
src/auteurs | 0 | 0 | 0 | 0 |
auteurs.controller.ts | 0 | 0 | 0 | 0 | 1-27
auteurs.service.ts | 0 | 0 | 0 | 0 | 1-27
src/common | 100 | 100 | 100 | 100 |
date.ts | 100 | 100 | 100 | 100 |
typeorm-erreurs.filter.ts | 100 | 100 | 100 | 100 |
src/emprunts | 65.62 | 60.71 | 38.46 | 67.92 |
emprunts.controller.ts | 0 | 0 | 0 | 0 | 1-26
emprunts.service.ts | 85.71 | 85 | 62.5 | 90 | 58-78
src/livres | 54.32 | 41.17 | 46.15 | 58.2 |
livres.controller.ts | 0 | 0 | 0 | 0 | 1-32
livres.service.ts | 68.75 | 53.84 | 85.71 | 75 | 20-37,50,76-78
----------------------------|---------|----------|---------|---------|-------------------
Test Suites: 4 passed, 4 total
Tests: 23 passed, 23 total
Snapshots: 0 total
Time: 2.355 s
Ran all test suites.
$ npm run test:e2e -- --verbose --coverage
PASS test/bibliotheque.e2e-spec.ts
API bibliothèque (e2e, base MySQL de test)
Livres
✓ GET /api/livres?q=mis → recherche par titre, avec méta de pagination (18 ms)
✓ POST /api/livres invalide → 400 avec les messages (5 ms)
✓ POST /api/livres avec un ISBN déjà utilisé → 409 (filtre TypeORM) (23 ms)
✓ DELETE /api/auteurs/:id d'un auteur qui a des livres → 409 (15 ms)
Emprunts
✓ POST /api/emprunts → 201 et un exemplaire de moins (31 ms)
✓ le même livre une deuxième fois → 409 (14 ms)
✓ PATCH /api/emprunts/:id/retour → 200, puis 409 au second retour (28 ms)
✓ deux emprunts SIMULTANÉS du dernier exemplaire : un seul réussit (37 ms)
✓ GET /api/emprunts/statistiques (5 ms)
----------------------------|---------|----------|---------|---------|-------------------
File | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
----------------------------|---------|----------|---------|---------|-------------------
All files | 75.7 | 56.34 | 74.41 | 78.97 |
src | 100 | 100 | 100 | 100 |
configurer-app.ts | 100 | 100 | 100 | 100 |
src/adherents | 75 | 60 | 66.66 | 76.92 |
adherents.controller.ts | 75 | 60 | 66.66 | 76.92 | 18-24
src/auteurs | 71.87 | 56.25 | 60 | 73.07 |
auteurs.controller.ts | 86.66 | 75 | 60 | 84.61 | 11,16
auteurs.service.ts | 58.82 | 37.5 | 60 | 61.53 | 12-18,27
src/common | 100 | 50 | 100 | 100 |
date.ts | 100 | 100 | 100 | 100 |
typeorm-erreurs.filter.ts | 100 | 50 | 100 | 100 | 15
src/emprunts | 89.06 | 71.42 | 84.61 | 94.33 |
emprunts.controller.ts | 93.33 | 75 | 80 | 92.3 | 21
emprunts.service.ts | 87.75 | 70 | 87.5 | 95 | 28,58
src/livres | 60.49 | 50 | 69.23 | 64.17 |
livres.controller.ts | 88.23 | 75 | 66.66 | 86.66 | 26,32
livres.service.ts | 53.12 | 42.3 | 71.42 | 57.69 | 28,55,66-92
----------------------------|---------|----------|---------|---------|-------------------
Test Suites: 1 passed, 1 total
Tests: 9 passed, 9 total
Snapshots: 0 total
Time: 2.093 s
Ran all test suites.
Analyse du résultat
- Les 23 tests unitaires s'exécutent en 2 secondes, sans base de données ; les 9 tests e2e en 3 à 4 secondes, avec la base.
- Le test des emprunts simultanés passe : un 201, un 409, et 0 exemplaire disponible. C'est le verrou
pessimistic_writedu TP 7 qui le garantit. Sans lui, les deux emprunts réussiraient (leçon 11.9). Ce comportement ne peut être prouvé qu'avec une vraie base. - Couverture unitaire : 100 % pour les utilitaires, environ 86 % des instructions d'
EmpruntsService. Les méthodesenRetardetstatistiques(lignes 58-78), simples requêtes, sont laissées aux e2e. Les contrôleurs sont à 0 en unitaire, mais couverts par les e2e. - Couverture e2e :
livres.service.tsà 53 % seulement, car la modification et la suppression de livres ne sont pas testées en e2e, ni la recherche par catégorie ou disponibilité. C'est la piste d'amélioration principale (activités ci-dessous).
Pour aller plus loin
- Compléter les e2e :
PATCHetDELETEdes livres, filtrescategorie,disponible,tri, emprunts en retard (en insérant un emprunt daté dans le passé). - Exécuter les migrations au lieu de
synchronize(true)dans les e2e (source.dropDatabase()puissource.runMigrations()), pour tester aussi les migrations. - Intégration continue : un workflow GitHub Actions qui démarre un service MySQL, crée
.env.testet lance les deux suites à chaque push. - Tests unitaires de
AuteursServiceet des contrôleurs.
Correction
src/configurer-app.ts
import { INestApplication, ValidationPipe } from '@nestjs/common';
// Réglages communs à main.ts ET aux tests e2e : une seule source de vérité
export function configurerApp(app: INestApplication) {
app.setGlobalPrefix('api');
app.useGlobalPipes(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true }));
return app;
}
src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { configurerApp } from './configurer-app';
async function bootstrap() {
const app = configurerApp(await NestFactory.create(AppModule));
await app.listen(process.env.PORT ?? 3000);
}
bootstrap();
.env.test
# Base dédiée aux tests e2e : elle est VIDÉE à chaque exécution
DB_HOTE=localhost
DB_PORT=3306
DB_UTILISATEUR=apc_dev
DB_MOT_DE_PASSE=secret_dev
DB_NOM=bibliotheque_test
src/common/date.spec.ts
import { aujourdHui, dansNJours } from './date';
describe('dates', () => {
beforeEach(() => jest.useFakeTimers().setSystemTime(new Date('2026-12-25T10:00:00Z')));
afterEach(() => jest.useRealTimers());
it('aujourdHui() renvoie la date du jour au format AAAA-MM-JJ', () => {
expect(aujourdHui()).toBe('2026-12-25');
});
it('dansNJours() passe correctement au mois et à l\'année suivants', () => {
expect(dansNJours(14)).toBe('2027-01-08');
expect(dansNJours(0)).toBe('2026-12-25');
});
});
src/common/typeorm-erreurs.filter.spec.ts
import { ArgumentsHost } from '@nestjs/common';
import { QueryFailedError } from 'typeorm';
import { TypeOrmErreursFilter } from './typeorm-erreurs.filter';
describe('TypeOrmErreursFilter', () => {
const filtre = new TypeOrmErreursFilter();
const res = { status: jest.fn().mockReturnThis(), json: jest.fn() };
const host = { switchToHttp: () => ({ getResponse: () => res }) } as unknown as ArgumentsHost;
const erreur = (code?: string) => Object.assign(new QueryFailedError('INSERT …', [], new Error('mysql')), { code });
beforeEach(() => jest.clearAllMocks());
it.each([
['ER_DUP_ENTRY', 409, 'Cette valeur existe déjà (champ unique)'],
['ER_ROW_IS_REFERENCED_2', 409, 'Suppression impossible : cet élément est utilisé ailleurs'],
['ER_NO_REFERENCED_ROW_2', 400, 'Référence vers un élément inexistant'],
['ER_INCONNUE', 500, 'Erreur de base de données'],
[undefined, 500, 'Erreur de base de données'],
])('%s → %i', (code, statut, message) => {
filtre.catch(erreur(code), host);
expect(res.status).toHaveBeenCalledWith(statut);
expect(res.json).toHaveBeenCalledWith({ statusCode: statut, message });
});
});
src/livres/livres.service.spec.ts
import { BadRequestException, ConflictException, NotFoundException } from '@nestjs/common';
import { Test } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { Auteur } from '../auteurs/auteur.entity';
import { Emprunt } from '../emprunts/emprunt.entity';
import { Categorie } from './categorie.entity';
import { Livre } from './livre.entity';
import { LivresService } from './livres.service';
describe('LivresService', () => {
let service: LivresService;
const livres = { create: jest.fn((d) => d), save: jest.fn(async (l) => ({ id: 10, ...l })), findOne: jest.fn(), remove: jest.fn() };
const auteurs = { existsBy: jest.fn() };
const categories = { findBy: jest.fn() };
const emprunts = { existsBy: jest.fn() };
const dto = { isbn: '9782070360024', titre: "L'Étranger", anneePublication: 1942, exemplaires: 3, auteurId: 5 };
const livreExistant = () => ({ id: 1, titre: 'Les Misérables', exemplaires: 5, disponibles: 2, auteurId: 1, categories: [] });
beforeEach(async () => {
jest.clearAllMocks();
const module = await Test.createTestingModule({
providers: [
LivresService,
{ provide: getRepositoryToken(Livre), useValue: livres },
{ provide: getRepositoryToken(Auteur), useValue: auteurs },
{ provide: getRepositoryToken(Categorie), useValue: categories },
{ provide: getRepositoryToken(Emprunt), useValue: emprunts },
],
}).compile();
service = module.get(LivresService);
});
describe('create()', () => {
it('crée le livre avec autant d\'exemplaires disponibles que d\'exemplaires', async () => {
auteurs.existsBy.mockResolvedValue(true);
const r = await service.create(dto);
expect(r).toMatchObject({ id: 10, exemplaires: 3, disponibles: 3, categories: [] });
expect(categories.findBy).not.toHaveBeenCalled(); // pas de catégories demandées
});
it('refuse un auteur inexistant (404) sans rien enregistrer', async () => {
auteurs.existsBy.mockResolvedValue(false);
await expect(service.create(dto)).rejects.toThrow(new NotFoundException('Auteur 5 introuvable'));
expect(livres.save).not.toHaveBeenCalled();
});
it('refuse des catégories inconnues (400)', async () => {
auteurs.existsBy.mockResolvedValue(true);
categories.findBy.mockResolvedValue([{ id: 1 }]); // 2 demandées, 1 trouvée
await expect(service.create({ ...dto, categorieIds: [1, 99] })).rejects.toThrow(BadRequestException);
});
});
describe('update()', () => {
it('recalcule les disponibles quand le nombre d\'exemplaires change', async () => {
livres.findOne.mockResolvedValue(livreExistant()); // 5 exemplaires, 2 disponibles → 3 empruntés
await service.update(1, { exemplaires: 4 });
expect(livres.save).toHaveBeenCalledWith(expect.objectContaining({ exemplaires: 4, disponibles: 1 }));
});
it('refuse de descendre sous le nombre d\'exemplaires empruntés (409)', async () => {
livres.findOne.mockResolvedValue(livreExistant());
await expect(service.update(1, { exemplaires: 2 })).rejects.toThrow(
'3 exemplaire(s) sont empruntés : impossible de descendre à 2',
);
expect(livres.save).not.toHaveBeenCalled();
});
it('404 si le livre n\'existe pas', async () => {
livres.findOne.mockResolvedValue(null);
await expect(service.update(99, { titre: 'X' })).rejects.toThrow(NotFoundException);
});
});
describe('remove()', () => {
it('refuse la suppression si des emprunts sont en cours (409)', async () => {
livres.findOne.mockResolvedValue(livreExistant());
emprunts.existsBy.mockResolvedValue(true);
await expect(service.remove(1)).rejects.toThrow(ConflictException);
expect(livres.remove).not.toHaveBeenCalled();
});
it('supprime sinon', async () => {
livres.findOne.mockResolvedValue(livreExistant());
emprunts.existsBy.mockResolvedValue(false);
await service.remove(1);
expect(livres.remove).toHaveBeenCalledWith(expect.objectContaining({ id: 1 }));
});
});
});
src/emprunts/emprunts.service.spec.ts
import { ConflictException, NotFoundException, UnprocessableEntityException } from '@nestjs/common';
import { Test } from '@nestjs/testing';
import { getDataSourceToken } from '@nestjs/typeorm';
import { Livre } from '../livres/livre.entity';
import { DUREE_JOURS, EmpruntsService, MAX_EMPRUNTS } from './emprunts.service';
describe('EmpruntsService', () => {
let service: EmpruntsService;
// Faux EntityManager : seules les méthodes utilisées dans les transactions
const m = {
findOne: jest.fn(), findOneBy: jest.fn(), countBy: jest.fn(), existsBy: jest.fn(),
decrement: jest.fn(), increment: jest.fn(),
create: jest.fn((_entite, donnees) => donnees),
save: jest.fn(async (e) => ({ id: 7, ...e })),
};
// Fausse DataSource : transaction() exécute directement le rappel avec le faux EntityManager
const source = { transaction: jest.fn((rappel: (em: typeof m) => unknown) => rappel(m)) };
const livre = (disponibles = 2) => ({ id: 1, titre: 'Les Misérables', disponibles });
const adherent = (actif = true) => ({ id: 3, prenom: 'Sami', nom: 'Ben Ali', actif });
beforeEach(async () => {
jest.clearAllMocks();
jest.useFakeTimers().setSystemTime(new Date('2026-11-15T09:00:00Z'));
const module = await Test.createTestingModule({
providers: [EmpruntsService, { provide: getDataSourceToken(), useValue: source }],
}).compile();
service = module.get(EmpruntsService);
});
afterEach(() => jest.useRealTimers());
const casNominal = () => {
m.findOne.mockResolvedValue(livre());
m.findOneBy.mockResolvedValue(adherent());
m.countBy.mockResolvedValue(0);
m.existsBy.mockResolvedValue(false);
};
describe('emprunter()', () => {
it(`enregistre l'emprunt pour ${DUREE_JOURS} jours et décrémente les disponibles`, async () => {
casNominal();
const r = await service.emprunter({ livreId: 1, adherentId: 3 });
expect(r).toEqual({ id: 7, livre: 'Les Misérables', adherent: 'Sami Ben Ali', dateRetourPrevue: '2026-11-29' });
expect(m.decrement).toHaveBeenCalledWith(Livre, { id: 1 }, 'disponibles', 1);
expect(m.findOne).toHaveBeenCalledWith(Livre, expect.objectContaining({ lock: { mode: 'pessimistic_write' } }));
});
it('404 si le livre est introuvable', async () => {
casNominal(); m.findOne.mockResolvedValue(null);
await expect(service.emprunter({ livreId: 9, adherentId: 3 })).rejects.toThrow(NotFoundException);
});
it('422 si l\'adhérent est inactif', async () => {
casNominal(); m.findOneBy.mockResolvedValue(adherent(false));
await expect(service.emprunter({ livreId: 1, adherentId: 3 })).rejects.toThrow(UnprocessableEntityException);
});
it(`422 au-delà de ${MAX_EMPRUNTS} emprunts en cours`, async () => {
casNominal(); m.countBy.mockResolvedValue(MAX_EMPRUNTS);
await expect(service.emprunter({ livreId: 1, adherentId: 3 })).rejects.toThrow(`Limite atteinte : ${MAX_EMPRUNTS} emprunts en cours`);
});
it('409 si le même livre est déjà emprunté par l\'adhérent', async () => {
casNominal(); m.existsBy.mockResolvedValue(true);
await expect(service.emprunter({ livreId: 1, adherentId: 3 })).rejects.toThrow('Cet adhérent a déjà emprunté ce livre');
});
it('409 s\'il ne reste aucun exemplaire, sans rien modifier', async () => {
casNominal(); m.findOne.mockResolvedValue(livre(0));
await expect(service.emprunter({ livreId: 1, adherentId: 3 })).rejects.toThrow(ConflictException);
expect(m.decrement).not.toHaveBeenCalled();
expect(m.save).not.toHaveBeenCalled();
});
});
describe('rendre()', () => {
it('enregistre le retour, incrémente les disponibles et signale le retard', async () => {
m.findOne.mockResolvedValue({ id: 4, livre: livre(), dateRetourPrevue: '2026-11-10', dateRetour: null });
const r = await service.rendre(4);
expect(r).toEqual({ id: 4, livre: 'Les Misérables', rendu: '2026-11-15', enRetard: true });
expect(m.increment).toHaveBeenCalledWith(Livre, { id: 1 }, 'disponibles', 1);
});
it('409 si l\'emprunt est déjà rendu', async () => {
m.findOne.mockResolvedValue({ id: 4, livre: livre(), dateRetour: '2026-11-12' });
await expect(service.rendre(4)).rejects.toThrow('Emprunt 4 déjà rendu le 2026-11-12');
expect(m.increment).not.toHaveBeenCalled();
});
});
});
test/bibliotheque.e2e-spec.ts
import { INestApplication } from '@nestjs/common';
import { Test } from '@nestjs/testing';
import request from 'supertest';
import { App } from 'supertest/types';
import { DataSource } from 'typeorm';
import { AppModule } from '../src/app.module';
import { configurerApp } from '../src/configurer-app';
import { Categorie } from '../src/livres/categorie.entity';
describe('API bibliothèque (e2e, base MySQL de test)', () => {
let app: INestApplication<App>;
let http: ReturnType<typeof request>;
let ids: { auteur: number; livre: number; livreUnique: number; sami: number; ines: number };
beforeAll(async () => {
const module = await Test.createTestingModule({ imports: [AppModule] }).compile();
app = configurerApp(module.createNestApplication());
await app.init();
http = request(app.getHttpServer());
// Base de test : schéma recréé à partir des entités, puis données minimales
const source = app.get(DataSource);
expect(source.options.database).toBe('bibliotheque_test'); // garde-fou : jamais la vraie base !
await source.synchronize(true);
await source.getRepository(Categorie).save([{ libelle: 'Roman' }, { libelle: 'Histoire' }]);
const auteur = await http.post('/api/auteurs').send({ nom: 'Hugo', prenom: 'Victor' }).expect(201);
const livre = await http.post('/api/livres')
.send({ isbn: '9782253096344', titre: 'Les Misérables', anneePublication: 1862, exemplaires: 3, auteurId: auteur.body.id, categorieIds: [1] })
.expect(201);
const unique = await http.post('/api/livres')
.send({ isbn: '9782070413119', titre: 'Notre-Dame de Paris', anneePublication: 1831, exemplaires: 1, auteurId: auteur.body.id })
.expect(201);
const sami = await http.post('/api/adherents').send({ nom: 'Ben Ali', prenom: 'Sami', email: 'sami@exemple.tn' }).expect(201);
const ines = await http.post('/api/adherents').send({ nom: 'Trabelsi', prenom: 'Ines', email: 'ines@exemple.tn' }).expect(201);
ids = { auteur: auteur.body.id, livre: livre.body.id, livreUnique: unique.body.id, sami: sami.body.id, ines: ines.body.id };
});
afterAll(() => app.close());
describe('Livres', () => {
it('GET /api/livres?q=mis → recherche par titre, avec méta de pagination', async () => {
const r = await http.get('/api/livres?q=mis').expect(200);
expect(r.body.donnees).toHaveLength(1);
expect(r.body.donnees[0]).toMatchObject({ titre: 'Les Misérables', disponibles: 3, auteur: { nom: 'Hugo' } });
expect(r.body.meta).toEqual({ total: 1, page: 1, limite: 10, pages: 1 });
});
it('POST /api/livres invalide → 400 avec les messages', async () => {
const r = await http.post('/api/livres').send({ isbn: '978', titre: '', anneePublication: 3000, exemplaires: 0, auteurId: 1 }).expect(400);
expect(r.body.message).toEqual(expect.arrayContaining(["L'ISBN doit contenir 13 chiffres", 'exemplaires must not be less than 1']));
});
it('POST /api/livres avec un ISBN déjà utilisé → 409 (filtre TypeORM)', async () => {
const r = await http.post('/api/livres')
.send({ isbn: '9782253096344', titre: 'Doublon', anneePublication: 1862, exemplaires: 1, auteurId: ids.auteur })
.expect(409);
expect(r.body.message).toBe('Cette valeur existe déjà (champ unique)');
});
it('DELETE /api/auteurs/:id d\'un auteur qui a des livres → 409', () =>
http.delete(`/api/auteurs/${ids.auteur}`).expect(409));
});
describe('Emprunts', () => {
let emprunt: number;
it('POST /api/emprunts → 201 et un exemplaire de moins', async () => {
const r = await http.post('/api/emprunts').send({ livreId: ids.livre, adherentId: ids.sami }).expect(201);
emprunt = r.body.id;
const livre = await http.get(`/api/livres/${ids.livre}`).expect(200);
expect(livre.body.disponibles).toBe(2);
});
it('le même livre une deuxième fois → 409', () =>
http.post('/api/emprunts').send({ livreId: ids.livre, adherentId: ids.sami }).expect(409));
it('PATCH /api/emprunts/:id/retour → 200, puis 409 au second retour', async () => {
const r = await http.patch(`/api/emprunts/${emprunt}/retour`).expect(200);
expect(r.body).toMatchObject({ id: emprunt, enRetard: false });
await http.patch(`/api/emprunts/${emprunt}/retour`).expect(409);
});
it('deux emprunts SIMULTANÉS du dernier exemplaire : un seul réussit', async () => {
const [a, b] = await Promise.all([
http.post('/api/emprunts').send({ livreId: ids.livreUnique, adherentId: ids.sami }),
http.post('/api/emprunts').send({ livreId: ids.livreUnique, adherentId: ids.ines }),
]);
expect([a.status, b.status].sort()).toEqual([201, 409]);
const livre = await http.get(`/api/livres/${ids.livreUnique}`).expect(200);
expect(livre.body.disponibles).toBe(0);
});
it('GET /api/emprunts/statistiques', async () => {
const r = await http.get('/api/emprunts/statistiques').expect(200);
expect(r.body.enCours).toBe(1);
});
});
});
test/jest-e2e.json
{
"moduleFileExtensions": ["js", "json", "ts"],
"rootDir": "..",
"testEnvironment": "node",
"testRegex": "test/.*\\.e2e-spec\\.ts$",
"transform": { "^.+\\.(t|j)s$": "ts-jest" },
"collectCoverageFrom": ["src/**/*.ts", "!src/main.ts", "!src/data-source.ts", "!src/seeds/**", "!src/**/*.spec.ts", "!src/**/*.module.ts", "!src/**/*.entity.ts", "!src/**/*.dto.ts"],
"coverageDirectory": "coverage-e2e"
}
jest.config.ts
import type { Config } from 'jest';
import { pathsToModuleNameMapper } from 'ts-jest';
import ts from 'typescript';
// Path aliases (e.g. the ones added by `nest g library`) live in tsconfig.json,
// so they are read from there instead of being duplicated here.
const { config: tsconfig } = ts.readConfigFile(
'./tsconfig.json',
ts.sys.readFile,
);
const paths = tsconfig?.compilerOptions?.paths ?? {};
const config: Config = {
moduleFileExtensions: ['js', 'json', 'ts'],
rootDir: '.',
testRegex: '.*\\.spec\\.ts$',
transform: {
'^.+\\.(t|j)s$': 'ts-jest',
},
moduleNameMapper: pathsToModuleNameMapper(paths, { prefix: '<rootDir>/' }),
collectCoverageFrom: [
'src/**/*.ts',
'!src/main.ts',
'!src/data-source.ts',
'!src/seeds/**',
'!src/migrations/**',
'!src/**/*.module.ts',
'!src/**/*.entity.ts',
'!src/**/*.dto.ts',
],
coverageDirectory: './coverage',
testEnvironment: 'node',
};
export default config;
Grille d'évaluation
| Critère | Points |
|---|---|
Branche, commits par étape, .env.test, dossiers de couverture ignorés, étiquette v1.1.0, README | 2 |
configurerApp partagé, base de test séparée et garde-fou | 2 |
Tests des utilitaires (horloge simulée, filtre avec it.each) | 2 |
LivresService: dépôts simulés, cas acceptés et refusés, absence d'effet vérifiée | 3 |
EmpruntsService: transaction simulée, toutes les règles, verrou et date vérifiés | 4 |
| E2e : validation, 409 des contraintes, parcours d'emprunt et de retour | 3 |
| E2e : emprunts simultanés du dernier exemplaire | 2 |
| Couverture mesurée (deux suites) et analysée | 2 |
| Total | 20 |
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 !