80 % des bugs rentrent dans 3 catégories. C'est l'affirmation de départ de cet article, et elle est utile. La plupart des bugs n'ont rien de mystérieux. Ils ont peu de causes, et chaque cause pointe vers une pratique que l'équipe a sautée.

Voici les trois groupes :

  1. Le comportement n'est pas celui attendu.
  2. Bug ou feature ?
  3. L'usage de certaines dépendances est buggé.

Chaque groupe a une raison, et chaque raison touche au process. Une catégorie vous dit où regarder. Elle vous dit aussi quelle habitude construire ensuite.

Pourquoi le comportement diffère-t-il de ce qui était attendu ?

La première catégorie a deux causes. Les développeurs ont livré sans tests, ou ils ont testé ce qui n'était pas clairement spécifié.

La première cause est simple. Sans test, il n'y a pas de définition de ce qui est correct. Le code tourne, quelqu'un l'essaie, et c'est lui qui décide si c'est bon. L'utilisateur devient la suite de tests, et c'est une façon coûteuse d'apprendre.

La seconde cause est plus subtile. Un test existe, mais il vérifie une supposition, pas une exigence. Le développeur a écrit le test et le code à partir de la même supposition. Les deux sont d'accord entre eux, et les deux peuvent avoir tort. Un build vert prouve seulement que la supposition est cohérente.

La solution : écrire le comportement attendu sous forme d'exemple avant de coder. Un exemple concret se lit de travers moins facilement qu'une phrase. Laissez ensuite le test porter cet exemple jusque dans le code, pour que l'exigence et la vérification soient une seule et même chose.

Est-ce un bug ou une feature ?

La deuxième catégorie est une affaire de limites. Les développeurs ont implémenté un comportement en plus, là où il n'y avait pas de spécification. Personne n'a décidé de ce comportement. Il est apparu parce que le code devait bien faire quelque chose dans un cas que personne n'avait décrit.

Puis les utilisateurs commencent à en dépendre. Une fois en production, ce comportement n'est plus une supposition. C'est une feature pour certains et un bug pour d'autres. La dispute qui suit porte sur l'historique, pas sur l'exigence.

La solution : définir la limite avant que le code existe. Gáspár Nagy et Seb Rose appellent cela explorer le comportement avec des exemples. Chaque exemple montre où une règle commence et où elle s'arrête. Quand le product owner ne sait pas répondre à une question, le code ne doit pas répondre à sa place.

Pourquoi les dépendances cassent-elles en production ?

La troisième catégorie vit aux jointures. L'équipe utilise une base de données, un service de paiement ou une librairie, et cette dépendance se comporte d'une façon que personne n'a testée. Les développeurs ont livré sans tests d'intégration. Le premier vrai appel à la dépendance a donc eu lieu en production.

Les tests unitaires ont ici un angle mort. Un test qui remplace la dépendance par un faux vérifie que votre code appelle correctement le faux. Mocks Aren't Stubs, de Martin Fowler, explique la différence entre vérifier un état et vérifier des interactions. Un mock peut passer alors que le vrai contrat est faux, et la suite de tests reste verte.

Les tests d'intégration comblent ce trou. Ils appellent la vraie dépendance, ou une copie proche, et vérifient la réponse qui revient. Ils sont moins nombreux que les tests unitaires, et plus lents. C'est le trade-off, et il vaut son prix à chaque frontière que votre système traverse.

Pourquoi un fix crée-t-il un autre bug ?

Voici la phrase que les équipes ressentent le plus : quand l'application grossit, corriger un bug sans tests automatisés créera à coup sûr au moins un autre bug, la plupart du temps.

Michael Feathers définit le legacy code, dans Working Effectively with Legacy Code, comme du code sans tests. Cette définition explique le schéma. Sans tests, vous ne pouvez vérifier un changement qu'en le lisant. Un fix change un comportement dont quelqu'un d'autre dépend déjà, et personne ne le remarque avant le prochain rapport de bug.

Les tests automatisés renversent ce schéma. Chaque fix laisse un test derrière lui, et chaque changement suivant passe par tous ces tests. La suite devient la mémoire du système. Personne n'a à se souvenir de ce que le code était censé faire : les tests le disent.

Comment installer l'habitude de tester ?

Tester fait partie de l'activité de coder. Appliquez ces étapes sur votre prochain ticket.

  1. Écrivez le comportement attendu sous forme d'exemple avant de coder.
  2. Écrivez aussi l'exemple pour l'entrée vide, l'entrée en retard et l'entrée fausse.
  3. Écrivez le test dans le même changement que le code, avant de commiter.
  4. Ajoutez un test d'intégration pour chaque dépendance externe que vous appelez.
  5. Écrivez un test qui échoue et qui reproduit chaque bug avant de le corriger.
  6. Interrogez le product owner sur tout comportement absent de la spécification.
  7. Supprimez le comportement inutilisé que vous trouvez, ou écrivez-le comme une exigence.
  8. Lancez la suite complète avant chaque merge.

L'étape 5 est celle qui change une équipe le plus vite. Un bug qui a son test en échec ne peut pas revenir en douce. Le test fait du bug un fait que le code doit respecter.

Où les trois catégories ne s'appliquent-elles pas ?

Tous les bugs ne rentrent pas dans ces trois groupes. Les problèmes de performance, les soucis de concurrence et les pannes causées par les données du monde réel forment une autre famille. Les tests aident là aussi, mais ils ne sont pas toute la réponse. Le monitoring et les tests de charge font une plus grande part du travail.

Les tests peuvent aussi mal tourner. Une suite qui vérifie des détails d'implémentation casse à chaque refactoring, et les gens ne lui font plus confiance. Testez le comportement dont dépendent les utilisateurs et les autres systèmes, et laissez les étapes internes tranquilles. Unit Testing Principles, Practices, and Patterns, de Khorikov, est un bon guide sur cette distinction.

Enfin, un prototype jetable n'a pas besoin de la suite complète. Il doit en revanche rester loin de la branche principale, et être reconstruit avec des tests avant de devenir du code de production.

💡 À retenir : les tests automatisés comptent. Faites-en une partie de l'activité de coder, ou vous passerez l'essentiel de votre temps et de votre argent sur des bugs !

Ressources et bibliographie

Publié d'abord sur LinkedIn : le post d'origine