TDD (Test-Driven Development)

Test-Driven Development (TDD) is a software development approach that reverses the traditional process by writing automated tests first before implementing production code. This methodology follows a short iterative cycle called "Red-Green-Refactor" that ensures high test coverage and modular design. TDD transforms testing from a verification activity into a design tool that guides code architecture.

TDD Fundamentals

• Red-Green-Refactor cycle: write a failing test (Red), implement minimal code to pass it (Green), then improve code quality (Refactor)
• Test First: functional specifications are translated into executable tests before any implementation
• Rapid feedback: immediate regression detection and continuous business logic validation
• Emergent design: code architecture emerges naturally from constraints imposed by tests

Benefits of TDD

• Superior quality: drastic reduction in production bugs through comprehensive test coverage
• Living documentation: tests serve as executable and always up-to-date specification of expected behavior
• Safe refactoring: code modification without risk thanks to automated test safety net
• Modular design: TDD naturally promotes decoupling and adherence to SOLID principles
• Increased confidence: more serene deployments and reduced technical debt over time

Practical Example

Let's take the example of a commercial discount calculation function following the complete TDD cycle:

// STEP 1 - RED: Write the failing test
import { describe, it, expect } from 'vitest';
import { calculateDiscount } from './discount';

describe('calculateDiscount', () => {
  it('should apply 10% discount for orders above €100', () => {
    const result = calculateDiscount(150);
    expect(result).toBe(135); // 150 - 15 = 135
  });

  it('should not apply discount for orders below €100', () => {
    const result = calculateDiscount(50);
    expect(result).toBe(50);
  });

  it('should apply 20% discount for premium customers', () => {
    const result = calculateDiscount(200, { isPremium: true });
    expect(result).toBe(160); // 200 - 40 = 160
  });
});

// STEP 2 - GREEN: Minimal implementation
interface DiscountOptions {
  isPremium?: boolean;
}

export function calculateDiscount(
  amount: number,
  options: DiscountOptions = {}
): number {
  if (options.isPremium) {
    return amount * 0.8; // 20% discount
  }
  
  if (amount >= 100) {
    return amount * 0.9; // 10% discount
  }
  
  return amount;
}

// STEP 3 - REFACTOR: Improved readability
const DISCOUNT_RATES = {
  premium: 0.20,
  standard: 0.10,
} as const;

const MINIMUM_AMOUNT_FOR_DISCOUNT = 100;

export function calculateDiscount(
  amount: number,
  options: DiscountOptions = {}
): number {
  const discountRate = options.isPremium
    ? DISCOUNT_RATES.premium
    : amount >= MINIMUM_AMOUNT_FOR_DISCOUNT
    ? DISCOUNT_RATES.standard
    : 0;

  return amount * (1 - discountRate);
}

Implementing TDD

1. Define a specific feature or behavior to implement starting from business needs
2. Write a unit test describing the expected behavior and verify it fails (Red)
3. Implement minimal code necessary to pass the test without over-engineering (Green)
4. Run all tests to ensure no regression has been introduced
5. Refactor the code to improve its structure while keeping tests green (Refactor)
6. Repeat the cycle for each new feature or edge case identified

Related Tools and Frameworks

• Jest / Vitest: JavaScript/TypeScript testing frameworks with integrated mocking and watch mode
• JUnit / TestNG: Java standards for unit testing with annotations and assertions
• pytest: Python framework favoring simplicity with fixtures and parameterized tests
• RSpec: Ruby DSL for behavioral tests with expressive syntax
• Mocha + Chai: flexible combination for Node.js with different assertion styles
• Kent Beck's TDD by Example: foundational book describing the complete methodology

TDD represents an initial time investment that translates into substantial gains in maintainability, bug reduction, and team velocity over the long term. By enforcing a discipline of design through tests, this approach produces more modular, better documented, and evolutionary code. For organizations seeking to reduce technical debt and improve software quality, TDD constitutes a fundamental practice that durably transforms engineering culture.