Test-Driven Development (TDD)

Also Known As

TL;DR

Explanation

TDD follows a tight cycle: (1) write a failing test (Red), (2) write the minimum code to make it pass (Green), (3) refactor for quality while keeping tests green. Writing tests first forces clarity about requirements before implementation, produces naturally testable code (small, focused, with injected dependencies), and creates a comprehensive test suite as a by-product. TDD is a design activity as much as a testing activity — the pain of writing tests signals design problems. Outside-in TDD (starting from integration/acceptance tests) is called ATDD or BDD.

Diagram

flowchart LR
    RED[Write failing test<br/>RED] -->|implement code| GREEN[Make test pass<br/>GREEN]
    GREEN -->|improve code| REFACTOR[Refactor<br/>BLUE]
    REFACTOR -->|write next test| RED
    subgraph Benefits
        DESIGN[Forces thinking about API<br/>before implementation]
        COVERAGE2[100pct coverage by default<br/>only code tests need]
        SAFETY[Refactor safely<br/>tests catch regressions]
    end
    subgraph TDD_vs_Tests_After
        AFTER[Tests after - verify it works]
        TDD2[TDD - design tool + verification]
    end
style RED fill:#f85149,color:#fff
style GREEN fill:#238636,color:#fff
style REFACTOR fill:#1f6feb,color:#fff

Common Misconception

Why It Matters

Common Mistakes

• Writing all tests first, then all implementation — TDD is red/green/refactor per small cycle, not a waterfall.
• Skipping the refactor step — without it TDD produces working but messy code.
• Writing tests that are too large — each cycle should test one specific behaviour.
• Abandoning TDD when time pressure hits — this is exactly when having tests matters most.

Code Examples

// Test-last approach — code written first, then retrofitted with tests:
class UserService {
    public function create(array $data): User {
        // 100 lines of code written without tests
        // Now write tests that 'fit' the existing code
        // Tests describe implementation, not behaviour
    }
}
// TDD: test first → drives minimal implementation → refactor safely

// RED: write a failing test first
public function test_discount_applied_for_vip(): void {
    $pricing = new PricingService();
    $price   = $pricing->calculate(product: $product, customer: $vip);
    $this->assertEquals(90.00, $price); // FAILS — method doesn't exist yet
}

// GREEN: write the minimum code to pass
class PricingService {
    public function calculate(Product $product, Customer $customer): float {
        $price = $product->basePrice;
        if ($customer->isVip()) $price *= 0.9;
        return $price;
    }
}

// REFACTOR: clean up while tests stay green

References

• ↗ https://martinfowler.com/bliki/TestDrivenDevelopment.html

Tags

Related Terms