Développement piloté par les tests
Le TDD est la boucle rouge → vert → refactor. Cette compétence est la référence qui permet à cette boucle de produire des tests qui valent la peine d'être conservés : ce qu'est un bon test, où placer les tests, les anti-patrons et les règles de la boucle. Chaque section s'applique à chaque cycle – consultez-les avant et pendant la boucle, pas après.
Lors de l'exploration de la base de code, lisez CONTEXT.md (s'il existe) pour que les noms des tests et le vocabulaire de l'interface correspondent au langage du domaine du projet, et respectez les ADR dans la zone que vous modifiez.
Ce qu'est un bon test
Les tests vérifient le comportement via les interfaces publiques, pas les détails d'implémentation. Le code peut changer entièrement ; les tests ne devraient pas. Un bon test se lit comme une spécification – « l'utilisateur peut finaliser sa commande avec un panier valide » vous indique exactement la capacité qui existe – et survit aux refactorisations parce qu'il ne se soucie pas de la structure interne.
Consultez tests.md pour des exemples et mocking.md pour les directives relatives aux simulations (mocking).
Coutures – où placer les tests
Une couture est l'endroit où le module testé présente son interface : là où vous observez le comportement sans accéder à l'intérieur. Les tests se placent au niveau des coutures, jamais contre les éléments internes.
Avant d'écrire un test, identifiez la couture testée. Si une interface publique existante constitue la couture évidente, indiquez-la et continuez. Si la couture est nouvelle ou ambiguë, confirmez-la d'abord avec l'utilisateur. Vous ne pouvez pas tout tester – choisir les coutures délibérément permet de concentrer l'effort de test sur les chemins critiques et la logique complexe plutôt que sur chaque cas limite.
Demandez : « Quelle est l'interface publique, et quelles coutures devrions-nous tester ? »
Anti-patrons
- Couplé à l'implémentation – simule les collaborateurs internes, teste les méthodes privées, ou vérifie via un canal secondaire (interroger la base de données au lieu d'utiliser l'interface). Le signe : le test casse lors d'une refactorisation alors que le comportement n'a pas changé.
- Tautologique – l'assertion recalcule la valeur attendue de la même manière que le code (
expect(add(a, b)).toBe(a + b), un instantané dérivé manuellement de la même façon, une constante affirmée égale à elle-même), donc il passe par construction et ne peut jamais être en désaccord avec le code. Les valeurs attendues doivent provenir d'une source de vérité indépendante – une valeur littérale connue comme correcte, un exemple travaillé, la spécification. - Découpage horizontal – écrire tous les tests d'abord, puis toute l'implémentation. Les tests en masse vérifient un comportement imaginé : vous testez la forme des choses plutôt que le comportement orienté utilisateur, les tests deviennent insensibles aux modifications réelles, et vous vous engagez dans une structure de test avant de comprendre l'implémentation. Travaillez plutôt en tranches verticales – un test → une implémentation → répéter, chaque test étant une balle traçante qui répond à ce que le dernier cycle vous a appris.
Règles de la boucle
- Rouge avant vert. Écrivez d'abord le test qui échoue, puis seulement assez de code pour le faire passer. N'anticipez pas les tests futurs et n'ajoutez pas de fonctionnalités spéculatives.
- Une tranche à la fois. Une couture, un test, une implémentation minimale par cycle.
- Refactorisez après le vert. Améliorez les noms et la structure tout en gardant le comportement inchangé et les tests réussis. N'ajoutez pas de nouveau comportement pendant la refactorisation ; les changements architecturaux plus larges appartiennent à l'étape de révision (voir la compétence
code-review).