Une régression passe en production malgré des tests unitaires au vert, et l’équipe de développement envisage aussitôt un test end to end pour chaque fonctionnalité. Il en faut bien moins : un par parcours critique.
Un test end to end (test de bout en bout, abrégé E2E) déroule un parcours complet d’utilisateur sur l’application déployée : il traverse l’interface, les services, la base de données et les systèmes voisins, comme le ferait une personne. Parmi les tests automatisés, lui seul vérifie que l’ensemble assemblé fonctionne. Il est aussi le test le plus lent, le plus coûteux à maintenir et le plus exposé aux échecs sans cause réelle. Il se réserve donc aux parcours dont la panne arrêterait l’activité. La méthode suit un ordre : choisir ces parcours, préparer les données et l’environnement, stabiliser la suite, puis lui donner sa place dans la chaîne de livraison.
Le test end to end au sommet de la pyramide : rare parce que cher
La pyramide des tests, présentée dans notre page qualité logicielle et tests, place le test de bout en bout à son sommet, en petit nombre. Cette place tient à trois coûts.
Le premier est l’exécution. Le test démarre un navigateur, charge des pages et attend des réponses du réseau : sa durée se compte en secondes ou en minutes, quand un test unitaire rend son verdict presque aussitôt. Le deuxième est le diagnostic. Un échec désigne un parcours, sans dire lequel des composants traversés est en cause. Le troisième est la maintenance. Un écran modifié, une donnée absente ou un service voisin indisponible suffisent à faire échouer un test dont l’objet n’a pas changé : c’est la source de son instabilité.
En contrepartie, il détecte ce qu’aucun niveau inférieur ne voit, les défauts d’assemblage : une configuration propre à l’environnement, une route mal déclarée, une authentification qui ne se propage pas d’un service à l’autre, une migration de base non appliquée. Chaque composant réussit ses propres tests, et le parcours échoue.
Un parcours peut aussi être rejoué par les seules interfaces de programmation, sans navigateur. Le test reste de bout en bout pour les services, il gagne en vitesse et en stabilité, mais il ne vérifie plus l’écran.
Choisir les parcours qui méritent un test de bout en bout
Un parcours entre dans la liste lorsqu’il réunit plusieurs de ces caractères :
- sa panne interrompt une vente, un paiement, une souscription, le dépôt d’un dossier ou l’accès même au service ;
- il traverse plusieurs systèmes, dont au moins un que l’équipe ne maîtrise pas ;
- une large part des utilisateurs l’emprunte ;
- aucun test de niveau inférieur ne peut en apporter la preuve.
La règle de découpage compte autant que la sélection : un test par parcours nominal. « Commander avec une carte valide » justifie un test de bout en bout. Les nombreux motifs de refus d’une carte se vérifient dans les tests unitaires et d’intégration du service de paiement, où chacun s’exécute vite et échoue pour une raison lisible.
Cette étape produit une liste courte de parcours, nommés dans le vocabulaire du métier. Le responsable de produit répond de leur criticité, l’équipe de développement de leur faisabilité. Tout ajout ultérieur passe par cette liste.
Préparer les données et l’environnement
Chaque test crée les données dont il a besoin (un compte, un panier, un contrat) par un appel d’API ou un script, sans passer par l’interface, et ne suppose rien de l’état laissé par un autre. Deux tests qui partagent le même compte client risquent d’échouer dès qu’ils s’exécutent en parallèle. Les jeux se construisent à partir de données fictives. Une copie de production qui contient des données personnelles soulève les questions traitées dans notre article sur l’anonymisation des données.
L’environnement reçoit l’application dans la version qui partira en production, avec une configuration aussi proche que possible. Les services tiers (paiement, envoi de messages, vérification d’identité) sont appelés dans le bac à sable de leur fournisseur lorsqu’il existe, ou remplacés par un simulateur. Dans le second cas, le test ne prouve plus la liaison réelle, et cette limite s’écrit.
Un environnement créé pour chaque exécution, puis détruit, supprime les états résiduels. Sa mise à disposition relève de la plateforme décrite dans notre page DevOps et platform engineering.
À l’issue de l’étape, la chaîne sait créer et remettre à zéro, sans intervention, un jeu de données reproductible et un environnement complet. L’équipe de développement tient les données, l’équipe chargée de la plateforme l’environnement.
Stabiliser la suite en traitant chaque échec intermittent à sa cause
Un test instable (flaky test) échoue puis réussit sans que le code ait changé. Quatre causes reviennent régulièrement.
La première est l’attente à durée fixe : une pause de quelques secondes est trop courte un jour de lenteur et inutile le reste du temps. Le test attend plutôt un état observable, comme un bouton devenu actif ou un message affiché. Des outils tels que Playwright ou Cypress intègrent ce mécanisme : ils vérifient qu’un élément est prêt avant d’agir et réessaient jusqu’à un délai limite.
Viennent ensuite les sélecteurs liés à la mise en page. Un test qui désigne un élément par sa position dans l’écran casse au premier changement de maquette. Le rôle de l’élément, son libellé ou un attribut réservé aux tests résistent mieux.
Les deux dernières causes sont la dépendance entre tests, par l’ordre d’exécution ou par des données communes, et l’environnement lui-même : service tiers lent, tâche de fond, horloge.
La relance automatique d’un test en échec, que proposent notamment Playwright et Cypress, sert à distinguer l’échec franc de l’échec intermittent. Elle ne règle rien : un test qui ne réussit qu’à la seconde tentative est compté comme instable et confié à quelqu’un. S’il n’est pas corrigé rapidement, il sort du chemin bloquant et entre en quarantaine, avec un responsable et une échéance, inscrit dans le même backlog que le reste de la dette technique. Passé l’échéance, il est réparé ou supprimé.
Les captures d’écran, les enregistrements vidéo et la trace des échanges réseau, conservés à chaque échec, raccourcissent le diagnostic. Le code des tests passe par la même revue de code que celui de l’application. L’étape livre une suite dont un échec signale un défaut ; l’équipe qui développe le parcours en répond.
Placer le test end to end dans la chaîne de livraison
| Moment | Ce qui s’exécute | Effet d’un échec |
|---|---|---|
| À chaque demande de fusion | Les quelques parcours vitaux, sur un environnement créé pour l’occasion | La fusion est bloquée |
| Après le déploiement sur l’environnement d’intégration | La suite complète, répartie sur plusieurs exécutions parallèles | La promotion vers la production est bloquée |
| Après la mise en production | Quelques parcours sans effet de bord, rejoués à intervalles réguliers | Une alerte est émise |
La durée commande cette répartition. Une suite plus longue que ce que l’équipe accepte d’attendre est contournée : elle se parallélise, ou elle maigrit. Le caractère bloquant se mérite, lui aussi. Il ne s’accorde qu’à des tests stabilisés, faute de quoi la chaîne s’arrête pour de fausses alertes.
Les parcours rejoués en production utilisent des comptes réservés et n’écrivent rien qui engage l’organisation : aucune commande réelle, aucun message à un client.
Ce dispositif vérifie qu’un parcours fonctionne pour un utilisateur. La tenue du même parcours sous un trafic élevé relève du test de charge, qui obéit à d’autres règles. L’équipe chargée de la chaîne de livraison répond de l’exécution, l’équipe de développement du verdict.
Une suite courte se défend à chaque incident
Chaque défaut échappé en production suggère d’ajouter un test de bout en bout. Avant de l’écrire, l’équipe se demande à quel niveau le défaut aurait pu être détecté. S’il relevait d’une règle de gestion ou d’un contrat entre deux services, le test s’ajoute à ce niveau.
La suite se relit ensuite à chaque évolution majeure du produit : un parcours qui a cessé d’être critique perd son test, un parcours devenu critique en reçoit un, et la liste validée par le responsable de produit reste la référence.