Un test de bout en bout se comporte comme une vraie personne devant l'application. Puissant, lent, fragile : il faut en faire peu, mais les faire bien.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Utilisateur automatique
🎬 L'histoire
Toutes les couches de HashBox passent leurs tests. Pourtant, lundi, personne ne peut s'inscrire à un cours : le bouton « S'inscrire » envoie le formulaire vers une mauvaise adresse après une refonte des pages. Aucun test unitaire ni d'API n'avait « cliqué » sur ce bouton.
« Il manque un test qui fasse exactement ce que fait Léo, dit Maya : se connecter, voir les cours, s'inscrire, vérifier sa liste. Un seul parcours, du début à la fin. C'est le rôle des tests E2E. »
Tu apprends à automatiser un parcours utilisateur complet, à le rendre stable (attentes explicites, sélecteurs fiables, page objects) et à choisir les rares parcours qui méritent ce coût.
🎯 Ta mission
À la fin, je serai capable de :
- expliquer le rôle et le coût des tests E2E dans la pyramide
- automatiser un parcours utilisateur (connexion, action, vérification) sans navigateur externe
- remplacer les
sleeppar des attentes explicites - structurer les tests avec le modèle page object
- choisir quels parcours tester en E2E et lesquels laisser aux niveaux inférieurs
🧩 Défi d'échauffement (5 XP)
Tu ouvres un restaurant. Avant l'ouverture, tu fais jouer le parcours d'un client du début à la fin : entrer, commander, être servi, payer. Quelles défaillances ce « test à blanc » trouve-t-il que la vérification séparée de chaque poste (cuisine, caisse, salle) n'aurait pas vues ? Pourquoi ne peut-on pas le faire jouer 500 fois par jour ?
💡 Le concept
Ce qu'est un test E2E
Un test de bout en bout (end-to-end) exerce l'application complète — interface, serveur, base — comme un utilisateur réel. Il vérifie que le parcours fonctionne, pas chaque détail.
| Avantage | Inconvénient |
|---|---|
| détecte les ruptures entre toutes les couches | lent (secondes à minutes) |
| teste ce que voit réellement l'utilisateur | fragile (interface qui change, timing) |
| confiance forte sur les parcours critiques | diagnostic large : « quelque part, ça casse » |
D'où la règle de la pyramide : peu de tests E2E, sur les parcours critiques (connexion, achat, inscription, paiement), pas sur chaque règle de gestion.
Ce qu'on automatise
- Navigateur piloté : Playwright, Selenium, Cypress. Ils démarrent un vrai navigateur, cliquent, remplissent, lisent.
- Client HTTP qui simule le navigateur : plus léger, suffisant pour des pages simples (c'est ce qu'on fait ici avec la bibliothèque standard).
# Exemple Playwright (à lancer sur ta machine après installation)
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
nav = p.chromium.launch()
page = nav.new_page()
page.goto("http://localhost:8000/login")
page.get_by_label("Nom").fill("ada")
page.get_by_role("button", name="Entrer").click()
page.get_by_test_id("cours-HEF-010").get_by_role("button", name="S'inscrire").click()
assert "HEF-010" in page.locator("#mes-cours").inner_text()
nav.close()
La stabilité : la grande bataille
| Cause d'instabilité | Remède |
|---|---|
sleep(2) « au cas où » | attente explicite d'une condition, avec délai maximal |
sélecteurs CSS dépendant de la mise en page (div > div:nth-child(3)) | sélecteurs stables : rôles, libellés, attributs data-testid |
| données partagées entre tests | chaque test crée ses données |
| dépendance à un service externe | doubles en E2E, ou environnement dédié |
| ordre des tests | parcours indépendants |
Attente explicite
attendre(condition, délai_max) :
tant que (temps < délai_max) :
si condition() est vraie : retourner
pause courte
lever TimeoutError
Un sleep(5) fait toujours perdre 5 s et échoue quand la machine est lente. Une attente explicite rend la main dès que c'est prêt.
Le modèle page object
On regroupe ce qu'on sait d'une page (adresses, champs, actions) dans une classe. Les tests racontent le parcours avec des verbes métier ; si l'interface change, un seul endroit à corriger.
page_login.se_connecter("ada")
page_cours.s_inscrire("HEF-010")
assert "HEF-010" in page_compte.mes_cours()
Smoke tests
Un test de fumée (smoke test) est un E2E minimal exécuté après chaque déploiement : « l'application démarre, la page d'accueil répond, on peut se connecter ». S'il échoue, on annule le déploiement.
Quand diagnostiquer un échec E2E
Garde des preuves : capture d'écran, journal réseau, HTML de la page au moment de l'échec, trace. Sans preuves, un test E2E qui échoue est une énigme.
🧠 Astuce : pour chaque comportement, demande-toi « quel est le test le plus bas de la pyramide qui l'attraperait ? ». N'élève le test que si les couches doivent vraiment travailler ensemble.
🔍 Exemple pas à pas
Problème : tester le parcours connexion → inscription → vérification d'une petite application web avec un « navigateur » minimal (cookies, redirections, formulaires), des page objects, et une attente explicite.
import html.parser, http.cookiejar, io, secrets, threading, time, unittest, urllib.parse, urllib.request
from http.server import BaseHTTPRequestHandler, HTTPServer
# ================= L'application (côté serveur) =================
COURS = {"HEF-010": "Algorithmes", "HEF-020": "Structures de données"}
SESSIONS, INSCRIPTIONS = {}, {}
PRET_A = {"t": 0.0}
class App(BaseHTTPRequestHandler):
def _page(self, corps, statut=200, entetes=None):
donnees = f"<html><body>{corps}</body></html>".encode()
self.send_response(statut)
self.send_header("Content-Type", "text/html; charset=utf-8")
self.send_header("Content-Length", str(len(donnees)))
for k, v in (entetes or {}).items():
self.send_header(k, v)
self.end_headers()
self.wfile.write(donnees)
def _rediriger(self, vers, entetes=None):
self._page("", 303, dict({"Location": vers}, **(entetes {})))
():
morceau .headers.get(, ).split():
nom, _, valeur = morceau.strip().partition()
nom == :
SESSIONS.get(valeur)
():
.path == :
._page()
membre = ._membre()
membre :
._rediriger()
.path == :
items = .join(
code, titre COURS.items())
._page()
.path == :
mes = .join( c (INSCRIPTIONS.get(membre, ())))
._page()
.path == :
._page( + ( time.monotonic() >= PRET_A[] ) + )
._page(, )
():
corps = .rfile.read((.headers.get(, ))).decode()
champs = {k: v[] k, v urllib.parse.parse_qs(corps).items()}
.path == :
jeton = secrets.token_hex()
SESSIONS[jeton] = champs.get(, )
._rediriger(, {: })
membre = ._membre()
membre :
._rediriger()
.path == :
INSCRIPTIONS.setdefault(membre, ()).add(champs[])
._rediriger()
.path == :
PRET_A[] = time.monotonic() +
._rediriger()
._page(, )
():
(html.parser.HTMLParser):
():
().__init__()
.formulaires, .ids, .texte, ._testid, ._forme, ._ = [], {}, [], , ,
():
a = (attrs)
a:
._testid = a[]
a:
._ = a[]; .ids[._] =
balise == :
._forme = {: a[], : {}, : ._testid}
.formulaires.append(._forme)
balise == ._forme a:
._forme[][a[]] = a.get(, )
():
balise == :
._forme =
balise == :
._testid =
balise (, ):
._ =
():
.texte.append(donnees)
._:
.ids[._] += donnees
:
():
.base = base
.opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
.page =
():
.url = reponse.geturl()
.page = Analyseur()
.page.feed(reponse.read().decode())
():
._charger(.opener.(.base + chemin, timeout=))
():
._charger(.opener.(.base + action, urllib.parse.urlencode(champs).encode(), timeout=))
():
.join(.page.texte)
():
fin = time.monotonic() + delai
time.monotonic() < fin:
condition():
time.sleep(pas)
TimeoutError()
:
(): .nav = nav
():
.nav.aller()
.nav.soumettre(, {: nom})
PageCours(.nav)
:
(): .nav = nav
():
forme = (f f .nav.page.formulaires f[] == )
.nav.soumettre(forme[], forme[])
PageCompte(.nav)
:
(): .nav = nav
():
.nav.page.ids.get(, )
(unittest.TestCase):
():
cls.serveur = HTTPServer((, ), App)
cls.base =
threading.Thread(target=cls.serveur.serve_forever, daemon=).start()
():
cls.serveur.shutdown(); cls.serveur.server_close()
():
.nav = Navigateur(.base)
():
cours = PageLogin(.nav).se_connecter()
.assertIn(, .nav.texte())
compte = cours.s_inscrire()
.assertEqual(compte.mes_cours(), )
():
cours = PageLogin(.nav).se_connecter()
cours.s_inscrire()
.nav.aller()
compte = PageCours(.nav).s_inscrire()
.assertEqual(compte.mes_cours(), )
():
.nav.aller()
.assertTrue(.nav.url.endswith())
():
PageLogin(.nav).se_connecter()
.nav.soumettre(, {})
.assertIn(, .nav.texte())
debut = time.monotonic()
():
.nav.aller()
.nav.texte()
attendre(pret)
duree = time.monotonic() - debut
.assertLess(duree, )
resultat = unittest.TextTestRunner(stream=io.StringIO()).run(unittest.defaultTestLoader.loadTestsFromTestCase(TestParcours))
(, resultat.testsRun, , resultat.wasSuccessful())
resultat.wasSuccessful(), resultat.failures + resultat.errors
Lecture :
- Le test E2E parcourt toutes les couches : serveur HTTP, session par cookie, redirections, formulaires, pages.
- Le page object
PageCours.s_inscrire("HEF-010")utilise un sélecteur stable (data-testid), pas la position dans la page : si le design change, le test survit. attendre()interroge la condition toutes les 20 ms : le test rend la main dès que le rapport est prêt (~0,3 s), alors qu'unsleep(5)aurait gaspillé 5 s à chaque exécution et échoué sur une machine lente.- Chaque test commence avec un navigateur neuf (cookies vides) : indépendance.
✍️ À toi, avec aide (10 XP)
Ajoute au scénario un test E2E négatif : une personne non connectée essaie d'envoyer directement le formulaire d'inscription (POST /inscrire avec cours=HEF-010) sans passer par la page de connexion. Vérifie qu'elle est redirigée vers /login et qu'aucune inscription n'a été créée.
(Utilise l'application, le navigateur et les classes de l'exemple.)
💡 Indice 1
Crée un Navigateur neuf (sans cookie) et appelle soumettre('/inscrire', {'cours': 'HEF-010'}).
💡 Indice 2
self.nav.url finit par /login après la redirection.
💡 Indice 3
Vérifie INSCRIPTIONS : aucune clé pour un membre anonyme.
✅ Réponse
# (à placer dans la classe TestParcours de l'exemple)
def test_inscription_directe_sans_connexion_refusee(self):
avant = {m: set(c) for m, c in INSCRIPTIONS.items()}
self.nav.soumettre("/inscrire", {"cours": "HEF-010"}) # navigateur neuf : aucun cookie de session
self.assertTrue(self.nav.url.endswith("/login"))
self.assertEqual(INSCRIPTIONS, avant) # rien n'a été créé
Ce test vérifie un comportement de sécurité (contrôle d'accès côté serveur) qu'aucune interface n'exerce « naturellement » : l'interface n'offre jamais ce chemin, mais un attaquant le peut (cf. HEF-100).
🚀 À toi, en solo (20 XP)
Rends un E2E fragile robuste. Voici trois mauvaises pratiques dans un script de test : un time.sleep(2) après chaque clic, un sélecteur par position (« le 3ᵉ bouton »), et un test qui dépend d'un compte créé par un autre test. Pour chacune :
- écris un petit exemple minimal qui échoue de façon intermittente (simule la lenteur avec un délai aléatoire à graine fixe) ;
- corrige-le avec une attente explicite, un sélecteur stable (
data-testid), et une fabrique de compte par test ; - mesure le temps gagné et le taux d'échec avant/après sur 200 exécutions simulées.
✅ Pistes de correction
import random, time
def simuler(attente, essais=200, graine=11):
# la page « devient prête » après un délai aléatoire (ms simulées), parfois lent
rng = random.Random(graine)
echecs, temps_total = 0, 0.0
for _ in range(essais):
pret_apres = rng.choice([0.1, 0.2, 0.3, 0.5, 2.5]) # secondes simulées, parfois très lent
reussi, ecoule = attente(pret_apres)
echecs += (not reussi)
temps_total += ecoule
return echecs, temps_total
def avec_sleep(pret_apres, duree=2.0):
return pret_apres <= duree, duree # attend toujours 2 s ; échoue si c'est plus lent
def avec_attente_explicite(pret_apres, delai_max=10.0):
return pret_apres <= delai_max, pret_apres # s'arrête dès que c'est prêt, tolère jusqu'à 10 s
e1, t1 = simuler(avec_sleep)
e2, t2 = simuler(avec_attente_explicite)
print(f"sleep(2) : {e1} échecs sur 200, temps cumulé {t1:.0f} s")
print(f"attente : échecs sur 200, temps cumulé s")
e1 > e2 == t2 < t1
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Trop de tests E2E | Suite lente, instable, coûteuse | Peu de parcours critiques ; le reste plus bas dans la pyramide |
sleep fixes | Lents et pourtant intermittents | Attentes explicites sur une condition |
| Sélecteurs liés à la mise en page | Cassent à chaque refonte | Rôles, libellés, data-testid |
| Tests qui s'enchaînent | Un échec en entraîne dix | Parcours indépendants, données fabriquées |
🐉 Mini-boss (40 XP)
Le parcours critique de HashBox. Étends l'application de l'exemple avec : inscription impossible quand le cours est complet (message « complet »), déconnexion (POST /logout qui détruit la session), et un second utilisateur.
- écris les page objects nécessaires ;
- écris 5 parcours E2E : (a) nominal, (b) cours complet, (c) déconnexion puis accès refusé, (d) deux utilisateurs indépendants, (e) rapport asynchrone avec attente explicite ;
- écris un smoke test de 3 assertions exécutable après déploiement ;
- fais sauvegarder le HTML de la page quand un test échoue (preuve de diagnostic) ;
- justifie dans un tableau pourquoi chacun de ces 5 comportements mérite (ou non) un E2E plutôt qu'un test plus bas.
✅ Pistes de correction
Un bon travail : classes PageLogin, PageCours, PageCompte, un setUp qui crée un Navigateur neuf, un tearDown ou un addCleanup qui écrit nav.page dans un fichier si le test a échoué (recherche de self._outcome), un smoke test (page de login répond, connexion possible, liste de cours affichée). Le tableau de justification attendu : nominal, déconnexion et accès refusé méritent l'E2E (ils traversent session + serveur + pages) ; la règle « cours complet » se teste plutôt au niveau service/unitaire, avec un seul E2E pour vérifier que le message atteint bien l'utilisateur.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un test E2E est approprié pour :
- A. chaque règle de calcul isolée
- B. un parcours utilisateur critique complet
- C. la syntaxe d'une fonction
2. Pour attendre qu'une page soit prête, on préfère :
- A. un
sleepfixe de 10 secondes - B. relancer jusqu'à ce que ça passe
- C. une attente explicite d'une condition avec délai maximal
3. Le modèle page object sert à :
- A. centraliser ce qu'on sait d'une page pour que les tests restent lisibles et robustes
- B. accélérer le serveur
- C. chiffrer les cookies
4. 🔁 Révision mission 05 : Un changement compatible d'une API est :
- A. le renommage d'un champ de réponse
- B. l'ajout d'un champ optionnel dans la réponse
- C. le changement du type d'un champ
5. 🔁 Révision mission 05 : Un test de contrat côté consommateur :
- A. remplace tous les tests
- B. teste la vitesse du réseau
- C. déclare ce dont le client dépend et le fait vérifier par le fournisseur
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Quel est le parcours dont la panne coûterait le plus cher à ton activité ?
- Quel test lent de ton projet pourrait être descendu d'un niveau dans la pyramide ?
🎒 À retenir
- E2E = parcours complet, peu nombreux, sur le critique.
- Attente explicite, jamais de
sleepfixe. - Sélecteurs stables (
data-testid, rôles), page objects. - Parcours indépendants avec données fabriquées.
- Smoke test après déploiement ; conserver les preuves d'échec.
flowchart LR
T(["Tests E2E"])
T --> R1["1. E2E = parcours complet, peu nombreux, sur le critique."]
T --> R2["2. Attente explicite, jamais de sleep fixe."]
T --> R3["3. Sélecteurs stables data-testid, rôles, page objects."]
T --> R4["4. Parcours indépendants avec données fabriquées."]
T --> R5["5. Smoke test après déploiement ; conserver les preuves d'échec."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Utilisateur automatique
← Mission 05 — Tests API et contrats · Mission 07 — Doubles de test →
HEF-110 — Tests et qualité

