Pour tester une pièce sans dépendre du monde entier, on la branche sur des doublures. Bien choisies, elles libèrent. Mal choisies, elles mentent.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Maître des doublures
🎬 L'histoire
Kodi veut tester l'envoi d'un e-mail de rappel d'inscription. Mais ses tests envoient de vrais e-mails (aux formateurs !), dépendent du réseau, et échouent quand le serveur de messagerie est en panne. Il remplace donc l'envoi par une fausse fonction… et sa suite devient verte, y compris le jour où le vrai envoi est cassé depuis une semaine.
« Une doublure bien choisie rend ton test rapide et fiable, dit Sam. Une doublure mal choisie lui fait raconter n'importe quoi. Il faut connaître les cinq sortes, et savoir quand arrêter. »
Tu apprends dummy, stub, spy, mock et fake, l'injection de dépendances, unittest.mock, et comment ne pas trop doubler.
🎯 Ta mission
À la fin, je serai capable de :
- distinguer dummy, stub, spy, mock et fake
- injecter des dépendances pour pouvoir les remplacer
- utiliser
unittest.mock(Mock,patch,side_effect, vérifications d'appels) - tester le temps et le hasard grâce à une horloge ou un générateur injecté
- reconnaître le sur-usage de mocks et le couplage à l'implémentation
🧩 Défi d'échauffement (5 XP)
Pour s'entraîner à l'atterrissage, un pilote utilise un simulateur de vol plutôt qu'un vrai avion. Quelles choses le simulateur reproduit-il bien ? Lesquelles risque-t-il de ne pas montrer (turbulences réelles, panne mécanique inattendue) ? Fais le parallèle avec un faux serveur d'e-mails.
💡 Le concept
Pourquoi des doublures
Un code dépend souvent de choses lentes, imprévisibles ou dangereuses : réseau, e-mail, paiement, horloge, hasard, base distante. Dans un test unitaire, on les remplace par des doubles de test que l'on contrôle.
Les cinq sortes (Meszaros)
| Double | Rôle | Exemple |
|---|---|---|
| Dummy | remplit un paramètre obligatoire, jamais utilisé vraiment | un logger qui ne fait rien |
| Stub | renvoie des réponses préparées | taux_de_change() renvoie toujours 1,10 |
| Spy | enregistre les appels reçus pour qu'on les inspecte ensuite | liste des e-mails « envoyés » |
| Mock | spy dont les attentes sont vérifiées (appelé 1 fois avec tel argument) | envoyer.assert_called_once_with(...) |
| Fake | implémentation simplifiée mais réellement fonctionnelle | dépôt en mémoire à la place de la base |
Retiens : le stub fournit des entrées, le spy/mock observe les sorties (effets de bord), le fake remplace une dépendance entière.
L'injection de dépendances
Pour pouvoir remplacer une dépendance, le code la reçoit de l'extérieur plutôt que de la créer :
# difficile à tester
class Rappel:
def envoyer(self): smtp = SMTP("mail.exemple.org"); smtp.send(...)
# facile à tester
class Rappel:
def __init__(self, expediteur): self.expediteur = expediteur
def envoyer(self): self.expediteur.envoyer(...)
Même idée pour l'horloge (maintenant en paramètre) et le hasard (générateur passé en paramètre).
unittest.mock
| Outil | Usage |
|---|---|
Mock() / MagicMock() | objet complaisant qui accepte tout appel et les enregistre |
mock.return_value = x | stub : valeur renvoyée |
mock.side_effect = Erreur ou liste | lever une exception, ou renvoyer des valeurs successives |
mock.assert_called_once_with(...) | vérification d'appel |
mock.call_args_list | historique des appels |
patch("module.nom") | remplace temporairement un objet là où il est utilisé |
Mock(spec=Classe) | refuse les attributs qui n'existent pas dans la vraie classe |
Piège de patch : on remplace le nom là où il est cherché, pas là où il est défini (patch("mon_module.requests"), pas patch("requests") si mon_module a fait import requests / from x import y).
Quand utiliser quoi
- Entrée externe (heure, hasard, réponse d'API) → stub.
- Effet de bord à vérifier (e-mail envoyé, paiement déclenché) → spy/mock.
- Dépendance riche (base, système de fichiers) → fake, si possible vérifié contre la vraie.
- Paramètre inutile → dummy.
Le danger des doublures
| Risque | Conséquence | Remède |
|---|---|---|
| Sur-usage de mocks | tests couplés à l'implémentation : cassent à chaque refactoring | doubler aux frontières (réseau, horloge), pas entre classes internes |
| Double qui diverge du réel | tests verts, production cassée | spec=, tests de contrat sur le fake et le réel |
| Tout est doublé | le test ne teste plus rien | un test d'intégration sans double pour les coutures |
| Vérifier le « comment » | refactoring impossible | vérifier l'effet observable (e-mail envoyé), pas la séquence d'appels internes |
Règle utile : ne double pas ce que tu ne possèdes pas sans l'envelopper — crée un petit adaptateur (ExpediteurMail) que tu possèdes, double celui-là, et teste l'adaptateur en intégration.
🧠 Astuce : si un test contient plus de lignes de configuration de mocks que de vérification, c'est un signal : le code testé a probablement trop de dépendances.
🔍 Exemple pas à pas
Problème : tester un service de rappel d'échéances avec les cinq sortes de doubles, plus unittest.mock, une horloge injectée, et un test de contrat qui garde le fake honnête.
import io, sqlite3, unittest
from datetime import date, timedelta
from unittest import mock
# ---------- code de production ----------
class ServiceRappel:
def __init__(self, depot, expediteur, journal):
self.depot, self.expediteur, self.journal = depot, expediteur, journal
def rappeler(self, aujourdhui):
envoyes = 0
for inscription in self.depot.echeances_avant(aujourdhui + timedelta(days=3)):
if inscription["rappele"]:
continue
try:
self.expediteur.envoyer(inscription["email"], f"Rappel : {inscription['cours']} le {inscription['date']}")
except ConnectionError:
self.journal.avertir(f"échec d'envoi à {inscription['email']}")
continue
self.depot.marquer_rappele(inscription["id"])
envoyes += 1
return envoyes
:
():
:
(): .messages = []
(): .messages.append(message)
:
(): .envoyes = []
(): .envoyes.append((destinataire, texte))
:
(): ConnectionError()
:
(): .lignes = {l[]: (l) l lignes}
(): [(l) l (.lignes.values(), key= l: l[]) l[] <= limite]
(): .lignes[id_][] =
AUJOURDHUI = date(, , )
LIGNES = [
{: , : , : , : date(, , ), : },
{: , : , : , : date(, , ), : },
{: , : , : , : date(, , ), : },
]
(unittest.TestCase):
():
exp = ExpediteurSpy()
n = ServiceRappel(DepotFake(LIGNES), exp, JournalDummy()).rappeler(AUJOURDHUI)
.assertEqual(n, )
.assertEqual(exp.envoyes, [(, )])
():
depot, exp = DepotFake(LIGNES), ExpediteurSpy()
service = ServiceRappel(depot, exp, JournalDummy())
service.rappeler(AUJOURDHUI); service.rappeler(AUJOURDHUI)
.assertEqual((exp.envoyes), )
():
depot, journal = DepotFake(LIGNES), JournalSpy()
n = ServiceRappel(depot, ExpediteurEnPanne(), journal).rappeler(AUJOURDHUI)
.assertEqual(n, )
.assertEqual(journal.messages, [])
.assertFalse(depot.lignes[][])
():
expediteur = mock.Mock(spec=[])
ServiceRappel(DepotFake(LIGNES), expediteur, JournalDummy()).rappeler(AUJOURDHUI)
expediteur.envoyer.assert_called_once_with(, )
():
lignes = [(LIGNES[]), (LIGNES[], =, email=)]
expediteur = mock.Mock(spec=[])
expediteur.envoyer.side_effect = [ConnectionError(), ]
n = ServiceRappel(DepotFake(lignes), expediteur, JournalSpy()).rappeler(AUJOURDHUI)
.assertEqual(n, )
():
types
module = types.SimpleNamespace(hasard=: )
(): module.hasard() >
mock.patch.(module, , return_value=):
.assertEqual(tirage(), )
.assertEqual(tirage(), )
:
():
.bd = sqlite3.connect()
.bd.execute()
l lignes:
.bd.execute(, (l[], l[], l[], l[].isoformat(), (l[])))
():
lignes = .bd.execute(, (limite.isoformat(),))
[{: i, : e, : c, : date.fromisoformat(d), : (r)} i, e, c, d, r lignes]
():
.bd.execute(, (id_,))
:
(): NotImplementedError
():
depot = .fabriquer(LIGNES)
.assertEqual([l[] l depot.echeances_avant(date(, , ))], [, ])
():
depot = .fabriquer(LIGNES)
depot.marquer_rappele()
.assertTrue((l l depot.echeances_avant(date(, , )) l[] == )[])
(ContratDepot, unittest.TestCase):
(): DepotFake(lignes)
(ContratDepot, unittest.TestCase):
(): DepotSQL(lignes)
classes = [TestServiceRappel, TestContratFake, TestContratSQL]
suite = unittest.TestSuite(unittest.defaultTestLoader.loadTestsFromTestCase(c) c classes)
resultat = unittest.TextTestRunner(stream=io.StringIO()).run(suite)
(, resultat.testsRun, , resultat.wasSuccessful())
resultat.wasSuccessful(), resultat.failures + resultat.errors
Lecture :
| Double | Où |
|---|---|
| Dummy | JournalDummy (obligatoire mais inutile dans ce test) |
| Stub | ExpediteurEnPanne (prépare une réponse : une panne) ; side_effect |
| Spy | ExpediteurSpy, JournalSpy : on inspecte après coup |
| Mock | Mock(spec=["envoyer"]) + assert_called_once_with |
| Fake | DepotFake (vraie logique, mémoire) |
L'horloge est un paramètre (AUJOURDHUI) : aucun test ne dépend de la date réelle. Le contrat partagé exécute les mêmes tests contre le fake et le vrai dépôt SQL : si le fake divergeait, un test de contrat échouerait. C'est ce qui rend le fake digne de confiance.
✍️ À toi, avec aide (10 XP)
Voici une fonction qui dépend de l'heure et du hasard :
def message_du_jour():
h = datetime.now().hour
salut = "Bonjour" if h < 18 else "Bonsoir"
astuce = random.choice(["Teste d'abord.", "Relis ton code.", "Fais une pause."])
return f"{salut} ! {astuce}"
Refactore-la pour qu'elle soit testable (injecte l'horloge et le générateur) et écris 3 tests déterministes : matin, soir, et le choix d'une astuce donnée par un générateur à graine.
💡 Indice 1
Passe maintenant et rng en paramètres, avec des valeurs par défaut.
💡 Indice 2
random.Random(0) est reproductible ; ou fournis un stub dont choice renvoie toujours le premier élément.
💡 Indice 3
datetime(2025, 6, 1, 9) pour le matin, datetime(2025, 6, 1, 20) pour le soir.
✅ Réponse
import random
from datetime import datetime
def message_du_jour(maintenant=None, rng=None):
maintenant = maintenant or datetime.now()
rng = rng or random
salut = "Bonjour" if maintenant.hour < 18 else "Bonsoir"
astuce = rng.choice(["Teste d'abord.", "Relis ton code.", "Fais une pause."])
return f"{salut} ! {astuce}"
class RngPremier: # stub : choisit toujours le premier élément
def choice(self, seq): return seq[0]
assert message_du_jour(datetime(2025, 6, 1, 9), RngPremier()) == "Bonjour ! Teste d'abord."
assert message_du_jour(datetime(2025, 6, 1, 20), RngPremier()) == "Bonsoir ! Teste d'abord."
a = message_du_jour(datetime(2025, 6, 1, ), random.Random())
b = message_du_jour(datetime(, , , ), random.Random())
a == b a.startswith()
(, a)
🚀 À toi, en solo (20 XP)
Écris ton propre mini-mock. Implémente une classe EspionAppels qui :
- enregistre chaque appel (arguments positionnels et nommés) ;
- permet de programmer des retours (
retourne(valeur)) ou une suite de retours, ou une exception ; - fournit
assert_appele_une_fois_avec(...),nombre_appelsetassert_jamais_appele(); - teste-le sur un service de paiement : le service doit appeler
passerelle.debiter(montant, devise)une fois, ne pas débiter un montant nul, et gérer une exceptionPaiementRefuseen renvoyantFalse.
✅ Pistes de correction
class PaiementRefuse(Exception):
pass
class EspionAppels:
def __init__(self):
self.appels, self._sorties = [], []
def retourne(self, *valeurs):
self._sorties = list(valeurs); return self
def leve(self, exception):
self._sorties = [exception]; return self
def __call__(self, *args, **kwargs):
self.appels.append((args, kwargs))
if self._sorties:
s = self._sorties.pop(0) if len(self._sorties) > 1 else self._sorties[0]
if isinstance(s, Exception):
raise s
return s
(): (.appels)
():
.nombre_appels == ,
.appels[] == (args, kwargs),
():
.nombre_appels == ,
:
(): .debiter = debiter
():
montant <= :
:
passerelle.debiter(montant, devise)
PaiementRefuse:
esp = EspionAppels().retourne()
payer(Passerelle(esp), )
esp.assert_appele_une_fois_avec(, )
esp = EspionAppels()
payer(Passerelle(esp), )
esp.assert_jamais_appele()
esp = EspionAppels().leve(PaiementRefuse())
payer(Passerelle(esp), , )
esp.assert_appele_une_fois_avec(, )
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Tout doubler | Le test ne vérifie plus que les doubles | Doubler aux frontières ; un test d'intégration sans double |
| Mocker ce qu'on ne possède pas | Couplage à une bibliothèque externe | Envelopper dans un adaptateur à soi, doubler l'adaptateur |
| Vérifier la séquence d'appels internes | Le moindre refactoring casse les tests | Vérifier l'effet observable |
| Fake qui diverge du réel | Tests verts, production cassée | Tests de contrat partagés fake/réel |
🐉 Mini-boss (40 XP)
Service de notification robuste. Écris ServiceNotification(depot_utilisateurs, canaux, horloge, journal) : pour chaque utilisateur, envoie un message par son canal préféré (e-mail, SMS) ; si le canal échoue, bascule sur le suivant ; ne dérange pas entre 22 h et 7 h (reporte) ; limite à 3 messages par jour.
- écris le service avec injection de toutes les dépendances ;
- écris 12+ tests en utilisant les 5 sortes de doubles (explique pourquoi chacun) ;
- écris un
FauxCanal(fake) avec pannes programmables, et un test de contrat partagé avec un canal « réel » simulé ; - écris une version « mal testée » qui mocke tout (séquence d'appels internes), montre qu'elle casse au refactoring alors que ta bonne suite survit.
✅ Pistes de correction
Un bon travail : horloge injectée (horloge() renvoie un datetime) ; canaux avec envoyer(utilisateur, texte) ; tests : bascule sur le canal suivant (stub qui lève), report la nuit (horloge stub), plafond de 3 messages (spy compteur), journalisation des échecs (spy), dummy pour le journal quand inutile ; fake FauxCanal avec programmer_pannes([True, False]). La démonstration finale : renommer une méthode privée interne casse la suite « mock-tout » (vérifie _choisir_canal appelé) mais ne change rien à la bonne suite (qui vérifie les messages effectivement reçus).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un stub sert à :
- A. fournir des réponses préparées au code testé
- B. enregistrer des appels pour les vérifier
- C. stocker des données en base
2. Un fake est :
- A. un test qui échoue toujours
- B. une implémentation simplifiée mais réellement fonctionnelle
- C. un paramètre inutilisé
3. Pour rendre testable un code dépendant de l'heure, on :
- A. attend minuit
- B. lit l'horloge dans chaque fonction
- C. injecte l'horloge en paramètre
4. 🔁 Révision mission 06 : Un test E2E est approprié pour :
- A. un parcours utilisateur critique complet
- B. chaque règle de calcul isolée
- C. la syntaxe d'une fonction
5. 🔁 Révision mission 06 : Pour attendre qu'une page soit prête, on préfère :
- A. un
sleepfixe de 10 secondes - B. une attente explicite d'une condition avec délai maximal
- C. relancer jusqu'à ce que ça passe
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Dans ton code, quelles dépendances (heure, hasard, réseau) rendent aujourd'hui les tests imprévisibles ?
- Quel test pourrait survivre à un refactoring complet parce qu'il ne vérifie que l'effet observable ?
🎒 À retenir
- Dummy, stub, spy, mock, fake : cinq rôles différents.
- Injecter les dépendances (horloge et hasard compris).
Mock(spec=...),side_effect,assert_called_once_with,patchlà où on cherche le nom.- Tests de contrat partagés pour garder un fake honnête.
- Ne pas sur-doubler : vérifier les effets observables, pas la mécanique interne.
flowchart LR
T(["Doubles de test"])
T --> R1["1. Dummy, stub, spy, mock, fake : cinq rôles différents."]
T --> R2["2. Injecter les dépendances horloge et hasard compris."]
T --> R3["3. Mockspec=..., sideeffect, assertcalledoncewith, patch là où on…"]
T --> R4["4. Tests de contrat partagés pour garder un fake honnête."]
T --> R5["5. Ne pas sur-doubler : vérifier les effets observables, pas la…"]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Maître des doublures
← Mission 06 — Tests E2E · Mission 08 — TDD et refactoring →
HEF-110 — Tests et qualité

