Un bon test unitaire est petit, rapide, indépendant, et il échoue pour une seule raison que l'on comprend tout de suite.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Orfèvre du test
🎬 L'histoire
La suite de tests de HashBox compte 300 tests. Un matin, un seul changement fait échouer 47 tests. Personne ne sait lequel regarder. Certains échouent seulement quand on les lance après d'autres. D'autres portent des noms comme test1 ou test_ok.
« Une suite de tests est du code, dit Sam. Elle doit être aussi lisible et maintenable que le reste. Un bon test unitaire, c'est le contraire d'un cas particulier : c'est une phrase claire, une cause, une raison d'échouer. »
Tu apprends à écrire des tests unitaires de qualité professionnelle, à mesurer ce qu'ils couvrent, et à reconnaître les mauvaises odeurs.
🎯 Ta mission
À la fin, je serai capable de :
- structurer un test (préparer, agir, vérifier) et le nommer par comportement
- utiliser
setUp/tearDown,assertRaises,assertAlmostEqual - garantir l'indépendance et le déterminisme des tests
- mesurer la couverture de lignes et en comprendre les limites
- reconnaître et corriger les mauvaises odeurs de tests
🧩 Défi d'échauffement (5 XP)
Compare deux noms de test : test1 et test_un_panier_vide_a_un_total_de_zero. Si l'un des deux échoue à 3 h du matin dans un pipeline, lequel te dit immédiatement ce qui ne va pas ? Écris trois autres noms de test pour un Panier selon ce modèle.
💡 Le concept
Ce qu'est une « unité »
Une unité est la plus petite partie du code qui a un comportement observable : une fonction, une méthode, une petite classe. Un test unitaire la vérifie isolée, sans réseau, sans base de données, sans disque lent, sans horloge réelle.
Les qualités d'un bon test (F.I.R.S.T.)
| Lettre | Qualité | Signification |
|---|---|---|
| F | Fast | rapide : des millisecondes |
| I | Independent | indépendant : l'ordre d'exécution ne change rien |
| R | Repeatable | reproductible : même résultat à chaque exécution et partout |
| S | Self-validating | auto-vérifiant : réussi ou échoué, sans interprétation humaine |
| T | Timely | écrit au bon moment : avec (ou avant) le code |
Nommer et structurer
- Nom = comportement :
test_un_code_expire_est_refuse, pastest_code_2. - Une idée par test : si le nom contient « et », ce sont deux tests.
- Préparer / agir / vérifier séparés par des lignes vides.
- Les valeurs du test sont visibles dans le test (pas cachées dans trois fichiers).
Fixtures : setUp et tearDown
setUp s'exécute avant chaque test pour préparer un état neuf ; tearDown nettoie après. Chaque test repart donc d'un état propre : c'est la clé de l'indépendance.
Assertions utiles
| Assertion | Usage |
|---|---|
assertEqual(a, b) | égalité (message clair avec les deux valeurs) |
assertAlmostEqual(a, b, places=2) | flottants |
assertIn(x, conteneur) | appartenance |
assertRaises(Erreur) + assertRaisesRegex | exception attendue |
assertIsNone, assertIsInstance | état et type |
assertCountEqual(a, b) | mêmes éléments, ordre indifférent |
Tester le comportement, pas l'implémentation
| Test fragile (implémentation) | Test robuste (comportement) |
|---|---|
| vérifie qu'une fonction privée a été appelée 3 fois | vérifie le résultat final observable |
lit les attributs internes _items | passe par l'interface publique |
Si tu peux réorganiser le code sans changer le comportement et que des tests cassent, ils testent l'implémentation.
La couverture
La couverture de lignes indique la part des lignes exécutées par les tests.
- Elle détecte ce qui n'est jamais exécuté (utile).
- Elle ne dit pas si le code est bien vérifié : une ligne exécutée sans assertion est « couverte ».
- Viser 100 % par principe produit des tests creux ; on vise la couverture des comportements importants, avec un seuil raisonnable (par exemple 80 %) comme alerte, pas comme but.
On peut la mesurer avec l'outil coverage ; en Python pur, sys.settrace suffit à comprendre le principe (voir l'exemple).
Mauvaises odeurs de tests
| Odeur | Problème | Remède |
|---|---|---|
| Test géant | fait vingt choses | un comportement par test |
| Dépendance d'ordre | passe seul, échoue en suite | setUp neuf, pas d'état global |
| Aléatoire/horloge | échecs intermittents | graine fixée, horloge injectée |
Assertion vague (assertTrue(x)) | échec peu informatif | assertEqual avec la valeur attendue |
Logique dans le test (boucles, if) | le test peut être faux | valeurs en dur, tables |
| Copier-coller massif | maintenance pénible |
🧠 Astuce : un test qui échoue doit répondre en 10 secondes à : quel comportement est cassé, avec quelle entrée, quelle sortie attendue et obtenue ?
🔍 Exemple pas à pas
Problème : tester un Panier proprement, vérifier l'indépendance des tests, et mesurer la couverture de lignes avec un mini-outil.
import io, sys, unittest
class Panier:
def __init__(self):
self._lignes = {} # code -> (prix_cents, quantite)
def ajouter(self, code, prix_cents, quantite=1):
if prix_cents < 0 or quantite <= 0:
raise ValueError("prix ou quantité invalide")
ancien = self._lignes.get(code, (prix_cents, 0))
self._lignes[code] = (prix_cents, ancien[1] + quantite)
def retirer(self, code):
if code not in self._lignes:
raise KeyError(code)
del self._lignes[code]
def total(self):
return sum(prix * qte for prix, qte in self._lignes.values())
def nombre_articles(self):
return sum(qte for _, qte ._lignes.values())
(unittest.TestCase):
():
.panier = Panier()
():
.assertEqual(.panier.total(), )
():
.panier.ajouter(, , )
.panier.ajouter(, )
.assertEqual(.panier.total(), )
():
.panier.ajouter(, )
.panier.ajouter(, )
.assertEqual(.panier.nombre_articles(), )
():
.panier.ajouter(, )
.panier.retirer()
.assertEqual(.panier.total(), )
():
.assertRaises(KeyError):
.panier.retirer()
():
.assertRaisesRegex(ValueError, ):
.panier.ajouter(, -)
():
unittest.defaultTestLoader.loadTestsFromTestCase(TestPanier)
random
tests = (suite())
random.Random().shuffle(tests)
resultat = unittest.TextTestRunner(stream=io.StringIO()).run(unittest.TestSuite(tests))
resultat.wasSuccessful(),
()
():
code_cible = {Panier.ajouter.__code__, Panier.retirer.__code__, Panier.total.__code__, Panier.nombre_articles.__code__}
vues = ()
():
frame.f_code code_cible:
evenement == :
vues.add((frame.f_code.co_name, frame.f_lineno))
traceur
sys.settrace(traceur)
:
fonction()
:
sys.settrace()
toutes = ()
c code_cible:
toutes |= {(c.co_name, ligne) _, _, ligne c.co_lines() ligne ligne != c.co_firstlineno}
vues, toutes
vues, toutes = mesurer(: unittest.TextTestRunner(stream=io.StringIO()).run(suite()))
()
(vues) / (toutes) >=
Lecture :
- Chaque test porte un nom de comportement ; une panne se lit comme une phrase.
setUpcrée un panier neuf : mélanger l'ordre ne change rien (indépendance).- Les tests passent par l'interface publique, jamais par
_lignes. - Le mini-outil de couverture compte les lignes exécutées par la suite. Les vrais outils (
coverage) font la même chose avec plus de confort et des rapports.
La couverture de 100 % ici ne prouve pas l'absence de bug : elle dit seulement que chaque ligne a été exécutée. Si on supprimait toutes les assertions, elle resterait à 100 %.
✍️ À toi, avec aide (10 XP)
Voici une suite de tests de mauvaise qualité pour la classe Panier de l'exemple :
def test1(self):
p = Panier()
p.ajouter("A", 100, 2)
p.ajouter("B", 50)
p.retirer("B")
assert p.total() >= 0
self.assertTrue(p._lignes)
for c in ["A", "B"]:
if c in p._lignes:
print(c)
Fais la liste des mauvaises odeurs, puis réécris en trois bons tests.
💡 Indice 1
Cherche : nom vague, plusieurs comportements, assertion vague (>= 0), accès à _lignes, logique et print dans le test.
💡 Indice 2
Un test par comportement : total après ajout, retrait, quantité.
💡 Indice 3
Utilise des valeurs précises pour assertEqual.
✅ Réponse
Mauvaises odeurs : nom test1 sans sens ; plusieurs comportements dans un seul test ; assert p.total() >= 0 ne détecterait presque aucun bug ; assertTrue(p._lignes) teste l'implémentation interne ; une boucle avec if et un print n'ont rien à faire dans un test.
import io, unittest
class Panier:
def __init__(self):
self._lignes = {}
def ajouter(self, code, prix_cents, quantite=1):
ancien = self._lignes.get(code, (prix_cents, 0))
self._lignes[code] = (prix_cents, ancien[1] + quantite)
def retirer(self, code):
del self._lignes[code]
def total(self):
return sum(p * q for p, q in self._lignes.values())
class TestPanierPropre(unittest.TestCase):
():
.p = Panier()
():
.p.ajouter(, , )
.p.ajouter(, )
.assertEqual(.p.total(), )
():
.p.ajouter(, , )
.p.ajouter(, )
.p.retirer()
.assertEqual(.p.total(), )
():
.p.ajouter(, )
.p.retirer()
.assertEqual(.p.total(), )
resultat = unittest.TextTestRunner(stream=io.StringIO()).run(unittest.defaultTestLoader.loadTestsFromTestCase(TestPanierPropre))
resultat.wasSuccessful()
(resultat.testsRun, )
🚀 À toi, en solo (20 XP)
Écris la suite complète d'une classe Pile bornée (capacité fixée : empiler, depiler, sommet, est_vide, est_pleine, taille) en respectant F.I.R.S.T. :
- au moins 12 tests, nommés par comportement, avec
setUp; - couvre : pile vide, pleine, dépassement (
OverflowError), dépilement d'une pile vide (IndexError), ordre LIFO, capacité 1, capacité invalide (≤ 0) ; - prouve l'indépendance en mélangeant l'ordre des tests ;
- mesure la couverture de lignes avec
sys.settrace; - injecte 3 bugs (mauvaise borne de capacité, ordre FIFO au lieu de LIFO,
taillefausse après dépilement) et montre que la suite les détecte.
✅ Pistes de correction
import io, random, sys, unittest
class Pile:
def __init__(self, capacite):
if capacite <= 0:
raise ValueError("capacité invalide")
self._capacite, self._elements = capacite, []
def empiler(self, x):
if self.est_pleine():
raise OverflowError("pile pleine")
self._elements.append(x)
def depiler(self):
if self.est_vide():
raise IndexError("pile vide")
return self._elements.pop()
def sommet(self):
if self.est_vide():
raise IndexError("pile vide")
return self._elements[-1]
def est_vide(self):
return ._elements
():
(._elements) == ._capacite
():
(._elements)
(unittest.TestCase):
():
.p = Pile()
():
.assertTrue(.p.est_vide()); .assertEqual(.p.taille(), )
():
.p.empiler(); .assertEqual(.p.taille(), ); .assertFalse(.p.est_vide())
():
x (, , ): .p.empiler(x)
.assertEqual([.p.depiler() _ ()], [, , ])
():
.p.empiler(); .assertEqual(.p.sommet(), ); .assertEqual(.p.taille(), )
():
x (): .p.empiler(x)
.assertTrue(.p.est_pleine())
.assertRaises(OverflowError): .p.empiler()
():
.assertRaises(IndexError): .p.depiler()
():
.assertRaises(IndexError): .p.sommet()
():
.p.empiler(); .p.empiler(); .p.depiler()
.assertEqual(.p.taille(), )
():
p = Pile(); p.empiler()
.assertTrue(p.est_pleine())
.assertRaises(OverflowError): p.empiler()
():
c (, -):
.assertRaises(ValueError): Pile(c)
():
x (): .p.empiler(x)
.p.depiler(); .assertFalse(.p.est_pleine())
():
.p.empiler(); .p.depiler(); .p.empiler()
.assertEqual(.p.sommet(), )
():
tests = (unittest.defaultTestLoader.loadTestsFromTestCase(TestPile))
ordre :
random.Random(ordre).shuffle(tests)
unittest.TextTestRunner(stream=io.StringIO()).run(unittest.TestSuite(tests))
lancer().wasSuccessful() lancer().wasSuccessful()
()
cibles = {m.__code__ m (Pile.empiler, Pile.depiler, Pile.sommet, Pile.est_vide, Pile.est_pleine, Pile.taille, Pile.__init__)}
vues = ()
():
frame.f_code cibles:
ev == : vues.add((frame.f_code.co_name, frame.f_lineno))
traceur
sys.settrace(traceur); lancer(); sys.settrace()
toutes = {(c.co_name, l) c cibles _, _, l c.co_lines() l l != c.co_firstlineno}
()
(vues) == (toutes)
originaux = (Pile.est_pleine, Pile.depiler, Pile.taille)
Pile.est_pleine = : (._elements) > ._capacite
lancer().wasSuccessful(); Pile.est_pleine = originaux[]
Pile.depiler = : ._elements.pop()
lancer().wasSuccessful(); Pile.depiler = originaux[]
Pile.taille = : (._elements) +
lancer().wasSuccessful(); Pile.taille = originaux[]
lancer().wasSuccessful()
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Test géant | Impossible de savoir ce qui casse | Un comportement par test, nom explicite |
| Dépendances entre tests | Passe seul, échoue en suite | setUp neuf, aucun état partagé |
| Viser 100 % de couverture par principe | Tests creux sans assertion | Viser les comportements importants ; la couverture sert d'alerte |
| Tester les détails internes | Casse à chaque refactoring | Passer par l'interface publique |
🐉 Mini-boss (40 XP)
Assainir une suite malade. On te donne une classe Inscription (inscrire un membre à un cours avec capacité maximale, liste d'attente, désinscription qui promeut le premier en attente) et une suite de 6 tests « malades » : noms test_a, dépendance d'ordre via une variable globale, assertions assertTrue(x), test de 40 lignes, heure réelle, accès à _attente.
- Écris la classe et la suite malade ;
- liste les mauvaises odeurs de chacune (tableau) ;
- réécris une suite saine de 12+ tests selon F.I.R.S.T. ;
- mesure la couverture avant/après ;
- injecte 5 bugs (promotion dans le mauvais ordre, dépassement de capacité, désinscription d'un absent, doublon, attente non vidée) : la suite malade en détecte combien ? la saine ?
✅ Pistes de correction
Un bon travail : tableau d'odeurs (nom, ordre, assertions vagues, test géant, horloge, détails internes) ; suite saine avec setUp, valeurs en dur, noms comme test_desinscrire_promeut_le_premier_de_la_liste_d_attente ; comparaison chiffrée (par exemple malade 2/5 bugs détectés, saine 5/5). Le point de réflexion attendu : la couverture de lignes de la suite malade pouvait être proche de la saine, alors que sa capacité de détection est bien plus faible — la couverture mesure l'exécution, pas la vérification.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. F.I.R.S.T. désigne les qualités d'un test :
- A. fort, intuitif, riche, simple, testable
- B. rapide, indépendant, reproductible, auto-vérifiant, écrit à temps
- C. fiable, interne, résilient, sûr, tracé
2. setUp sert à :
- A. arrêter les tests
- B. mesurer la couverture
- C. préparer un état neuf avant chaque test
3. Une couverture de 100 % signifie :
- A. que chaque ligne a été exécutée, pas forcément bien vérifiée
- B. que le code n'a aucun bug
- C. que les tests sont rapides
4. 🔁 Révision mission 02 : Une valeur limite est :
- A. une valeur extrêmement grande seulement
- B. une valeur située juste autour d'un seuil de la règle
- C. une valeur choisie au hasard
5. 🔁 Révision mission 02 : Une propriété de test est :
- A. un exemple unique
- B. une variable privée
- C. un énoncé vrai pour toute entrée, vérifié sur beaucoup d'entrées
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Dans ton code actuel, quel test aurait besoin d'un meilleur nom ?
- Pourquoi une couverture élevée peut-elle donner une fausse confiance ?
🎒 À retenir
- Un test unitaire isole une unité : rapide, indépendant, reproductible.
- Nom = comportement ; préparer / agir / vérifier ; une raison d'échouer.
setUppour repartir d'un état neuf.- Tester le comportement public, pas l'implémentation.
- La couverture détecte le non exécuté, pas le mal vérifié.
flowchart LR
T(["Tests unitaires"])
T --> R1["1. Un test unitaire isole une unité : rapide, indépendant, reproductible."]
T --> R2["2. Nom = comportement ; préparer / agir / vérifier ; une raison…"]
T --> R3["3. setUp pour repartir d'un état neuf."]
T --> R4["4. Tester le comportement public, pas l'implémentation."]
T --> R5["5. La couverture détecte le non exécuté, pas le mal vérifié."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Orfèvre du test
← Mission 02 — Spécifications et comportements · Mission 04 — Tests d'intégration →
HEF-110 — Tests et qualité

