Test- and Behavior-Driven Development (TDD/BDD) Course

Lesson 1 • TDD vs. BDD: Similarities and Differences

Maps the overlap and divergence between TDD and BDD across scope, audience, and tooling. Prepares students to choose the right approach per context.

Lesson 2 • Why Test-First Development Matters

Covers the cost of late defect detection and the feedback-loop advantage of writing tests before code. Sets the motivational foundation for the entire course.

Lesson 3 • Core Principles of TDD

Introduces the Red-Green-Refactor cycle and the discipline of writing minimal production code. Anchors all subsequent TDD technique chapters.

Lesson 4 • Setting Up a Development Environment

Guides students through installing a test runner, project scaffolding, and version control integration. Ensures every student has a working environment before writing code.

Lesson 1 • Running and Interpreting Test Results

Teaches students to read test output, diagnose failures, and use watch mode for rapid feedback. Builds the habit of treating a failing test as actionable information.

Lesson 2 • Assertions and Matchers

Surveys common assertion types—equality, truthiness, exceptions, and collections. Students learn to select the most expressive matcher for each scenario.

Lesson 3 • Parameterized and Data-Driven Tests

Shows how to run a single test logic against multiple input sets to maximise coverage with minimal duplication. Reinforces the DRY principle within test suites.

Lesson 4 • Anatomy of a Good Unit Test

Breaks down the Arrange-Act-Assert pattern and naming conventions that make tests self-documenting. Directly shapes the quality of all tests written in later chapters.

Lesson 1 • Writing a Failing Test First

Drills the discipline of committing a failing test before touching production code. Establishes the habit that defines TDD from ad-hoc testing.

Lesson 2 • TDD Kata Practice

Uses classic coding exercises to build muscle memory for the TDD cycle. Repetition across varied problems ingrains the rhythm before tackling real codebases.

Lesson 3 • Making Tests Pass Minimally

Teaches the practice of writing just enough code to turn red to green without over-engineering. Reinforces YAGNI and prevents speculative complexity.

Lesson 4 • Refactoring Under a Green Suite

Covers safe refactoring techniques applied only when all tests pass. Students learn to improve design continuously without breaking behaviour.

Lesson 1 • Mocks and Interaction Testing

Covers mocks as objects that verify collaboration between units via call assertions. Students learn when interaction testing adds value versus when it over-specifies.

Lesson 2 • Why Isolation Requires Test Doubles

Explains how real dependencies—databases, APIs, clocks—make tests slow and non-deterministic. Motivates the need for controlled substitutes in unit testing.

Lesson 3 • Stubs and Fakes

Defines stubs as canned-response providers and fakes as lightweight working implementations. Students practice replacing I/O and time dependencies with stubs.

Lesson 4 • Spies and Partial Mocking

Introduces spies as wrappers that record calls on real objects without replacing behaviour. Clarifies when partial mocking is appropriate and when it signals design issues.

Lesson 1 • Writing Effective Given-When-Then Steps

Teaches how to write steps that are declarative, context-free, and reusable across scenarios. Poor step writing is the most common BDD failure mode addressed here.

Lesson 2 • Collaborating on Scenarios with Stakeholders

Guides the Three Amigos workshop process for co-authoring scenarios before development begins. Connects Gherkin writing to its collaborative discovery purpose.

Lesson 3 • Scenario Outlines and Examples Tables

Shows how to parameterize scenarios with Examples tables to cover multiple data cases. Mirrors the data-driven testing concept from unit testing in a BDD context.

Lesson 4 • Organizing Features and Tags

Explains how to group related scenarios into feature files and use tags for selective execution. Supports scalable BDD suites as the feature set grows.

Lesson 1 • BDD Framework Setup and Configuration

Covers installing and configuring a BDD framework, linking it to the test runner, and loading feature files. Establishes the technical infrastructure for all BDD automation work.

Lesson 2 • Managing State Across Steps

Addresses the challenge of passing data between Given, When, and Then steps without global variables. Covers world objects, context injection, and scenario-scoped state.

Lesson 3 • Reusing and Composing Step Definitions

Shows how to build a reusable step library that reduces duplication across feature files. Reinforces the DRY principle at the BDD automation layer.

Lesson 4 • Writing Step Definition Functions

Teaches how to map Gherkin step text to code using regex or expression patterns. Students implement Given, When, and Then handlers for a sample feature.

Lesson 1 • SOLID Principles Through a TDD Lens

Connects each SOLID principle to specific TDD practices that naturally enforce it. Students see how TDD guides them toward single-responsibility and open-closed designs.

Lesson 2 • Managing Technical Debt in Test Suites

Addresses test code quality, including duplication, fragility, and poor naming in test suites. Students learn that test code deserves the same refactoring discipline as production code.

Lesson 3 • Listening to Your Tests

Teaches students to interpret difficult-to-write tests as symptoms of design problems in production code. Reframes test pain as a valuable architectural feedback mechanism.

Lesson 4 • Refactoring to Patterns

Demonstrates how common design patterns arise naturally during TDD refactoring phases. Students apply Strategy, Template Method, and Observer patterns driven by test needs.

Lesson 1 • BDD in Agile Sprint Cycles

Maps BDD activities—discovery, formulation, and automation—to sprint ceremonies and backlog refinement. Students see how BDD fits naturally into iterative delivery.

Lesson 2 • Measuring and Communicating TDD/BDD Value

Provides metrics—defect escape rate, cycle time, scenario coverage—to demonstrate ROI to stakeholders. Equips students to advocate for these practices with data.

Lesson 3 • Integrating TDD into Team Workflows

Guides teams on pairing, code review standards, and definition-of-done criteria that enforce TDD. Addresses the social and process dimensions of adoption.

Lesson 4 • Adding Tests to Legacy Code

Covers characterisation tests, seam identification, and safe refactoring strategies for untested code. Addresses the most common barrier practitioners face when adopting TDD.