Les tests automatisés sont devenus un standard de l'industrie. Plus personne ne conteste sérieusement leur utilité. Mais dès qu'on entre dans le détail, un débat émerge : faut-il écrire les tests avant le code ? Après ? Avec le métier ?
TDD, BDD, tests a posteriori — chaque approche a ses défenseurs passionnés et ses détracteurs tout aussi convaincus. La réalité est plus nuancée que les positions dogmatiques. Chaque stratégie a sa place, et les meilleures équipes les combinent en fonction du contexte.
Cet article passe en revue les trois approches sans parti pris, analyse leurs forces et limites respectives, et propose une stratégie de combinaison adaptée aux projets réels.
TDD : écrire le test avant le code
Le Test-Driven Development (TDD) suit un cycle strict en trois étapes, popularisé par Kent Beck : red, green, refactor.
- Red — écrire un test qui échoue. Le test décrit le comportement attendu d'un morceau de code qui n'existe pas encore.
- Green — écrire le minimum de code nécessaire pour que le test passe. Pas d'optimisation, pas de généralisation. Juste assez pour passer au vert.
- Refactor — nettoyer le code sans changer le comportement. Le test vert garantit qu'on ne casse rien.
Ce cycle se répète en boucles courtes — parfois toutes les deux minutes. Le test guide la conception. Le code émerge du besoin, pas d'une architecture imaginée à l'avance.
Quand le TDD brille
Le TDD donne ses meilleurs résultats sur la logique métier complexe. Algorithmes de calcul, règles de tarification, moteurs de validation, transformations de données — tout ce qui a des entrées, des sorties et des règles précises.
Dans ces contextes, le TDD force à clarifier le comportement attendu avant d'écrire la moindre ligne d'implémentation. C'est un outil de conception autant qu'un outil de test. Le code résultant est naturellement découplé, car il a été écrit pour être testable dès le départ.
Le TDD excelle aussi dans les situations où les cas limites sont nombreux. Chaque cas limite devient un test explicite. On ne les découvre pas en production — on les spécifie à l'avance.
Forces
- Feedback immédiat — chaque changement est validé en secondes.
- Conception émergente — le code est structuré par les besoins réels, pas par des abstractions prématurées.
- Documentation exécutable — les tests décrivent exactement ce que fait le code, avec des exemples concrets.
- Confiance dans le refactoring — on peut restructurer le code sans crainte tant que les tests passent.
Limites
- Coût d'apprentissage élevé — le TDD demande une discipline qui s'acquiert avec la pratique. Les premières semaines sont frustrantes : on a l'impression d'aller plus lentement.
- Inadapté à l'exploration — quand on ne sait pas encore à quoi ressemblera la solution (prototype, POC, spike technique), écrire des tests avant le code est contre-productif.
- Difficulté sur le code à effets de bord — les interactions avec une base de données, une API externe ou un système de fichiers requièrent des mocks ou des doubles de test qui alourdissent le cycle.
- Risque de sur-spécification — des tests trop couplés à l'implémentation empêchent le refactoring au lieu de le faciliter.
BDD : spécifier par l'exemple
Le Behavior-Driven Development (BDD) est né d'un constat de Dan North : le TDD, malgré ses qualités, ne résout pas le problème de communication entre développeurs et métier. Les tests techniques sont illisibles pour les parties prenantes non techniques.
Le BDD propose d'écrire les spécifications dans un langage structuré mais lisible par tous : le format Gherkin.
Le format Given/When/Then
Chaque scénario BDD suit une structure en trois parties :
- Given (étant donné) — le contexte initial, l'état du système avant l'action.
- When (quand) — l'action déclenchée par l'utilisateur ou le système.
- Then (alors) — le résultat attendu, l'état du système après l'action.
Un scénario Gherkin ressemble à ceci : « Étant donné un utilisateur avec un panier de 3 articles, quand il applique un code promo de 20 %, alors le total affiché est réduit de 20 % et le code promo apparaît dans le récapitulatif. »
Ce scénario est à la fois une spécification métier,
un critère d'acceptance et un test automatisé.
Les outils BDD comme Behat (PHP) ou Cucumber (multi-langage)
exécutent ces scénarios directement.
Quand le BDD brille
Le BDD est particulièrement efficace dans les projets multi-parties prenantes où la communication entre métier et technique est un enjeu.
Quand les spécifications sont ambiguës — « l'utilisateur doit pouvoir gérer ses abonnements » — le BDD force à les concrétiser par des exemples. Chaque scénario élimine une ambiguïté. Le résultat est une spécification vivante, toujours à jour car exécutée à chaque build.
Le BDD excelle aussi pour les critères d'acceptance. Au lieu de débattre de ce que « terminé » signifie, l'équipe écrit les scénarios qui valident la fonctionnalité. Quand tous les scénarios passent, la fonctionnalité est terminée. C'est une définition concrète, vérifiable, automatisée.
Forces
- Langage partagé — les scénarios sont lisibles par les développeurs, les product owners et les testeurs.
- Spécifications vivantes — les scénarios Gherkin sont à la fois documentation et tests exécutables.
- Réduction des malentendus — spécifier par l'exemple élimine les interprétations divergentes.
- Couverture fonctionnelle — les tests BDD vérifient le comportement du point de vue de l'utilisateur, pas de l'implémentation.
Limites
- Coût de maintenance des scénarios — les scénarios Gherkin peuvent proliférer et devenir un fardeau à maintenir si l'équipe n'est pas disciplinée.
-
Tentation du « Gherkin everywhere » — tout n'a pas besoin
d'être spécifié en Gherkin. Les règles de calcul pures
sont mieux testées en unitaire avec
PHPUnit. - Adoption organisationnelle — le BDD ne fonctionne que si le métier participe à l'écriture des scénarios. Sans cette collaboration, on se retrouve avec des développeurs qui écrivent du Gherkin pour eux-mêmes — ce qui en annule l'intérêt.
- Performance des tests — les scénarios BDD traversent toute la pile applicative. Ils sont plus lents que des tests unitaires et plus fragiles face aux changements d'UI.
Tests a posteriori : le pragmatisme assumé
Écrire les tests après le code est souvent présenté comme une pratique inférieure — un compromis regrettable face aux contraintes du monde réel. C'est une vision réductrice.
Les tests a posteriori sont une stratégie légitime qui, dans certains contextes, est non seulement acceptable mais préférable.
Quand c'est le bon choix
Les projets legacy sans tests. Quand on hérite d'une application de 100 000 lignes sans un seul test, le débat TDD vs BDD est académique. L'urgence est d'ajouter des tests de caractérisation pour sécuriser le code existant. Ces tests sont nécessairement a posteriori — le code est déjà écrit depuis des années.
Le prototypage et l'exploration technique. Quand on explore une nouvelle API, un nouveau framework ou une approche architecturale inconnue, écrire des tests avant le code est prématuré. On ne sait pas encore quelles seront les bonnes abstractions. Mieux vaut explorer, stabiliser, puis tester.
Le code d'interface utilisateur. Les composants visuels, les animations, le responsive — ce code se valide visuellement, pas via des assertions programmatiques. Les tests snapshot ou les tests de régression visuelle sont par nature des tests a posteriori.
L'exploration technique (spike). Un spike est un investissement en connaissance, pas en code. Le code produit pendant un spike est jetable. Le tester serait une perte de temps. Les tests viendront quand la solution sera stabilisée.
Forces
- Aucune barrière d'entrée — pas besoin de maîtriser le TDD ou le BDD pour commencer à tester.
- Flexibilité — on peut tester à n'importe quel moment, sur n'importe quel code, sans contrainte de processus.
- Adapté au legacy — c'est la seule approche viable pour couvrir du code existant.
Limites
- Pas d'effet sur la conception — les tests a posteriori ne guident pas l'architecture du code. Le code est déjà écrit, pour le meilleur et pour le pire.
- Risque de « tester l'implémentation » — quand on écrit un test en regardant le code, on a tendance à reproduire sa logique dans le test au lieu de vérifier son comportement.
- Discipline requise — sans le cadre imposé par le TDD, il est facile de « reporter les tests à plus tard ». Et « plus tard » arrive rarement.
Comparaison sur 5 axes
Pour choisir entre ces trois approches, il est utile de les comparer sur les critères qui comptent en pratique.
Coût d'adoption
Les tests a posteriori ont le coût d'adoption le plus bas : il suffit de savoir écrire un test. Le BDD demande un investissement organisationnel significatif (formation, outillage, collaboration métier/technique). Le TDD se situe entre les deux : le coût est surtout individuel (discipline, pratique), mais il ne nécessite pas de réorganisation de l'équipe.
Boucle de feedback
Le TDD offre la boucle la plus courte : quelques secondes entre l'écriture d'un test et sa validation. Les tests a posteriori ont une boucle variable, selon le moment où ils sont écrits. Le BDD a la boucle la plus longue, car les scénarios traversent toute la pile applicative.
Documentation vivante
Le BDD produit la meilleure documentation : les scénarios Gherkin sont lisibles par tous et toujours à jour. Le TDD produit une documentation technique de qualité, mais réservée aux développeurs. Les tests a posteriori documentent le comportement actuel, mais manquent souvent de la clarté intentionnelle des tests écrits en amont.
Capacité de refactoring
Le TDD et le BDD permettent un refactoring en confiance, car les tests existent avant toute modification. Les tests a posteriori protègent aussi le refactoring, mais avec un risque : si les tests sont couplés à l'implémentation (ce qui arrive plus souvent quand on teste après), ils freinent le refactoring au lieu de le faciliter.
Couverture
Les tests a posteriori offrent la couverture la plus flexible : on peut cibler n'importe quelle partie du code. Le TDD garantit une couverture intrinsèque — tout code écrit est couvert, car il a été écrit pour satisfaire un test. Le BDD couvre les parcours fonctionnels de bout en bout, mais laisse des zones non couvertes dans la logique interne.
La combinaison optimale par couche
La question n'est pas « TDD ou BDD ou tests a posteriori ? » La question est : quelle approche pour quel type de code ?
Une stratégie de test mature combine les trois approches, chacune appliquée là où elle apporte le plus de valeur.
Domaine et logique métier : TDD
La logique métier pure — calculs, validations, règles, transformations de données — est le terrain de prédilection du TDD. Le code est sans effets de bord, les entrées et sorties sont claires, et la spécification est précise.
Le TDD force à découpler cette logique du reste de l'application. Le résultat : des classes métier testables, réutilisables et indépendantes du framework.
Use cases et services : tests d'intégration a posteriori
Les services applicatifs orchestrent la logique métier, accèdent à la base de données, appellent des APIs externes. Les tester en isolation pure (avec des mocks partout) produit des tests fragiles qui ne détectent pas les vrais problèmes.
Les tests d'intégration a posteriori sont plus adaptés : on teste le service avec ses dépendances réelles, dans un environnement proche de la production. On écrit ces tests une fois que l'implémentation est stabilisée.
Controllers et UI : BDD ou tests E2E
Les controllers et les interfaces utilisateur n'ont pas de logique métier (ou ne devraient pas en avoir). Ils assemblent des composants et orchestrent des flux. Les tester unitairement est rarement utile.
Le BDD est idéal pour cette couche :
les scénarios décrivent le parcours utilisateur
de bout en bout, dans un langage métier.
Alternativement, des tests E2E avec Playwright
ou Cypress couvrent les mêmes besoins
sans le formalisme Gherkin.
Infrastructure : tests de contrat
Les adaptateurs d'infrastructure (clients HTTP, repositories, connecteurs de messagerie) doivent respecter un contrat défini par l'application. Les tests de contrat vérifient que l'adaptateur respecte ce contrat sans tester toute la logique applicative au-dessus.
Ces tests sont typiquement écrits a posteriori, une fois que le contrat est stabilisé. Ils protègent contre les régressions lors des mises à jour de librairies ou de changements d'API externes.
Plan d'adoption progressif
La pire erreur est d'imposer le TDD à toute l'équipe du jour au lendemain. C'est le meilleur moyen de générer de la frustration, de ralentir les livraisons et de décrédibiliser la démarche.
Une adoption progressive est bien plus efficace.
Phase 1 : les tests a posteriori comme socle
Commencer par l'approche la plus accessible. Définir une règle simple : tout bug corrigé s'accompagne d'un test de non-régression. C'est une habitude facile à prendre, qui produit des résultats immédiats.
En parallèle, couvrir les parcours critiques avec des tests E2E. L'objectif n'est pas la couverture maximale — c'est d'avoir un filet de sécurité qui détecte les régressions majeures.
Phase 2 : introduire le TDD sur les nouveaux modules critiques
Une fois que l'équipe est à l'aise avec les tests, introduire le TDD sur les nouveaux développements critiques. Pas sur tout — sur la logique métier complexe, là où les cas limites sont nombreux et les erreurs coûteuses.
Accompagner cette introduction par du pair programming ou du mob programming. Le TDD s'apprend en pratiquant avec quelqu'un qui maîtrise la discipline. Les formations théoriques ne suffisent pas.
Phase 3 : BDD pour les user stories complexes
Quand l'équipe a un bon niveau de maturité en tests, introduire le BDD sur les fonctionnalités où la collaboration métier/technique est critique.
Organiser des ateliers « Example Mapping » avec les développeurs et les product owners. Chaque user story complexe est décomposée en exemples concrets qui deviennent les scénarios Gherkin.
Ne pas généraliser le BDD à toutes les stories. Le réserver aux fonctionnalités où les spécifications sont ambiguës, où les règles métier sont complexes, où plusieurs parties prenantes ont des attentes divergentes.
Phase 4 : affiner et optimiser
Avec l'expérience, l'équipe développe un sens intuitif de l'approche adaptée à chaque situation. Le développeur senior sait qu'un calcul de commission mérite du TDD, qu'un CRUD basique se teste a posteriori et qu'un parcours d'onboarding complexe bénéficie du BDD.
À ce stade, les trois approches coexistent naturellement. L'équipe ne débat plus de « TDD vs BDD » — elle choisit l'outil adapté au problème.
Ce que les tests ne remplacent pas
Quelle que soit la stratégie adoptée, les tests automatisés ne sont qu'un élément d'une démarche qualité plus large.
Ils ne remplacent pas la revue de code, qui détecte des problèmes de lisibilité, de convention et de conception qu'aucun test ne peut capturer.
Ils ne remplacent pas l'analyse statique
(PHPStan, Psalm),
qui détecte des catégories de bugs
que les tests manquent (types incorrects,
variables indéfinies, code mort).
Et ils ne remplacent pas une architecture saine. Des tests sur du code mal structuré sont des tests fragiles. La meilleure stratégie de test commence par une réduction de la dette technique qui rend le code structurellement testable.
Choisir sa stratégie
Il n'y a pas de réponse universelle à la question « TDD, BDD ou tests a posteriori ? ». La bonne réponse dépend du contexte : le type de code, la maturité de l'équipe, la nature du projet, les contraintes organisationnelles.
Ce qui compte, c'est d'avoir une stratégie. Un projet sans stratégie de test finit toujours de la même manière : avec une base de code que personne n'ose toucher.
Chez x10, j'aide les équipes à définir et mettre en œuvre une stratégie de test adaptée à leur contexte. Que ce soit dans le cadre d'un développement sur mesure ou d'un audit technique d'un projet existant, je privilégie le pragmatisme : les bonnes pratiques au bon endroit, pas le dogmatisme. Échangeons sur votre projet.