AI 시대에 TDD가 더 중요해진 이유 - Mock과 레이어드 아키텍처 관점에서

1. 코드 작성
2. 실행해서 확인
3. 버그 발견
4. 수정
5. 다시 실행
6. (반복...)

1. 테스트 먼저 작성 (이 시점엔 당연히 실패)
2. 테스트가 통과할 만큼만 코드 작성
3. 리팩토링
4. (반복...)

// Red 단계: 실패하는 테스트 먼저 작성
@Test
void 주문_금액이_10만원_이상이면_배송비_무료() {
    // given
    Order order = Order.create(100_000);
    
    // when
    int shippingFee = order.calculateShippingFee();
    
    // then
    assertThat(shippingFee).isEqualTo(0);
}

@Service
public class OrderService {
    private final OrderRepository orderRepository;
    private final PaymentGateway paymentGateway;  // 외부 결제 API
    private final InventoryService inventoryService;  // 재고 서비스
    
    public Order placeOrder(OrderRequest request) {
        // 재고 확인
        if (!inventoryService.checkStock(request.getProductId())) {
            throw new OutOfStockException();
        }
        
        // 결제 처리
        PaymentResult result = paymentGateway.pay(request.getAmount());
        if (!result.isSuccess()) {
            throw new PaymentFailedException();
        }
        
        // 주문 저장
        Order order = Order.create(request);
        return orderRepository.save(order);
    }
}

// PaymentGateway Mock 예시
PaymentGateway mockGateway = mock(PaymentGateway.class);

// "pay() 호출하면 성공 결과를 리턴해라"라고 지시
when(mockGateway.pay(anyLong()))
    .thenReturn(PaymentResult.success());

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {

    @Mock
    private OrderRepository orderRepository;
    
    @Mock
    private PaymentGateway paymentGateway;
    
    @Mock
    private InventoryService inventoryService;
    
    @InjectMocks
    private OrderService orderService;
    
    @Test
    void 재고가_없으면_주문_실패() {
        // given
        OrderRequest request = new OrderRequest("product-1", 1, 10000);
        
        // 재고 없다고 설정
        when(inventoryService.checkStock("product-1")).thenReturn(false);
        
        // when & then
        assertThatThrownBy(() -> orderService.placeOrder(request))
            .isInstanceOf(OutOfStockException.class);
        
        // 결제 API는 호출되지 않아야 함
        verify(paymentGateway, never()).pay(anyLong());
    }
    
    @Test
    void 결제_성공시_주문_저장() {
        // given
        OrderRequest request = new OrderRequest("product-1", 1, 10000);
        Order expectedOrder = Order.create(request);
        
        when(inventoryService.checkStock("product-1")).thenReturn(true);
        when(paymentGateway.pay(10000L)).thenReturn(PaymentResult.success());
        when(orderRepository.save(any(Order.class))).thenReturn(expectedOrder);
        
        // when
        Order result = orderService.placeOrder(request);
        
        // then
        assertThat(result).isNotNull();
        verify(orderRepository).save(any(Order.class));
    }
}

┌─────────────────┐
│   Controller    │   ← 요청/응답 처리
├─────────────────┤
│    Service      │   ← 비즈니스 로직
├─────────────────┤
│   Repository    │   ← 데이터 접근
├─────────────────┤
│    Database     │
└─────────────────┘

@WebMvcTest(OrderController.class)
class OrderControllerTest {

    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private OrderService orderService;
    
    @Test
    void 주문_생성_성공시_201_응답() throws Exception {
        // given
        OrderRequest request = new OrderRequest("product-1", 1, 10000);
        Order order = Order.create(request);
        when(orderService.placeOrder(any())).thenReturn(order);
        
        // when & then
        mockMvc.perform(post("/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(request)))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.orderId").exists());
    }
}

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {

    @Mock
    private OrderRepository orderRepository;
    
    @InjectMocks
    private OrderService orderService;
    
    @Test
    void 주문_생성시_주문번호_생성() {
        // given
        OrderRequest request = new OrderRequest("product-1", 1, 10000);
        when(orderRepository.save(any())).thenAnswer(invocation -> {
            Order order = invocation.getArgument(0);
            return order;
        });
        
        // when
        Order order = orderService.createOrder(request);
        
        // then
        assertThat(order.getOrderNumber()).isNotBlank();
    }
}

// application-test.yml
spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
  jpa:
    hibernate:
      ddl-auto: create-drop

@Testcontainers
@DataJpaTest
class OrderRepositoryTest {

    @Container
    static MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.0");
    
    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", mysql::getJdbcUrl);
        registry.add("spring.datasource.username", mysql::getUsername);
        registry.add("spring.datasource.password", mysql::getPassword);
    }
}

@BeforeEach
void setUp() {
    // 테스트 데이터 세팅
    orderRepository.save(Order.create(...));
}

@AfterEach
void tearDown() {
    // 데이터 정리
    orderRepository.deleteAll();
}

// 이런 건 굳이 테스트 안 해도 됨 (JPA가 알아서 처리)
Order save(Order order);
Optional<Order> findById(Long id);

// 이런 건 테스트하는 게 좋음 (비즈니스 로직이 있음)
@Query("SELECT o FROM Order o WHERE o.userId = :userId AND o.status = :status")
List<Order> findByUserIdAndStatus(@Param("userId") Long userId, @Param("status") OrderStatus status);

public int applyDiscount(int price, Coupon coupon) {
    if (coupon.getType() == CouponType.PERCENTAGE) {
        return price - (price * coupon.getDiscountRate() / 100);
    }
    return price;
}

@Test
void 최소_주문_금액_미만이면_쿠폰_적용_불가() {
    Order order = Order.of(8000);
    Coupon coupon = Coupon.percentage(10);
    
    assertThatThrownBy(() -> order.applyCoupon(coupon))
        .isInstanceOf(MinimumOrderAmountException.class);
}

@Test
void 할인_금액은_최대_5천원() {
    Order order = Order.of(100000);
    Coupon coupon = Coupon.percentage(10);  // 1만원 할인 예상
    
    // 근데 최대 5천원까지만
    int discountedPrice = order.applyCoupon(coupon);
    assertThat(discountedPrice).isEqualTo(95000);  // 5천원만 할인
}

@Test
void 이미_사용한_쿠폰은_적용_불가() {
    Coupon usedCoupon = Coupon.percentage(10);
    usedCoupon.markAsUsed();
    
    assertThatThrownBy(() -> order.applyCoupon(usedCoupon))
        .isInstanceOf(CouponAlreadyUsedException.class);
}

1. 요구사항을 테스트로 먼저 작성
2. AI에게 "이 테스트 통과하도록 코드 만들어줘" 요청
3. 테스트 실행해서 통과 확인
4. 리팩토링 (AI에게 요청하거나 직접)

// 이 테스트는 AI 코드가 뭐가 됐든 검증해줌
@Test
void 주문_상태는_PENDING에서_시작() {
    Order order = Order.create(request);
    assertThat(order.getStatus()).isEqualTo(OrderStatus.PENDING);
}

./gradlew test jacocoTestReport

# GitHub Actions 예시
- name: Run Tests
  run: ./gradlew test