Test-Driven Development Workshop

Foundations

Test-Driven Development (TDD)

Writing a failing test before the code that makes it pass, using tests to drive design and quality.

Hands-On Practice

TDD is a skill built through repeated practice; this workshop centers on doing with feedback.

Katas

Small, repeatable coding exercises used to practice and internalize the TDD rhythm.

Deliberate Practice

Focused, repeated practice with feedback that builds mastery of TDD technique.

The Cycle

Red-Green-Refactor

Write a failing test, make it pass simply, then improve the design.

Small Steps

Working in tiny increments for immediate feedback and easy error detection.

Triangulation

Driving out a general solution by adding tests that force more general code.

Fake It Till You Make It

Starting with a hard-coded return and generalizing as more tests are added.

Unit Testing

Unit Test

An automated test verifying a small unit of code in isolation.

Arrange-Act-Assert

A test structure: set up context, act, then assert the expected result.

FIRST Principles

Good tests are Fast, Isolated, Repeatable, Self-validating, and Timely.

Test Readability

Writing clear tests that document behavior and make failures easy to diagnose.

Test Doubles

Test Doubles

Stubs, mocks, and fakes that isolate the code under test from its dependencies.

When to Use Doubles

Using doubles to isolate units and control dependencies, without over-mocking.

Refactoring

Refactoring Safely

Improving code with confidence because passing tests catch regressions.

Code Smells

Signs of poor design — duplication, long methods, tight coupling — that refactoring removes.

Simple Design

Aiming for the simplest design that passes tests and expresses intent clearly.

Legacy Code

TDD with Legacy Code

Adding characterization tests around existing code to enable safe change.

Seams

Places where behavior can be altered to insert tests without changing existing behavior.

Characterization Tests

Tests that capture current behavior so it can be preserved during refactoring.

Applying It

Common Pitfalls

Writing tests after code, testing too much at once, or skipping refactoring undermine TDD.

Sustaining TDD

Building the discipline and team habits to keep practicing TDD after the workshop.