Les tests n'ont de valeur que s'ils tournent à chaque changement, vite, et si leur verdict bloque ce qui est cassé.
⏱️ Durée : environ 110 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Gardien du pipeline
🎬 L'histoire
La suite de HashBox est belle… mais elle ne tourne que sur l'ordinateur de Kodi, quand il y pense. Un jeudi, quelqu'un fusionne un changement sans lancer les tests : le dimanche, l'inscription est cassée. Personne ne s'en rend compte avant lundi.
« Un test qu'on peut oublier de lancer sera oublié, dit Sam. Mets-le dans la chaîne : chaque proposition de modification déclenche automatiquement les vérifications, et rien de rouge ne passe. C'est l'intégration continue. »
Dans cette dernière mission, tu bâtis un pipeline de tests complet : étapes, retour rapide, rapports, seuils de qualité, tests en parallèle, sélection des tests utiles, et gestion des instables.
🎯 Ta mission
À la fin, je serai capable de :
- décrire le rôle de l'intégration continue et des portes de qualité
- organiser un pipeline en étapes à retour rapide (échouer vite)
- produire des rapports exploitables (JUnit, couverture) et fixer des seuils
- répartir les tests en parallèle (sharding) et sélectionner ceux qui sont concernés par un changement
- maintenir la santé du pipeline (durée, instabilité, propriété)
🧩 Défi d'échauffement (5 XP)
Dans une usine, un contrôle qualité en bout de chaîne trouve un défaut… produit trois jours plus tôt, sur 4 000 pièces. Compare avec un contrôle à chaque poste. Combien de pièces sont perdues dans chaque cas ? Quelle est la logique du « retour rapide » ?
💡 Le concept
L'intégration continue (CI)
La CI exécute automatiquement, à chaque changement proposé, une série de vérifications : compilation, style, tests, sécurité. Le résultat bloque ou autorise la fusion.
| Pratique | Bénéfice |
|---|---|
| fusionner souvent, en petits changements | conflits et bugs plus petits |
| vérifications automatiques à chaque changement | pas d'oubli, même niveau d'exigence pour tous |
| rouge = priorité | le pipeline cassé se répare tout de suite |
| résultat visible de tous | responsabilité partagée |
Un pipeline de tests : des étapes ordonnées
flowchart LR
A["Style et analyse statique"] --> B["Tests unitaires"]
B --> C["Tests d'intégration"]
C --> D["Tests de contrat / API"]
D --> E["E2E (parcours critiques)"]
E --> F["Porte de qualité"]
Description du schéma : cinq étapes en chaîne, des plus rapides aux plus lentes : style et analyse statique, tests unitaires, tests d'intégration, tests de contrat et d'API, E2E sur les parcours critiques, puis une porte de qualité finale.
Principe : échouer vite. On place en premier ce qui est rapide et décisif. Si le style ou les tests unitaires échouent, inutile de lancer les E2E de dix minutes.
Les portes de qualité (quality gates)
Des seuils automatiques qui bloquent la fusion :
| Porte | Exemple |
|---|---|
| Tous les tests passent | aucune exception |
| Couverture minimale | ≥ 80 % de lignes sur le code modifié |
| Pas de nouvelle faille | analyse de sécurité (HEF-100) |
| Pas de dépendance vulnérable | audit des dépendances |
| Taille et revue | une relecture humaine obligatoire |
Une porte doit être stable et comprise : une porte qui bloque pour de mauvaises raisons est contournée.
Rapports exploitables
- JUnit XML : format standard lu par tous les outils de CI (nom de chaque test, durée, échec, message).
- Couverture : par fichier, et surtout sur le code modifié.
- Artefacts : captures d'écran, journaux, HTML des pages en échec (mission 6).
- Tendances : durée de la suite, taux d'instabilité, nombre de tests.
Rester rapide
Objectif courant : un retour en moins de 10 minutes sur un changement.
| Technique | Principe |
|---|---|
| Parallélisme | répartir les tests sur plusieurs machines (sharding) en équilibrant les durées |
| Cache | réutiliser dépendances et résultats de build |
| Sélection des tests | ne lancer que les tests concernés par les fichiers modifiés (analyse d'impact) ; suite complète en parallèle ou la nuit |
| Pyramide respectée | beaucoup d'unitaires rapides, peu d'E2E |
| Chasse aux tests lents | traiter les 10 plus lents |
Répartition équilibrée (LPT) : trier les tests par durée décroissante, et affecter chacun à la machine la moins chargée. Simple et près de l'optimum.
Analyse d'impact
Un graphe de dépendances indique quel test dépend de quel module. Si tarifs.py change, on lance les tests de tarifs et de tout ce qui en dépend (transitivement). En cas de doute (fichier de configuration global), on lance tout. Sécurité d'abord : mieux vaut un test en trop qu'un bug raté.
Un exemple de configuration
name: tests
on: [pull_request, push]
jobs:
verification:
runs-on: ubuntu-latest
timeout-minutes: 15
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with: { python-version: "3.12", cache: pip }
- run: python -m compileall -q src # style / syntaxe
- run: python -m unittest discover -s tests -v # unitaires + intégration
- run: python ci/porte_couverture.py --minimum 80
- uses: actions/upload-artifact@v4
if: always()
with: { name: , }
Santé du pipeline
| Indicateur | Cible |
|---|---|
| Durée | < 10 min |
| Taux d'instabilité | proche de 0 % (mission 9) |
| Temps de réparation d'un rouge | quelques heures au plus |
| Propriétaire de chaque test | identifié |
| Branches protégées | fusion impossible si rouge |
🧠 Astuce : un pipeline est un produit avec des utilisateurs (l'équipe). Mesure leur frustration : durée, relances, rouges inexpliqués.
🔍 Exemple pas à pas
Problème : construire un mini pipeline de CI en Python : étapes, échec rapide, rapport JUnit XML, porte de couverture, sur un vrai petit projet créé dans un dossier temporaire ; puis simuler une régression et un manque de couverture.
import ast, io, sys, tempfile, time, unittest
import xml.etree.ElementTree as ET
from pathlib import Path
sys.dont_write_bytecode = True # pas de .pyc périmé quand on réécrit un fichier de même taille dans la même seconde
CALC = '''
def somme(a, b):
return a + b
def moyenne(valeurs):
if not valeurs:
raise ValueError("vide")
return sum(valeurs) / len(valeurs)
'''
TESTS = '''
import unittest
from calc import somme, moyenne
class TestCalc(unittest.TestCase):
def test_somme(self):
self.assertEqual(somme(2, 3), 5)
def test_moyenne(self):
self.assertEqual(moyenne([2, 4]), 3)
def test_moyenne_vide(self):
with self.assertRaises(ValueError):
moyenne([])
'''
# ---------------- étapes du pipeline ----------------
def etape_syntaxe(projet):
for fichier in Path(projet).glob("*.py"):
compile(fichier.read_text(), str(fichier), "exec") # SyntaxError = échec
return True, "syntaxe valide"
class Collecteur(unittest.TextTestResult):
def __init__(self, *a, **k):
super().__init__(*a, **k)
self.lignes, self._debut = [], {}
def startTest(self, test):
self._debut[test] = time.perf_counter(); super().startTest(test)
():
.lignes.append((test.(), time.perf_counter() - ._debut[test], statut, detail))
(): ().addSuccess(test); ._noter(test, )
(): ().addFailure(test, err); ._noter(test, , ._exc_info_to_string(err, test))
(): ().addError(test, err); ._noter(test, , ._exc_info_to_string(err, test))
():
nom (, ):
sys.modules.pop(nom, )
():
sys.path.insert(, projet)
:
oublier_modules()
suite = unittest.defaultTestLoader.discover(projet, pattern=)
resultat = unittest.TextTestRunner(stream=io.StringIO(), resultclass=Collecteur).run(suite)
:
sys.path.remove(projet)
racine = ET.Element(, name=, tests=(resultat.testsRun),
failures=((resultat.failures) + (resultat.errors)))
nom, duree, statut, detail resultat.lignes:
cas = ET.SubElement(racine, , name=nom, time=)
statut != :
ET.SubElement(cas, , message=detail.strip().splitlines()[-]).text = detail
ET.ElementTree(racine).write(rapport, encoding=, xml_declaration=)
resultat.wasSuccessful(),
():
{n.lineno n ast.walk(ast.parse(source)) (n, ast.stmt)}
():
chemin = (Path(projet, ))
source = Path(chemin).read_text()
vues = ()
():
frame.f_code.co_filename == chemin:
ev == : vues.add(frame.f_lineno)
traceur
sys.path.insert(, projet)
oublier_modules()
sys.settrace(traceur)
:
suite = unittest.defaultTestLoader.discover(projet, pattern=)
unittest.TextTestRunner(stream=io.StringIO()).run(suite)
:
sys.settrace(); sys.path.remove(projet)
cibles = lignes_executables(source)
taux = (vues & cibles) / (cibles) *
taux >= minimum,
():
rapport = (Path(projet, ))
etapes = [(, : etape_syntaxe(projet)),
(, : etape_tests(projet, rapport)),
(, : etape_couverture(projet, minimum))]
journal = []
nom, fonction etapes:
debut = time.perf_counter()
ok, message = fonction()
journal.append((nom, ok , message, time.perf_counter() - debut))
ok:
journal += [(restante, , , ) restante, _ etapes[(journal):]]
, journal, rapport
, journal, rapport
():
()
nom, icone, message, duree journal:
()
tempfile.TemporaryDirectory() d:
Path(d, ).write_text(CALC)
Path(d, ).write_text(TESTS)
code, journal, rapport = pipeline(d)
afficher(, code, journal)
code == (e[] == e journal)
Path(d, ).write_text(CALC.replace(, ))
code, journal, rapport = pipeline(d)
afficher(, code, journal)
code == journal[][] == journal[][] ==
xml = ET.parse(rapport).getroot()
echecs = [c.get() c xml.() c.find() ]
(, echecs)
echecs == []
Path(d, ).write_text(CALC + )
code, journal, rapport = pipeline(d)
afficher(, code, journal)
code == journal[][] ==
Lecture :
- Les trois étapes s'enchaînent dans l'ordre du plus rapide au plus lent ; à la première panne, les suivantes sont ignorées (échouer vite) et le code de sortie vaut 1 : c'est ce code que lit un outil de CI pour bloquer la fusion.
- La régression (
a + bdevenua - b) est attrapée partest_sommeet nommée dans le rapport JUnit : le format que tous les outils savent afficher. - La porte de couverture bloque une nouvelle fonction sans test, même si tous les tests existants passent.
- Tout se passe dans un dossier temporaire : le pipeline est reproductible et sans effet de bord.
✍️ À toi, avec aide (10 XP)
Écris repartir(tests, machines) qui répartit des tests (nom → durée en secondes) sur machines machines parallèles en minimisant la durée totale (algorithme LPT : trier par durée décroissante, affecter à la machine la moins chargée). Teste avec ces durées :
{"e2e_a": 120, "e2e_b": 90, "integ_a": 45, "integ_b": 40, "integ_c": 35, "unit_a": 5, "unit_b": 4, "unit_c": 3, "unit_d": 2}
Compare la durée de la machine la plus chargée avec la durée séquentielle, pour 1, 2, 3 et 4 machines.
💡 Indice 1
Utilise une liste de charges et min(range(machines), key=...).
💡 Indice 2
La durée totale en parallèle = charge maximale.
💡 Indice 3
La somme des durées vaut 344 s.
✅ Réponse
def repartir(tests, machines):
charges = [0] * machines
affectation = [[] for _ in range(machines)]
for nom, duree in sorted(tests.items(), key=lambda kv: -kv[1]):
m = min(range(machines), key=lambda i: charges[i])
affectation[m].append(nom)
charges[m] += duree
return affectation, charges
TESTS = {"e2e_a": 120, "e2e_b": 90, "integ_a": 45, "integ_b": 40, "integ_c": 35, "unit_a": 5, "unit_b": 4, "unit_c": 3, "unit_d": 2}
sequentiel = sum(TESTS.values())
for k in (1, 2, 3, 4):
_, charges = repartir(TESTS, k)
print(f"{k} machine(s) : {max(charges):3d} s (gain x{sequentiel / (charges):f})")
sequentiel ==
(repartir(TESTS, )[]) == (repartir(TESTS, )[]) <= (repartir(TESTS, )[]) ==
🚀 À toi, en solo (20 XP)
Sélection des tests par analyse d'impact. Écris un outil tests_a_lancer(changes, dependances, tests_par_module) :
dependances: module → modules qu'il importe (ex.serviceimportedepotettarifs) ;- calcule les modules impactés (les modules modifiés et tous ceux qui en dépendent, transitivement) ;
- renvoie les tests associés aux modules impactés ;
- si un fichier « global » est modifié (
config,requirements,setup), renvoie tous les tests ; - gère les cycles de dépendances sans boucle infinie ;
- teste avec un graphe de 8 modules et 5 scénarios de changement, et calcule le gain moyen (tests évités).
✅ Pistes de correction
GLOBAUX = {"config", "requirements", "setup"}
def modules_impactes(modifies, dependances):
inverse = {}
for module, imports in dependances.items():
for i in imports:
inverse.setdefault(i, set()).add(module)
vus, pile = set(), list(modifies)
while pile:
m = pile.pop()
if m in vus:
continue
vus.add(m)
pile.extend(inverse.get(m, ())) # tous ceux qui importent m
return vus
def tests_a_lancer(changes, dependances, tests_par_module):
if set(changes) & GLOBAUX:
return sorted(t for ts in tests_par_module.values() for t in ts)
impactes = modules_impactes(changes, dependances)
return sorted(t for m in impactes for t in tests_par_module.get(m, ()))
DEPENDANCES = {"depot": [], "tarifs": [], "mail": [], "service": ["depot", ], : [, ],
: [, ], : [], : [], : []}
TESTS = {m: [ i (, )] m (, , , , , , , , )}
total = ((t) t TESTS.values())
scenarios = [[], [], [], [], [], []]
evites = []
s scenarios:
choisis = tests_a_lancer(s, DEPENDANCES, TESTS)
evites.append(total - (choisis))
()
(tests_a_lancer([], DEPENDANCES, TESTS)) == *
(tests_a_lancer([], DEPENDANCES, TESTS)) == total
{t.split()[] t tests_a_lancer([], DEPENDANCES, TESTS)} == {}
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Tests qu'on peut oublier de lancer | Régressions en production | Exécution automatique à chaque changement, fusion bloquée si rouge |
| Pipeline lent (30 min+) | On contourne ou on empile les changements | Échouer vite, paralléliser, sélectionner, viser < 10 min |
| Porte de qualité arbitraire ou instable | Contournée, ignorée | Seuils compris, stables, sur le code modifié |
| « Rouge » toléré | Les vrais bugs passent inaperçus | Rouge = priorité ; instabilités en quarantaine tracée |
🐉 Mini-boss (60 XP)
Ton pipeline de tests complet. Construis mini_ci.py qui prend un projet Python (dossier) et une configuration (dictionnaire) et exécute :
- étapes configurables (syntaxe, unitaires, intégration, couverture) avec échec rapide et temps par étape ;
- rapport JUnit XML et résumé Markdown (tests, durées, les 5 plus lents, couverture par fichier) ;
- porte de couverture sur le code modifié (en utilisant la liste de fichiers/lignes changés fournie) ;
- sélection des tests par analyse d'impact, avec repli sur la suite complète pour les fichiers globaux ;
- répartition des tests sur N machines simulées (LPT) à partir des durées de la dernière exécution ;
- quarantaine : un fichier
quarantaine.jsonliste des tests instables, exécutés mais non bloquants ; - 10 tests de
mini_ci.pylui-même, y compris régression, couverture insuffisante, test en quarantaine qui échoue sans bloquer.
Conclus par 10 lignes : parmi les mesures du pipeline, laquelle surveillerais-tu chaque semaine, et pourquoi ?
✅ Pistes de correction
Un bon projet : une fonction par étape et un orchestrateur qui retourne un code de sortie ; un Collecteur de résultats (voir exemple) pour le JUnit et les durées ; la couverture « sur le code modifié » en croisant lignes tracées et lignes changées ; l'analyse d'impact de la mission ; LPT pour la répartition ; un test en quarantaine détecté par son identifiant et compté séparément (non bloquant). L'indicateur hebdomadaire attendu : plutôt la durée de retour (l'indicateur d'expérience développeur) ou le taux d'instabilité (indicateur de confiance) — avec une justification liant la métrique à un comportement d'équipe (contournement, relance, abandon).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Dans un pipeline, on place en premier :
- A. les étapes rapides et décisives
- B. les étapes les plus longues
- C. les tests E2E
2. Une porte de qualité est :
- A. une règle facultative
- B. un seuil automatique qui bloque la fusion s'il n'est pas respecté
- C. un outil de design
3. Pour accélérer une suite lente, on peut :
- A. supprimer les assertions
- B. désactiver les tests qui échouent
- C. paralléliser, mettre en cache et ne lancer que les tests concernés
4. 🔁 Révision mission 09 : Un test instable est un test qui :
- A. passe ou échoue sur le même code sans modification
- B. est très lent
- C. n'a pas d'assertion
5. 🔁 Révision mission 09 : Un mutant survivant indique :
- A. que le code est parfait
- B. que la suite n'a pas détecté une altération du code
- C. que le mutant est mort
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Combien de temps s'écoule aujourd'hui entre ton changement et le verdict des tests ? Que ferais-tu si cela doublait ?
- Quelle règle d'équipe garantirait que le rouge soit réparé tout de suite ?
🎒 À retenir
- CI : vérifications automatiques à chaque changement ; rouge = priorité.
- Étapes ordonnées du plus rapide au plus lent : échouer vite.
- Rapports (JUnit, couverture) et portes de qualité stables.
- Rapidité : parallélisme (LPT), cache, sélection par impact.
- Santé : durée, instabilité, quarantaine tracée, propriétaires.
🏅 Récompenses
Total possible : 120 XP · 🏅 Badge Gardien du pipeline
← Mission 09 — Flakiness et qualité des suites
🎉 Félicitations
Tu as terminé HEF-110 — Tests et qualité. Tu sais spécifier un comportement par des exemples, écrire des tests unitaires, d'intégration, d'API et de bout en bout, utiliser des doubles avec discernement, avancer en TDD, traquer l'instabilité, mesurer la qualité d'une suite par la mutation et la faire tourner dans un pipeline.
→ Prochain module : HEF-120 — DevOps et livraison
HEF-110 — Tests et qualité

