Formation TDD et BDD

Leçon 1 • TDD contre BDD : similitudes et différences

Cartographie les chevauchements et les divergences entre le TDD et le BDD en termes de portée, d'audience et d'outillage. Prépare les étudiants à choisir la bonne approche selon le contexte.

Leçon 2 • Pourquoi le développement piloté par les tests est important

Couvre le coût de la détection tardive des défauts et l'avantage de la boucle de rétroaction d'écrire les tests avant le code. Établit la base motivationnelle de l'ensemble du cours.

Leçon 3 • Principes fondamentaux du TDD

Présente le cycle Rouge-Vert-Réfactorisation et la discipline d'écrire un code de production minimal. Ancre tous les chapitres suivants sur les techniques de TDD.

Leçon 4 • Mise en place d'un environnement de développement

Guide les étudiants dans l'installation d'un lanceur de tests, la structure du projet et l'intégration de la gestion de versions. S'assure que chaque étudiant dispose d'un environnement de travail avant d'écrire du code.

Leçon 1 • Exécution et interprétation des résultats de tests

Apprend aux étudiants à lire la sortie des tests, à diagnostiquer les échecs et à utiliser le mode de surveillance pour un retour rapide. Construit l'habitude de traiter un test en échec comme une information exploitable.

Leçon 2 • Assertions et comparateurs

Passe en revue les types d'assertions courants — égalité, véracité, exceptions et collections. Les étudiants apprennent à sélectionner le comparateur le plus expressif pour chaque scénario.

Leçon 3 • Tests paramétrés et pilotés par les données

Montre comment exécuter une logique de test unique sur plusieurs ensembles d'entrées pour maximiser la couverture avec un minimum de duplication. Renforce le principe DRY au sein des suites de tests.

Leçon 4 • Anatomie d'un bon test unitaire

Décompose le motif Organiser-Agir-Affirmer et les conventions de nommage qui rendent les tests auto-documentés. Façonne directement la qualité de tous les tests écrits dans les chapitres suivants.

Leçon 1 • Écrire un test en échec en premier

Entraîne la discipline de s'engager à écrire un test en échec avant de toucher au code de production. Établit l'habitude qui définit le TDD par rapport aux tests ad-hoc.

Leçon 2 • Pratique du kata TDD

Utilise des exercices de codage classiques pour construire la mémoire musculaire du cycle TDD. La répétition sur des problèmes variés ancre le rythme avant de s'attaquer à des bases de code réelles.

Leçon 3 • Faire passer les tests au vert de manière minimale

Enseigne la pratique d'écrire juste assez de code pour passer du rouge au vert sans sur-ingénierie. Renforce YAGNI et empêche la complexité spéculative.

Leçon 4 • Réusinage sous une suite verte

Couvre les techniques de réusinage sécurisées appliquées uniquement lorsque tous les tests réussissent. Les étudiants apprennent à améliorer la conception en continu sans casser le comportement.

Leçon 1 • Mocks et tests d'interaction

Couvre les mocks en tant qu'objets qui vérifient la collaboration entre les unités via des assertions d'appel. Les étudiants apprennent quand le test d'interaction apporte de la valeur par rapport à quand il sur-spécifie.

Leçon 2 • Pourquoi l'isolation nécessite des doubles de test

Explique comment les dépendances réelles — bases de données, API, horloges — rendent les tests lents et non déterministes. Motive le besoin de substituts contrôlés dans les tests unitaires.

Leçon 3 • Stubs et Fakes

Définit les stubs comme des fournisseurs de réponses préprogrammées et les fakes comme des implémentations légères et fonctionnelles. Les étudiants s'exercent à remplacer les dépendances d'E/S et de temps par des stubs.

Leçon 4 • Espions et mockage partiel

Présente les espions comme des enveloppes qui enregistrent les appels sur des objets réels sans remplacer le comportement. Clarifie quand le mockage partiel est approprié et quand il signale des problèmes de conception.

Leçon 1 • Rédiger des étapes Given-When-Then efficaces

Enseigne comment écrire des étapes qui sont déclaratives, sans contexte et réutilisables entre les scénarios. La mauvaise rédaction des étapes est le mode de défaillance le plus courant du BDD, abordé ici.

Leçon 2 • Collaboration sur les scénarios avec les parties prenantes

Guide le processus d'atelier des Trois Amis pour la co-écriture de scénarios avant le début du développement. Relie l'écriture Gherkin à son objectif de découverte collaborative.

Leçon 3 • Plan de scénario et tableaux d'exemples

Montre comment paramétrer les scénarios avec des tableaux d'exemples pour couvrir plusieurs cas de données. Reprend le concept de test piloté par les données du test unitaire dans un contexte BDD.

Leçon 4 • Organisation des fonctionnalités et des tags

Explique comment regrouper des scénarios connexes dans des fichiers de fonctionnalités et utiliser des tags pour une exécution sélective. Prend en charge les suites BDD évolutives à mesure que l'ensemble des fonctionnalités grandit.

Leçon 1 • Configuration et mise en place du framework BDD

Couvre l'installation et la configuration d'un framework BDD, son lien avec le lanceur de tests et le chargement des fichiers de fonctionnalités. Établit l'infrastructure technique pour tout le travail d'automatisation BDD.

Leçon 2 • Gestion de l'état entre les étapes

Aborde le défi du passage de données entre les étapes Given, When et Then sans variables globales. Couvre les objets monde, l'injection de contexte et l'état propre au scénario.

Leçon 3 • Réutilisation et composition des définitions d'étapes

Montre comment construire une bibliothèque d'étapes réutilisables qui réduit la duplication entre les fichiers de fonctionnalités. Renforce le principe DRY au niveau de la couche d'automatisation BDD.

Leçon 4 • Rédaction des fonctions de définition d'étapes

Apprend à mapper le texte des étapes Gherkin au code en utilisant des expressions rationnelles ou des motifs. Les étudiants implémentent des gestionnaires Given, When et Then pour une fonctionnalité exemple.

Leçon 1 • Principes SOLID à travers le prisme du TDD

Relie chaque principe SOLID à des pratiques TDD spécifiques qui le renforcent naturellement. Les étudiants voient comment le TDD les guide vers des conceptions à responsabilité unique et ouvertes-fermées.

Leçon 2 • Gestion de la dette technique dans les suites de tests

Aborde la qualité du code de test, notamment la duplication, la fragilité et le mauvais nommage dans les suites de tests. Les étudiants apprennent que le code de test mérite la même discipline de réusinage que le code de production.

Leçon 3 • Écouter vos tests

Apprend aux étudiants à interpréter les tests difficiles à écrire comme des symptômes de problèmes de conception dans le code de production. Recadre la douleur du test comme un mécanisme de rétroaction architecturale précieux.

Leçon 4 • Réusinage vers des patrons

Démontre comment les patrons de conception courants apparaissent naturellement pendant les phases de réusinage TDD. Les étudiants appliquent les patrons Stratégie, Template Method et Observateur, guidés par les besoins des tests.

Leçon 1 • BDD dans les cycles de sprint Agile

Mappe les activités BDD — découverte, formulation et automatisation — aux cérémonies du sprint et au raffinement du backlog. Les étudiants voient comment le BDD s'intègre naturellement dans la livraison itérative.

Leçon 2 • Mesure et communication de la valeur du TDD/BDD

Fournit des métriques — taux d'échappement des défauts, temps de cycle, couverture des scénarios — pour démontrer le ROI aux parties prenantes. Équipe les étudiants pour défendre ces pratiques avec des données.

Leçon 3 • Intégration du TDD dans les flux de travail d'équipe

Guide les équipes sur le travail en binôme, les normes de revue de code et les critères de définition de « fait » qui imposent le TDD. Aborde les dimensions sociales et de processus de l'adoption.

Leçon 4 • Ajout de tests à un code existant

Couvre les tests de caractérisation, l'identification des jointures et les stratégies de réusinage sécurisées pour le code non testé. Aborde la barrière la plus courante à laquelle les praticiens sont confrontés lors de l'adoption du TDD.