Chaque pièce fonctionne seule. Mais la machine, elle, fonctionne-t-elle ? Les tests d'intégration vérifient les coutures.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Assembleur de preuves
🎬 L'histoire
Toutes les pages de la suite verte. Pourtant, le jour du déploiement, l'inscription à un cours échoue pour tout le monde. Le coupable : le service d'inscription appelle le dépôt avec (membre, cours), alors que le dépôt attend (cours, membre). Les tests unitaires de chacun passaient : chacun testait avec son hypothèse sur l'autre.
« Les bugs adorent les coutures, dit Sam. Entre deux modules, entre le code et la base, entre ton service et celui d'un autre. Un test d'intégration prend les vraies pièces et les fait travailler ensemble. »
Tu apprends à tester des composants réels ensemble : base de données, fichiers, transactions, jeux de données maîtrisés.
🎯 Ta mission
À la fin, je serai capable de :
- expliquer ce que testent les tests d'intégration et ce que les tests unitaires ne voient pas
- tester du code avec une vraie base de données (SQLite en mémoire)
- isoler chaque test grâce à des transactions ou une base neuve
- gérer les données de test et les fichiers temporaires
- décider quoi tester en unitaire et quoi en intégration
🧩 Défi d'échauffement (5 XP)
Une équipe de relais 4×100 m : chaque coureur est excellent seul, mais le témoin tombe à chaque passage. Quels tests n'auraient jamais détecté le problème (chronométrer chaque coureur seul) ? Quel test le détecterait immédiatement ?
💡 Le concept
Ce qu'on teste
Un test d'intégration vérifie que plusieurs composants réels fonctionnent ensemble : service + base de données, module + système de fichiers, deux services, code + bibliothèque externe.
| Les unitaires voient | Les intégrations voient |
|---|---|
| la logique de chaque pièce | les contrats entre pièces (ordre des arguments, formats, noms de colonnes) |
| rapide, précis | requêtes SQL réelles, transactions, contraintes |
| faux collaborateurs possibles | configuration, sérialisation, encodages |
Les pièges classiques d'intégration
- ordre ou nom des paramètres ;
- format de date ou d'encodage (UTF-8 !) ;
- contrainte d'unicité ou clé étrangère violée ;
- transaction jamais validée (
commitoublié) ou jamais annulée ; - requête SQL correcte… sur une autre base de données que celle de production ;
- fuseau horaire, arrondi, tri.
Une base de test fiable
| Technique | Avantage | Limite |
|---|---|---|
SQLite en mémoire (:memory:) | rapide, isolée | dialecte différent de la production |
| Base réelle jetable (conteneur) | fidèle à la production | plus lent à démarrer |
| Transaction annulée en fin de test | très rapide | ne teste pas le commit réel |
| Base recréée à chaque test | isolation totale | un peu plus long |
Règle d'or : chaque test crée ses données et ne dépend d'aucun autre.
Données de test
- Fixtures : jeu de données minimal construit par le test (ou une fonction fabrique).
- Fabriques (builders) :
un_membre(nom="Ada")crée un objet valide avec des valeurs par défaut, et on ne précise que ce qui compte pour le test. - Jamais de données de production réelles (confidentialité, mission 5 de HEF-100).
Fichiers et temps
- Fichiers :
tempfile.TemporaryDirectory()(nettoyage automatique). - Horloge : injectée (mission 9).
- Réseau : localhost, port éphémère (mission 5).
Où placer la frontière ?
Un principe pratique : la logique métier se teste en unitaire (rapide, nombreux) ; les adaptateurs (base, fichiers, API) se testent en intégration (moins nombreux, plus réalistes). Un test d'intégration étroit vérifie un adaptateur avec sa vraie dépendance ; un test d'intégration large fait traverser plusieurs couches.
🧠 Astuce : écris un test d'intégration pour chaque dépendance externe que tu utilises (base, disque, API) : c'est là que se cachent les surprises.
🔍 Exemple pas à pas
Problème : tester un DepotInscriptions (SQLite) et un ServiceInscription ensemble, avec une base neuve par test, des contraintes réelles et un scénario complet.
import io, sqlite3, unittest
class DepotInscriptions:
def __init__(self, connexion):
self.bd = connexion
self.bd.executescript('''
CREATE TABLE IF NOT EXISTS cours (code TEXT PRIMARY KEY, titre TEXT NOT NULL, places INTEGER NOT NULL CHECK (places >= 0));
CREATE TABLE IF NOT EXISTS inscriptions (
membre TEXT NOT NULL, cours TEXT NOT NULL REFERENCES cours(code),
PRIMARY KEY (membre, cours));
''')
def ajouter_cours(self, code, titre, places):
self.bd.execute("INSERT INTO cours VALUES (?, ?, ?)", (code, titre, places))
def places_restantes(self, code):
ligne = self.bd.execute(
"SELECT places - (SELECT COUNT(*) FROM inscriptions WHERE cours = ?) FROM cours WHERE code = ?", (code, code)).fetchone()
if ligne is None:
raise KeyError(code)
return ligne[0]
def inscrire(self, membre, cours):
self.bd.execute("INSERT INTO inscriptions VALUES (?, ?)", (membre, cours))
def inscrits(self, cours):
return [r[0] for r in self.bd.execute(, (cours,))]
:
():
.depot = depot
():
.depot.places_restantes(cours) <= :
RuntimeError()
:
.depot.inscrire(membre, cours)
sqlite3.IntegrityError:
RuntimeError()
.depot.bd.commit()
(unittest.TestCase):
():
.bd = sqlite3.connect()
.bd.execute()
.depot = DepotInscriptions(.bd)
.service = ServiceInscription(.depot)
.depot.ajouter_cours(, , )
():
.bd.close()
():
.service.s_inscrire(, )
.assertEqual(.depot.places_restantes(), )
.assertEqual(.depot.inscrits(), [])
():
.service.s_inscrire(, )
.service.s_inscrire(, )
.assertRaisesRegex(RuntimeError, ):
.service.s_inscrire(, )
.assertEqual(.depot.inscrits(), [, ])
():
.service.s_inscrire(, )
.assertRaisesRegex(RuntimeError, ):
.service.s_inscrire(, )
():
.assertRaises(KeyError):
.service.s_inscrire(, )
():
.assertRaises(sqlite3.IntegrityError):
.depot.inscrire(, )
():
tempfile, os
tempfile.TemporaryDirectory() d:
chemin = os.path.join(d, )
c1 = sqlite3.connect(chemin)
service = ServiceInscription(DepotInscriptions(c1))
service.depot.ajouter_cours(, , )
c1.commit()
service.s_inscrire(, )
c2 = sqlite3.connect(chemin)
.assertEqual(DepotInscriptions(c2).inscrits(), [])
c1.close(); c2.close()
resultat = unittest.TextTestRunner(stream=io.StringIO()).run(unittest.defaultTestLoader.loadTestsFromTestCase(TestInscriptionIntegration))
(, resultat.testsRun, , resultat.wasSuccessful())
resultat.wasSuccessful(), resultat.failures + resultat.errors
Lecture :
- Chaque test crée une base neuve : aucune dépendance entre tests.
- Certains comportements n'existent que grâce à la vraie base : la contrainte d'unicité qui produit « déjà inscrit », la clé étrangère. Un faux dépôt en mémoire ne les aurait pas vus.
- Le dernier test vérifie le
commitavec deux connexions : un oubli decommitserait invisible avec une seule.
✍️ À toi, avec aide (10 XP)
Ajoute à l'exemple une fonctionnalité désinscription et teste-la en intégration :
depot.desinscrire(membre, cours); si le membre n'est pas inscrit, leverKeyError;service.se_desinscrire(membre, cours)aveccommit;- tests : la désinscription libère une place ; désinscrire un absent lève
KeyError; après désinscription, une personne qui était refusée (cours complet) peut s'inscrire.
💡 Indice 1
cursor.rowcount indique combien de lignes ont été supprimées.
💡 Indice 2
Pense au commit dans le service.
💡 Indice 3
Crée une base neuve dans setUp comme dans l'exemple.
✅ Réponse
import io, sqlite3, unittest
class Depot:
def __init__(self, bd):
self.bd = bd
bd.executescript('''CREATE TABLE cours (code TEXT PRIMARY KEY, places INTEGER);
CREATE TABLE inscriptions (membre TEXT, cours TEXT, PRIMARY KEY (membre, cours));''')
def places_restantes(self, code):
return self.bd.execute("SELECT places - (SELECT COUNT(*) FROM inscriptions WHERE cours=?) FROM cours WHERE code=?", (code, code)).fetchone()[0]
def inscrire(self, m, c):
self.bd.execute("INSERT INTO inscriptions VALUES (?, ?)", (m, c))
def desinscrire(self, m, c):
if self.bd.execute("DELETE FROM inscriptions WHERE membre=? AND cours=?", (m, c)).rowcount == 0:
raise KeyError((m, c))
class Service:
def __init__(self, depot): self.depot = depot
def s_inscrire(self, m, c):
if self.depot.places_restantes(c) <= :
RuntimeError()
.depot.inscrire(m, c); .depot.bd.commit()
():
.depot.desinscrire(m, c); .depot.bd.commit()
(unittest.TestCase):
():
.bd = sqlite3.connect()
.depot = Depot(.bd)
.service = Service(.depot)
.bd.execute()
(): .bd.close()
():
.service.s_inscrire(, )
.service.se_desinscrire(, )
.assertEqual(.depot.places_restantes(), )
():
.assertRaises(KeyError):
.service.se_desinscrire(, )
():
.service.s_inscrire(, )
.assertRaises(RuntimeError):
.service.s_inscrire(, )
.service.se_desinscrire(, )
.service.s_inscrire(, )
.assertEqual(.depot.places_restantes(), )
r = unittest.TextTestRunner(stream=io.StringIO()).run(unittest.defaultTestLoader.loadTestsFromTestCase(TestDesinscription))
r.wasSuccessful(), r.failures + r.errors
()
🚀 À toi, en solo (20 XP)
Test d'intégration de fichiers. Écris ArchiveurJournaux qui lit un dossier de journaux .log (une ligne par événement NIVEAU message) et produit un fichier resume.json avec le nombre d'événements par niveau et la première ligne d'erreur. Teste avec de vrais fichiers dans un dossier temporaire :
- plusieurs fichiers, dont un vide et un avec des lignes mal formées (comptées à part) ;
- un fichier d'un autre encodage (UTF-8 avec accents) ;
- un dossier inexistant (erreur claire) ;
- exécution deux fois : le résultat doit être identique (idempotence) ;
- le fichier
resume.jsonest écrit atomiquement (écriture dans un fichier temporaire puis renommage) : teste qu'aucun fichier temporaire ne reste.
✅ Pistes de correction
import json, os, tempfile, unittest, io
from collections import Counter
class ArchiveurJournaux:
def __init__(self, dossier):
self.dossier = dossier
def resumer(self):
if not os.path.isdir(self.dossier):
raise FileNotFoundError(f"dossier introuvable : {self.dossier}")
niveaux, mal_formees, premiere_erreur = Counter(), 0, None
for nom in sorted(os.listdir(self.dossier)):
if not nom.endswith(".log"):
continue
with open(os.path.join(self.dossier, nom), encoding="utf-8") as f:
for ligne in f:
ligne = ligne.rstrip("\n")
if not ligne:
continue
niveau, _, message = ligne.partition(" ")
if niveau (, , ) message:
mal_formees +=
niveaux[niveau] +=
niveau == premiere_erreur :
premiere_erreur = message
resume = {: ((niveaux.items())), : mal_formees, : premiere_erreur}
temporaire = os.path.join(.dossier, )
(temporaire, , encoding=) f:
json.dump(resume, f, ensure_ascii=, sort_keys=)
os.replace(temporaire, os.path.join(.dossier, ))
resume
(unittest.TestCase):
():
.tmp = tempfile.TemporaryDirectory()
.d = .tmp.name
(): .tmp.cleanup()
():
(os.path.join(.d, nom), , encoding=) f: f.write(texte)
():
.ecrire(, )
.ecrire(, )
.ecrire(, )
r = ArchiveurJournaux(.d).resumer()
.assertEqual(r[], {: , : , : })
.assertEqual(r[], )
.assertEqual(r[], )
():
.ecrire(, )
ArchiveurJournaux(.d).resumer()
(os.path.join(.d, ), encoding=) f:
.assertIn(, f.read())
():
.assertRaises(FileNotFoundError):
ArchiveurJournaux(os.path.join(.d, )).resumer()
():
.ecrire(, )
a = ArchiveurJournaux(.d)
.assertEqual(a.resumer(), a.resumer())
.assertNotIn(, os.listdir(.d))
r = unittest.TextTestRunner(stream=io.StringIO()).run(unittest.defaultTestLoader.loadTestsFromTestCase(TestArchiveur))
r.wasSuccessful(), r.failures + r.errors
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Tester l'intégration avec des faux partout | Les vraies coutures ne sont pas testées | Au moins un test avec les vraies dépendances |
| Base partagée entre tests | Ordre et pollution des données | Base neuve ou transaction annulée par test |
| Tout en intégration | Suite lente, diagnostic flou | Pyramide : logique en unitaire, adaptateurs en intégration |
| Données de production dans les tests | Fuite de données personnelles | Données fabriquées, minimales |
🐉 Mini-boss (40 XP)
Intégration complète de HashBox. Construis trois composants : DepotMembres (SQLite), DepotCours (SQLite) et ServiceInscription (règles : capacité, un seul cours simultané au même horaire, prérequis).
- Écris le schéma avec contraintes (clés étrangères, unicité, CHECK) ;
- écris des fabriques (
un_membre(),un_cours()) ; - écris 12+ tests d'intégration, dont 3 scénarios de bout en bout ;
- écris un test qui détecte un oubli de
commit; - mesure le temps de la suite (objectif < 1 s) et explique comment tu la garderais rapide à 500 tests.
✅ Pistes de correction
Un bon travail : base en mémoire neuve dans setUp, PRAGMA foreign_keys = ON, fabriques avec valeurs par défaut valides et paramètres nommés, tests des contraintes (clé étrangère, unicité, CHECK de capacité), scénarios (inscription → complet → désinscription → promotion), test à deux connexions sur un fichier temporaire pour le commit, chronométrage avec time.perf_counter(). Pour rester rapide : base en mémoire, schéma créé une fois puis copié ou transaction annulée, tests indépendants parallélisables, peu de tests larges.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un test d'intégration vérifie surtout :
- A. que des composants réels fonctionnent ensemble
- B. la vitesse du processeur
- C. l'orthographe des messages
2. Pour isoler les tests de base de données, on peut :
- A. partager une seule base entre tous les tests
- B. créer une base neuve (ou annuler la transaction) pour chaque test
- C. tester en production
3. Un test avec un faux dépôt ne détecterait pas :
- A. une faute de frappe dans le nom d'un test
- B. une ligne vide
- C. une contrainte d'unicité de la vraie base
4. 🔁 Révision mission 03 : F.I.R.S.T. désigne les qualités d'un test :
- A. rapide, indépendant, reproductible, auto-vérifiant, écrit à temps
- B. fort, intuitif, riche, simple, testable
- C. fiable, interne, résilient, sûr, tracé
5. 🔁 Révision mission 03 : Une couverture de 100 % signifie :
- A. que le code n'a aucun bug
- B. que chaque ligne a été exécutée, pas forcément bien vérifiée
- C. que les tests sont rapides
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Quelle dépendance externe de ton projet (base, fichier, API) n'est jamais testée avec la réalité ?
- Quand un faux collaborateur t'a-t-il déjà donné une fausse confiance ?
🎒 À retenir
- Intégration = composants réels ensemble : on teste les coutures.
- Base neuve par test (mémoire, transaction annulée, fichier temporaire).
- Fabriques de données plutôt que données de production.
- Logique en unitaire, adaptateurs en intégration.
- Un
commitoublié ne se voit qu'avec une deuxième connexion.
flowchart LR
T(["Tests d'intégration"])
T --> R1["1. Intégration = composants réels ensemble : on teste les coutures."]
T --> R2["2. Base neuve par test mémoire, transaction annulée, fichier temporaire."]
T --> R3["3. Fabriques de données plutôt que données de production."]
T --> R4["4. Logique en unitaire, adaptateurs en intégration."]
T --> R5["5. Un commit oublié ne se voit qu'avec une deuxième connexion."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Assembleur de preuves
← Mission 03 — Tests unitaires · Mission 05 — Tests API et contrats →
HEF-110 — Tests et qualité

