Tests automatisés sur une application existante : par où commencer
Par où commencer les tests automatisés d’une application existante : parcours critiques, tests de caractérisation, pyramide, tests instables et CI/CD.
Sur une application existante sans tests, on ne commence ni par viser un taux de couverture, ni par automatiser tous les écrans : on protège d’abord les quelques parcours dont l’activité dépend, on fige le comportement du code avant de le modifier, puis on exige des tests pour tout code nouveau ou modifié. Ce guide donne l’ordre des étapes, les types de tests à privilégier, le traitement des tests instables et leur place dans le pipeline.
Il s’adresse aux dirigeants techniques, aux DSI et aux responsables d’application qui héritent d’un code peu ou pas testé et veulent le faire évoluer sans régressions. Les tests automatisés sont au cœur de notre offre assurance qualité et tests.
Pourquoi automatiser les tests d’une application existante ?
Automatiser les tests d’une application existante, c’est pouvoir la modifier sans casser ce qui marche. Une application en production change sans cesse : correctifs, évolutions demandées par les métiers, montées de version du langage ou du framework. Sans tests, chaque changement se vérifie à la main, ou ne se vérifie pas, et les régressions sont découvertes par les utilisateurs.
Les tests automatisés rendent cette vérification rapide et répétable, à chaque modification. Ils sont aussi la condition pour réduire la dette technique : on ne restructure pas sans filet un code que personne ne connaît plus entièrement. Une montée de version, comme celle qu’impose la fin des correctifs de Symfony 6.4, est le moment où ce filet manque le plus.
Par où commencer les tests automatisés ?
Les tests automatisés d’une application existante commencent par les parcours dont la panne coûte le plus, pas par le code le plus facile à tester. Pour les systèmes existants, le programme de recherche DORA, porté par Google Cloud, recommande de ne pas chercher à tout couvrir : écrire quelques tests d’acceptation sur les fonctions à forte valeur, puis exiger des tests unitaires et d’acceptation pour tout code nouveau ou modifié. La couverture progresse alors au rythme des changements, là où se trouve le risque.
- Lister les parcours critiques. Avec les métiers et le support : ce qui rapporte, ce qui casse souvent, ce qui est soumis à une obligation (facturation, données personnelles).
- Les protéger par quelques tests de bout en bout ou d’API. Un ou deux par parcours, qui vérifient le résultat attendu plutôt que le détail de l’écran.
- Les faire tourner à chaque modification. Quelques tests fiables lancés automatiquement valent mieux qu’une longue campagne manuelle rarement refaite.
- Exiger un test pour chaque correction. Une anomalie corrigée reçoit le test qui l’aurait détectée : elle ne reviendra pas sans bruit.
- Figer le comportement avant de restructurer. Avant de toucher à un module ancien, des tests de caractérisation décrivent ce qu’il fait aujourd’hui.
Qu’est-ce qu’un test de caractérisation ?
Un test de caractérisation décrit le comportement réel d’un code existant, tel qu’il est aujourd’hui, et non tel qu’il devrait être. Michael Feathers a décrit la méthode dans son livre Working Effectively with Legacy Code (Pearson, 2004) : avant de modifier un code ancien, on écrit des tests qui enregistrent ce qu’il produit, pour être sûr de ne pas en changer le comportement sans le vouloir.
La méthode est simple : on fait tourner le code avec des entrées représentatives, on enregistre les sorties (une page, un fichier, une réponse d’API), et le test vérifie ensuite qu’elles ne changent pas. On parle aussi de « golden master ». Les valeurs qui varient d’une exécution à l’autre, comme une date ou un identifiant, doivent être masquées. Si le test révèle un comportement étrange, on le garde tel quel : sa correction fera l’objet d’une modification à part, décidée et testée.
Quels types de tests, et dans quelles proportions ?
La bonne proportion suit la pyramide des tests : beaucoup de tests unitaires, petits et rapides, moins de tests d’intégration ou de service, et très peu de tests de bout en bout qui passent par l’interface. Le modèle vient de Mike Cohn (Succeeding with Agile) ; Ham Vocke le résume dans « The Practical Test Pyramid », publié en 2018 sur le site de Martin Fowler : plus un test est de haut niveau, moins il en faut.
| Type de test | Ce qu’il vérifie | Vitesse et entretien |
|---|---|---|
| Test unitaire | Une fonction ou une classe, isolée du reste | Rapide et peu coûteux : à écrire en grand nombre |
| Test d’intégration ou d’API | Plusieurs composants ensemble : base de données, service, appel HTTP | Plus lent : en nombre raisonnable |
| Test de bout en bout | Un parcours complet, par l’interface, comme un utilisateur | Lent et fragile : réservé aux parcours critiques |
La forme inverse, avec beaucoup de tests par l’interface et peu de tests unitaires, porte un nom : le cornet de glace. Ham Vocke rappelle que les tests de bout en bout sont réputés instables, demandent beaucoup d’entretien et tournent lentement ; il conseille de les réduire au strict minimum et de pousser chaque test aussi bas que possible dans la pyramide. Sur une application existante, la pyramide se construit pourtant souvent par le haut : les tests de bout en bout des parcours critiques viennent d’abord, parce que le code n’est pas encore découpé pour les tests unitaires ; les tests unitaires suivent, au fil des corrections et des restructurations.
Que faire des tests instables ?
Un test instable, qui échoue parfois sans que le code ait changé, se retire de la suite principale et se corrige vite. Martin Fowler les qualifie de contagieux : quand quelques tests échouent au hasard, l’équipe prend l’habitude d’ignorer les échecs, y compris les vrais. Il recommande de les placer en quarantaine, dans une suite à part dont on limite la taille ou la durée de séjour, puis de les réparer.
Les causes reviennent presque toujours : des tests qui dépendent les uns des autres, un traitement asynchrone attendu au mauvais moment, un service distant indisponible, l’heure ou la date du jour, des ressources mal libérées. Le programme DORA tient la même ligne : une petite suite fiable vaut mieux qu’une grande suite à laquelle personne ne croit, et les tests instables ne se tolèrent pas.
Quelles données utiliser pour les tests ?
Chaque test prépare ses propres données et ne dépend pas de ce qu’un autre test a laissé : une base de test partagée, modifiée par un test et relue par un autre, est une source classique d’instabilité. Ces données ne doivent pas non plus être une copie de la production. Notre article sur les données de test et le RGPD explique comment tester sans copier les données personnelles.
Quels outils de test selon la technologie ?
L’outil de test dépend d’abord du langage et du framework de l’application : la plupart des frameworks courants livrent le leur, déjà configuré. Pour les technologies que nous rencontrons le plus souvent :
| Technologie | Outils de test | Ce que prévoit la documentation |
|---|---|---|
| Symfony (PHP) | PHPUnit | Tests unitaires, d’intégration et d’application (fonctionnels), qui envoient des requêtes HTTP réelles ou simulées |
| Laravel (PHP) | Pest ou PHPUnit, inclus dès l’installation | Deux dossiers, Feature et Unit ; la documentation conseille d’écrire surtout des tests de fonctionnalité |
| Angular | Vitest par défaut dans les nouveaux projets ; Karma reste pris en charge | Tests exécutés dans un navigateur simulé (jsdom) |
| Flutter | flutter_test, integration_test | Tests unitaires, de widget et d’intégration |
| Parcours web de bout en bout | Playwright, Selenium | Un navigateur piloté qui rejoue un parcours ; Playwright couvre Chromium, WebKit et Firefox |
Les conseils varient d’un framework à l’autre. La documentation de Laravel recommande d’écrire surtout des tests de fonctionnalité, qui démarrent l’application, parce qu’ils donnent le plus de confiance sur le système entier ; celle de Flutter vise beaucoup de tests unitaires et de widget, et assez de tests d’intégration pour couvrir les cas d’usage importants. Le principe commun : réserver les tests lents, par le navigateur, aux parcours qui le justifient.
Comment brancher les tests dans le pipeline CI/CD ?
Les tests automatisés ne protègent que s’ils tournent tout seuls, à chaque modification, dans le pipeline d’intégration continue. Le programme DORA conseille de commencer petit : un pipeline squelette avec un seul test unitaire, un seul test d’acceptation et un script de déploiement automatique, que l’on étoffe ensuite. Il donne aussi un ordre de grandeur : un développeur doit savoir en moins de dix minutes si sa modification casse quelque chose. Notre guide du CI/CD détaille les étapes d’un pipeline.
- Les tests rapides d’abord. Tests unitaires et d’intégration à chaque modification ; les tests de bout en bout après le déploiement en recette.
- Un échec arrête la chaîne. Une modification qui casse un test ne va pas plus loin.
- Un pipeline rouge se répare tout de suite. Avant toute nouvelle fonction, sinon l’équipe s’habitue à l’ignorer.
- Les développeurs écrivent et tiennent les tests. DORA range parmi les erreurs courantes le fait de tenir les développeurs à l’écart des tests.
Comment mesurer les progrès des tests automatisés ?
Les progrès se mesurent à la confiance que l’équipe accorde aux tests, pas au seul taux de couverture. Martin Fowler le dit sans détour : la couverture de code est utile pour trouver les parties non testées, mais elle dit peu de chose de la qualité des tests, et un chiffre proche de 100 % doit plutôt éveiller le soupçon. Le programme DORA propose des mesures plus parlantes :
- la part des anomalies trouvées tôt, dans les phases de test les moins coûteuses, plutôt qu’en recette ou en production ;
- le temps passé à corriger les échecs de tests ;
- la part des échecs qui signalent un vrai défaut, et non un test instable ;
- le fait que toutes les suites de tests tournent à chaque déclenchement du pipeline ;
- la part des tests écrits par les développeurs eux-mêmes.
Pour une application en maintenance, ces mesures rejoignent celles de la maintenance corrective : moins de régressions en production, ce sont moins d’anomalies à corriger en urgence.
Questions fréquentes
Qu’est-ce qu’un test de non-régression ?
Peut-on ajouter des tests à une application qui n’en a aucun ?
Faut-il viser 100 % de couverture de code ?
Les tests automatisés remplacent-ils les tests manuels ?
Qui doit écrire les tests automatisés ?
Combien de temps doit durer une suite de tests ?
Tests automatisés : protégez d’abord ce dont l’activité dépend
Automatiser les tests d’une application existante ne demande ni de tout réécrire, ni d’atteindre un chiffre de couverture. On protège d’abord les parcours dont l’activité dépend, on fige le comportement du code avant de le toucher, on fait tourner les tests à chaque modification, et on ne laisse pas un test instable entamer la confiance de l’équipe.
L’équipe iones met en place et maintient des tests automatisés sur des applications existantes, dans le cadre de son offre assurance qualité et tests et lors d’une reprise d’application web. Pour faire le point sur les tests de votre application, écrivez-nous.
Sources
- The Practical Test Pyramid, Ham Vocke — Ham Vocke, 26 février 2018
- Capabilities: Test automation, DORA — Mise à jour du 17 juillet 2025
- Eradicating Non-Determinism in Tests, Martin Fowler — 14 avril 2011
- TestCoverage, Martin Fowler — 17 avril 2012
- Working Effectively with Legacy Code, Michael Feathers — Pearson, 2004
- Characterization test, Wikipedia — Définition et golden master
- Testing, Symfony — Documentation Symfony 8.1
- Testing: Getting Started, Laravel — Documentation Laravel 13.x
- Testing, Angular — Documentation Angular
- Testing Flutter apps, Flutter — Documentation Flutter
- Installation, Playwright — Documentation Playwright