Écrire le test avant le code, avancer par petits pas, nettoyer sans peur : un rythme qui rend la conception plus simple et le code plus sûr.
⏱️ Durée : environ 110 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Danseur rouge-vert
🎬 L'histoire
Kodi doit écrire un convertisseur de nombres en chiffres romains pour les certificats de HashBox. Il ouvre l'éditeur et commence par la boucle la plus compliquée, avec les cas spéciaux (4, 9, 40, 90…). Trois heures plus tard, 60 lignes de if imbriqués, des bugs dans 1994, et plus personne n'ose y toucher.
« Autre méthode, propose Sam. Écris un seul test tout simple. Regarde-le échouer. Fais-le passer avec le code le plus bête possible. Puis le test suivant. Le code grossit par petits pas, toujours vérifié. Et à chaque fois qu'il est vert, tu peux nettoyer. »
Tu apprends le cycle rouge-vert-refactor, à avancer par petits pas, à utiliser des tests comme filet de sécurité pour refactorer, et à apprivoiser du code existant sans tests.
🎯 Ta mission
À la fin, je serai capable de :
- pratiquer le cycle rouge → vert → refactor
- avancer par petits pas avec la solution la plus simple
- refactorer sous la protection d'une suite de tests
- écrire des tests de caractérisation pour du code existant
- identifier les cas où le TDD aide et ceux où il aide moins
🧩 Défi d'échauffement (5 XP)
Tu construis un pont de cordes : à chaque planche posée, tu tires dessus pour vérifier qu'elle tient avant d'avancer. Compare avec quelqu'un qui pose 200 planches puis teste en marchant dessus. Que se passe-t-il quand une planche cède au milieu ? Où est le défaut ?
💡 Le concept
Le cycle du TDD
flowchart LR
R["🔴 Rouge : écrire un test qui échoue"] --> V["🟢 Vert : faire passer au plus simple"]
V --> F["🔵 Refactor : nettoyer sans changer le comportement"]
F --> R
Description du schéma : trois étapes en boucle : rouge (écrire un test qui échoue), vert (écrire le code le plus simple qui le fait passer), refactor (améliorer le code en gardant les tests verts), puis retour au rouge pour le comportement suivant.
| Étape | Règle |
|---|---|
| Rouge | un test qui échoue pour la bonne raison, petit, qui exprime un seul comportement nouveau |
| Vert | le code le plus simple qui passe tous les tests, même « bête » (renvoyer une constante) |
| Refactor | supprimer la duplication, clarifier les noms, simplifier — sans nouveau comportement, tests toujours verts |
Les trois lois (Robert C. Martin)
- N'écris pas de code de production sans un test qui échoue.
- N'écris pas plus de test qu'il n'en faut pour échouer.
- N'écris pas plus de code qu'il n'en faut pour passer le test.
Pourquoi ça aide
- Conception guidée : tu écris d'abord l'usage (l'API), donc elle est plus agréable.
- Petits pas : un bug a été introduit dans les dernières minutes, donc il est facile à situer.
- Couverture naturelle : tout comportement a un test qui l'a motivé.
- Confiance : le refactoring devient routine.
Triangulation et « faux » vert
Pour éviter de coder trop tôt une règle générale, on peut d'abord faire passer avec une constante (return 1), puis ajouter un deuxième exemple qui force la généralisation : c'est la triangulation.
Refactoring : changer la structure, pas le comportement
Un refactoring modifie la forme du code sans changer son comportement observable. Les tests en sont la preuve. Mouvements courants :
| Mouvement | Exemple |
|---|---|
| Renommer | x → nombre_restant |
| Extraire une fonction | sortir un bloc nommé |
Remplacer des if par une table | dictionnaire de correspondances |
| Supprimer la duplication | factoriser |
| Simplifier une condition | utiliser une clause de garde |
Règle : un pas de refactoring à la fois, tests après chaque pas. Ne mélange jamais refactoring et changement de comportement dans le même pas.
Du code existant sans tests : caractériser
Avant de refactorer du code hérité :
- appelle-le avec des entrées variées et note ce qu'il renvoie réellement ;
- transforme ces observations en tests de caractérisation (ils fixent le comportement actuel, même s'il est bizarre) ;
- refactore sous leur protection ;
- corrige les vrais bugs séparément, avec de vrais tests.
Limites du TDD
- Peu adapté à l'exploration pure (on ne sait pas encore ce qu'on veut) : on peut écrire un prototype jetable, puis recommencer en TDD.
- Les interfaces graphiques, l'apprentissage automatique, les systèmes physiques demandent d'autres stratégies.
- Ce n'est pas une religion : c'est un outil, très utile pour la logique métier.
🧠 Astuce : si tu ne sais pas quel test écrire, tu ne sais pas encore ce que le code doit faire. Retourne à la mission 2 : décris le comportement avec un exemple.
🔍 Exemple pas à pas
Problème : implémenter la conversion en chiffres romains en TDD, étape par étape (script qui rejoue le cycle), puis refactorer sous protection.
import io, unittest
def lancer(source_tests, source_code):
espace = {"unittest": unittest}
exec(source_code, espace) # le code de production
exec(source_tests, espace) # les tests (classe TestRomains)
suite = unittest.defaultTestLoader.loadTestsFromTestCase(espace["TestRomains"])
return unittest.TextTestRunner(stream=io.StringIO()).run(suite)
T = "class TestRomains(unittest.TestCase):\n"
def tests(*cas):
corps = T
for i, (n, attendu) in enumerate(cas):
corps += f" def test_{n}(self):\n self.assertEqual(romain({n}), '{attendu}')\n"
return corps
ETAPES = [
# (cas de test cumulés, code de production « le plus simple »)
([(1, "I")],
"def romain(n):\n return 'I'\n"), # constante !
([(1, "I"), (2, "II"), (3, "III")],
"def romain(n):\n return 'I' * n\n"), # généralisation forcée par 2 et 3
([(1, "I"), (2, "II"), (3, "III"), (, ), (, ), (, )],
),
([(, ), (, ), (, ), (, ), (, ), (, ), (, ), (, )],
),
]
i, (cas, code) (ETAPES, ):
precedent = ETAPES[i - ][] i >
rouge = lancer(tests(*cas), precedent)
vert = lancer(tests(*cas), code)
()
rouge.wasSuccessful() vert.wasSuccessful()
CAS_COMPLETS = [(, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, )]
():
r =
valeur, signe ((, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, )):
n >= valeur:
r += signe
n -= valeur
r
TABLE = [(, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, )]
():
<= n <= :
ValueError()
morceaux = []
valeur, signe TABLE:
fois, n = (n, valeur)
morceaux.append(signe * fois)
.join(morceaux)
(unittest.TestCase):
():
n, attendu CAS_COMPLETS:
.subTest(n=n):
.assertEqual(romain(n), attendu)
():
n (, ):
.assertEqual(romain(n), romain_avant(n), n)
():
n (, -, ):
.assertRaises(ValueError):
romain(n)
r = unittest.TextTestRunner(stream=io.StringIO()).run(unittest.defaultTestLoader.loadTestsFromTestCase(TestRomains))
(, r.testsRun, )
r.wasSuccessful(), r.failures + r.errors
Lecture :
- À chaque étape, on vérifie deux choses : le nouveau test est rouge contre l'ancien code (donc il teste bien du neuf), puis vert avec le nouveau.
- La première implémentation est volontairement bête (
return 'I') ; ce sont les exemples qui obligent à généraliser (triangulation). - Le refactoring (une table au lieu de cascades de
if) est protégé par un test d'équivalence sur tous les nombres de 1 à 3 999 : si l'on casse un détail, on le voit instantanément. - Le refactoring et le changement de comportement (validation hors limites) sont séparés dans le temps : la validation a été ajoutée avec son propre test rouge.
✍️ À toi, avec aide (10 XP)
Fais un mini-kata TDD : FizzBuzz paramétrable fizzbuzz(n) (3 → « Fizz », 5 → « Buzz », 15 → « FizzBuzz », sinon le nombre en texte). Écris la séquence de cycles dans l'ordre :
- test pour 1 → « 1 » (le plus bête qui passe :
return "1") ; - test pour 2 → « 2 » (force
str(n)) ; - test pour 3 → « Fizz » ;
- test pour 5 → « Buzz » ;
- test pour 15 → « FizzBuzz » ;
- refactor : élimine la duplication avec une construction de texte par morceaux.
Montre le code après chaque étape (les tests doivent rester verts).
💡 Indice 1
À l'étape 5, vérifie 15 avant 3 et 5, ou construis "Fizz" * (n%3==0) + "Buzz" * (n%5==0).
💡 Indice 2
Le refactor final doit passer les mêmes 5 tests sans en modifier un seul.
💡 Indice 3
Garde la liste des tests cumulés.
✅ Réponse
import unittest, io
def verifier(fizzbuzz):
cas = [(1, "1"), (2, "2"), (3, "Fizz"), (4, "4"), (5, "Buzz"), (6, "Fizz"), (10, "Buzz"), (15, "FizzBuzz"), (30, "FizzBuzz")]
for n, attendu in cas:
assert fizzbuzz(n) == attendu, (n, fizzbuzz(n), attendu)
# étape 1 : le plus bête
def v1(n): return "1"
# étape 2 : généralisation
def v2(n): return str(n)
# étape 3-4
def v3(n):
if n % 3 == 0: return "Fizz"
if n % 5 == 0: return
(n)
():
n % == :
n % == :
n % == :
(n)
():
( n % == ) + ( n % == ) (n)
v (v4, v5):
verifier(v)
v (v1, v2, v3):
:
verifier(v); SystemExit()
AssertionError:
(v4(n) == v5(n) n (, ))
()
🚀 À toi, en solo (20 XP)
Caractériser puis refactorer du code existant. Voici une fonction « héritée » dont personne ne connaît toutes les règles :
def calc(a, b, t):
if t == 1:
if a > 100: r = a * 0.9
else: r = a
elif t == 2:
r = a * b
if r > 500: r = r - 50
elif t == 3:
r = a / b if b != 0 else 0
else:
r = -1
return round(r, 2)
- écris des tests de caractérisation à partir de ses sorties réelles (une grille de 30 entrées au moins, y compris
b = 0ettinconnu) ; - refactore en trois fonctions nommées + un dispatch par table, sans changer le comportement ;
- prouve l'équivalence sur 5 000 entrées aléatoires (graine fixée) ;
- ajoute ensuite, séparément, un test qui révèle le comportement discutable de
b = 0(renvoie 0) et décide ce qu'il faudrait faire (sans le changer sans accord).
✅ Pistes de correction
import random
def calc_ancien(a, b, t):
if t == 1:
if a > 100: r = a * 0.9
else: r = a
elif t == 2:
r = a * b
if r > 500: r = r - 50
elif t == 3:
r = a / b if b != 0 else 0
else:
r = -1
return round(r, 2)
# 1. tests de caractérisation : on enregistre ce que fait réellement le code
GRILLE = [(a, b, t) for a in (0, 50, 100, 101, 200) for b in (0, 2, 7) for t in (1, 2, 3, 9)]
OBSERVE = {entree: calc_ancien(*entree) for entree in GRILLE}
assert len(GRILLE) == OBSERVE[(, , )] == OBSERVE[(, , )] == -
():
a * a > a
():
r = a * b
r - r > r
():
a / b b !=
OPERATIONS = {: remise_gros_montant, : produit_avec_rabais, : quotient_ou_zero}
():
operation = OPERATIONS.get(t)
(operation(a, b), ) operation -
entree, attendu OBSERVE.items():
calc(*entree) == attendu, entree
rng = random.Random()
_ ():
entree = (rng.choice([, rng.uniform(, )]), rng.choice([, rng.randint(-, ), rng.uniform(, )]), rng.choice([, , , , ]))
calc(*entree) == calc_ancien(*entree), entree
calc(, , ) ==
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Écrire un gros test avant un gros bout de code | On perd les petits pas | Un comportement par cycle |
| Refactorer avec des tests rouges | On ne sait plus si on a cassé quelque chose | Toujours partir du vert |
| Mélanger refactoring et nouvelle fonctionnalité | Impossible d'isoler la cause d'un bug | Deux commits, deux pas distincts |
| Tests de caractérisation pris pour des specs | On fige des bugs | Les marquer ; corriger plus tard avec décision explicite |
🐉 Mini-boss (40 XP)
Kata complet : le score d'un jeu de bowling. Implémente score(lancers) (liste de quilles tombées par lancer, 10 manches, spares et strikes avec bonus, dernière manche spéciale) en TDD strict.
- note la liste ordonnée de tes cycles (test, code, refactor) avec au moins 12 cycles ;
- fais rejouer par un script chaque étape comme dans l'exemple (rouge avant, vert après) ;
- refactore en séparant
decouper_en_manchesetscore_manchesous la protection des tests ; - prouve l'invariant : le score max (12 strikes) est 300 et le score minimum 0 ; 5000 parties aléatoires valides ne dépassent jamais 300 ;
- rédige 10 lignes : qu'est-ce que le TDD a changé dans ta façon de concevoir l'API ?
✅ Pistes de correction
Un bon travail : une première étape score([0]*20) == 0, puis score([1]*20) == 20, puis spare ([5,5,3] + zéros → 16), puis strike ([10,3,4] + zéros → 24), puis dernière manche (spare et strike avec lancers bonus), puis partie parfaite (300). Le refactor extrait une fonction qui lit les manches avec un indice. Le générateur aléatoire doit produire des parties valides (le second lancer ne peut dépasser les quilles restantes). L'apport attendu du TDD : l'API (score(liste)) est apparue naturellement de l'usage, et les cas limites de la dernière manche ont été découverts un par un.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Le cycle du TDD est :
- A. vert, rouge, déployer
- B. refactor, rouge, vert
- C. rouge, vert, refactor
2. L'étape « vert » consiste à :
- A. écrire le code le plus simple qui fait passer le test
- B. écrire le code parfait immédiatement
- C. supprimer le test
3. Un test de caractérisation sert à :
- A. spécifier un nouveau comportement
- B. figer le comportement actuel d'un code existant avant de le refactorer
- C. accélérer le code
4. 🔁 Révision mission 07 : Un stub sert à :
- A. enregistrer des appels pour les vérifier
- B. stocker des données en base
- C. fournir des réponses préparées au code testé
5. 🔁 Révision mission 07 : Pour rendre testable un code dépendant de l'heure, on :
- A. injecte l'horloge en paramètre
- B. attend minuit
- C. lit l'horloge dans chaque fonction
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Sur quel code de ton projet n'ose-t-on plus toucher, faute de tests ?
- Quel serait le premier test de caractérisation que tu écrirais ?
🎒 À retenir
- Rouge → vert → refactor, par petits pas.
- Le code le plus simple qui passe ; triangulation pour généraliser.
- Refactorer = changer la forme, pas le comportement, sous protection des tests.
- Code hérité : caractériser d'abord, corriger ensuite.
- Le TDD guide la conception de l'API ; ce n'est pas un dogme.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Danseur rouge-vert
← Mission 07 — Doubles de test · Mission 09 — Flakiness et qualité des suites →
HEF-110 — Tests et qualité

