Un test qui échoue parfois sans raison est pire qu'un test absent : il apprend à toute l'équipe à ignorer le rouge.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Chasseur de tests instables
🎬 L'histoire
Chez HashBox, le pipeline est rouge un jour sur cinq. Les développeurs ont pris l'habitude de cliquer « relancer ». Un mardi, le pipeline est rouge pour de bon : un vrai bug. Personne ne le remarque pendant deux jours, tout le monde pensant à « un test instable ».
« C'est la pire conséquence, dit Maya. Quand le rouge ne veut plus rien dire, la suite de tests ne protège plus personne. Et ce n'est pas une fatalité : l'instabilité a des causes précises, qu'on sait chasser. »
Tu apprends à reconnaître les causes d'instabilité, à les détecter par la méthode, à les corriger, et à mesurer la vraie qualité d'une suite avec le test de mutation.
🎯 Ta mission
À la fin, je serai capable de :
- lister les causes classiques d'instabilité (temps, hasard, ordre, concurrence, réseau, état partagé)
- détecter un test instable en le rejouant dans des ordres et conditions variés
- corriger une instabilité par injection, graine fixée, isolation et attente explicite
- mesurer la qualité d'une suite avec le test de mutation
- gérer les tests instables (quarantaine) sans les laisser s'installer
🧩 Défi d'échauffement (5 XP)
Une balance de cuisine affiche 250 g, puis 247 g, puis 253 g pour le même sac de farine. Pourrais-tu t'en servir pour une recette précise ? Compare avec un test qui passe 9 fois sur 10 : qu'apprend-il à ceux qui voient le rouge ?
💡 Le concept
Un test instable (flaky)
Un test est instable s'il peut passer ou échouer sur le même code, sans modification. Conséquences : confiance perdue, relances inutiles, vrais bugs masqués, pipeline ralenti.
Les causes classiques
| Cause | Exemple | Remède |
|---|---|---|
| Temps | « il est entre 9 h et 18 h » ; durée mesurée ; expiration | horloge injectée, durées larges ou simulées |
| Hasard | random sans graine | générateur injecté, graine fixée, afficher la graine |
| Ordre | un test suppose que le précédent a créé des données | isolation complète (mission 3) |
| État partagé | variable globale, fichier, base commune | créer/détruire dans chaque test |
| Concurrence | threads dont l'ordre varie | synchronisation explicite, attentes sur conditions |
| Attentes fixes | sleep(1) en espérant que ce soit prêt | attente explicite (mission 6) |
Détecter : rejouer pour révéler
Un test instable se révèle en variant les conditions :
- Rejouer N fois le même test ;
- Mélanger l'ordre des tests ;
- Varier la graine du hasard ;
- Exécuter en parallèle ou sous charge ;
- Changer l'environnement (fuseau, locale, vitesse).
Un test est instable si, sur le même code, il réussit parfois et échoue parfois. Son taux d'échec (par exemple 3/30) le classe par urgence.
Gérer : la quarantaine
Un test instable ne doit pas bloquer toute l'équipe, ni être ignoré :
- le sortir de la voie bloquante (quarantaine), avec une étiquette, un responsable et une échéance ;
- continuer à l'exécuter (pour mesurer) dans une voie non bloquante ;
- le corriger ou le supprimer — un test en quarantaine qui traîne est une dette.
Jamais de « relancer automatiquement jusqu'au vert » sans trace : ça cache le problème.
La qualité d'une suite : au-delà de la couverture
La couverture dit ce qui est exécuté. Le test de mutation mesure ce qui est vérifié :
- on crée des mutants : copies du code avec une petite altération (
>=devient>,*devient/,3devient4) ; - on lance la suite sur chaque mutant ;
- un mutant tué = au moins un test échoue ; un mutant survivant = la suite n'a rien remarqué ;
- score de mutation = mutants tués / mutants total.
Un mutant survivant désigne un test manquant ou trop vague. Certains survivants sont des mutants équivalents (la modification ne change pas le comportement) : on les écarte à la main.
| Mesure | Ce qu'elle dit |
|---|---|
| Couverture de lignes | quelles lignes sont exécutées |
| Couverture des branches | quelles décisions ont pris les deux chemins |
| Score de mutation | si les tests détectent réellement des défauts |
| Taux d'instabilité | à quel point on peut leur faire confiance |
| Durée de la suite | à quelle vitesse on a un retour |
Entretenir la suite
- Supprimer les tests redondants ou sans valeur ;
- Accélérer : repérer les 10 tests les plus lents ;
- Lire les échecs : message clair, valeurs attendues et obtenues ;
- Revoir les tests comme du code : une suite est un produit.
🧠 Astuce : un test instable est un bug dans le test ou dans le code (courses, états cachés). Ne conclus jamais « c'est juste instable » sans avoir cherché laquelle des deux causes c'est.
🔍 Exemple pas à pas
Problème : (1) détecter des tests instables en variant ordre et graine, (2) les corriger, (3) montrer avec un mini test de mutation qu'une couverture de 100 % peut cacher une suite faible.
import ast, io, random, sys, unittest
from datetime import datetime
# ================= 1. une classe de tests FRAGILE =================
COMPTEUR = {"n": 0}
def prochain_id():
COMPTEUR["n"] += 1
return COMPTEUR["n"]
def tirage():
return random.randint(1, 6)
def est_heure_ouvrable():
return 9 <= datetime.now().hour < 18 # dépend de l'heure réelle
class TestFragile(unittest.TestCase):
def test_premier_identifiant_vaut_un(self):
self.assertEqual(prochain_id(), 1) # ❌ dépend de l'ordre (état global)
def test_deux_identifiants_successifs(self):
a = prochain_id(); b = prochain_id()
self.assertEqual(b, a + 1)
def test_le_de_ne_donne_pas_six(self):
self.assertLess(tirage(), 6) # ❌ dépend du hasard (échoue quand on tire 6)
def test_stable():
.assertEqual(([, , ]), [, , ])
():
echecs = {}
essai (essais):
random.seed(essai)
COMPTEUR[] =
tests = (unittest.defaultTestLoader.loadTestsFromTestCase(classe))
random.Random(essai).shuffle(tests)
resultat = unittest.TextTestRunner(stream=io.StringIO()).run(unittest.TestSuite(tests))
test, _ resultat.failures + resultat.errors:
echecs[test._testMethodName] = echecs.get(test._testMethodName, ) +
echecs
taux = detecter(TestFragile)
instables = {nom: n nom, n taux.items() < n < }
(, {nom: nom, n (instables.items())})
instables instables
taux
:
(): .n =
():
.n += ; .n
():
rng.randint(, )
():
<= maintenant.hour <
(unittest.TestCase):
():
.g = Generateur()
():
.assertEqual(.g.prochain(), )
():
a = .g.prochain(); b = .g.prochain()
.assertEqual(b, a + )
():
graine ():
.assertIn(tirage_corrige(random.Random(graine)), (, ))
():
.assertTrue(est_heure_ouvrable_corrigee(datetime(, , , , )))
.assertFalse(est_heure_ouvrable_corrigee(datetime(, , , , )))
detecter(TestStable) == {}
()
SOURCE =
():
[n n ast.walk(arbre)
(n, (ast.Compare, ast.BinOp)) ((n, ast.Constant) (n.value, (, )) (n.value, ))]
PERMUTATION = {ast.GtE: ast.Gt, ast.Gt: ast.GtE, ast.Eq: ast.NotEq, ast.NotEq: ast.Eq, ast.Lt: ast.LtE, ast.LtE: ast.Lt}
():
arbre = ast.parse(source)
n = sites(arbre)[k]
(n, ast.Compare):
n.ops[] = PERMUTATION[(n.ops[])]()
(n, ast.BinOp):
n.op = ast.Div() (n.op, ast.Mult) ast.Sub() (n.op, ast.Add) n.op
:
n.value = n.value +
ast.fix_missing_locations(arbre)
ast.unparse(arbre)
():
remise(, ) ==
remise(, ) >
remise(, ) ==
():
remise(, ) ==
remise(, ) ==
remise(, ) ==
remise(, ) ==
():
total = (sites(ast.parse(SOURCE)))
survivants = []
k (total):
espace = {}
(muter(SOURCE, k), espace)
:
suite(espace[]); survivants.append(k)
AssertionError:
Exception:
total, survivants
():
espace = {}
((SOURCE, , ), espace)
vues = ()
():
frame.f_code.co_filename == :
ev == : vues.add(frame.f_lineno)
traceur
sys.settrace(traceur); suite(espace[]); sys.settrace()
corps = {ligne c [espace[].__code__] _, _, ligne c.co_lines() ligne ligne != c.co_firstlineno}
(vues & corps) / (corps)
nom, suite ((, suite_faible), (, suite_forte)):
total, survivants = score(suite)
()
couverture(suite_faible) ==
(score(suite_faible)[]) > score(suite_forte)[] == []
Lecture :
detecter()rejoue la suite 40 fois en variant la graine et l'ordre. Les tests qui échouent seulement parfois sont identifiés avec leur taux d'échec. Les causes sont visibles : état global (COMPTEUR) et hasard non maîtrisé.- La version corrigée applique les remèdes : état créé dans
setUp, hasard injecté (on teste toutes les graines), horloge passée en paramètre. - Le test de mutation montre qu'une suite peut avoir 100 % de couverture (toutes les lignes sont exécutées) et laisser survivre des mutants (
> 0est une assertion trop vague). La suite forte tue tous les mutants.
✍️ À toi, avec aide (10 XP)
Corrige ces trois tests instables en écrivant pour chacun la cause et la version stable :
# A
def test_expiration():
token = creer_token()
time.sleep(1)
assert token.est_valide() # valide pendant 1 s seulement
# B
def test_liste_utilisateurs():
assert str(set(["ada", "bob", "cleo"])) == "{'ada', 'bob', 'cleo'}"
# C
def test_resultat_asynchrone():
lancer_calcul()
time.sleep(0.5)
assert lire_resultat() == 42
💡 Indice 1
A : le temps réel. Injecte une horloge ou fixe une durée de validité large avec horloge simulée.
💡 Indice 2
B : l'ordre des éléments d'un ensemble n'est pas garanti ; compare des ensembles.
💡 Indice 3
C : remplace sleep par une attente explicite avec délai maximal.
✅ Réponse
| Test | Cause | Correction |
|---|---|---|
| A | dépendance au temps réel (sleep près de l'expiration) | creer_token(maintenant) avec horloge injectée ; avancer l'horloge simulée de 0,9 s puis de 1,1 s |
| B | ordre non garanti d'un set converti en texte | assert set(lister()) == {"ada", "bob", "cleo"} ou sorted(...) |
| C | attente fixe | attendre(lambda: lire_resultat() is not None, delai=5) puis assert lire_resultat() == 42 |
from datetime import datetime, timedelta
class :
():
.cree, .duree = maintenant, duree
():
maintenant - .cree < .duree
t0 = datetime(, , , , , )
token = Token(t0)
token.est_valide(t0 + timedelta(seconds=))
token.est_valide(t0 + timedelta(seconds=))
{, , } == ([, , ])
()
🚀 À toi, en solo (20 XP)
Mini outil de gestion d'instabilité. Écris Suivi qui :
- enregistre, pour chaque exécution de suite, le résultat (réussi/échoué) de chaque test, avec le numéro de validation (commit) ;
- calcule le taux d'instabilité d'un test : parmi les exécutions sur le même commit, la proportion de résultats qui diffèrent du résultat majoritaire ;
- met en quarantaine (liste) les tests avec taux > 5 % sur au moins 5 exécutions ;
- sort un rapport : tests en quarantaine, depuis quand, taux ;
- teste avec 3 commits simulés : un test stable, un test cassé réellement (échoue toujours après le commit 2), un test instable (échoue 30 % du temps, graine fixée). Montre que le test réellement cassé n'est pas mis en quarantaine.
✅ Pistes de correction
import random
from collections import defaultdict
class Suivi:
def __init__(self):
self.executions = defaultdict(lambda: defaultdict(list)) # test -> commit -> [bool, ...]
def enregistrer(self, commit, resultats):
for test, ok in resultats.items():
self.executions[test][commit].append(ok)
def taux_instabilite(self, test):
diff = total = 0
for resultats in self.executions[test].values():
if len(resultats) < 2:
continue
majoritaire = max(set(resultats), key=resultats.count)
diff += sum(1 for r in resultats if r != majoritaire)
total += len(resultats)
return diff / total if total else 0.0
def ():
((r) r .executions[test].values())
():
(t t .executions .nombre_executions(t) >= minimum .taux_instabilite(t) > seuil)
rng = random.Random()
suivi = Suivi()
commit (, , ):
_ ():
suivi.enregistrer(commit, {
: ,
: commit < ,
: rng.random() > ,
})
quarantaine = suivi.quarantaine()
t (, , ):
()
quarantaine == []
suivi.taux_instabilite() ==
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| « Relancer jusqu'au vert » | Cache les vrais bugs et l'instabilité | Tracer, mesurer le taux, corriger |
sleep fixes pour attendre | Lents et instables à la fois | Attentes explicites sur une condition |
| Hasard, horloge, réseau non maîtrisés | Échecs non reproductibles | Injection, graines fixées, doubles |
| Se fier uniquement à la couverture | Une suite peut tout exécuter sans rien vérifier | Compléter par le test de mutation |
🐉 Mini-boss (40 XP)
Audit de santé d'une suite de tests. On te fournit (ou tu écris) un petit projet de 4 fonctions et une suite de 15 tests dont 4 sont instables (heure, hasard, ordre, état global) et 3 sont faibles (assertions vagues).
- écris le détecteur d'instabilité (ordre mélangé, 50 graines, mesure du taux) et classe les tests ;
- corrige les 4 tests instables ;
- écris un test de mutation pour les 4 fonctions (au moins 25 mutants) et calcule le score avant/après renforcement des tests faibles ;
- liste les mutants survivants équivalents que tu écartes, avec justification ;
- produis un rapport de santé : couverture, taux d'instabilité, score de mutation, tests les plus lents.
✅ Pistes de correction
Un bon travail : detecter() qui renvoie des taux ; corrections par injection (horloge, rng), setUp pour l'état ; un mutateur AST paramétrable (opérateurs de comparaison, arithmétiques, constantes, and/or, return de constantes) ; score avant (par exemple 60 %) et après (par exemple 95 %) ; justification des équivalents (par exemple x >= 0 → x > 0 quand x est toujours un entier strictement positif par construction) ; rapport en tableau. Le point important : le mutant équivalent doit être démontré équivalent, pas simplement « gênant ».
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un test instable est un test qui :
- A. est très lent
- B. passe ou échoue sur le même code sans modification
- C. n'a pas d'assertion
2. Pour détecter l'instabilité, on peut :
- A. supprimer le test
- B. lancer une seule fois
- C. rejouer en variant l'ordre, la graine et l'environnement
3. Un mutant survivant indique :
- A. que la suite n'a pas détecté une altération du code
- B. que le code est parfait
- C. que le mutant est mort
4. 🔁 Révision mission 08 : Le cycle du TDD est :
- A. vert, rouge, déployer
- B. rouge, vert, refactor
- C. refactor, rouge, vert
5. 🔁 Révision mission 08 : Un test de caractérisation sert à :
- A. spécifier un nouveau comportement
- B. accélérer le code
- C. figer le comportement actuel d'un code existant avant de le refactorer
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Quel test « qui échoue parfois » existe dans ton équipe ? Que s'est-il passé la dernière fois qu'un vrai bug s'y est caché ?
- Pourquoi mesurer l'instabilité sur le même code (même commit) est-il essentiel ?
🎒 À retenir
- Instable = résultat variable sans changement de code.
- Causes : temps, hasard, ordre, état partagé, concurrence, attentes fixes, réseau.
- Détecter : rejouer en variant ordre, graine, environnement.
- Quarantaine tracée avec échéance, jamais « relancer jusqu'au vert ».
- Mutation : le score mesure ce que les tests vérifient vraiment.
flowchart LR
T(["Flakiness et qualité des suites"])
T --> R1["1. Instable = résultat variable sans changement de code."]
T --> R2["2. Causes : temps, hasard, ordre, état partagé, concurrence, attentes…"]
T --> R3["3. Détecter : rejouer en variant ordre, graine, environnement."]
T --> R4["4. Quarantaine tracée avec échéance, jamais « relancer jusqu'au vert »."]
T --> R5["5. Mutation : le score mesure ce que les tests vérifient vraiment."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Chasseur de tests instables
← Mission 08 — TDD et refactoring · Mission 10 — Tests dans CI →
HEF-110 — Tests et qualité

