{"canonical_url":"https://engineer.company/fr/glossary/test-driven-development/","content_markdown":"# Développement guidé par les tests\n\n## Ce que c'est\n\nLe développement guidé par les tests est une manière de programmer dans laquelle le test d'un comportement est écrit avant le code qui réalise ce comportement, un petit test à la fois. Kent Beck, qui décrit son propre rôle comme une redécouverte, le qualifie de démarche de programmation. En 2023, constatant que les programmeurs ne s'accordaient pas sur le sens du terme, il a décrit cette démarche dans un court billet intitulé Canon TDD, où il utilise presque partout l'abréviation TDD.\n\nLa démarche comporte cinq étapes :\n\n1. Dresser la liste des cas que la modification doit traiter.\n2. Choisir exactement un cas de la liste et en faire un test concret qui s'exécute.\n3. Faire réussir ce test sans faire échouer les précédents et ajouter à la liste chaque nouveau cas révélé par le travail.\n4. Si la conception de l'implémentation peut être améliorée, la remanier maintenant ; cette étape est facultative.\n5. Revenir à l'étape 2 jusqu'à ce que la liste soit vide.\n\nLa liste est une analyse du comportement, pas un document de conception : d'abord le cas de base, puis ses variantes, puis ce que la modification doit préserver du fonctionnement existant. Le test écrit à l'étape 2 est un véritable test automatisé, avec une préparation, un appel et des assertions ; il échoue à sa première exécution, puisque le comportement qu'il décrit reste à écrire. Beck appelle l'étape 3 le passage du rouge au vert, d'un test en échec à un test réussi.\n\nIl est tout aussi utile de savoir ce que cette démarche ne signifie pas. On reproche souvent au TDD d'imposer l'écriture de tous les tests avant la moindre ligne de code, et Beck répond directement : ce n'est pas du TDD, et le critiquer revient à critiquer autre chose. Il est tout aussi souple dans l'autre sens. Une équipe qui procède autrement avec de bons résultats peut continuer ainsi ; il précise qu'aucune récompense n'est décernée pour avoir suivi exactement ces étapes.\n\n## Pourquoi c'est important\n\nBeck précise le but de la démarche. Un programmeur qui modifie le comportement d'un système doit obtenir un système où la modification préserve le comportement existant tout en satisfaisant les nouvelles exigences, où le code est prêt pour la modification suivante et où le programmeur et ses collègues ont confiance dans ces trois points. Puisque chaque test est écrit alors que la modification qu'il vérifie est encore limitée et récente, le filet de sécurité grandit au même rythme que le code, au lieu d'être promis pour plus tard.\n\nLa deuxième raison concerne la conception. Beck distingue deux types de décisions : comment appeler un comportement et comment le système le réalise. Écrire le test d'abord force les décisions d'interface, parce que le test doit appeler quelque chose et indiquer ce qui revient. Les décisions d'implémentation attendent l'étape de refactoring, où des tests réussis les protègent. Un test difficile à écrire annonce tôt une interface qui sera difficile à utiliser.\n\nLa troisième raison est la double vérification. Une personne calcule la valeur attendue d'un test à partir de l'exigence, tandis que le code y parvient par une autre voie. Lorsqu'elles concordent, deux démarches indépendantes ont atteint la même réponse ; selon Beck, cette double vérification représente une grande partie de la valeur du TDD comme contrôle.\n\nLa démarche aide aussi à savoir quand s'arrêter. Beck conseille de continuer à tester et à coder jusqu'à ce que la crainte du comportement du code se transforme en ennui. Cette habitude précède largement le billet. Il situe sa redécouverte entre 1994, lorsqu'il a écrit SUnit pour un client à l'occasion d'une mission de conseil, et octobre 1995, lorsqu'il a présenté le TDD à Ward Cunningham à la conférence OOPSLA d'Austin. Son article Simple Smalltalk Testing décrit un cadre de test simple pour Smalltalk, et la documentation unittest de Python le cite toujours comme l'article d'origine de Beck sur le modèle que partage unittest.\n\n## À quoi cela ressemble en pratique\n\nPrenons un contrôle de contenu qui doit signaler les mots à la mode interdits dans les textes d'un site web. Le travail commence par la liste de tests, sous forme de simples notes :\n\n```text\n- un mot interdit est signalé\n- un mot interdit contenant une majuscule est signalé\n```\n\nL'étape 2 transforme exactement un élément en test. Le premier cas vient en premier pour une raison : il fournit au contrôle un mot interdit connu et vérifie que ce mot est signalé. Le test échoue tant que le contrôle ne peut pas le détecter. Il va dans un fichier nommé `test_wording.py`, que pytest découvre parce que son nom correspond à `test_*.py` :\n\n```python\nfrom wording import find_banned\n\n\ndef test_reports_a_banned_word():\n    assert find_banned(\"we leverage it\", {\"leverage\"}) == [\"leverage\"]\n```\n\nL'exécution de `pytest -q` échoue immédiatement, car il n'existe aucun `find_banned` à importer. Cet échec est le but : on a vu le test échouer, donc une réussite ultérieure aura un sens. Le code le plus simple qui le fait réussir suffit pour l'instant, dans `wording.py` :\n\n```python\ndef find_banned(text, banned):\n    return [word for word in text.split() if word in banned]\n```\n\nLe test réussit. L'élément suivant devient le test suivant :\n\n```python\ndef test_reports_a_capitalised_banned_word():\n    assert find_banned(\"Leverage it\", {\"leverage\"}) == [\"Leverage\"]\n```\n\nIl échoue et, comme pytest affiche les valeurs intermédiaires d'une assertion, la sortie montre une liste vide là où `[\"Leverage\"]` était attendu. Comparer `word.lower()` au lieu de `word` le fait réussir. En écrivant cette modification, le programmeur remarque que `text.split()` laisse la ponctuation attachée au mot : « leverage, », avec une virgule, passerait donc inaperçu. Ce cas va sur la liste plutôt que dans le code, puis devient le troisième test :\n\n```python\ndef test_reports_a_banned_word_before_a_comma():\n    assert find_banned(\"Use it, leverage, win\", {\"leverage\"}) == [\"leverage\"]\n```\n\nIl échoue, puis une ligne de plus fait réussir les trois :\n\n```python\ndef find_banned(text, banned):\n    words = [word.strip(\".,;:!?\") for word in text.split()]\n    return [word for word in words if word.lower() in banned]\n```\n\nL'étape 4 est facultative et il y a peu à améliorer ici : deux lignes, chacune avec une tâche. Chaque élément de la liste a maintenant un test qui réussit ; le travail est donc terminé. Chaque valeur attendue a été écrite à partir de l'élément de la liste, jamais copiée depuis une exécution.\n\nL'ordre de la liste était délibéré, et le propre historique du site en montre la raison. Un [projet qui a écrit des tests pour ses propres contrôles](/fr/portfolio/wrote-tests-for-the-checkers-themselves/), réalisé en août 2026, a constaté que ses contrôles personnalisés, notamment ceux d'orthographe, de voix rédactionnelle et de cohérence des chiffres, avaient réussi pendant des mois. Un contrôle qui n'a vu que des entrées correctes est indiscernable d'un contrôle qui ne lit rien. La correction consistait à introduire le défaut que chaque contrôle doit détecter : le contrôle orthographique reçoit un mot volontairement mal orthographié et le test échoue si l'exécution ne signale rien, le contrôle de voix reçoit un texte à la première personne qu'il doit rejeter et le contrôle des mots à la mode reçoit un mot interdit. Deux contrôles se sont révélés lire un ensemble de fichiers plus restreint que ne l'annonçait leur documentation. La page ne décrit pas le TDD, mais sa leçon est celle que le TDD intègre dès la première étape : un test n'a de valeur qu'une fois qu'on l'a vu échouer.\n\n## Où les problèmes surviennent\n\n**Tous les tests sont écrits en premier.** Transformer chaque élément de la liste en test avant qu'un seul réussisse est le contresens que Beck désigne. Si le premier test oblige à revoir la démarche, chaque test spéculatif doit être repris ; un programmeur au sixième test sans aucune réussite est gagné, écrit-il, par la déprime ou l'ennui. Écrivez un test, faites-le réussir, puis choisissez le suivant. Si un nouveau test montre que le travail existant ne peut pas traiter un cas, choisissez entre poursuivre et recommencer ; Beck conseille de recommencer en prenant les cas dans un autre ordre.\n\n**Le test ne contient aucune assertion.** Un test qui appelle le code sans rien vérifier augmente le taux de couverture sans rien prouver. Chaque test demande une préparation, un appel et une assertion ; Beck suggère d'essayer, de temps à autre, de l'écrire à rebours en partant de ses assertions.\n\n**L'assertion est supprimée.** Quand un test ne réussit pas, supprimer son assertion donne l'illusion d'une réussite. Faites-le réellement réussir, ou remettez le cas sur la liste et revoyez l'ordre.\n\n**Les valeurs attendues sont copiées depuis la sortie.** Exécuter le code, copier ce qu'il renvoie et le coller dans le test transforme une double vérification en vérification unique : le test se contente désormais de confirmer que le code fait ce qu'il a déjà fait. Calculez la valeur attendue à partir de l'exigence, à la main si nécessaire.\n\n**Le refactoring se fait pendant qu'on cherche à faire réussir le test.** Modifier structure et comportement dans la même étape, c'est ce que Beck appelle porter deux casquettes. Faites d'abord fonctionner le code, puis améliorez sa structure : obtenez un résultat vert avec le changement le plus simple, puis ne nettoyez le code qu'une fois les tests réussis.\n\n**Le rangement va trop loin, ou l'abstraction arrive trop tôt.** Ranger donne satisfaction et peut sembler plus sûr que d'affronter le prochain test. Arrêtez-vous lorsque le code est assez bon pour cette séance et laissez deux morceaux semblables tels quels jusqu'à ce que le motif soit clair. Beck le résume ainsi : « La duplication est un indice, pas un ordre. »\n\n**Les tests connaissent l'implémentation.** Les tests qui appellent des méthodes privées ou vérifient les appels effectués par le code, plutôt que ce qu'il a produit, cassent dès que les mécanismes internes changent. Dans son chapitre sur les tests unitaires de _Software Engineering at Google_, Erik Kuefler les qualifie de tests fragiles : ils échouent sur une modification sans rapport, qui n'introduit aucun véritable bogue. En TDD, c'est doublement coûteux, car le refactoring dépend de tests qui restent verts pendant les changements internes. Testez par l'interface publique, vérifiez l'état obtenu plutôt que les interactions et nommez chaque test d'après le comportement qu'il vérifie.\n\n## Pour aller plus loin\n\n- [Canon TDD](https://newsletter.kentbeck.com/p/canon-tdd) — la propre présentation de Kent Beck en 2023 : les cinq étapes, la séparation entre conception de l'interface et de l'implémentation et les erreurs de chaque étape.\n- [Simple Smalltalk Testing: With Patterns](https://web.archive.org/web/20150315073817/http://www.xprogramming.com/testfram.htm) — l'article de Beck sur un cadre de test simple pour Smalltalk, avec ses fixtures, cas et suites de tests, dans une copie archivée.\n- [Tests unitaires](https://abseil.io/resources/swe-book/html/ch12.html) — le chapitre d'Erik Kuefler dans _Software Engineering at Google_ sur les tests qui survivent au refactoring, passent par les API publiques et vérifient les comportements.\n- [Premiers pas](https://docs.pytest.org/en/stable/getting-started.html) — l'introduction de pytest : installation, premier test en échec et son compte rendu, et découverte des fichiers de test.\n- [unittest: cadre de tests unitaires](https://docs.python.org/3/library/unittest.html) — le cadre de la bibliothèque standard de Python, qui cite l'article de Beck comme la description d'origine du modèle qu'il partage.\n\n\u003chttps://engineer.company/fr/glossary/test-driven-development/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Les cinq étapes du développement guidé par les tests, un exemple pytest de la liste de tests à leur réussite et les pièges signalés par Kent Beck.","formats":{"gemtext":"https://engineer.company/fr/glossary/test-driven-development/index.gmi","gopher":"https://engineer.company/fr/glossary/test-driven-development/gophermap","html":"https://engineer.company/fr/glossary/test-driven-development/","json":"https://engineer.company/fr/glossary/test-driven-development/index.json","markdown":"https://engineer.company/fr/glossary/test-driven-development/index.md","pdf":"https://engineer.company/fr/glossary/test-driven-development/index.pdf"},"kind":"page","language":"fr","title":"Qu'est le développement guidé par les tests ?","url":"https://engineer.company/fr/glossary/test-driven-development/","version":1}