TDDアンチパターン完全ガイド - 避けるべき落とし穴と具体的な改善策

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// userService.js
export class UserService {
  constructor(repository, cache) {
    this.repository = repository
    this.cache = cache
  }

  async getUser(id) {
    // キャッシュをチェック
    const cached = this.cache.get(`user:${id}`)
    if (cached) {
      return cached
    }
    
    // データベースから取得
    const user = await this.repository.findById(id)
    if (user) {
      this.cache.set(`user:${id}`, user, 3600)
    }
    return user
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 悪い例: 実装詳細に密結合したテスト
describe('UserService', () => {
  it('should check cache first, then database, then set cache', async () => {
    const mockCache = {
      get: jest.fn().mockReturnValue(null),
      set: jest.fn(),
    }
    const mockRepository = {
      findById: jest.fn().mockResolvedValue({ id: 1, name: 'Alice' }),
    }
    
    const service = new UserService(mockRepository, mockCache)
    await service.getUser(1)
    
    // 実装詳細を検証している
    expect(mockCache.get).toHaveBeenCalledWith('user:1')
    expect(mockCache.get).toHaveBeenCalledBefore(mockRepository.findById)
    expect(mockRepository.findById).toHaveBeenCalledWith(1)
    expect(mockCache.set).toHaveBeenCalledWith('user:1', { id: 1, name: 'Alice' }, 3600)
  })
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// 良い例: 振る舞いを検証するテスト
describe('UserService', () => {
  it('should return user when user exists', async () => {
    const expectedUser = { id: 1, name: 'Alice' }
    const mockCache = { get: jest.fn().mockReturnValue(null), set: jest.fn() }
    const mockRepository = { findById: jest.fn().mockResolvedValue(expectedUser) }
    
    const service = new UserService(mockRepository, mockCache)
    const result = await service.getUser(1)
    
    // 振る舞いを検証: 正しいユーザーが返される
    expect(result).toEqual(expectedUser)
  })

  it('should return cached user without hitting database', async () => {
    const cachedUser = { id: 1, name: 'Alice' }
    const mockCache = { get: jest.fn().mockReturnValue(cachedUser), set: jest.fn() }
    const mockRepository = { findById: jest.fn() }
    
    const service = new UserService(mockRepository, mockCache)
    const result = await service.getUser(1)
    
    // 振る舞いを検証: キャッシュされたユーザーが返され、DBは呼ばれない
    expect(result).toEqual(cachedUser)
    expect(mockRepository.findById).not.toHaveBeenCalled()
  })

  it('should return null when user does not exist', async () => {
    const mockCache = { get: jest.fn().mockReturnValue(null), set: jest.fn() }
    const mockRepository = { findById: jest.fn().mockResolvedValue(null) }
    
    const service = new UserService(mockRepository, mockCache)
    const result = await service.getUser(999)
    
    expect(result).toBeNull()
  })
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// 悪い例: すべてをモックで置き換えている
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
    @Mock private OrderRepository orderRepository;
    @Mock private PaymentGateway paymentGateway;
    @Mock private InventoryService inventoryService;
    @Mock private NotificationService notificationService;
    @Mock private PricingCalculator pricingCalculator;
    @Mock private TaxCalculator taxCalculator;
    @Mock private DiscountEngine discountEngine;
    @Mock private AuditLogger auditLogger;
    
    @InjectMocks
    private OrderService orderService;
    
    @Test
    void shouldProcessOrder() {
        // 8つのモックすべてに詳細な振る舞いを設定
        when(pricingCalculator.calculate(any())).thenReturn(new BigDecimal("100.00"));
        when(taxCalculator.calculate(any())).thenReturn(new BigDecimal("10.00"));
        when(discountEngine.apply(any())).thenReturn(new BigDecimal("5.00"));
        when(inventoryService.checkAvailability(any())).thenReturn(true);
        when(paymentGateway.process(any())).thenReturn(PaymentResult.SUCCESS);
        when(orderRepository.save(any())).thenReturn(new Order());
        doNothing().when(notificationService).sendConfirmation(any());
        doNothing().when(auditLogger).log(any());
        
        Order order = new Order();
        OrderResult result = orderService.processOrder(order);
        
        assertThat(result.isSuccess()).isTrue();
        
        // すべてのモックが正しく呼ばれたことを検証
        verify(pricingCalculator).calculate(any());
        verify(taxCalculator).calculate(any());
        // ... 以下8つのverify
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// 良い例: 適切なレベルでモックを使用
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
    // 外部システムとの境界のみモック
    @Mock private PaymentGateway paymentGateway;
    @Mock private NotificationService notificationService;
    
    // 純粋なドメインロジックは実オブジェクトを使用
    private PricingCalculator pricingCalculator = new PricingCalculator();
    private TaxCalculator taxCalculator = new TaxCalculator();
    private DiscountEngine discountEngine = new DiscountEngine();
    
    // インメモリ実装を使用
    private OrderRepository orderRepository = new InMemoryOrderRepository();
    private InventoryService inventoryService = new InMemoryInventoryService();
    
    @Test
    void shouldProcessOrderSuccessfully() {
        // 在庫を準備
        inventoryService.addStock("PROD-001", 10);
        
        // 外部システムのモックのみ設定
        when(paymentGateway.process(any())).thenReturn(PaymentResult.SUCCESS);
        
        OrderService orderService = new OrderService(
            orderRepository, paymentGateway, inventoryService,
            notificationService, pricingCalculator, taxCalculator, discountEngine
        );
        
        Order order = new Order("PROD-001", 2);
        OrderResult result = orderService.processOrder(order);
        
        assertThat(result.isSuccess()).isTrue();
        assertThat(result.getTotalAmount()).isEqualTo(new BigDecimal("231.00")); // 実際の計算結果
        assertThat(orderRepository.findById(result.getOrderId())).isPresent();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 悪い例: 1つのテストで複数のことを検証
describe('UserRegistration', () => {
  it('should handle complete registration flow', async () => {
    const userData = {
      email: 'test@example.com',
      password: 'SecurePass123!',
      name: 'Test User',
    }
    
    // 1. バリデーション
    expect(validateEmail(userData.email)).toBe(true)
    expect(validatePassword(userData.password)).toBe(true)
    expect(validateName(userData.name)).toBe(true)
    
    // 2. ユーザー作成
    const user = await createUser(userData)
    expect(user.id).toBeDefined()
    expect(user.email).toBe(userData.email)
    expect(user.passwordHash).not.toBe(userData.password)
    
    // 3. メール送信
    expect(mockEmailService.send).toHaveBeenCalledWith(
      expect.objectContaining({ to: userData.email })
    )
    
    // 4. 監査ログ
    expect(mockAuditLog.log).toHaveBeenCalledWith('USER_CREATED', user.id)
    
    // 5. ウェルカムキャンペーン
    expect(mockCampaignService.enroll).toHaveBeenCalledWith(user.id, 'welcome')
    
    // このテストが失敗したとき、何が原因か特定しづらい
  })
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

// 良い例: 関心事ごとにテストを分離
describe('UserRegistration', () => {
  describe('validation', () => {
    it('should accept valid email format', () => {
      expect(validateEmail('user@example.com')).toBe(true)
    })

    it('should reject invalid email format', () => {
      expect(validateEmail('invalid-email')).toBe(false)
    })

    it('should require minimum password strength', () => {
      expect(validatePassword('weak')).toBe(false)
      expect(validatePassword('SecurePass123!')).toBe(true)
    })
  })

  describe('user creation', () => {
    it('should create user with hashed password', async () => {
      const userData = createValidUserData()
      const user = await createUser(userData)
      
      expect(user.passwordHash).not.toBe(userData.password)
    })

    it('should generate unique user id', async () => {
      const user = await createUser(createValidUserData())
      expect(user.id).toBeDefined()
    })
  })

  describe('notification', () => {
    it('should send welcome email after registration', async () => {
      const user = await registerUser(createValidUserData())
      
      expect(mockEmailService.send).toHaveBeenCalledWith(
        expect.objectContaining({ 
          to: user.email,
          template: 'welcome' 
        })
      )
    })
  })
})

// テストヘルパー関数
function createValidUserData() {
  return {
    email: 'test@example.com',
    password: 'SecurePass123!',
    name: 'Test User',
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// 悪い例: テストしづらい設計
public class ReportGenerator {
    public String generateMonthlyReport() {
        // 隠れた依存: 現在日時を直接取得
        LocalDate today = LocalDate.now();
        LocalDate startOfMonth = today.withDayOfMonth(1);
        
        // 隠れた依存: シングルトンからDBアクセス
        Connection conn = DatabaseManager.getInstance().getConnection();
        
        // 密結合: SQL直接実行
        String sql = "SELECT * FROM sales WHERE date >= ?";
        PreparedStatement stmt = conn.prepareStatement(sql);
        stmt.setDate(1, java.sql.Date.valueOf(startOfMonth));
        ResultSet rs = stmt.executeQuery();
        
        // ロジックとI/Oが混在
        StringBuilder report = new StringBuilder();
        while (rs.next()) {
            report.append(formatRow(rs));
        }
        
        // 副作用: ファイル出力
        Files.writeString(Path.of("/reports/monthly.txt"), report.toString());
        
        return report.toString();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// 良い例: テスタブルな設計
public class ReportGenerator {
    private final SalesRepository salesRepository;
    private final ReportWriter reportWriter;
    private final Clock clock;
    
    // 依存性を明示的に注入
    public ReportGenerator(SalesRepository salesRepository, 
                          ReportWriter reportWriter, 
                          Clock clock) {
        this.salesRepository = salesRepository;
        this.reportWriter = reportWriter;
        this.clock = clock;
    }
    
    public String generateMonthlyReport() {
        LocalDate today = LocalDate.now(clock);
        LocalDate startOfMonth = today.withDayOfMonth(1);
        
        List<Sale> sales = salesRepository.findByDateAfter(startOfMonth);
        
        String report = formatReport(sales);
        
        reportWriter.write(report);
        
        return report;
    }
    
    // 純粋関数として分離
    String formatReport(List<Sale> sales) {
        return sales.stream()
            .map(this::formatSale)
            .collect(Collectors.joining("\n"));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// テストコード
@Test
void shouldGenerateReportForCurrentMonth() {
    // 固定された時刻を使用
    Clock fixedClock = Clock.fixed(
        LocalDate.of(2026, 1, 15).atStartOfDay(ZoneId.systemDefault()).toInstant(),
        ZoneId.systemDefault()
    );
    
    // インメモリ実装を使用
    InMemorySalesRepository repository = new InMemorySalesRepository();
    repository.save(new Sale(LocalDate.of(2026, 1, 5), new BigDecimal("100")));
    repository.save(new Sale(LocalDate.of(2026, 1, 10), new BigDecimal("200")));
    
    StringReportWriter writer = new StringReportWriter();
    
    ReportGenerator generator = new ReportGenerator(repository, writer, fixedClock);
    String report = generator.generateMonthlyReport();
    
    assertThat(report).contains("100", "200");
    assertThat(writer.getWrittenContent()).isEqualTo(report);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 悪い例: プライベートメソッドを無理やりテスト
class PriceCalculator {
  calculate(items) {
    const subtotal = this._calculateSubtotal(items)
    const tax = this._calculateTax(subtotal)
    const discount = this._applyDiscount(subtotal)
    return subtotal + tax - discount
  }
  
  // これらはプライベートメソッド
  _calculateSubtotal(items) { /* ... */ }
  _calculateTax(amount) { /* ... */ }
  _applyDiscount(amount) { /* ... */ }
}

// プライベートメソッドを直接テスト（悪い例）
describe('PriceCalculator internals', () => {
  it('should calculate tax correctly', () => {
    const calculator = new PriceCalculator()
    // プライベートメソッドに直接アクセス
    expect(calculator._calculateTax(100)).toBe(10)
  })
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// 良い例: パブリックインターフェースを通してテスト
describe('PriceCalculator', () => {
  it('should include 10% tax in final price', () => {
    const calculator = new PriceCalculator()
    const items = [{ price: 100, quantity: 1 }]
    
    const result = calculator.calculate(items)
    
    // 税込み価格が期待通りであることを検証
    expect(result).toBe(110) // 100 + 10% tax
  })
})

// もしプライベートメソッドが複雑なら、別クラスに抽出
class TaxCalculator {
  calculate(amount) {
    return amount * 0.1
  }
}

class PriceCalculator {
  constructor(taxCalculator = new TaxCalculator()) {
    this.taxCalculator = taxCalculator
  }
  
  calculate(items) {
    const subtotal = this.calculateSubtotal(items)
    const tax = this.taxCalculator.calculate(subtotal)
    return subtotal + tax
  }
}

// 抽出したクラスを個別にテスト
describe('TaxCalculator', () => {
  it('should calculate 10% tax', () => {
    const calculator = new TaxCalculator()
    expect(calculator.calculate(100)).toBe(10)
  })
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// リファクタリングを省略し続けた結果
function processOrder(order) {
  // TODO: リファクタリングする
  if (order.type === 'standard') {
    if (order.total > 100) {
      if (order.customer.isPremium) {
        order.discount = order.total * 0.15
      } else {
        order.discount = order.total * 0.1
      }
    } else {
      if (order.customer.isPremium) {
        order.discount = order.total * 0.05
      } else {
        order.discount = 0
      }
    }
  } else if (order.type === 'express') {
    // 同様のネストが続く...
  }
  // 以下200行続く
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// 悪い例: カバレッジのためだけのテスト
@Test
void shouldHaveToStringMethod() {
    User user = new User("Alice", "alice@example.com");
    assertThat(user.toString()).isNotNull(); // 何も検証していない
}

@Test
void shouldHaveGettersAndSetters() {
    User user = new User();
    user.setName("Alice");
    assertThat(user.getName()).isEqualTo("Alice"); // trivial
}

@Test
void shouldConstructWithNoArgs() {
    User user = new User();
    assertThat(user).isNotNull(); // 無意味
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 悪い例: 順序に依存した脆いテスト
it('should return users in correct format', () => {
  const users = getUserList()
  
  // 順序に依存
  expect(users[0].name).toBe('Alice')
  expect(users[1].name).toBe('Bob')
  expect(users[2].name).toBe('Charlie')
})

// 悪い例: 完全一致に依存した脆いテスト
it('should format error message', () => {
  const error = validateUser({ name: '' })
  
  // エラーメッセージの文言変更で壊れる
  expect(error.message).toBe('Name is required. Please enter a valid name.')
})

// 悪い例: 日時に依存した脆いテスト
it('should set creation date', () => {
  const user = createUser({ name: 'Alice' })
  
  // テスト実行タイミングで結果が変わる
  expect(user.createdAt).toBe(new Date().toISOString())
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// 良い例: 順序非依存のテスト
it('should return all expected users', () => {
  const users = getUserList()
  const names = users.map(u => u.name)
  
  expect(names).toContain('Alice')
  expect(names).toContain('Bob')
  expect(names).toContain('Charlie')
  expect(names).toHaveLength(3)
})

// 良い例: 部分一致のテスト
it('should return error for empty name', () => {
  const error = validateUser({ name: '' })
  
  expect(error.field).toBe('name')
  expect(error.type).toBe('required')
  // メッセージは含まれていればOK
  expect(error.message).toContain('name')
})

// 良い例: 固定された時刻を使用
it('should set creation date', () => {
  const fixedDate = new Date('2026-01-05T12:00:00Z')
  jest.useFakeTimers().setSystemTime(fixedDate)
  
  const user = createUser({ name: 'Alice' })
  
  expect(user.createdAt).toBe('2026-01-05T12:00:00.000Z')
  
  jest.useRealTimers()
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 遅い例: 実DBを使用
@Test
void shouldSaveUser() {
    // 実際のPostgreSQLに接続（遅い）
    UserRepository repository = new PostgresUserRepository(dataSource);
    repository.save(new User("Alice"));
    // ...
}

// 速い例: インメモリ実装を使用
@Test
void shouldSaveUser() {
    // インメモリ実装（高速）
    UserRepository repository = new InMemoryUserRepository();
    repository.save(new User("Alice"));
    
    assertThat(repository.findByName("Alice")).isPresent();
}