On ne teste pas du code : on teste des comportements promis. Il faut donc d'abord savoir les décrire.
⏱️ Durée : environ 90 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Traducteur de besoins
🎬 L'histoire
Léo, formateur, demande : « Je voudrais que la livraison des supports papier soit gratuite à partir d'un certain montant. » Kodi code, teste… et Léo répond : « Ah non, pas pour les colis lourds ! Et c'est à partir de 50 €, c'est-à-dire 50 € compris ? »
« Le bug n'est pas dans le code, dit Maya. Il est dans la phrase. Avant de tester, il faut rendre la règle précise : quelles entrées, quelles sorties, quelles exceptions, et quels cas aux limites. »
Tu apprends à transformer une demande floue en comportements précis, à en dériver des cas de test méthodiquement, et à penser aux frontières.
🎯 Ta mission
À la fin, je serai capable de :
- transformer une exigence en exemples concrets (étant donné / quand / alors)
- dériver des cas de test par classes d'équivalence et valeurs limites
- écrire des tests pilotés par table avec
subTest - tester les erreurs et cas interdits
- vérifier des propriétés générales avec des entrées aléatoires
🧩 Défi d'échauffement (5 XP)
« Les enfants paient moins cher. » Écris trois questions qui montrent que cette phrase est ambiguë (À partir de quel âge ? 12 ans pile ? Compte-t-on l'âge à la date du billet ?). Puis réécris la règle en une table précise de 5 lignes.
💡 Le concept
De la phrase au comportement
Une exigence floue (« livraison gratuite pour les gros paniers ») doit devenir une spécification testable. Un bon format : Étant donné / Quand / Alors (Given / When / Then).
Étant donné un panier de 60 € et un colis de 1 kg
Quand on calcule les frais de livraison
Alors les frais sont de 0 €
Cette phrase est à la fois une exigence, un exemple, et — bientôt — un test.
Exemples, pas adjectifs
Remplace « rapide », « petit », « correct » par des nombres et des exemples. Les exemples révèlent les ambiguïtés (50 € inclus ou non ?).
Classes d'équivalence
On ne peut pas tester toutes les entrées. On les range en classes dont tous les membres sont traités de la même manière, et on teste un représentant par classe.
| Règle | Classes |
|---|---|
| frais selon le montant (seuil 50) | montant < 50 / montant ≥ 50 |
| frais selon le poids (seuil 5 kg) | ≤ 5 kg / > 5 kg |
| entrée invalide | montant négatif, poids ≤ 0, type incorrect |
Valeurs limites
Les bugs se cachent aux frontières (< contre <=). Pour chaque seuil, teste : juste en dessous, pile sur le seuil, juste au-dessus.
| Seuil 50 € | Valeurs à tester |
|---|---|
| 49,99 · 50,00 · 50,01 |
Ajoute les cas extrêmes : zéro, vide, un seul élément, très grand.
Tests pilotés par table
Un même comportement, plusieurs exemples : une table (tuples) parcourue par une boucle. unittest fournit subTest : chaque ligne est rapportée séparément en cas d'échec.
CAS = [(49.99, 4.90), (50.00, 0.0), (50.01, 0.0)]
for montant, attendu in CAS:
with self.subTest(montant=montant):
self.assertEqual(frais(montant), attendu)
Cas d'erreur
Une spécification dit aussi ce qui est refusé : exception levée (laquelle ?), message clair, rien d'écrit à moitié.
Propriétés
Au lieu d'exemples, on énonce une propriété vraie pour toute entrée, et on la vérifie sur beaucoup d'entrées aléatoires (graine fixée pour la reproductibilité) :
| Fonction | Propriété |
|---|---|
trier | le résultat est ordonné, de même taille, mêmes éléments |
encoder/decoder | decoder(encoder(x)) == x |
prix_total | croissant avec le nombre d'articles ; jamais négatif |
Cette approche (property-based testing) trouve des cas auxquels on n'avait pas pensé.
Matrice de comportements
Pour garder une vue d'ensemble, liste les comportements et le test qui les couvre :
| Comportement | Test |
|---|---|
| Livraison gratuite dès 50 € inclus | test_seuil |
| Surcharge au-delà de 5 kg | test_poids |
| Entrée invalide refusée | test_erreurs |
🧠 Astuce : quand deux personnes ne sont pas d'accord sur une règle, demande-leur un exemple chiffré. Le désaccord apparaît en trente secondes.
🔍 Exemple pas à pas
Problème : spécifier et tester la règle de livraison de HashBox : base 4,90 € ; gratuite dès 50 € de panier inclus ; supplément de 3 € si le colis dépasse 5 kg (même si la livraison est gratuite le supplément s'applique) ; entrées invalides refusées.
import io, random, unittest
def lancer(*classes):
suite = unittest.TestSuite(unittest.defaultTestLoader.loadTestsFromTestCase(c) for c in classes)
return unittest.TextTestRunner(stream=io.StringIO(), verbosity=0).run(suite)
def frais_livraison(montant, poids_kg):
if not isinstance(montant, (int, float)) or isinstance(montant, bool) or montant < 0:
raise ValueError("montant invalide")
if not isinstance(poids_kg, (int, float)) or isinstance(poids_kg, bool) or poids_kg <= 0:
raise ValueError("poids invalide")
base = 0.0 if montant >= 50 else 4.90
supplement = 3.0 if poids_kg > 5 else 0.0
return round(base + supplement, 2)
class (unittest.TestCase):
():
montant, attendu [(, ), (, ), (, ), (, ), (, )]:
.subTest(montant=montant):
.assertEqual(frais_livraison(montant, ), attendu)
():
poids, attendu [(, ), (, ), (, )]:
.subTest(poids=poids):
.assertEqual(frais_livraison(, poids), attendu)
():
.assertEqual(frais_livraison(, ), )
():
montant, poids [(-, ), (, ), (, -), (, ), (, ), (, )]:
.subTest(montant=montant, poids=poids):
.assertRaises(ValueError):
frais_livraison(montant, poids)
():
rng = random.Random()
_ ():
m, p = rng.uniform(, ), rng.uniform(, )
f = frais_livraison(m, p)
.assertGreaterEqual(f, )
.assertLessEqual(f, )
():
rng = random.Random()
_ ():
p = rng.uniform(, )
m1 = rng.uniform(, )
m2 = m1 + rng.uniform(, )
.assertGreaterEqual(frais_livraison(m1, p), frais_livraison(m2, p))
resultat = lancer(TestFraisLivraison)
(, resultat.testsRun, , resultat.wasSuccessful())
resultat.wasSuccessful(), resultat.failures + resultat.errors
():
base = montant >
supplement = poids_kg >
(base + supplement, )
resultat = lancer(TestFraisLivraison)
(, (resultat.failures), )
(resultat.failures) >=
Lecture : la table de valeurs limites (49,99 / 50,00 / 50,01 ; 5,0 / 5,01) est ce qui attrape le bug > contre >=. Les deux propriétés couvrent 2 000 entrées aléatoires reproductibles. Les entrées invalides sont une partie explicite de la spécification.
✍️ À toi, avec aide (10 XP)
Voici la règle de tarification d'un billet : moins de 4 ans = gratuit ; de 4 à 11 ans inclus = 8 € ; de 12 à 64 ans inclus = 15 € ; 65 ans et plus = 10 €. Âge négatif ou supérieur à 130 = erreur.
Écris :
- la table des classes d'équivalence et des valeurs limites ;
- la fonction
prix_billet(age); - les tests avec
subTestcouvrant toutes les limites (3, 4, 11, 12, 64, 65, 0, 130) et les erreurs (−1, 131).
💡 Indice 1
Les limites sont 3/4, 11/12, 64/65 et les extrêmes 0/130.
💡 Indice 2
Utilise une liste de tuples (age, attendu).
💡 Indice 3
Les erreurs sont testées à part avec assertRaises.
✅ Réponse
import io, unittest
def prix_billet(age):
if age < 0 or age > 130:
raise ValueError("âge hors plage")
if age < 4:
return 0
if age <= 11:
return 8
if age <= 64:
return 15
return 10
class TestBillet(unittest.TestCase):
def test_tarifs_et_limites(self):
table = [(0, 0), (3, 0), (4, 8), (11, 8), (12, 15), (64, 15), (65, 10), (130, 10)]
for age, attendu in table:
with self.subTest(age=age):
.assertEqual(prix_billet(age), attendu)
():
age (-, ):
.subTest(age=age):
.assertRaises(ValueError):
prix_billet(age)
suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestBillet)
resultat = unittest.TextTestRunner(stream=io.StringIO()).run(suite)
resultat.wasSuccessful()
()
🚀 À toi, en solo (20 XP)
Tests de propriétés sur un tri. Écris ton propre fusionner(a, b) qui fusionne deux listes déjà triées en une liste triée (sans utiliser sorted). Puis, sans aucun exemple chiffré, vérifie sur 2 000 paires aléatoires (graine fixée) ces propriétés :
- le résultat est trié ;
- sa longueur est
len(a) + len(b); - il contient exactement les mêmes éléments (comparaison de multiensembles) ;
- fusionner avec la liste vide renvoie l'autre liste ;
fusionner(a, b) == fusionner(b, a).
Ajoute un bug (par exemple oublier le reste d'une liste) et montre que les propriétés le détectent.
✅ Pistes de correction
import random
from collections import Counter
def fusionner(a, b):
i = j = 0
sortie = []
while i < len(a) and j < len(b):
if a[i] <= b[j]:
sortie.append(a[i]); i += 1
else:
sortie.append(b[j]); j += 1
sortie.extend(a[i:])
sortie.extend(b[j:])
return sortie
def proprietes(f, essais=2000, graine=3):
rng = random.Random(graine)
for _ in range(essais):
a = sorted(rng.randint(-20, 20) for _ in range(rng.randint(0, 8)))
b = sorted(rng.randint(-20, 20) for _ in range(rng.randint(0, 8)))
r = f(a, b)
assert r == sorted(r), (a, b, r)
assert len(r) == len(a) + (b), (a, b, r)
Counter(r) == Counter(a) + Counter(b), (a, b, r)
f(a, []) == a f([], b) == b
f(a, b) == f(b, a)
proprietes(fusionner)
()
():
i = j =
sortie = []
i < (a) j < (b):
a[i] <= b[j]:
sortie.append(a[i]); i +=
:
sortie.append(b[j]); j +=
sortie
:
proprietes(fusionner_bug)
SystemExit()
AssertionError e:
(, e.args[][:])
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Spécification floue (« petit », « rapide ») | Chacun comprend autre chose | Remplacer les adjectifs par des nombres et des exemples |
| Oublier les valeurs limites | Les bugs vivent aux frontières | Tester juste en dessous, pile, juste au-dessus |
| Ne tester que les cas heureux | Les erreurs sont aussi un comportement | Spécifier et tester les entrées invalides |
| Aléatoire sans graine | Test qui échoue « parfois » | Fixer la graine, afficher le cas fautif |
🐉 Mini-boss (40 XP)
Spécification complète d'un code promo. Règles : le code est composé de 3 à 12 caractères alphanumériques majuscules ; HASH10 = −10 % ; BIENVENUE = −5 € ; un code expiré (date) est refusé ; un code ne se cumule pas avec un autre ; sur un panier de 0 €, aucun code n'est appliqué ; la remise ne rend jamais le total négatif.
- Écris la matrice de comportements (au moins 12 lignes, avec exemples chiffrés) ;
- liste les classes d'équivalence et les limites (longueur 2/3/12/13, date d'expiration veille/jour/lendemain) ;
- implémente
appliquer_code(total_cents, code, aujourdhui, expirations)en passant la date en paramètre ; - écris les tests pilotés par table et au moins 2 propriétés ;
- détecte 4 bugs injectés.
✅ Pistes de correction
Un bon travail : une table de 12+ comportements avec valeurs chiffrées (par exemple ("HASH10", 10000) → 9000, ("BIENVENUE", 300) → 0), la date injectée (jamais date.today() dans la fonction : mission 9), les limites de longueur (« AB » refusé, « ABC » accepté, 12 caractères accepté, 13 refusé), l'expiration (expiration < aujourdhui refusé, égale acceptée — à décider avec un exemple puis noter la décision). Propriétés : le total après remise est toujours entre 0 et le total initial ; appliquer un code invalide ne change jamais le total.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Une valeur limite est :
- A. une valeur extrêmement grande seulement
- B. une valeur choisie au hasard
- C. une valeur située juste autour d'un seuil de la règle
2. Un test piloté par table avec subTest permet de :
- A. rapporter séparément chaque ligne qui échoue
- B. accélérer le programme
- C. éviter d'écrire des assertions
3. Une propriété de test est :
- A. un exemple unique
- B. un énoncé vrai pour toute entrée, vérifié sur beaucoup d'entrées
- C. une variable privée
4. 🔁 Révision mission 01 : Un test automatisé sert surtout à :
- A. rendre le code plus rapide
- B. remplacer la documentation du projet
- C. rejouer une vérification à l'identique après chaque modification
5. 🔁 Révision mission 01 : Un test qui n'a jamais été rouge :
- A. n'a pas prouvé qu'il sait détecter un bug
- B. est forcément parfait
- C. est inutile à exécuter
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Quelle règle de ton quotidien professionnel est floue au point que deux collègues la comprennent différemment ?
- Pourquoi un exemple chiffré lève-t-il les ambiguïtés plus vite qu'une définition ?
🎒 À retenir
- Exigence → exemples « étant donné / quand / alors ».
- Classes d'équivalence : un représentant par classe.
- Valeurs limites : sous, pile, au-dessus.
- Tests pilotés par table (
subTest) et cas d'erreur explicites. - Propriétés vérifiées avec une graine fixée.
flowchart LR
T(["Spécifications et comportements"])
T --> R1["1. Exigence → exemples « étant donné / quand / alors »."]
T --> R2["2. Classes d'équivalence : un représentant par classe."]
T --> R3["3. Valeurs limites : sous, pile, au-dessus."]
T --> R4["4. Tests pilotés par table subTest et cas d'erreur explicites."]
T --> R5["5. Propriétés vérifiées avec une graine fixée."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Traducteur de besoins
← Mission 01 — Pourquoi tester · Mission 03 — Tests unitaires →
HEF-110 — Tests et qualité

