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.