Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
Node.js

Tester une API avec le module node:test et Supertest

Cette leçon apprend à tester une API Node.js avec le module natif node:test, sans installer de framework. Après un premier test qui échoue puis réussit, elle présente test, describe, it, les assertion...

0 chapitres 0 QCM Accès gratuit
Tester une API avec le module node:test et Supertest

À propos de ce cours

Cette leçon apprend à tester une API Node.js avec le module natif node:test, sans installer de framework. Après un premier test qui échoue puis réussit, elle présente test, describe, it, les assertions du module assert et les fonctions simulées avec mock.fn. Supertest teste ensuite l'API de produits (Express 5, Mongoose, JWT) sans démarrer de serveur : liste paginée, 401, 403, 201, 400, 404 et 204, sur une base MongoDB de test séparée. La leçon montre aussi le filtrage des tests, la couverture du code, une régression réellement détectée et l'exécution automatique avec GitHub Actions. Activités corrigées.

Objectifs de la leçon

  • Comprendre l'intérêt des tests automatisés.
  • Écrire des tests avec le module natif node:test et node:assert.
  • Tester les routes d'une API Express avec Supertest, sans démarrer le serveur.
  • Isoler les tests dans une base MongoDB dédiée.
  • Mesurer la couverture et exécuter les tests automatiquement à chaque push.

Versions: Node.js 24 LTS, npm 11, Express 5, Mongoose 9, MongoDB 8.0, Supertest 7, Socket.IO 4.8, PM2 7, nginx 1.24 (Ubuntu 24.04). Le code de ce chapitre est celui de l'API de produits (TP 6, 8 et 9) : Express 5 en modules ES (import), Mongoose, authentification JWT avec les rôles admin et utilisateur, code réparti en routes, contrôleurs et services (séparation des couches). Toutes les commandes ont réellement été exécutées et leurs sorties sont reproduites telles quelles.

Pourquoi des tests automatisés ?

Jusqu'ici, vous avez testé l'API à la main avec Postman, Thunder Client ou des fichiers .http (tester une API avec Postman). C'est utile pour explorer, mais il faut tout refaire après chaque modification, et personne ne revérifie les 30 routes quand on en modifie une. Un test automatisé est un petit programme qui appelle votre code et vérifie le résultat. On les lance tous en une commande, en quelques secondes, aussi souvent qu'on veut.

Depuis Node.js 20, le module node:test est intégré : plus besoin d'installer Jest ou Mocha pour écrire et lancer des tests.

Tests avec node:test et Supertest

Deux niveaux de tests, lancés par node --test, sur une base de test séparée.

Un premier test

Dans un dossier vide (npm init -y, puis "type": "module" dans package.json), une fonction qui calcule un prix TTC arrondi au millime, avec une erreur volontaire :

📄 prix.js

// Prix TTC arrondi au millime (TVA de 19 % par défaut)
export function prixTTC(prixHT, tva = 0.19) {
  if (prixHT < 0) throw new RangeError('Le prix HT doit être positif');
  return Math.round(prixHT * (1 + tva));
}

📄 prix.test.js

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { prixTTC } from './prix.js';

test('applique une TVA de 19 % par défaut', () => {
  assert.equal(prixTTC(100), 119);
});

test('accepte un autre taux', () => {
  assert.equal(prixTTC(100, 0.07), 107);
});

test('arrondit au millime', () => {
  assert.equal(prixTTC(45.5), 54.145);
});

test('refuse un prix négatif', () => {
  assert.throws(() => prixTTC(-1), RangeError);
});
  • test(nom, fonction) déclare un test. Si la fonction lève une erreur, le test échoue.
  • node:assert/strict fournit les vérifications : equal (égalité stricte), deepEqual (objets et tableaux), throws (une erreur est levée), match (expression régulière), ok (valeur vraie)…
  • node --test trouve tout seul les fichiers *.test.js, *-test.js, *_test.js et tous les .js d'un dossier test/.

Résultat réellement obtenu :

$ node --test
✔ applique une TVA de 19 % par défaut (1.88201ms)
✔ accepte un autre taux (0.150952ms)
✖ arrondit au millime (0.822062ms)
✔ refuse un prix négatif (1.519017ms)
ℹ tests 4
ℹ suites 0
ℹ pass 3
ℹ fail 1
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 94.672441

✖ failing tests:

test at prix.test.js:13:1
✖ arrondit au millime (0.822062ms)
  AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
  
  54 !== 54.145
  
    generatedMessage: true,
    code: 'ERR_ASSERTION',
    actual: 54,
    expected: 54.145,
    operator: 'strictEqual',
    diff: 'simple'
  }

Le rapport désigne le test en échec, la ligne, la valeur obtenue (54) et la valeur attendue (54.145) : Math.round arrondit à l'unité, pas au millime. Le code de sortie 1 signale l'échec (utile pour l'intégration continue). Après correction (return Math.round(prixHT * (1 + tva) * 1000) / 1000;) :

Résultat réellement obtenu :

$ node --test
✔ applique une TVA de 19 % par défaut (0.764788ms)
✔ accepte un autre taux (0.137991ms)
✔ arrondit au millime (0.096882ms)
✔ refuse un prix négatif (0.353243ms)
ℹ tests 4
ℹ suites 0
ℹ pass 4
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 73.827278
Organiser les tests : describe, it et les crochets

Pour l'API de produits, on regroupe les tests avec describe (un groupe) et it (un test, synonyme de test). Une boucle permet de tester plusieurs cas sans copier-coller :

Rappel de l'organisation du projet :

api-produits/
├── src/
│   ├── app.js              # crée l'application Express (sans l'écouter)
│   ├── server.js           # connexion à MongoDB + écoute du port
│   ├── config/             # index.js (variables d'environnement), db.js
│   ├── models/             # produit.js, utilisateur.js (Mongoose)
│   ├── services/           # règles métier : produits.service.js, auth.service.js
│   ├── controllers/        # traduisent HTTP ↔ services
│   ├── routes/             # express.Router + express-validator
│   ├── middlewares/        # auth.js, valider.js, erreurs.js
│   └── utils/              # erreur-api.js, pagination.js
├── test/                   # (cette leçon)
├── .env  .env.example  .env.test
└── package.json            # "type": "module"

📄 test/pagination.test.js

import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import { lirePagination } from '../src/utils/pagination.js';

describe('lirePagination', () => {
  it('donne des valeurs par défaut', () => {
    assert.deepEqual(lirePagination({}), { page: 1, limite: 10, saut: 0 });
  });

  it('calcule le saut à partir de la page', () => {
    assert.deepEqual(lirePagination({ page: '3', limite: '20' }), { page: 3, limite: 20, saut: 40 });
  });

  it('borne la limite à 50', () => {
    assert.equal(lirePagination({ limite: '100000' }).limite, 50);
  });

  // plusieurs cas avec une simple boucle
  for (const page of ['0', '-4', 'abc']) {
    it(`ramène la page « ${page} » à 1`, () => {
      assert.equal(lirePagination({ page }).page, 1);
    });
  }
});
Remplacer une dépendance : mock.fn()

Un middleware Express reçoit req, res et next. Pour le tester seul, on lui passe de faux objets et une fonction simulée mock.fn(), qui enregistre chacun de ses appels et leurs arguments :

📄 src/middlewares/auth.js

import { verifierJeton } from '../services/auth.service.js';
import { ErreurApi } from '../utils/erreur-api.js';

export function authentifier(req, res, next) {
  const [type, jeton] = (req.headers.authorization ?? '').split(' ');
  if (type !== 'Bearer' || !jeton) return next(new ErreurApi(401, 'Authentification requise'));
  try {
    const charge = verifierJeton(jeton);
    req.utilisateur = { id: charge.sub, role: charge.role, nom: charge.nom };
    next();
  } catch {
    next(new ErreurApi(401, 'Jeton invalide ou expiré'));
  }
}

export const autoriser = (...roles) => (req, res, next) =>
  roles.includes(req.utilisateur?.role) ? next() : next(new ErreurApi(403, 'Accès refusé'));

📄 test/auth-middleware.test.js

import { describe, it, mock } from 'node:test';
import assert from 'node:assert/strict';
import { autoriser } from '../src/middlewares/auth.js';
import { ErreurApi } from '../src/utils/erreur-api.js';

describe('autoriser()', () => {
  it("appelle next() sans erreur pour un rôle autorisé", () => {
    const next = mock.fn(); // une fausse fonction qui enregistre ses appels
    autoriser('admin')({ utilisateur: { role: 'admin' } }, {}, next);
    assert.equal(next.mock.callCount(), 1);
    assert.deepEqual(next.mock.calls[0].arguments, []);
  });

  it('transmet une erreur 403 pour un autre rôle', () => {
    const next = mock.fn();
    autoriser('admin')({ utilisateur: { role: 'utilisateur' } }, {}, next);
    const [erreur] = next.mock.calls[0].arguments;
    assert.ok(erreur instanceof ErreurApi);
    assert.equal(erreur.statut, 403);
  });
});
Tester l'API avec Supertest

Supertest envoie de vraies requêtes HTTP à une application Express sans qu'elle écoute un port : il démarre un serveur temporaire pour chaque requête. Il faut donc pouvoir obtenir l'application sans la démarrer. C'est pourquoi le projet sépare app.js (création) et server.js (connexion à la base et écoute) :

📄 src/app.js

import express from 'express';
import helmet from 'helmet';
import cors from 'cors';
import morgan from 'morgan';
import { routesProduits } from './routes/produits.routes.js';
import { routesAuth } from './routes/auth.routes.js';
import { routeIntrouvable, gererErreurs } from './middlewares/erreurs.js';
import { config } from './config/index.js';
import pkg from '../package.json' with { type: 'json' };

// Crée l'application SANS la démarrer : server.js l'écoute, les tests l'utilisent directement
export function creerApp() {
  const app = express();
  if (config.trustProxy) app.set('trust proxy', config.trustProxy);
  app.use(helmet());
  app.use(cors({ origin: config.corsOrigines }));
  if (config.env === 'development') app.use(morgan('dev'));
  if (config.env === 'production') app.use(morgan('combined'));
  app.use(express.json({ limit: '10kb' }));
  app.use(express.static('public'));

  app.get('/api/sante', (req, res) => res.json({ statut: 'ok', version: pkg.version, uptime: Math.round(process.uptime()) }));
  app.use('/api/auth', routesAuth);
  app.use('/api/produits', routesProduits);

  app.use(routeIntrouvable);
  app.use(gererErreurs);
  return app;
}
npm install --save-dev supertest
Une base de données de test

Les tests créent et suppriment des produits : ils ne doivent jamais toucher votre base de développement. Un fichier .env.test, chargé avec --env-file, désigne une autre base. Il ne contient aucun secret réel et peut être versionné :

📄 .env.test

# Variables des tests : une base séparée, vidée par les tests
NODE_ENV=test
MONGODB_URI=mongodb://127.0.0.1:27017/produits_test
JWT_SECRET=secret-de-test-uniquement
JWT_DUREE=5m

Attention : node --test exécute chaque fichier de test dans un processus séparé, en parallèle. Si deux fichiers vident la même collection en même temps, les tests échouent au hasard. Chaque fichier utilise donc sa propre base (produits_test_produits, produits_test_auth…), créée par un fichier d'outils commun :

📄 test/aide.js

// Outils communs aux tests d'intégration
import mongoose from 'mongoose';
import bcrypt from 'bcrypt';
import request from 'supertest';
import { creerApp } from '../src/app.js';
import { Utilisateur } from '../src/models/utilisateur.js';

export const app = creerApp();

// Chaque fichier de test a SA base : node --test exécute les fichiers en parallèle
export async function ouvrirBase(nom) {
  await mongoose.connect(`${process.env.MONGODB_URI}_${nom}`);
  await mongoose.connection.dropDatabase();
}

export async function fermerBase() {
  await mongoose.connection.dropDatabase();
  await mongoose.disconnect();
}

// Crée un compte et renvoie son jeton JWT
export async function jetonPour(role) {
  const email = `${role}@test.tn`;
  await Utilisateur.create({ nom: role, email, role, motDePasse: await bcrypt.hash('MotDePasse1!', 4) });
  const res = await request(app).post('/api/auth/connexion').send({ email, motDePasse: 'MotDePasse1!' });
  return res.body.jeton;
}

Le coût de bcrypt est réduit à 4 dans les tests (12 dans l'application) : le hachage est volontairement lent, et les tests créent beaucoup de comptes.

Les tests de l'API de produits

📄 test/produits.test.js

import { describe, it, before, after, beforeEach } from 'node:test';
import assert from 'node:assert/strict';
import request from 'supertest';
import { app, ouvrirBase, fermerBase, jetonPour } from './aide.js';
import { Produit } from '../src/models/produit.js';

const souris = { nom: 'Souris sans fil', prix: 45.5, categorie: 'accessoires', stock: 80 };

describe('API /api/produits', () => {
  let admin, utilisateur;

  before(async () => {
    await ouvrirBase('produits');
    admin = await jetonPour('admin');
    utilisateur = await jetonPour('utilisateur');
  });
  after(fermerBase);
  beforeEach(() => Produit.deleteMany({})); // chaque test part d'une collection vide

  describe('lecture (public)', () => {
    it('GET / renvoie une liste paginée', async () => {
      await Produit.create([souris, { ...souris, nom: 'Clavier' }, { ...souris, nom: 'Écran', categorie: 'informatique' }]);
      const res = await request(app).get('/api/produits?limite=2').expect(200).expect('Content-Type', /json/);
      assert.equal(res.body.donnees.length, 2);
      assert.equal(res.body.total, 3);
      assert.equal(res.body.pages, 2);
    });

    it('GET /?categorie= filtre par catégorie', async () => {
      await Produit.create([souris, { ...souris, nom: 'Écran', categorie: 'informatique' }]);
      const res = await request(app).get('/api/produits?categorie=informatique').expect(200);
      assert.deepEqual(res.body.donnees.map((p) => p.nom), ['Écran']);
    });

    it('GET /:id renvoie 404 pour un produit inexistant', async () => {
      const res = await request(app).get('/api/produits/6650f1a2b3c4d5e6f7a8b9c0').expect(404);
      assert.equal(res.body.erreur, 'Produit introuvable');
    });

    it('GET /:id renvoie 400 pour un identifiant mal formé', () =>
      request(app).get('/api/produits/123').expect(400));
  });

  describe('écriture (admin)', () => {
    it('POST / sans jeton : 401', () => request(app).post('/api/produits').send(souris).expect(401));

    it('POST / avec un compte utilisateur : 403', () =>
      request(app).post('/api/produits').set('Authorization', `Bearer ${utilisateur}`).send(souris).expect(403));

    it('POST / avec un compte admin : 201 et produit enregistré', async () => {
      const res = await request(app).post('/api/produits').set('Authorization', `Bearer ${admin}`).send(souris).expect(201);
      assert.equal(res.body.nom, souris.nom);
      assert.ok(res.body._id);
      assert.equal(await Produit.countDocuments(), 1);
    });

    it('POST / avec des données invalides : 400 et détail des erreurs', async () => {
      const res = await request(app).post('/api/produits').set('Authorization', `Bearer ${admin}`)
        .send({ nom: '', prix: -5, categorie: 'jardin' }).expect(400);
      assert.deepEqual(res.body.details.map((d) => d.champ), ['nom', 'prix', 'categorie']);
    });

    it('PATCH /:id modifie le stock', async () => {
      const p = await Produit.create(souris);
      const res = await request(app).patch(`/api/produits/${p.id}`).set('Authorization', `Bearer ${admin}`).send({ stock: 3 }).expect(200);
      assert.equal(res.body.stock, 3);
    });

    it('DELETE /:id : 204 puis 404', async () => {
      const p = await Produit.create(souris);
      await request(app).delete(`/api/produits/${p.id}`).set('Authorization', `Bearer ${admin}`).expect(204);
      await request(app).get(`/api/produits/${p.id}`).expect(404);
    });
  });
});
  • before / after: une fois avant et après tous les tests du groupe (connexion, comptes, jetons) ; beforeEach: avant chaque test, pour qu'il parte d'une collection vide et ne dépende pas des autres.
  • request(app).get(...) renvoie une promesse : on l'attend avec await. .expect(200) vérifie le statut, .expect('Content-Type', /json/) un en-tête ; res.body est le JSON déjà décodé.
  • .set('Authorization', `Bearer ${admin}`) ajoute le jeton, .send(objet) envoie un corps JSON.
  • On vérifie aussi l'effet en base (Produit.countDocuments()), pas seulement la réponse.

📄 test/auth.test.js

import { describe, it, before, after } from 'node:test';
import assert from 'node:assert/strict';
import request from 'supertest';
import { app, ouvrirBase, fermerBase } from './aide.js';

describe('API /api/auth', () => {
  before(() => ouvrirBase('auth'));
  after(fermerBase);

  const lina = { nom: 'Lina', email: 'lina@exemple.tn', motDePasse: 'Lina2026!' };

  it('inscription : 201, sans le mot de passe dans la réponse', async () => {
    const res = await request(app).post('/api/auth/inscription').send(lina).expect(201);
    assert.equal(res.body.role, 'utilisateur');
    assert.equal(res.body.motDePasse, undefined);
  });

  it('inscription avec un e-mail déjà utilisé : 409', () =>
    request(app).post('/api/auth/inscription').send(lina).expect(409));

  it('connexion : renvoie un jeton JWT', async () => {
    const res = await request(app).post('/api/auth/connexion').send({ email: lina.email, motDePasse: lina.motDePasse }).expect(200);
    assert.match(res.body.jeton, /^ey[\w-]+\.[\w-]+\.[\w-]+$/);
  });

  it('connexion avec un mauvais mot de passe : 401', () =>
    request(app).post('/api/auth/connexion').send({ email: lina.email, motDePasse: 'faux' }).expect(401));
});
Lancer les tests

Premier essai avec node --env-file=.env.test --test:

Résultat réellement obtenu :

$ node --env-file=.env.test --test
✔ test/aide.js (545.219784ms)
▶ autoriser()
  ✔ appelle next() sans erreur pour un rôle autorisé (1.94081ms)
  ✔ transmet une erreur 403 pour un autre rôle (0.335634ms)

test/aide.js est compté comme un test : node --test exécute tous les fichiers .js d'un dossier test/. On précise donc le motif des fichiers de test dans les scripts de package.json:

📄 package.json (scripts de test)

{
  "test": "node --env-file=.env.test --test \"test/**/*.test.js\"",
  "test:watch": "node --env-file=.env.test --test --watch \"test/**/*.test.js\"",
  "test:couverture": "node --env-file=.env.test --test --experimental-test-coverage --test-coverage-include=\"src/**\" \"test/**/*.test.js\""
}

Résultat réellement obtenu :

$ npm test
> api-produits@1.2.0 test
> node --env-file=.env.test --test "test/**/*.test.js"

▶ autoriser()
  ✔ appelle next() sans erreur pour un rôle autorisé (2.038057ms)
  ✔ transmet une erreur 403 pour un autre rôle (0.479956ms)
✔ autoriser() (3.99903ms)
▶ API /api/auth
  ✔ inscription : 201, sans le mot de passe dans la réponse (319.891466ms)
  ✔ inscription avec un e-mail déjà utilisé : 409 (11.836799ms)
  ✔ connexion : renvoie un jeton JWT (275.446416ms)
  ✔ connexion avec un mauvais mot de passe : 401 (267.390865ms)
✔ API /api/auth (938.16776ms)
▶ lirePagination
  ✔ donne des valeurs par défaut (1.843451ms)
  ✔ calcule le saut à partir de la page (0.230016ms)
  ✔ borne la limite à 50 (0.150493ms)
  ✔ ramène la page « 0 » à 1 (0.10895ms)
  ✔ ramène la page « -4 » à 1 (0.138382ms)
  ✔ ramène la page « abc » à 1 (0.083154ms)
✔ lirePagination (5.150796ms)
▶ API /api/produits
  ▶ lecture (public)
    ✔ GET / renvoie une liste paginée (33.532934ms)
    ✔ GET /?categorie= filtre par catégorie (9.998687ms)
    ✔ GET /:id renvoie 404 pour un produit inexistant (6.802004ms)
    ✔ GET /:id renvoie 400 pour un identifiant mal formé (4.225245ms)
  ✔ lecture (public) (55.565176ms)
  ▶ écriture (admin)
    ✔ POST / sans jeton : 401 (4.042826ms)
    ✔ POST / avec un compte utilisateur : 403 (4.566026ms)
    ✔ POST / avec un compte admin : 201 et produit enregistré (9.950483ms)
    ✔ POST / avec des données invalides : 400 et détail des erreurs (5.737522ms)
    ✔ PATCH /:id modifie le stock (10.183732ms)
    ✔ DELETE /:id : 204 puis 404 (9.771025ms)
  ✔ écriture (admin) (45.146887ms)
✔ API /api/produits (226.339563ms)
ℹ tests 22
ℹ suites 6
ℹ pass 22
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 2422.266576

22 tests en un peu plus de 2 secondes, dont la plus grande partie pour les hachages bcrypt de la connexion. Pour ne lancer qu'une partie des tests, filtrez par nom avec une expression régulière :

Résultat réellement obtenu :

$ node --env-file=.env.test --test --test-name-pattern="40[13]" "test/**/*.test.js"
▶ autoriser()
  ✔ transmet une erreur 403 pour un autre rôle (1.155926ms)
✔ autoriser() (2.113468ms)
▶ API /api/auth
  ✔ connexion avec un mauvais mot de passe : 401 (44.748137ms)
✔ API /api/auth (102.827793ms)
✔ test/pagination.test.js (58.782226ms)
▶ API /api/produits
  ▶ écriture (admin)
    ✔ POST / sans jeton : 401 (5.86844ms)
    ✔ POST / avec un compte utilisateur : 403 (10.42765ms)
  ✔ écriture (admin) (17.401346ms)
✔ API /api/produits (131.451151ms)
ℹ tests 5
ℹ pass 5
ℹ fail 0
ℹ skipped 0

Autres options utiles : it.only(...) avec --test-only pour un seul test pendant la mise au point, it.skip(...) pour en désactiver un, et npm run test:watch qui relance les tests à chaque enregistrement.

Ce que les tests protègent

Un développeur retire par erreur autoriser('admin') de la route de création. L'application fonctionne toujours… mais n'importe quel utilisateur connecté peut créer des produits. Les tests le voient immédiatement :

Résultat réellement obtenu :

$ npm test     # après avoir retiré autoriser('admin') de la route POST
    ✖ POST / avec un compte utilisateur : 403 (9.762343ms)
  ✖ écriture (admin) (57.301313ms)
✖ API /api/produits (263.962256ms)
ℹ tests 22
ℹ pass 21
ℹ fail 1
✖ failing tests:
✖ POST / avec un compte utilisateur : 403 (9.762343ms)
  Error: expected 403 "Forbidden", got 201 "Created"
La couverture du code

La couverture mesure les lignes, les branches (if, ?:) et les fonctions exécutées au moins une fois par les tests :

Résultat réellement obtenu :

$ npm run test:couverture
ℹ start of coverage report
ℹ -------------------------------------------------------------------------
ℹ file                     | line % | branch % | funcs % | uncovered lines
ℹ -------------------------------------------------------------------------
ℹ src                      |        |          |         | 
ℹ  app.js                  | 100.00 |    40.00 |   50.00 | 
ℹ  config                  |        |          |         | 
ℹ   index.js               | 100.00 |    40.00 |  100.00 | 
ℹ  controllers             |        |          |         | 
ℹ   auth.controller.js     | 100.00 |   100.00 |  100.00 | 
ℹ   produits.controller.js | 100.00 |   100.00 |  100.00 | 
ℹ  evenements.js           | 100.00 |   100.00 |  100.00 | 
ℹ  middlewares             |        |          |         | 
ℹ   auth.js                |  88.24 |    90.91 |  100.00 | 12-13
ℹ   erreurs.js             |  66.67 |    50.00 |   33.33 | 5-6 12-14 19-20
ℹ   valider.js             | 100.00 |   100.00 |  100.00 | 
ℹ  models                  |        |          |         | 
ℹ   produit.js             | 100.00 |   100.00 |  100.00 | 
ℹ   utilisateur.js         | 100.00 |   100.00 |  100.00 | 
ℹ  routes                  |        |          |         | 
ℹ   auth.routes.js         | 100.00 |   100.00 |  100.00 | 
ℹ   produits.routes.js     | 100.00 |   100.00 |  100.00 | 
ℹ  services                |        |          |         | 
ℹ   auth.service.js        | 100.00 |   100.00 |  100.00 | 
ℹ   produits.service.js    |  98.04 |    80.00 |  100.00 | 27
ℹ  utils                   |        |          |         | 
ℹ   erreur-api.js          | 100.00 |   100.00 |  100.00 | 
ℹ   pagination.js          | 100.00 |   100.00 |  100.00 | 
ℹ -------------------------------------------------------------------------
ℹ all files                |  96.18 |    82.19 |   90.00 | 
ℹ -------------------------------------------------------------------------
ℹ end of coverage report

Les lignes non couvertes indiquent les cas oubliés : ici, un jeton invalide (auth.js, lignes 12-13), le JSON mal formé et l'erreur 500 (erreurs.js). Ne visez pas 100 % à tout prix : visez les règles importantes (droits, validation, calculs) et les erreurs déjà rencontrées.

Lancer les tests à chaque push : GitHub Actions

Ce workflow exécute les tests sur les serveurs de GitHub à chaque push et à chaque Pull Request, avec une base MongoDB 8.0 dans un conteneur (services). Le résultat (coche verte ou croix rouge) s'affiche à côté de chaque commit :

📄 .github/workflows/tests.yml

name: Tests

on:
  push:
    branches: [main]
  pull_request:

jobs:
  tests:
    runs-on: ubuntu-24.04
    services:
      mongodb:
        image: mongo:8.0
        ports:
          - 27017:27017
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-node@v7
        with:
          node-version: 24
          cache: npm
      - run: npm ci
      # .env.test est versionné : il ne contient que des valeurs de test
      - run: npm test

Vérification du fichier avec actionlint :

$ actionlint .github/workflows/tests.yml && echo "workflow valide"
workflow valide
Activités

Activité 1 Choisir l'assertion

Quelle assertion de node:assert/strict utiliser pour vérifier : (a) que res.body.total vaut 3 ; (b) que res.body est exactement { erreur: 'Produit introuvable' }; (c) qu'un e-mail ressemble à une adresse ; (d) que new Produit({ prix: -1 }).validateSync() renvoie une erreur ; (e) qu'une fonction asynchrone rejette sa promesse ?

Voir le corrigé

(a) assert.equal(res.body.total, 3); (b) assert.deepEqual(res.body, { erreur: 'Produit introuvable' }) (equal comparerait les références et échouerait) ; (c) assert.match(email, /^[^@\s]+@[^@\s]+\.[a-z]+$/i); (d) assert.ok(new Produit({ prix: -1 }).validateSync()); (e) await assert.rejects(maFonction(), ErreurApi).

Activité 2 Compléter les tests

Ajoutez à test/produits.test.js: (a) un test qui vérifie qu'un PATCH avec un prix négatif renvoie 400 ; (b) un test qui vérifie que GET /api/produits?limite=1000 renvoie au plus 50 produits. Pour (b), créez 60 produits avec Produit.insertMany().

Voir le corrigé
it('PATCH /:id refuse un prix négatif', async () => {
  const p = await Produit.create(souris);
  await request(app).patch(`/api/produits/${p.id}`).set('Authorization', `Bearer ${admin}`)
    .send({ prix: -10 }).expect(400);
});

it('GET / borne la limite à 50', async () => {
  await Produit.insertMany(Array.from({ length: 60 }, (_, i) => ({ ...souris, nom: `Produit ${i}` })));
  const res = await request(app).get('/api/produits?limite=1000').expect(200);
  assert.equal(res.body.donnees.length, 50);
  assert.equal(res.body.total, 60);
});

(a) passe grâce à runValidators: true dans le service : Mongoose applique la règle min: 0 du schéma à la mise à jour, et le middleware d'erreurs renvoie 400.

Activité 3 Couvrir les lignes oubliées

Le rapport de couverture signale auth.js lignes 12-13 et erreurs.js (JSON mal formé). Écrivez les deux tests qui couvrent ces lignes.

Voir le corrigé
it('POST / avec un jeton falsifié : 401', () =>
  request(app).post('/api/produits').set('Authorization', 'Bearer faux.jeton.jwt').send(souris).expect(401));

it('POST / avec un JSON mal formé : 400', async () => {
  const res = await request(app).post('/api/produits').set('Authorization', `Bearer ${admin}`)
    .set('Content-Type', 'application/json').send('{"nom": ').expect(400);
  assert.equal(res.body.erreur, 'JSON mal formé');
});

Relancez npm run test:couverture: auth.js passe à 100 % des lignes.

Activité 4 Tests et GitHub

Dans le dépôt GitHub de votre TP 9 : ajoutez test/, .env.test, les scripts de test et le workflow. Poussez sur une branche tests, ouvrez une Pull Request et vérifiez la coche verte dans l'onglet Actions. Puis modifiez volontairement une règle (retirer autoriser('admin')) dans un nouveau commit : que voyez-vous dans la Pull Request ?

Voir le corrigé

Le workflow s'exécute à chaque push sur la branche de la Pull Request. Avec la régression, l'étape npm test échoue (code de sortie 1) : croix rouge dans la Pull Request, et le détail du test en échec dans l'onglet Actions, comme dans la leçon. Annulez le commit (git revert HEAD) : la coche redevient verte. Dans Settings → Branches, une règle peut interdire la fusion tant que les tests ne passent pas.

À retenir

  • node:test est intégré à Node.js : describe, it, before, beforeEach, mock.fn(); assertions avec node:assert/strict.
  • Séparer app.js (création) et server.js (écoute) pour tester l'application avec Supertest sans démarrer de serveur.
  • Une base de test séparée, chargée avec --env-file=.env.test, une base par fichier car les fichiers s'exécutent en parallèle.
  • Un motif explicite "test/**/*.test.js" pour ne pas exécuter les fichiers d'outils comme des tests.
  • Couverture avec --experimental-test-coverage; tests automatiques à chaque push avec GitHub Actions.

Cet article vous a-t-il aidé ?