1. Fake it
Renvoyer la valeur attendue, en dur, pour voir le test passer. Le test suivant démasque la triche.
Informatique · Qualité et livraison
Tester avant de coder, et laisser un robot vérifier chaque modification avant la mise en production.
Déjà à l'aise ? Aller au quizVendredi, 17 h
Une petite correction part en ligne. Lundi matin, l'appli de réservation des salles ne marche plus, et personne ne sait depuis quand.
Deux habitudes l'évitent : écrire les tests avant le code (TDD), et laisser un robot les lancer à chaque modification (CI/CD).
Après cette fiche, tu sais
Je dirais oui : s'il passe, c'est qu'il marche, non ?
Une question, une réponse
Notion 1 · Le test unitaire
Un test unitaire vérifie une petite unité de code, une fonction ou une méthode, en isolation. Il dure quelques millisecondes et se juge seul : vert ou rouge.
Le plan AAA
Presque tous les bons tests suivent le même plan en trois temps : Arrange (préparer les données), Act (appeler le code testé), Assert (vérifier le résultat).
Ici, avec le taux normal de la TVA suisse, 8,1 %.7
Le test, ligne par ligne
test('ajoute la TVA de 8,1 %', () => { // Arrange : préparer les données const ht = 100; // Act : appeler le code testé const ttc = prixTTC(ht); // Assert : vérifier le résultat expect(ttc).toBe(108.1); });
Le nom du test dit déjà ce qu'on vérifie.
Les cinq qualités
L'acronyme FIRST, popularisé par Clean Code de Robert C. Martin (2008), résume un bon test.4
Fast : rapide. Independent : aucun test ne dépend d'un autre. Repeatable : même résultat partout, sans réseau ni heure. Self-validating : vert ou rouge, sans lecture humaine. Timely : écrit juste avant le code qu'il vérifie.
// prix.js
export function prixTTC(ht, taux = 0.081) {
const ttc = ht * (1 + taux);
return Math.round(ttc * 100) / 100; // au centime
}
// prix.test.js
import { prixTTC } from './prix.js';
test('ajoute la TVA de 8,1 %', () => {
// Arrange : préparer les données
const ht = 100;
// Act : appeler le code testé
const ttc = prixTTC(ht);
// Assert : vérifier le résultat
expect(ttc).toBe(108.1);
});@Test sur la méthode et assertEquals(attendu, obtenu). L'ordre des arguments compte : la valeur attendue d'abord, sinon le message d'erreur inverse les deux. La fiche Java, Maven et JUnit le détaille.Les huit lignes du test ont été mélangées. Touche une ligne, puis celle avec laquelle l'échanger, jusqu'à retrouver le plan Arrange, Act, Assert.
Un test rouge d'abord
Notion 2 · Le cycle TDD
Le TDD (Test-Driven Development, développement piloté par les tests) a été mis au point par Kent Beck à la fin des années 1990, dans le cadre de l'Extreme Programming.1 On inverse l'ordre habituel : d'abord un test qui échoue, puis le code minimal qui le fait passer, puis un nettoyage.
D'abord un test rouge, puis le code vert, puis le nettoyage. On recommence par pas de quelques minutes.
Avant le premier test
Kent Beck commence même par écrire la liste des cas à couvrir, puis les transforme un par un en tests.3
Fais défiler : le cycle tourne sur une fonction estBissextile(annee).
On écrit d'abord le test : 2024 doit être bissextile. Il échoue, et c'est normal : la fonction n'existe pas encore.
Le code le plus bête qui passe : return true. Une triche assumée (fake it) : le test suivant va la démasquer.
Deuxième exemple : 2023 ne l'est pas. Le test échoue, puisque le code renvoie toujours true.
On généralise : divisible par 4. Forcer la généralisation par un nouvel exemple, c'est la triangulation.
Les siècles : 1900 ne l'est pas, 2000 l'est. Le test échoue sur 1900.
La vraie règle : divisible par 4, sauf les siècles, à moins qu'ils soient divisibles par 400. Trois tests verts.
On rend le code lisible avec une petite fonction divisible. Le comportement ne change pas : les trois tests restent verts.
Passer au vert
Ces stratégies viennent du livre de Kent Beck.3 Chaque ligne de code est justifiée par un test.
Renvoyer la valeur attendue, en dur, pour voir le test passer. Le test suivant démasque la triche.
Ajouter un exemple qui oblige à généraliser, comme 2023 ici.
Écrire tout de suite le bon code quand il est simple, comme a + b pour une somme.
Chaque ligne existe parce qu'un test l'a exigée, et un test rouge pointe presque toujours vers la dernière modification.
La suite de tests devient un filet de sécurité qui autorise le refactoring, sans crainte de tout casser.
Non : un test qui n'a jamais échoué ne prouve peut-être rien.
expect oublié, ou appelle la mauvaise fonction. Le voir échouer d'abord, c'est la preuve qu'il vérifie quelque chose.Piège
On mélange correction et nettoyage, et on ne sait plus ce qui a cassé quoi. Kent Beck le dit en une phrase : d'abord faire marcher, ensuite rendre propre.3
Cinq moments d'une séance de TDD. À chaque fois, choisis ce que tu dois faire ensuite.
Beaucoup de petits tests
Notion 3 · La pyramide des tests
Plus un test couvre de terrain, plus il est lent, coûteux et fragile. La pyramide des tests, popularisée par Mike Cohn dans Succeeding with Agile (2009), range les tests en trois étages.1
Des tests unitaires, rapides, en grand nombre ; des tests de bout en bout, lents, en petit nombre.
Trois étages, trois cadrages
Un test unitaire isole une fonction. Un test d'intégration branche de vraies briques. Un test de bout en bout pilote un navigateur.
Une fonction ou une classe isolée. Les dépendances lentes (base de données, réseau) sont remplacées par des doublures (mocks, stubs). Outils : Jest, Vitest, JUnit, pytest.
Plusieurs briques réelles ensemble, par exemple ton code et une vraie base de données de test. Outils : Supertest, Testcontainers, Spring Boot Test.
Un robot pilote un vrai navigateur et rejoue le parcours d'un utilisateur. Outils : Playwright, Cypress, Selenium.
Fais défiler : les trois étages se remplissent, et la durée de la suite s'affiche. Puis la pyramide se renverse en « cornet de glace », l'anti-modèle.
Une base large de tests rapides
unitaires 0intégration 0E2E 0
durée de la suite 0 s
hypothèses : 5 ms, 0,5 s et 20 s par test, lancés l'un après l'autre
Donc on supprime les tests lents ?
Piège
Un outil de couverture mesure les lignes exécutées. 100 % de lignes exécutées ne veut pas dire 100 % de cas vérifiés.9
Un test sans expect « couvre » du code sans rien contrôler. Sers-t'en pour repérer les zones jamais testées.
Six tests d'une appli d'inscription aux cours facultatifs. Range chacun dans son étage.
Le gardien de la production
Notion 4 · L'intégration continue
En intégration continue (CI), chacun fusionne son travail dans la branche principale au moins une fois par jour. À chaque push, un serveur récupère le code, installe, compile et lance les tests.2 Si ça casse, l'équipe le sait en quelques minutes, tant que la modification est encore fraîche.
Quatre règles
Chaque règle évite une dérive. Fais défiler les cartes pour les lire.
Une branche qui vit trois semaines produit des conflits géants. Une fusion quotidienne, de petits conflits faciles à régler.
L'Extreme Programming vise dix minutes au plus.2 Au-delà, plus personne n'attend le résultat avant de passer à autre chose.
Quand la branche principale casse, on répare, ou on annule le commit, avant tout le reste.
Le serveur repart de zéro à chaque fois, ce qui démasque le « chez moi, ça marche ».
Le build, sur la balance
Au-delà, plus personne n'attend le résultat. Voici un pipeline à 25 minutes, face à la cible.2
Fais défiler : trois commits traversent le pipeline. Un commit sain, un commit avec un bug, puis un commit sain en livraison continue. Les boutons rejouent chaque cas.
Commit sain · déploiement continu
Tu as vu ? Le commit avec un bug n'arrive jamais en production. Les tests ont bloqué la porte, et toute l'équipe a reçu l'alerte en quelques minutes.
Le commit sain, lui, part seul en déploiement continu, et attend un clic humain en livraison continue.
Un pipeline typique
Récupération du code, installation des dépendances, build, tests, analyse, puis empaquetage de l'artefact.
Les étapes
Le serveur télécharge le code du dépôt, sur une machine neuve.
Les dépendances sont installées, exactement selon le fichier de verrouillage.
Le build prépare le programme. En Java, Maven compile avant de tester.
Toute la suite de tests s'exécute. Un test rouge arrête le job.
Le lint et l'analyse des dépendances vulnérables vérifient la qualité et la sécurité.
L'artefact, testé, est prêt à être livré.
L'ordre exact varie selon le langage : en JavaScript, on lance souvent les tests avant le build de production.
Qui appuie sur le bouton ?
Notion 5 · Livraison ou déploiement continu
Le sigle CD recouvre deux pratiques qui prolongent l'intégration continue. En déploiement continu, chaque modification verte part toute seule en production. En livraison continue, on peut déployer à tout moment, mais c'est une décision humaine, souvent celle de l'entreprise.1
| Intégration continue | Livraison continue | Déploiement continu | |
|---|---|---|---|
| Automatisé | build et tests à chaque push | tout, jusqu'à un paquet prêt pour la production | tout, mise en production comprise |
| Mise en prod | manuelle, souvent rare et stressante | un clic, décidé par un humain | automatique dès que tout est vert |
| Prérequis | des tests automatiques fiables | un pipeline qui produit toujours un livrable testé | des tests assez solides pour se passer de validation humaine |
Déployer souvent sans trembler
Pour déployer souvent, on ajoute des filets. Chacun réduit un risque. Le retour arrière, lui, doit rester rapide si les indicateurs se dégradent.
Le déploiement canari
D'abord quelques pour cent des utilisateurs, puis tous, si les indicateurs restent bons.10
Le blue-green
Deux environnements identiques, bleu et vert : on bascule le trafic de l'un à l'autre. Revenir en arrière consiste à rebasculer.10
Deux filets de plus
Les feature flags : le code part en production, mais la fonctionnalité reste éteinte tant qu'on ne l'allume pas.10
Le retour arrière : revenir vite à la version précédente dès que les indicateurs se dégradent.
Six équipes décrivent leur façon de travailler. Range chacune dans la bonne pratique.
Un pipeline, en YAML
Notion 6 · Un pipeline réel
Sur GitHub, un pipeline est un fichier YAML dans .github/workflows/. Il teste chaque push sur main et chaque pull request, et ne déploie que depuis main, si les tests sont verts.5
Quand le pipeline se lance : à chaque push sur main et à chaque pull request.
Un job, test, sur une machine neuve (ubuntu-latest) : rien ne traîne d'une exécution à l'autre.
Récupérer le code, installer Node 24 (la version LTS active), garder en cache les paquets npm.
npm ci installe exactement les versions du package-lock.json, puis les tests, puis le build.
deploy attend la réussite de test (needs) et ne tourne que sur main (if) : une pull request est testée, jamais déployée.
La clé vient des secrets du dépôt : elle n'apparaît ni dans le code ni dans l'historique Git.
Le secret
La clé de déploiement ne figure pas dans le fichier. Le pipeline la lit dans les secrets du dépôt, au moment de l'exécution.8
Quand un test casse
deploy attend la réussite de test grâce à needs. Si un test échoue, le déploiement est ignoré.
name: CI
on:
push:
branches: [main]
pull_request:
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- uses: actions/setup-node@v7
with:
node-version: 24
cache: npm
- run: npm ci
- run: npm test
- run: npm run build
deploy:
needs: test
if: github.ref == 'refs/heads/main'
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- run: ./scripts/deploy.sh
env:
DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}on : les événements qui déclenchent le pipeline (un push sur main, toute pull request).jobs : les tâches. Chacune tourne sur une machine neuve, choisie par runs-on. Sans needs, les jobs tournent en parallèle.steps : les étapes, soit une action toute faite (uses, ici en version 7), soit une commande (run).npm ci part de zéro, installe exactement les versions notées dans package-lock.json et s'arrête en erreur s'il ne correspond pas à package.json : l'installation est identique à chaque fois.6needs: test : si test échoue, deploy est ignoré. Un seul test rouge, et rien ne part.secrets.DEPLOY_KEY : la clé est rangée dans les réglages du dépôt, jamais écrite dans le code.environment: production au job deploy et, dans les réglages du dépôt, on donne à cet environnement des relecteurs obligatoires : le job attend qu'une de ces personnes l'approuve.5Trois situations, avec le fichier ci.yml ci-dessus. Que se passe-t-il ?
Six pièges à éviter
Erreurs fréquentes
Six pièges reviennent sans cesse. Fais défiler les cartes pour les voir.
Ils décrivent alors ce que fait le code, pas ce qu'il devrait faire.
Un test qui n'a jamais échoué n'a peut-être jamais rien vérifié.
Dépendants de l'heure, du réseau ou de l'ordre d'exécution : ils passent, puis échouent sans raison, et l'équipe finit par les ignorer.
On obtient des tests qui exécutent tout et ne vérifient rien.
Les pushs suivants s'empilent sur une base cassée, et plus personne ne fait confiance au voyant.
Le dépôt garde tout l'historique : un jeton poussé une seule fois doit être considéré comme compromis, et régénéré.
Entraînement
Réfléchis avant d'ouvrir le corrigé. Chaque réponse s'explique.
statut(note) renvoie 'échec' si la note est inférieure à 4, 'réussi' de 4 à 6, et lève une RangeError si la note sort de l'intervalle 1 à 6. Écris la liste des tests avant le code. Quelles valeurs choisis-tu ?Voir le corrigéUn cas par comportement, et surtout les limites, là où se cachent les erreurs de < ou <= :
test('3,5 : échec', () => expect(statut(3.5)).toBe('échec'));
test('4 : réussi (limite)', () => expect(statut(4)).toBe('réussi'));
test('6 : réussi (limite)', () => expect(statut(6)).toBe('réussi'));
test('1 : échec (limite basse)', () => expect(statut(1)).toBe('échec'));
test('hors intervalle', () => {
expect(() => statut(0.5)).toThrow(RangeError);
expect(() => statut(6.5)).toThrow(RangeError);
});
Un code qui les fait tous passer :
function statut(note) {
if (note < 1 || note > 6) throw new RangeError('note hors de 1 à 6');
return note < 4 ? 'échec' : 'réussi';
}test('prixTTC arrondit au centime', () => { prixTTC(19.90); });Voir le corrigéIl appelle la fonction mais ne vérifie rien : il passerait même si prixTTC renvoyait n'importe quoi. Il « couvre » du code sans le tester. On ajoute l'assertion : expect(prixTTC(19.90)).toBe(21.51); (19,90 × 1,081 = 21,5119, arrondi à 21,51). Et on vérifie qu'il sait échouer, par exemple en attendant d'abord 21,52 : il doit passer au rouge.
Viser une dizaine de minutes, la règle de l'Extreme Programming.2 Repérer les tests les plus lents (souvent les tests de bout en bout) et remplacer ceux qui le peuvent par des tests d'intégration ou unitaires ; mettre les dépendances en cache (cache: npm) ; lancer en parallèle les jobs indépendants ; garder les longs tests de bout en bout pour une seconde étape du pipeline, après un premier passage rapide.
À retenir
Douze questions pour finir
Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026.