FREN

Restons en contact

Social

Technologie· 10 min de lecture

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 testCe qu’il vérifieVitesse et entretien
Test unitaireUne fonction ou une classe, isolée du resteRapide et peu coûteux : à écrire en grand nombre
Test d’intégration ou d’APIPlusieurs composants ensemble : base de données, service, appel HTTPPlus lent : en nombre raisonnable
Test de bout en boutUn parcours complet, par l’interface, comme un utilisateurLent 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 :

TechnologieOutils de testCe que prévoit la documentation
Symfony (PHP)PHPUnitTests 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’installationDeux dossiers, Feature et Unit ; la documentation conseille d’écrire surtout des tests de fonctionnalité
AngularVitest par défaut dans les nouveaux projets ; Karma reste pris en chargeTests exécutés dans un navigateur simulé (jsdom)
Flutterflutter_test, integration_testTests unitaires, de widget et d’intégration
Parcours web de bout en boutPlaywright, SeleniumUn 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 ?
Un test de non-régression vérifie qu’une modification n’a pas cassé ce qui fonctionnait déjà. Automatisé, il tourne à chaque modification du code et signale aussitôt une fonction qui ne se comporte plus comme avant.
Peut-on ajouter des tests à une application qui n’en a aucun ?
Oui. On commence par quelques tests de bout en bout ou d’API sur les parcours critiques, puis on ajoute des tests à chaque correction et à chaque évolution. Avant de restructurer un module ancien, des tests de caractérisation figent son comportement actuel.
Faut-il viser 100 % de couverture de code ?
Non. La couverture aide à repérer le code que rien ne teste, mais elle ne dit pas si les tests sont bons. Un chiffre très élevé peut cacher des tests écrits pour le chiffre plutôt que pour le risque.
Les tests automatisés remplacent-ils les tests manuels ?
Non. Ils prennent en charge les vérifications répétitives, à chaque modification. Les tests exploratoires, la recette par les métiers et le contrôle de l’ergonomie restent humains.
Qui doit écrire les tests automatisés ?
D’abord les développeurs qui écrivent le code, dans la même modification. Une équipe qualité peut construire les tests de bout en bout et animer la démarche, mais des tests tenus à l’écart des développeurs vieillissent mal.
Combien de temps doit durer une suite de tests ?
Le programme DORA vise un retour en moins de dix minutes pour le développeur. Les tests lents, comme les tests de bout en bout, peuvent tourner plus tard dans le pipeline, après le déploiement en recette.

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

  1. The Practical Test Pyramid, Ham Vocke — Ham Vocke, 26 février 2018
  2. Capabilities: Test automation, DORA — Mise à jour du 17 juillet 2025
  3. Eradicating Non-Determinism in Tests, Martin Fowler — 14 avril 2011
  4. TestCoverage, Martin Fowler — 17 avril 2012
  5. Working Effectively with Legacy Code, Michael Feathers — Pearson, 2004
  6. Characterization test, Wikipedia — Définition et golden master
  7. Testing, Symfony — Documentation Symfony 8.1
  8. Testing: Getting Started, Laravel — Documentation Laravel 13.x
  9. Testing, Angular — Documentation Angular
  10. Testing Flutter apps, Flutter — Documentation Flutter
  11. Installation, Playwright — Documentation Playwright

Démarrer un projet

Prêt à passer à l’action ?

Expliquez-nous votre besoin — nous revenons rapidement avec une lecture technique et un plan d’attaque.

  • Réponse sous 48–72 h
  • Échange sans engagement
  • Confidentialité NDA