Formation TDD et BDD

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

Cartographie les recoupements et les divergences entre TDD et BDD en termes de périmètre, de public 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. Pose la base motivationnelle pour l'ensemble du cours.

Leçon 3 • Principes fondamentaux du TDD

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

Leçon 4 • Configuration d'un environnement de développement

Guide les étudiants dans l'installation d'un exécuteur de tests, la mise en place du projet et l'intégration avec la gestion de versions. 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

Enseigne aux étudiants à lire les résultats des tests, à diagnostiquer les échecs et à utiliser le mode veille pour un retour rapide. Construit l'habitude de considérer un test qui échoue 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 seule logique de test avec plusieurs ensembles d'entrées pour maximiser la couverture avec un minimum de duplication. Renforce le principe DRY dans les suites de tests.

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

Décompose le modèle Organiser-Agir-Asserter et les conventions de nommage qui rendent les tests auto-documentés. Influence directement la qualité de tous les tests écrits dans les chapitres suivants.

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

Entraîne la discipline de commettre un test qui échoue 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 développer la mémoire musculaire du cycle TDD. La répétition sur des problèmes variés ancre le rythme avant d'aborder des bases de code réelles.

Leçon 3 • Faire passer les tests minimalement

Enseigne la pratique d'écrire juste assez de code pour passer du rouge au vert sans sur-ingénierie. Renforce le principe 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é appliquées uniquement lorsque tous les tests sont verts. 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 unités via des assertions d'appel. Les étudiants apprennent quand les tests d'interaction ajoutent de la valeur par rapport à quand ils sur-spécifient.

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 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 wrappers 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édaction d'étapes Given-When-Then efficaces

Enseigne comment écrire des étapes déclaratives, sans contexte et réutilisables entre scénarios. Une mauvaise rédaction d'étapes est le mode d'échec 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 Amigos pour co-écrire des scénarios avant le début du développement. Relie la rédaction Gherkin à son objectif de découverte collaborative.

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

Montre comment paramétrer des scénarios avec des tableaux d'exemples pour couvrir plusieurs cas de données. Fait écho au concept de tests pilotés par les données des tests unitaires 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 l'exécution sélective. Permet des suites BDD évolutives à mesure que l'ensemble des fonctionnalités grandit.

Leçon 1 • Configuration et installation du framework BDD

Couvre l'installation et la configuration d'un framework BDD, son liaison avec l'exécuteur de tests et le chargement des fichiers de fonctionnalités. Établit l'infrastructure technique pour tout 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 limité au scénario.

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

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

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

Enseigne comment mapper le texte d'une étape Gherkin au code à l'aide d'expressions régulières ou de motifs d'expression. Les étudiants implémentent des gestionnaires Given, When et Then pour une fonctionnalité exemple.

Leçon 1 • Principes SOLID vus à 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-à-l'extension.

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

Aborde la qualité du code de test, y compris 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

Enseigne aux étudiants à interpréter les tests difficiles à écrire comme des symptômes de problèmes de conception dans le code de production. Recadre la difficulté des tests comme un mécanisme de retour architectural précieux.

Leçon 4 • Réusinage vers des patrons de conception

Démontre comment les patrons de conception courants apparaissent naturellement pendant les phases de réusinage du TDD. Les étudiants appliquent les patrons Strategy, Template Method et Observer 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 de sprint et au raffinement du backlog. Les étudiants voient comment le BDD s'intègre naturellement dans la livraison itérative.

Leçon 2 • Mesurer et communiquer la valeur du TDD/BDD

Fournit des métriques — taux d'échappement de défauts, temps de cycle, couverture de 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 les standards de programmation en binôme, de revue de code et de définition du terminé qui imposent le TDD. Aborde les dimensions sociales et processuelles de l'adoption.

Leçon 4 • Ajout de tests au code hérité

Couvre les tests de caractérisation, l'identification des jointures et les stratégies de réusinage sécurisé pour le code non testé. Aborde l'obstacle le plus courant rencontré par les praticiens lors de l'adoption du TDD.