J'hérite d'une suite de tests qu'un collègue parti depuis a laissée derrière lui. Je change une ligne, une histoire d'arrondi, rien de méchant. Je lance les tests. Un feu rouge : expect(calculePrix(100, 'VIP')).toBe(80). Le test attendait 80, il obtient 78.
Et là, je bloque. 80, c'est quoi ? Une vérité que ce test protège, ou un chiffre gravé un jour par quelqu'un pour une raison oubliée ? Aucun commentaire. Le nom du test : test calculePrix. Merci bien. Je fais un git blame : l'auteur a quitté la boîte il y a deux ans. Je suis devant l'échelle, et plus personne ne se souvient de la douche froide.
Un test enregistre une décision : « ce comportement compte assez pour qu'on le surveille ». Sauf qu'il n'en garde que la moitié. Il grave le quoi, la valeur attendue, avec une précision de machine. Le pourquoi, la décision et le risque qui justifient cette valeur, ne vit nulle part dans le code. Il est dans la tête de l'auteur, ou dans un message de commit, ou parti avec lui. Et le jour où le test vire au rouge, c'est le pourquoi, pas le quoi, dont tu as besoin.
Un test vert n'a jamais besoin de son pourquoi
Tant qu'un test passe, personne ne lui demande de comptes. Il est vert, on avance. Le pourquoi ne devient vital qu'au moment exact où le test casse. Là, tu dois trancher entre deux verdicts opposés, et tout le reste dépend de ce choix.
Soit tu as introduit une régression : le test protégeait un vrai comportement, ton changement l'a cassé, tu répares ton code. Soit l'attente est périmée : le comportement a légitimement évolué, et c'est le test qu'il faut mettre à jour. Les deux situations allument exactement le même feu rouge. La seule chose qui les distingue, c'est le pourquoi. Sans lui, tu ne débugges pas, tu devines.
Et devine ce que fait un dev pressé devant un test rouge qu'il ne comprend pas. Deux options, aussi mauvaises l'une que l'autre.
Il ajuste son code jusqu'à ce que le test redevienne vert. Peut-être qu'il vient de restaurer une règle métier essentielle. Ou peut-être qu'il vient de se plier à un fossile, de nourrir un test qui ne protège plus rien. Il est le nouveau singe : il respecte l'interdiction de l'échelle sans savoir pourquoi, juste parce que le rouge fait peur.
Ou alors il supprime le test, ou l'assouplit, parce qu'« il est sûrement obsolète ». Peut-être. Ou peut-être qu'il vient de retirer la seule garde sur un comportement discret et coûteux. Le test qui semble inutile est parfois celui qui surveille le pixel de tracking dont dépend la moitié du revenu. Tu ne le sauras qu'en production.
Dans les deux cas, le test censé supprimer le doute est devenu une machine à en fabriquer. C'est ça, une dette déguisée en assurance : ça a la couleur de la sécurité (vert, tout va bien), mais au moment précis où tu comptes dessus, ça ne sait pas te dire ce que ça protège.
Le quoi s'écrit tout seul, le pourquoi se décide
Le remède ne coûte presque rien. L'assertion dit le quoi ; une ligne dit le pourquoi. Pas un commentaire qui répète le code, ça n'aide personne :
// Vérifie que le prix est 80
test('calculePrix', () => {
expect(calculePrix(100, 'VIP')).toBe(80);
});
Ce commentaire redit le quoi. Il ne dit toujours pas pourquoi 80. Ce qu'il te faut, c'est un nom et une intention qui portent la décision et le risque :
// La remise VIP est plafonnée à 20 %. En dessous de 80, la marge passe sous zéro.
test('plafonne la remise VIP à 20 % pour ne pas vendre à perte', () => {
expect(calculePrix(100, 'VIP')).toBe(80);
});
Même assertion, même 80. Mais cette fois, le jour où le test vire au rouge, tu lis le nom et tu sais quoi faire en trois secondes. Ton changement a fait passer le prix VIP sous 80 ? Tu as cassé le garde-fou de la marge, c'est une régression, tu répares. Le métier a vraiment relevé le plafond ? Tu mets à jour le test et sa raison. Le rouge est redevenu une décision au lieu d'une devinette.
Quand l'IA écrit tes tests, le pourquoi est tout ce qui te reste
Le quoi n'a jamais été aussi bon marché. Donne une fonction à l'assistant, il te sort douze assertions en dix secondes, il couvre des cas limites que tu aurais oubliés, il fait grimper ta couverture sans effort. Sur le quoi, la machine te bat à plate couture.
Mais l'assistant lit le pourquoi dans le code tel qu'il est. Il écrit des tests qui affirment le comportement actuel, sans pouvoir distinguer la règle métier structurante du hasard d'implémentation. Il gravera toBe(80) avec le même aplomb qu'il aurait mis pour n'importe quelle autre valeur, et s'il commente, ce sera « vérifie que le prix est 80 » : le quoi, redit. Parce que le pourquoi, le plafond à 20 %, le « vendre à perte », l'incident qui a mené à cette règle, n'est pas dans le code. Il est dans ta tête et dans la mémoire de ta boîte.
Résultat : la génération produit la pire version de l'interdiction du singe, mais à l'échelle. Des centaines d'assertions vertes qui figent le comportement présent comme s'il était tout entier voulu, et pas une qui dise pourquoi. La couverture monte, la compréhension tombe à zéro. Tu hérites d'une suite maximalement verte et maximalement muette.
C'est ça, la bascule. Le quoi est devenu le travail de la machine. Le pourquoi est le tien. La seule chose que tu peux ajouter à un test que l'IA a écrit, la seule qu'elle ne peut pas inférer, c'est la raison pour laquelle il compte. Le junior qui apprend à écrire ce pourquoi ne fait pas un travail de junior : il fait la partie qui ne s'automatise pas.
Ce que je te conseille
Nomme tes tests par la décision qu'ils protègent, jamais par la fonction qu'ils appellent. plafonne la remise VIP à 20 %, pas calculePrix. Et si tu es incapable de nommer le pourquoi, ne l'invente pas : c'est le signe que tu ne sais pas encore ce que tu testes. Va le chercher avant d'écrire l'assertion, pas après.
Devant un test rouge que tu n'as pas écrit, ne le rends jamais vert à l'aveugle. Retrouve d'abord son pourquoi : le git log, le ticket, la personne. Un vert que tu ne comprends pas ne te protège pas, il t'endort.
Un test sans son pourquoi, ce n'est pas une assurance, c'est une superstition. Et une suite de superstitions, même toute verte, ne te dira jamais le jour où tu casses vraiment quelque chose.
La parabole complète du singe (le versant psychologie, l'expérience d'Asch, ce conformisme qui nous fait éviter l'échelle sans jamais poser la question) est sur mon blog perso : Et si les singes demandaient pourquoi ?.
Pour le reste sous le capot : le test unitaire, l'assertion, la couverture de code, la régression et le test de non-régression.