tdd-workflow

TDD Workflow Skill

Test-Driven Development methodology with advanced patterns for real-world applications.

When to Use

Activate this skill when:

• Implementing new features or fixing bugs
• Writing or reviewing tests
• Discussing testing strategy
• Setting up test infrastructure

---

1. The TDD Cycle

┌─────────────────────────────────────────────────────────┐
│                                                         │
│   1. RED    — Write a test that FAILS                   │
│   2. GREEN  — Write MINIMAL code to PASS                │
│   3. REFACTOR — Improve code, keep tests GREEN          │
│   4. REPEAT — Next requirement                          │
│                                                         │
│   Key insight: Tests drive DESIGN, not just correctness │
│                                                         │
└─────────────────────────────────────────────────────────┘

Step 0: Define the Interface FIRST

// Before writing any test, define WHAT you're building
// This is your contract — tests verify the contract

interface OrderService {
  createOrder(input: CreateOrderInput): Promise<Result<Order>>
  getOrder(id: string): Promise<Result<Order>>
  cancelOrder(id: string, reason: string): Promise<Result<void>>
}

interface CreateOrderInput {
  userId: string
  items: Array<{ productId: string; quantity: number }>
  shippingAddress: Address
}

interface Order {
  id: string
  userId: string
  items: OrderItem[]
  status: OrderStatus
  total: number
  createdAt: Date
}

type OrderStatus = 'pending' | 'confirmed' | 'shipped' | 'delivered' | 'cancelled'

Step 1: RED — Write a Failing Test

describe('OrderService', () => {
  let service: OrderService
  let mockProductRepo: MockProductRepository
  let mockOrderRepo: MockOrderRepository

  beforeEach(() => {
    mockProductRepo = createMockProductRepo()
    mockOrderRepo = createMockOrderRepo()
    service = new OrderServiceImpl(mockOrderRepo, mockProductRepo)
  })

  describe('createOrder', () => {
    it('creates order with valid items and calculates total', async () => {
      // Arrange
      mockProductRepo.findById.mockResolvedValueOnce({ id: 'p1', price: 29.99, stock: 10 })
      mockProductRepo.findById.mockResolvedValueOnce({ id: 'p2', price: 49.99, stock: 5 })

      const input: CreateOrderInput = {
        userId: 'user-1',
        items: [
          { productId: 'p1', quantity: 2 },
          { productId: 'p2', quantity: 1 },
        ],
        shippingAddress: { street: '123 Main St', city: 'NYC', zip: '10001' },
      }

      // Act
      const result = await service.createOrder(input)

      // Assert
      expect(result.success).toBe(true)
      if (result.success) {
        expect(result.data.total).toBe(109.97)  // 29.99*2 + 49.99*1
        expect(result.data.status).toBe('pending')
        expect(result.data.items).toHaveLength(2)
      }
    })

    it('rejects order when product is out of stock', async () => {
      mockProductRepo.findById.mockResolvedValue({ id: 'p1', price: 10, stock: 0 })

      const result = await service.createOrder({
        userId: 'user-1',
        items: [{ productId: 'p1', quantity: 1 }],
        shippingAddress: validAddress,
      })

      expect(result.success).toBe(false)
      if (!result.success) {
        expect(result.error).toContain('out of stock')
      }
    })

    it('rejects order with empty items', async () => {
      const result = await service.createOrder({
        userId: 'user-1',
        items: [],
        shippingAddress: validAddress,
      })

      expect(result.success).toBe(false)
    })
  })
})