Aller au contenu
Cabinet d'expertise en transformation technologique · ARDIANE Group Innover, sécuriser, réussir

Ingénierie

Décider ce qui mérite des tests automatisés, et à quel niveau

L'essentiel

Les tests automatisés sont des vérifications écrites sous forme de code et rejouées sans intervention à chaque modification d'une application. Chacun se paie à l'écriture, à l'exécution et à l'entretien : Management Square propose ici des critères pour décider quoi automatiser, à quel niveau placer chaque vérification et dans quels cas s'abstenir.

Sommaire de la page

Les tests automatisés se paient trois fois : à l’écriture, à chaque exécution, puis à chaque évolution du code qu’ils vérifient. Le troisième coût échappe facilement au chiffrage initial, alors que la durée de vie d’une suite en dépend.

Ce sont des vérifications écrites sous forme de code, que la chaîne de livraison rejoue sans intervention à chaque modification. La décision d’en écrire une se prend vérification par vérification. Mérite un script ce qui sera rejoué de nombreuses fois, dont le résultat attendu s’énonce sans ambiguïté et dont l’objet est assez stable pour que le test survive aux prochaines livraisons. Chaque vérification retenue descend ensuite aussi près du code que le défaut redouté le permet : test unitaire, test d’intégration ou de contrat, test de bout en bout. Ce qui demande un jugement, ce qui change chaque semaine et ce qui sera bientôt supprimé reste confié à une personne, ou attend.

Les vérifications qui gagnent à être automatisées

Trois critères se cumulent, et un quatrième départage.

La répétition vient d’abord. Un contrôle rejoué à chaque modification du code amortit son écriture. Un contrôle utile une fois par an se fait à la main, à partir d’une procédure écrite.

Vient ensuite l’existence d’un verdict. Un test compare un résultat obtenu à un résultat attendu. Si personne ne sait écrire ce résultat attendu, parce qu’un barème est encore en discussion ou qu’un écran sera jugé « à l’œil », le script ne vérifiera rien d’utile : la règle est à trancher d’abord.

Le troisième critère est la stabilité de l’objet testé. Une règle de calcul fixée par un contrat change peu. La disposition d’un écran en cours de conception peut changer à chaque atelier, et un changement suffit à faire échouer le test alors qu’aucun défaut n’existe.

La gravité départage les candidats restants : la priorité va aux comportements dont la défaillance coûterait cher, comme un montant facturé, un droit d’accès ou une échéance réglementaire. La manière de relier ces risques à une stratégie de test d’ensemble est décrite dans notre page qualité logicielle et tests ; cet article s’en tient à la décision d’automatiser.

À quel niveau placer chaque vérification

La pyramide des tests, présentée dans notre page qualité logicielle et tests, donne un principe de répartition. Le tableau ci-dessous la lit dans l’autre sens, en partant de ce que l’équipe redoute.

Défaut redouté Niveau où le vérifier Ce que ce niveau ne voit pas
Une règle de gestion fausse : arrondi, barème, date limite, valeur absente Test unitaire, sans base de données ni réseau Tout ce qui tient à l’assemblage
Une requête qui renvoie les mauvaises lignes, une migration de schéma oubliée Test d’intégration, sur une base du même moteur que la production Les autres services et l’interface
Deux services qui ne s’accordent plus sur le format d’un échange Test de contrat, exécuté des deux côtés de l’interface Le comportement d’ensemble sur des données réelles
Un parcours vital rompu une fois l’application assemblée et déployée Test de bout en bout, pour un petit nombre de parcours Le composant à l’origine de l’échec
Des temps de réponse qui se dégradent sous le trafic Test de charge L’exactitude fonctionnelle

Un test placé trop haut détecte encore le défaut, mais plus tard, plus lentement et sans désigner le composant fautif. Un barème vérifié à travers l’interface demande un navigateur, un compte et des données pour chaque cas. Le même barème, en test unitaire, se vérifie cas par cas sans rien démarrer d’autre que le code du calcul.

Un test placé trop bas rassure à tort. Des tests unitaires qui remplacent la base de données par un simulacre peuvent tous réussir alors que la requête réelle est fausse.

Les deux dernières lignes du tableau obéissent à leurs propres règles. Le choix des parcours, les données et la stabilité de la suite sont traités dans notre article sur le test end to end. Le cadrage d’une campagne et la lecture de ses résultats le sont dans celui consacré au test de charge.

Le coût d’entretien des tests automatisés se décide à l’écriture

Une suite de tests est du code : elle se lit, se remanie et vieillit comme le reste. Quatre choix, faits au moment où le test est écrit, fixent sa charge d’entretien.

Ce que le test observe compte en premier lieu. Un test qui contrôle un résultat visible de l’extérieur (une valeur renvoyée, un enregistrement créé, un message émis) survit à une réécriture interne. Un test qui contrôle la manière (telle méthode appelée, dans tel ordre) risque d’échouer à chaque remaniement, alors qu’aucun comportement n’a changé. Le signal se relève sans outil : lorsqu’un remaniement sans effet fonctionnel oblige à corriger des dizaines de tests, la suite est couplée à l’implémentation.

Les doublures pèsent ensuite. Remplacer une dépendance par un simulacre (mock, stub) accélère le test et l’isole. Chaque simulacre est aussi une hypothèse sur le comportement de cette dépendance, que rien ne met à jour quand elle évolue. Les simulacres se réservent donc aux frontières lentes ou extérieures à l’équipe, et un test de contrat vérifie que l’hypothèse tient encore.

Les données de test suivent la même logique. Un test qui fabrique les données dont il a besoin se lit seul et s’exécute dans n’importe quel ordre. Un jeu commun à toute la suite devient une dépendance partagée : le modifier pour un test peut en faire échouer d’autres.

Reste la durée. Convenez d’un délai maximal pour le verdict qui précède chaque intégration : ce budget de temps borne ce qui peut s’exécuter à ce moment et renvoie le reste à une exécution moins fréquente. L’exécution en parallèle et la sélection des tests concernés par un changement relèvent de la chaîne décrite dans notre page DevOps et platform engineering.

Un test qui ne paie plus son entretien se supprime. Conservé par précaution, il pèse sur chaque modification, au même titre que le reste de la dette technique.

Quand s’abstenir, ou attendre

Renoncer à automatiser est une décision comme une autre, pourvu qu’elle soit prise en connaissance de cause. Plusieurs situations la justifient :

  • le code est un prototype, destiné à être jeté une fois son hypothèse vérifiée (si le prototype est conservé, la décision se rouvre) ;
  • l’interface est en cours de conception : les règles de gestion placées derrière elle se testent dès maintenant, les écrans attendent d’être stabilisés ;
  • la vérification demande un jugement, sur la lisibilité d’un écran, la cohérence d’un parcours ou la réaction à une situation que personne n’avait prévue ;
  • le contrôle est rare et son exécution manuelle coûte peu, comme une vérification annuelle de clôture ;
  • le code existant ne se prête pas au test sans être restructuré.

Le dernier cas appelle une précision. Vouloir couvrir en entier une application ancienne avant d’y toucher immobilise l’équipe. Des tests de caractérisation, qui figent le comportement actuel autour de la seule zone à modifier, suffisent pour commencer.

Dans chacune de ces situations, la vérification demeure : elle est manuelle, décrite par écrit, et quelqu’un en répond. La décision de ne pas automatiser se consigne avec la condition qui la fera revoir.

Relire la suite existante avant de l’agrandir

Dans une application déjà dotée de tests, la première étape n’ajoute rien. Relevez, pour chaque groupe de tests, trois informations : sa durée d’exécution, le dernier défaut réel qu’il a détecté, et le nombre de fois où il a fallu le corriger alors que l’application fonctionnait. Les groupes lents, muets et maintes fois réparés sont à redescendre d’un niveau ou à supprimer. Les zones où un défaut est arrivé en production sans qu’aucun test n’échoue désignent ce qu’il reste à automatiser.

FAQ

Questions fréquentes

Une autre question ? Posez-la-nous

Par quels tests automatisés commencer sur une application qui n'en a aucun ?

Par la zone que l'équipe s'apprête à modifier. Des tests de caractérisation y figent le comportement actuel, tel qu'il est, avant toute intervention : ils signalent ensuite tout changement involontaire. Les tests unitaires s'ajoutent à mesure que le code est restructuré et devient testable. Chercher à couvrir toute l'application avant d'y toucher retarde les livraisons sans réduire davantage le risque de la prochaine modification.

Les tests automatisés remplacent-ils la recette ?

Ils en reprennent la partie répétitive : vérifier, à chaque livraison, que ce qui fonctionnait fonctionne encore. La recette conserve ce qui demande un jugement, à commencer par la question de savoir si l'application répond au besoin du métier. Une recette déchargée des contrôles de non-régression peut se concentrer sur les nouveautés et sur les situations inattendues.

Faut-il écrire les tests avant le code ?

Le développement piloté par les tests (test-driven development, ou TDD) consiste à écrire un test qui échoue, puis le code qui le fait réussir, puis à remanier l'ensemble. Cette discipline conduit à un code testable par construction, puisque chaque fonction naît avec son test. Elle relève d'un choix d'équipe : un test écrit juste après le code a la même valeur de vérification s'il contrôle un comportement et s'il échoue quand ce comportement est rompu.

Qu'est-ce qu'un test de non-régression ?

Un test de non-régression vérifie qu'une modification n'a pas altéré un comportement qui fonctionnait auparavant. Le terme désigne un usage, sans préjuger du niveau : tout test automatisé conservé et rejoué à chaque modification joue ce rôle, qu'il soit unitaire, d'intégration ou de bout en bout. Une campagne de non-régression menée à la main avant chaque livraison est une bonne candidate à l'automatisation, à condition de redescendre chaque vérification au niveau qui lui convient.

Un projet à faire aboutir ?

Un premier échange suffit pour situer votre enjeu, identifier les bons interlocuteurs et vous dire franchement ce que nous pouvons apporter.