Écrire des tests automatisés prend du temps
Dans la plupart des cas, débugger prend le même temps. Écrire les tests automatisés prend à peu près aussi longtemps. La différence, c'est ce que chacun laisse derrière lui.
Que laisse le debugging derrière lui ?
Le debugging s'arrête quand le bug a disparu. Ce qu'il laisse, c'est un souvenir dans une seule tête.
❌ Quand vous débuggez, vous gardez la connaissance pour vous.
❌ Tous ceux qui voudront comprendre le même bout de code devront repasser par les mêmes étapes de debugging.
Chaque personne qui ouvre ce code reprend la même enquête de zéro. Les logs, les breakpoints, la seule entrée qui déclenche le problème. La connaissance est réelle, mais elle vit dans la tête d'une personne et nulle part ailleurs.
N'est-ce pas un énorme gaspillage ? Et à quel point est-ce égoïste ?
Vient ensuite la question qui compte le plus. Quelle garantie que le fix n'a pas introduit un nouveau bug ? Que le chemin débuggé est le seul buggé ?
Aucune.
Une session de debugging répond à une seule question : pourquoi ça a cassé, cette fois ? Elle n'a aucun moyen de répondre aux questions qui viennent après le fix. Est-ce que ça marche encore demain ? Est-ce que ça marche encore quand quelqu'un change le code d'à côté ? Rien dans la session n'y répond.
Le fix est peut-être bon. Personne ne peut l'affirmer à partir de la seule session de debugging. Et le prochain changement dans ce code remettra le fix à l'épreuve sans que personne s'en aperçoive.
Qu'apporte un test automatisé que le debugging n'apporte pas ?
✅ Les tests automatisés, quand ils sont bien faits, sont une documentation vivante et attrapent les régressions de comportement.
✅ Ils permettent de refactorer en sécurité, de corriger les bugs à grande vitesse, et ils partagent la connaissance dans l'équipe.
La documentation vivante marche parce que le test s'exécute. Un commentaire peut dire n'importe quoi, personne ne le vérifie. Un test tourne à chaque changement. Ce qu'il affirme reste donc honnête aussi longtemps que la suite existe.
La régression de comportement est le deuxième cadeau. Une fois le scénario dans la suite, le bug ne peut plus revenir en douce. Le build rejoue le scénario à chaque fois, et le bug est attrapé avant qu'un utilisateur le voie.
Le refactoring est le troisième. Changer la structure du code n'est sûr que si quelque chose peut vous dire que le comportement a changé. Sans tests, chaque refactoring est un pari. Avec des tests, c'est une étape de routine.
Le quatrième cadeau, c'est l'équipe. Le prochain développeur lit le test avant de lire le code, et le test lui dit ce que le code est censé faire. La connaissance passe d'une seule tête à toute l'équipe.
Une étude sur quatre équipes industrielles, menée par Nachiappan Nagappan et ses collègues, a constaté une amélioration de la qualité avec le test-driven development. Le mécanisme est celui décrit plus haut. Les tests existent avant le changement, et le changement est jugé par rapport à eux.
Qu'est-ce qui fait qu'un test mérite d'être gardé ?
« Quand ils sont bien faits » : ces quelques mots portent beaucoup dans cette phrase. Vladimir Khorikov, dans Unit Testing Principles, Practices, and Patterns, nomme quatre propriétés d'un test qui a de la valeur. Il protège contre les régressions. Il résiste au refactoring. Il donne un feedback rapide. Il est maintenable.
La résistance au refactoring est celle que la plupart des équipes ratent. Un test qui vérifie des détails internes casse quand on améliore le code, même si le comportement est intact. Le test devient alors une taxe sur chaque changement, et les gens commencent à l'ignorer.
Donc testez le comportement, pas les détails techniques. Un test capture des comportements, PAS des détails techniques. Il doit échouer quand un utilisateur ou un appelant remarquerait une différence, et passer quand seul l'intérieur du code a bougé.
La vitesse compte aussi. Super rapide ! Un test unitaire doit tourner en une seconde environ, pour être lancé tout le temps. La TestPyramid de Martin Fowler explique la forme qui en découle : beaucoup de tests unitaires rapides, moins de tests d'intégration, et seulement quelques tests UI au sommet.
Comment écrire un test qui capture un comportement ?
- Nommez le comportement, pas la méthode. Écrivez « refuse un paiement au-dessus du plafond », pas « validate_amount ».
- Préparez seulement les entrées dont le comportement a besoin.
- Agissez une seule fois, sur le point d'entrée public du code.
- Vérifiez le résultat qu'un appelant peut voir.
- Ne remplacez que ce que vous ne contrôlez pas, comme l'horloge ou un service externe.
- Lancez le test à chaque changement, pas une fois par semaine.
- Gardez le test qui a reproduit le bug, et laissez-le dans la suite.
L'étape 7, c'est là que la session de debugging finit par payer. L'enquête que vous avez menée une fois devient un test que chaque futur développeur lance gratuitement.
Les étapes 1 à 4 sont des décisions que vous prenez une seule fois. Le nom, les entrées et l'assertion sont les premières choses que lit le prochain développeur. Elles valent quelques minutes de plus, car elles décident si le test sera encore utile dans un an.
Quand les tests ne sont-ils pas rentables ?
Toute pratique a un coût, et les tests en ont trois.
Le premier coût, ce sont les tests fragiles. Des tests écrits contre les détails internes cassent à chaque refactoring, se font désactiver, puis n'apprennent plus rien à personne. De mauvais tests sont pires que pas de tests, parce qu'ils donnent l'impression que le changement est dangereux.
Le deuxième coût, c'est le code jetable. Si un prototype doit être supprimé la semaine prochaine, une suite autour de lui est du gaspillage. Écrivez le test quand le code va rester, et quand quelqu'un devra le modifier.
Le troisième coût, c'est le sommet de la pyramide. Les tests UI sont lents et fragiles. N'en gardez que quelques-uns, pour les chemins qui comptent le plus pour l'utilisateur, et poussez le reste des vérifications vers les niveaux du bas.
Faites preuve de jugement sur la limite. La règle n'est pas « tout tester ». La règle, c'est que les tests doivent protéger le comportement dont quelqu'un dépend.
💡 Il vaut mieux se concentrer sur la montée en compétences et apprendre à travailler efficacement avec le logiciel.
Ressources et bibliographie
- Kent Beck, Test-Driven Development: By Example (Addison-Wesley, 2002). https://www.oreilly.com/library/view/test-driven-development/0321146530/
- Vladimir Khorikov, Unit Testing Principles, Practices, and Patterns (Manning, 2020). https://www.manning.com/books/unit-testing
- Martin Fowler, TestPyramid (martinfowler.com, 2012). https://martinfowler.com/bliki/TestPyramid.html
- Martin Fowler, Refactoring: Improving the Design of Existing Code, 2nd edition (Addison-Wesley, 2018). https://martinfowler.com/books/refactoring.html
- Nachiappan Nagappan, E. Michael Maximilien, Thirumalesh Bhat, Laurie Williams, Realizing quality improvement through test driven development: results and experiences of four industrial teams (Empirical Software Engineering 13, 2008). https://link.springer.com/article/10.1007/s10664-008-9062-z
Publié d'abord sur LinkedIn : le post d'origine
