How to TDD in legacy code

The secret to TDD in legacy code isn't just red-green-refactor. It's separating the work: first make the change possible, then make the change right.

#1about 6 minutes

Why standard TDD fails in complex legacy code

Real-world code complexity and dependencies make the simple red-green-refactor cycle difficult and risky without existing tests.

#2about 3 minutes

A modified TDD process for existing codebases

A four-step approach is introduced, involving characterization tests and pre-refactoring before applying the standard TDD cycle.

#3about 7 minutes

Using characterization tests to create a safety net

Characterization tests are written to capture the current behavior of a system, including its bugs, providing a baseline for safe refactoring.

#4about 6 minutes

A step-by-step guide to fixing a bug

A bug is fixed by first writing a failing test, making the minimal code change to pass, and then refactoring both production and test code for clarity.

#5about 6 minutes

Pre-refactoring code to prepare for new features

Before adding new functionality, the code is refactored using techniques like guard clauses and switch statements to make the insertion point clear and simple.

#6about 3 minutes

Adding a new feature with the TDD cycle

After preparing the codebase, a new feature is added by writing a failing test and then implementing the minimal code required to make it pass.

#7about 5 minutes

Core principles for safe and fast development

The key takeaways are minimizing risk, separating new functionality from cleanup, and consistently leaving the code better than you found it.

#8about 9 minutes

Q&A on BDD and testing untestable code

The discussion covers the role of BDD and how to handle untestable code using tools like approval tests or snapshot testing to capture system behavior.