테스트 코드 — 단위 테스트부터 TDD까지, 왜 테스트를 짜야 하나

         /  E2E  \          ← 느리고 비쌈, 적게
        /----------\
       / Integration \      ← 중간
      /----------------\
     /    Unit Tests     \  ← 빠르고 쌈, 많이
    /______________________\

@Test
@DisplayName("주문 금액이 50,000원 이상이면 배송비 무료")
void freeShippingOver50000() {
    // Given — 사전 조건 설정
    Order order = new Order(List.of(
        new OrderItem("노트북 거치대", 55000)
    ));

    // When — 테스트할 동작 실행
    int shippingFee = order.calculateShippingFee();

    // Then — 결과 검증
    assertThat(shippingFee).isZero();
}

class OrderServiceTest {

    private OrderService orderService;

    @BeforeEach
    void setUp() {
        // 각 테스트 메서드 실행 전에 호출
        orderService = new OrderService();
    }

    @AfterEach
    void tearDown() {
        // 각 테스트 메서드 실행 후에 호출
    }

    @Test
    @DisplayName("정상 주문이면 COMPLETED 상태를 반환한다")
    void orderCompletes() {
        OrderResult result = orderService.placeOrder(new OrderRequest("item-1", 2));

        assertEquals(OrderStatus.COMPLETED, result.getStatus());
        assertNotNull(result.getOrderId());
    }

    @Test
    @DisplayName("수량이 0 이하면 IllegalArgumentException 발생")
    void zeroQuantityThrows() {
        assertThrows(IllegalArgumentException.class, () ->
            orderService.placeOrder(new OrderRequest("item-1", 0))
        );
    }
}

@ParameterizedTest
@CsvSource({
    "10000, 3000",   // 10,000원 → 배송비 3,000원
    "30000, 3000",   // 30,000원 → 배송비 3,000원
    "50000, 0",      // 50,000원 → 배송비 무료
    "100000, 0"      // 100,000원 → 배송비 무료
})
@DisplayName("주문 금액별 배송비 계산")
void shippingFeeByAmount(int orderAmount, int expectedFee) {
    Order order = new Order(orderAmount);

    assertThat(order.calculateShippingFee()).isEqualTo(expectedFee);
}

// 기본
assertEquals(expected, actual);
assertNotEquals(a, b);
assertTrue(condition);
assertFalse(condition);
assertNull(object);
assertNotNull(object);

// 예외 검증
assertThrows(IllegalStateException.class, () -> service.doSomething());

// 시간 제한
assertTimeout(Duration.ofSeconds(2), () -> service.heavyTask());

// 한 번에 여러 검증 (하나 실패해도 나머지도 실행)
assertAll(
    () -> assertEquals("홍길동", user.getName()),
    () -> assertEquals("hong@test.com", user.getEmail()),
    () -> assertTrue(user.isActive())
);

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {

    @Mock
    private OrderRepository orderRepository;

    @Mock
    private PaymentGateway paymentGateway;

    @InjectMocks
    private OrderService orderService;

    @Test
    @DisplayName("결제 성공 시 주문이 저장된다")
    void saveOrderOnPaymentSuccess() {
        // Given
        Order order = new Order("item-1", 10000);
        when(paymentGateway.charge(anyInt())).thenReturn(PaymentResult.SUCCESS);
        when(orderRepository.save(any(Order.class))).thenReturn(order);

        // When
        OrderResult result = orderService.placeOrder(order);

        // Then
        assertThat(result.getStatus()).isEqualTo(OrderStatus.COMPLETED);
        verify(orderRepository, times(1)).save(any(Order.class));
        verify(paymentGateway).charge(10000);
    }

    @Test
    @DisplayName("결제 실패 시 주문이 저장되지 않는다")
    void noSaveOnPaymentFailure() {
        // Given
        Order order = new Order("item-1", 10000);
        when(paymentGateway.charge(anyInt())).thenReturn(PaymentResult.FAILURE);

        // When & Then
        assertThrows(PaymentFailedException.class,
            () -> orderService.placeOrder(order));

        verify(orderRepository, never()).save(any());
    }
}

// Spy — 실제 객체를 기반으로 일부만 오버라이드
@Spy
private OrderValidator orderValidator = new OrderValidator();

@Test
void spyExample() {
    // 실제 validate()는 그대로 호출되지만, 특정 조건만 오버라이드
    doReturn(true).when(orderValidator).isWeekend();

    // 나머지 메서드는 진짜 로직이 실행됨
    boolean result = orderValidator.validate(order);
    assertThat(result).isTrue();
}

@SpringBootTest
@Transactional // 테스트 끝나면 롤백
class OrderIntegrationTest {

    @Autowired
    private OrderService orderService;

    @Autowired
    private OrderRepository orderRepository;

    @Test
    @DisplayName("주문 생성 → 조회 흐름이 정상 동작한다")
    void createAndFind() {
        // Given
        OrderRequest request = new OrderRequest("item-1", 2, 15000);

        // When
        Long orderId = orderService.createOrder(request);

        // Then
        Order saved = orderRepository.findById(orderId).orElseThrow();
        assertThat(saved.getItemName()).isEqualTo("item-1");
        assertThat(saved.getTotalPrice()).isEqualTo(30000);
    }
}

@DataJpaTest
class OrderRepositoryTest {

    @Autowired
    private OrderRepository orderRepository;

    @Test
    @DisplayName("상태별 주문 조회")
    void findByStatus() {
        orderRepository.save(new Order("item-1", OrderStatus.COMPLETED));
        orderRepository.save(new Order("item-2", OrderStatus.CANCELLED));
        orderRepository.save(new Order("item-3", OrderStatus.COMPLETED));

        List<Order> completed = orderRepository.findByStatus(OrderStatus.COMPLETED);

        assertThat(completed).hasSize(2);
        assertThat(completed).allMatch(o -> o.getStatus() == OrderStatus.COMPLETED);
    }
}

@SpringBootTest
@Testcontainers
class OrderRepositoryRealDbTest {

    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test");

    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }

    @Autowired
    private OrderRepository orderRepository;

    @Test
    @DisplayName("PostgreSQL 네이티브 쿼리가 정상 동작한다")
    void nativeQueryWorks() {
        // 실제 PostgreSQL에서 테스트
        orderRepository.save(new Order("item-1", 10000));
        List<Order> result = orderRepository.findExpensiveOrders(5000);
        assertThat(result).isNotEmpty();
    }
}

WebDriver driver = new ChromeDriver();
driver.get("http://localhost:8080/login");

driver.findElement(By.id("username")).sendKeys("testuser");
driver.findElement(By.id("password")).sendKeys("password123");
driver.findElement(By.id("login-btn")).click();

WebElement welcome = driver.findElement(By.className("welcome-message"));
assertEquals("환영합니다, testuser님!", welcome.getText());

driver.quit();

// Playwright Java API
try (Playwright playwright = Playwright.create()) {
    Browser browser = playwright.chromium().launch();
    Page page = browser.newPage();

    page.navigate("http://localhost:8080/login");
    page.fill("#username", "testuser");
    page.fill("#password", "password123");
    page.click("#login-btn");

    assertThat(page.locator(".welcome-message"))
        .hasText("환영합니다, testuser님!");
}

1. Red    → 실패하는 테스트를 먼저 작성한다
2. Green  → 테스트를 통과하는 최소한의 코드를 작성한다
3. Refactor → 코드를 정리한다 (테스트는 계속 통과해야 함)

// 1. Red — 실패하는 테스트 먼저
@Test
void passwordMustBeAtLeast8Characters() {
    PasswordValidator validator = new PasswordValidator();
    assertFalse(validator.isValid("Short1A")); // 7자 → 실패해야 함
    assertTrue(validator.isValid("ValidPw1")); // 8자 → 성공해야 함
}

// 2. Green — 테스트를 통과하는 최소 코드
public class PasswordValidator {
    public boolean isValid(String password) {
        if (password.length() < 8) return false;
        if (!password.chars().anyMatch(Character::isUpperCase)) return false;
        if (!password.chars().anyMatch(Character::isDigit)) return false;
        return true;
    }
}

// 3. Refactor — 구조 개선
public class PasswordValidator {

    private static final int MIN_LENGTH = 8;

    public boolean isValid(String password) {
        return hasMinLength(password)
            && hasUpperCase(password)
            && hasDigit(password);
    }

    private boolean hasMinLength(String pw) {
        return pw.length() >= MIN_LENGTH;
    }

    private boolean hasUpperCase(String pw) {
        return pw.chars().anyMatch(Character::isUpperCase);
    }

    private boolean hasDigit(String pw) {
        return pw.chars().anyMatch(Character::isDigit);
    }
}

public String getGrade(int score) {
    if (score >= 90) return "A";
    if (score >= 80) return "B";
    return "C";
}

@Test
void uselessHighCoverage() {
    // 라인은 다 실행하지만 아무것도 검증 안 함
    userService.createUser("hong", "hong@test.com");
    // assertion 없음!
}

// 순수 함수 테스트
describe('calculateDiscount', () => {
  test('VIP 회원이면 20% 할인', () => {
    const result = calculateDiscount(10000, 'VIP');
    expect(result).toBe(8000);
  });

  test('일반 회원이면 할인 없음', () => {
    const result = calculateDiscount(10000, 'NORMAL');
    expect(result).toBe(10000);
  });
});

import { render, screen, fireEvent } from '@testing-library/react';
import Counter from './Counter';

test('버튼 클릭 시 카운트가 증가한다', () => {
  render(<Counter />);

  const button = screen.getByRole('button', { name: '증가' });
  fireEvent.click(button);

  expect(screen.getByText('카운트: 1')).toBeInTheDocument();
});

// 테스트하기 어려운 코드
public class OrderService {
    public void placeOrder(OrderRequest req) {
        // 현재 시간에 의존
        if (LocalDateTime.now().getHour() < 9) {
            throw new TooEarlyException();
        }
        // DB에 직접 접근
        Connection conn = DriverManager.getConnection(...);
        // ...
    }
}

// 테스트하기 좋은 코드
public class OrderService {
    private final Clock clock;
    private final OrderRepository repository;

    public OrderService(Clock clock, OrderRepository repository) {
        this.clock = clock;
        this.repository = repository;
    }

    public void placeOrder(OrderRequest req) {
        if (LocalDateTime.now(clock).getHour() < 9) {
            throw new TooEarlyException();
        }
        repository.save(new Order(req));
    }
}

// 단위 테스트 — @Mock
@ExtendWith(MockitoExtension.class)
class UnitTest {
    @Mock OrderRepository repo;         // 스프링 없이 가짜 객체
    @InjectMocks OrderService service;  // 가짜 객체 주입
}

// 통합 테스트 — @MockBean
@SpringBootTest
class IntegrationTest {
    @MockBean PaymentGateway gateway;   // 스프링 빈을 Mock으로 교체
    @Autowired OrderService service;    // 나머지는 진짜 빈
}