Split View: Java 테스트 완전 정복: JUnit 5, Mockito, WireMock 실전 가이드

<!-- build.gradle.kts (Kotlin DSL) -->
dependencies {
    testImplementation("org.junit.jupiter:junit-jupiter:5.10.2")
    testImplementation("org.mockito:mockito-junit-jupiter:5.11.0")
    testImplementation("com.github.tomakehurst:wiremock-jre8:3.0.1")
    testImplementation("org.testcontainers:junit-jupiter:1.19.7")
    testImplementation("org.assertj:assertj-core:3.25.3")
}

tasks.test {
    useJUnitPlatform()
}

import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

class CalculatorTest {

    private Calculator calculator;

    @BeforeAll
    static void initAll() {
        // 클래스 전체에서 한 번만 실행 (static)
        System.out.println("테스트 클래스 초기화");
    }

    @BeforeEach
    void setUp() {
        // 각 테스트 메서드 전에 실행
        calculator = new Calculator();
    }

    @AfterEach
    void tearDown() {
        // 각 테스트 메서드 후에 실행
        calculator = null;
    }

    @AfterAll
    static void tearDownAll() {
        // 클래스 전체에서 마지막에 한 번만 실행 (static)
        System.out.println("테스트 클래스 종료");
    }

    @Test
    @DisplayName("두 수의 합이 올바르게 계산되어야 한다")
    void add_shouldReturnCorrectSum() {
        // given
        int a = 3, b = 5;

        // when
        int result = calculator.add(a, b);

        // then
        assertEquals(8, result, "3 + 5 = 8 이어야 합니다");
    }

    @Test
    @Disabled("미구현 기능")
    void notImplementedYet() {
        // 이 테스트는 건너뜀
    }

    @Test
    @Tag("slow")
    void slowTest() {
        // 태그로 그룹화, ./gradlew test -Dtests.groups=slow
    }
}

@DisplayName("주문 서비스 테스트")
class OrderServiceTest {

    @Nested
    @DisplayName("주문 생성 시")
    class WhenCreatingOrder {

        @Test
        @DisplayName("재고가 충분하면 성공해야 한다")
        void shouldSucceedWhenStockIsSufficient() { /* ... */ }

        @Test
        @DisplayName("재고가 부족하면 예외를 던져야 한다")
        void shouldThrowWhenStockIsInsufficient() { /* ... */ }
    }

    @Nested
    @DisplayName("주문 취소 시")
    class WhenCancellingOrder {

        @Test
        @DisplayName("배송 전이면 취소 가능해야 한다")
        void shouldAllowCancellationBeforeShipping() { /* ... */ }

        @Test
        @DisplayName("배송 후에는 취소 불가능해야 한다")
        void shouldNotAllowCancellationAfterShipping() { /* ... */ }
    }
}

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.*;

class ParameterizedTests {

    // @ValueSource: 단일 타입 값 목록
    @ParameterizedTest
    @ValueSource(strings = {"", " ", "\t", "\n"})
    @DisplayName("공백 문자열은 blank로 판단되어야 한다")
    void blankStringsShouldBeBlank(String input) {
        assertTrue(input.isBlank());
    }

    @ParameterizedTest
    @ValueSource(ints = {1, 3, 5, 7, 9})
    void shouldBeOdd(int number) {
        assertEquals(1, number % 2);
    }

    // @CsvSource: 여러 컬럼 데이터
    @ParameterizedTest
    @CsvSource({
        "apple,  5",
        "banana, 6",
        "cherry, 6"
    })
    @DisplayName("과일 이름의 길이가 올바르게 반환되어야 한다")
    void fruitLengthShouldMatch(String fruit, int expectedLength) {
        assertEquals(expectedLength, fruit.length());
    }

    // @CsvFileSource: CSV 파일에서 읽기
    @ParameterizedTest
    @CsvFileSource(resources = "/test-data.csv", numLinesToSkip = 1)
    void fromCsvFile(String input, int expected) { /* ... */ }

    // @MethodSource: 메서드에서 인자 제공
    @ParameterizedTest
    @MethodSource("provideStringsForIsBlank")
    void isBlank_ShouldReturnTrue(String input, boolean expected) {
        assertEquals(expected, input == null || input.isBlank());
    }

    static Stream<Arguments> provideStringsForIsBlank() {
        return Stream.of(
            Arguments.of(null, true),
            Arguments.of("", true),
            Arguments.of("  ", true),
            Arguments.of("not blank", false)
        );
    }

    // @EnumSource: Enum 값으로 테스트
    @ParameterizedTest
    @EnumSource(value = DayOfWeek.class, names = {"SATURDAY", "SUNDAY"})
    void weekendsAreNotWorkdays(DayOfWeek day) {
        assertFalse(isWorkday(day));
    }
}

class AssertionsTest {

    @Test
    void groupAssertions() {
        // assertAll: 모든 검증 수행 후 실패 목록 출력
        assertAll("person",
            () -> assertEquals("Alice", person.getName()),
            () -> assertEquals(30, person.getAge()),
            () -> assertEquals("alice@example.com", person.getEmail())
        );
    }

    @Test
    void exceptionTesting() {
        // assertThrows: 예외 타입 검증
        Exception exception = assertThrows(
            ArithmeticException.class,
            () -> calculator.divide(10, 0)
        );
        assertEquals("Division by zero", exception.getMessage());
    }

    @Test
    void timeoutTesting() {
        // assertTimeout: 시간 초과 검증
        assertTimeout(Duration.ofSeconds(1), () -> {
            // 1초 내에 완료되어야 함
            Thread.sleep(500);
        });

        // assertTimeoutPreemptively: 시간 초과 시 즉시 중단
        assertTimeoutPreemptively(Duration.ofSeconds(1), () -> {
            someBlockingOperation();
        });
    }

    @Test
    void assumptionsTest() {
        // 조건이 false이면 테스트 건너뜀 (실패 아님)
        assumeTrue("CI".equals(System.getenv("ENV")),
            "CI 환경에서만 실행");
        // CI 환경일 때만 아래 코드 실행
        heavyIntegrationTest();
    }
}

@TestFactory
Collection<DynamicTest> dynamicTests() {
    return List.of(
        DynamicTest.dynamicTest("1 + 1 = 2", () -> assertEquals(2, 1 + 1)),
        DynamicTest.dynamicTest("2 + 3 = 5", () -> assertEquals(5, 2 + 3))
    );
}

@TestFactory
Stream<DynamicTest> dynamicTestsFromStream() {
    return Stream.of("apple", "banana", "cherry")
        .map(fruit -> DynamicTest.dynamicTest(
            fruit + "는 과일이다",
            () -> assertTrue(isFruit(fruit))
        ));
}

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @Mock
    private EmailService emailService;

    @InjectMocks
    private UserService userService; // @Mock 필드들이 자동 주입

    @Spy
    private PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
    // @Spy: 실제 객체이지만 일부 메서드만 모의 가능

    @Captor
    private ArgumentCaptor<User> userCaptor;
    // ArgumentCaptor: 메서드 호출 시 전달된 인자를 캡처
}

@Test
void stubbing_examples() {
    // 기본 스텁: 특정 값 반환
    when(userRepository.findById("user1"))
        .thenReturn(Optional.of(new User("user1", "Alice")));

    // null 또는 비어있는 경우
    when(userRepository.findById("nonexistent"))
        .thenReturn(Optional.empty());

    // 예외 발생
    when(userRepository.findById("error"))
        .thenThrow(new DatabaseException("Connection refused"));

    // 연속 반환 (순서대로)
    when(userRepository.findAll())
        .thenReturn(List.of(user1))
        .thenReturn(List.of(user1, user2))
        .thenReturn(Collections.emptyList());

    // thenAnswer: 인자에 따른 동적 반환
    when(userRepository.findByName(anyString()))
        .thenAnswer(invocation -> {
            String name = invocation.getArgument(0);
            return Optional.of(new User(name.toLowerCase(), name));
        });

    // doReturn: void 메서드나 spy에서 유용
    doReturn(Optional.of(mockUser)).when(userRepository).findById("spy-test");

    // doThrow: void 메서드에서 예외 발생
    doThrow(new MailException("SMTP error")).when(emailService).sendWelcomeEmail(any());

    // doNothing: void 메서드를 아무 동작 없이
    doNothing().when(emailService).sendNotification(anyString());

    // doCallRealMethod: spy에서 실제 메서드 호출
    doCallRealMethod().when(passwordEncoder).encode(anyString());
}

@Test
void verify_examples() {
    // 기본 검증: 정확히 1번 호출되었는가
    verify(userRepository).findById("user1");
    verify(userRepository, times(1)).findById("user1");

    // 호출 횟수 검증
    verify(emailService, times(3)).sendEmail(anyString());
    verify(userRepository, never()).delete(any());
    verify(emailService, atLeast(2)).sendEmail(anyString());
    verify(emailService, atMost(5)).sendEmail(anyString());

    // 호출 순서 검증
    InOrder inOrder = inOrder(userRepository, emailService);
    inOrder.verify(userRepository).save(any(User.class));
    inOrder.verify(emailService).sendWelcomeEmail(anyString());

    // 특정 인터랙션 외 다른 호출 없음 검증
    verifyNoMoreInteractions(emailService);
    verifyNoInteractions(auditService);
}

@Test
void argumentCaptor_example() {
    // given
    String name = "Alice";
    String email = "alice@example.com";

    // when
    userService.registerUser(name, email);

    // then - 저장된 User 객체 캡처
    verify(userRepository).save(userCaptor.capture());
    User savedUser = userCaptor.getValue();

    assertAll("저장된 사용자 검증",
        () -> assertEquals(name, savedUser.getName()),
        () -> assertEquals(email.toLowerCase(), savedUser.getEmail()),
        () -> assertNotNull(savedUser.getCreatedAt()),
        () -> assertEquals(UserStatus.PENDING, savedUser.getStatus())
    );

    // 여러 호출의 모든 캡처된 값
    verify(emailService, times(3)).sendEmail(emailCaptor.capture());
    List<String> sentEmails = emailCaptor.getAllValues();
    assertThat(sentEmails).containsExactly("admin@example.com", "alice@example.com", "support@example.com");
}

@Test
void matchers_examples() {
    // any(): 모든 타입 (null 포함)
    when(repo.findAll(any())).thenReturn(list);

    // any(SpecificClass.class): 특정 타입
    when(repo.findByExample(any(User.class))).thenReturn(list);

    // eq(): 정확히 같은 값
    when(repo.findById(eq("specific-id"))).thenReturn(Optional.of(user));

    // anyString(), anyInt(), anyList(), anyMap() 등
    when(service.process(anyString(), anyInt())).thenReturn(result);

    // argThat(): 커스텀 조건
    when(repo.save(argThat(u -> u.getName().startsWith("A")))).thenReturn(savedUser);

    // 주의: ArgumentMatchers 사용 시 모든 인자를 matcher로 사용해야 함
    // Bad: verify(service).method("literal", anyInt());
    // Good: verify(service).method(eq("literal"), anyInt());

    // assertj와 함께 사용
    verify(repo).save(argThat(user -> {
        assertThat(user.getName()).isNotBlank();
        assertThat(user.getEmail()).contains("@");
        return true; // true 반환 필수
    }));
}

// MockitoExtension은 기본적으로 strict stubbing 사용
// 불필요한 스텁(실제로 호출되지 않은 스텁)이 있으면 UnnecessaryStubbingException 발생
@ExtendWith(MockitoExtension.class)
class StrictStubbingTest {

    @Test
    void unnecessaryStubbingCausesFailure() {
        // 이 스텁이 테스트 내에서 사용되지 않으면 예외 발생
        when(userRepository.findById("unused")).thenReturn(Optional.of(user));
        // 실제 테스트 코드에서 "unused"로 조회하지 않으면 실패
    }

    // Lenient 모드: 불필요한 스텁 허용 (공유 fixture에서 유용)
    @Test
    void lenientStubbing() {
        lenient().when(userRepository.findById("maybe-unused"))
            .thenReturn(Optional.of(user));
        // 사용되지 않아도 예외 없음
    }
}

// 인터페이스 기반 수동 Stub
public class InMemoryUserRepository implements UserRepository {
    private final Map<String, User> store = new HashMap<>();
    private long idSequence = 1;

    @Override
    public User save(User user) {
        if (user.getId() == null) {
            user = user.withId(String.valueOf(idSequence++));
        }
        store.put(user.getId(), user);
        return user;
    }

    @Override
    public Optional<User> findById(String id) {
        return Optional.ofNullable(store.get(id));
    }

    @Override
    public List<User> findAll() {
        return new ArrayList<>(store.values());
    }

    @Override
    public void deleteById(String id) {
        store.remove(id);
    }

    @Override
    public boolean existsByEmail(String email) {
        return store.values().stream()
            .anyMatch(u -> email.equals(u.getEmail()));
    }

    // 테스트 헬퍼 메서드
    public void clear() { store.clear(); }
    public int count() { return store.size(); }
}

// 시간 Stub (Clock.fixed() 활용)
public class OrderServiceTest {

    private final Clock fixedClock = Clock.fixed(
        Instant.parse("2026-03-17T10:00:00Z"),
        ZoneId.of("Asia/Seoul")
    );

    @Test
    void orderShouldHaveCreationTime() {
        OrderService service = new OrderService(orderRepo, fixedClock);
        Order order = service.createOrder(userId, items);

        LocalDateTime expected = LocalDateTime.of(2026, 3, 17, 19, 0, 0); // KST
        assertEquals(expected, order.getCreatedAt());
    }
}

import com.github.tomakehurst.wiremock.junit5.WireMockExtension;
import com.github.tomakehurst.wiremock.junit5.WireMockTest;
import static com.github.tomakehurst.wiremock.client.WireMock.*;
import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.wireMockConfig;

// 방법 1: 어노테이션 방식 (간단)
@WireMockTest(httpPort = 8089)
class SimpleWireMockTest {

    @Test
    void testWithWireMock(WireMockRuntimeInfo wmRuntimeInfo) {
        stubFor(get("/api/users/1")
            .willReturn(aResponse()
                .withStatus(200)
                .withHeader("Content-Type", "application/json")
                .withBody("{\"id\": \"1\", \"name\": \"Alice\"}")));

        // HTTP 요청 수행
        String baseUrl = wmRuntimeInfo.getHttpBaseUrl();
        // WebClient나 RestTemplate으로 baseUrl + "/api/users/1" 호출
    }
}

// 방법 2: Extension 방식 (더 많은 제어)
@ExtendWith(WireMockExtension.class)
class AdvancedWireMockTest {

    @RegisterExtension
    static WireMockExtension wm = WireMockExtension.newInstance()
        .options(wireMockConfig()
            .dynamicPort()
            .dynamicHttpsPort()
            .usingFilesUnderClasspath("wiremock"))
        .build();

    @Test
    void advancedTest() {
        wm.stubFor(get(urlPathEqualTo("/api/users"))
            .withQueryParam("page", equalTo("1"))
            .withHeader("Authorization", matching("Bearer .+"))
            .willReturn(aResponse()
                .withStatus(200)
                .withBodyFile("users-response.json"))); // src/test/resources/wiremock/__files/
    }
}

@Test
void requestMatching_examples() {
    // URL 매칭
    stubFor(get(urlEqualTo("/exact/path")));           // 정확히 일치
    stubFor(get(urlPathEqualTo("/path")));             // 쿼리 파라미터 무시
    stubFor(get(urlPathMatching("/api/users/[0-9]+")));// 정규식

    // 요청 바디 매칭 (POST/PUT)
    stubFor(post(urlPathEqualTo("/api/users"))
        .withRequestBody(equalToJson("""
            {"name": "Alice", "email": "alice@example.com"}
            """, true, true)) // ignoreArrayOrder, ignoreExtraElements
        .withRequestBody(matchingJsonPath("$.email", containing("@")))
        .willReturn(aResponse().withStatus(201)));

    // 응답 지연 시뮬레이션
    stubFor(get("/slow-endpoint")
        .willReturn(aResponse()
            .withStatus(200)
            .withFixedDelay(2000)     // 2초 고정 지연
            .withBody("Slow response")));

    stubFor(get("/random-delay")
        .willReturn(aResponse()
            .withStatus(200)
            .withUniformRandomDelay(100, 500))); // 100~500ms 랜덤

    // 네트워크 오류 시뮬레이션
    stubFor(get("/network-error")
        .willReturn(aResponse().withFault(Fault.CONNECTION_RESET_BY_PEER)));

    // 헤더 응답
    stubFor(get("/with-headers")
        .willReturn(aResponse()
            .withStatus(200)
            .withHeader("X-Request-Id", "$(randomValue)")
            .withHeader("Cache-Control", "max-age=3600")
            .withBody("response body")));
}

@Test
void statefulMock_scenario() {
    // 시나리오: 재시도 패턴 테스트
    // 1번째 호출: 503 오류
    // 2번째 호출: 200 성공

    stubFor(get("/flaky-endpoint")
        .inScenario("Retry Scenario")
        .whenScenarioStateIs(STARTED)
        .willReturn(aResponse().withStatus(503))
        .willSetStateTo("First call failed"));

    stubFor(get("/flaky-endpoint")
        .inScenario("Retry Scenario")
        .whenScenarioStateIs("First call failed")
        .willReturn(aResponse()
            .withStatus(200)
            .withBody("Success on retry")));

    // 재시도 로직을 가진 클라이언트 테스트
    String result = retryableClient.get("/flaky-endpoint");
    assertEquals("Success on retry", result);

    // 요청 검증
    verify(exactly(2), getRequestedFor(urlEqualTo("/flaky-endpoint")));
}

@WireMockTest
class UserApiClientTest {

    private UserApiClient client;

    @BeforeEach
    void setUp(WireMockRuntimeInfo wmRuntimeInfo) {
        WebClient webClient = WebClient.builder()
            .baseUrl(wmRuntimeInfo.getHttpBaseUrl())
            .build();
        client = new UserApiClient(webClient);
    }

    @Test
    void getUser_shouldReturnUser_whenFound(WireMockRuntimeInfo wm) {
        // given
        stubFor(get(urlPathEqualTo("/api/users/alice"))
            .willReturn(aResponse()
                .withStatus(200)
                .withHeader("Content-Type", "application/json")
                .withBody("""
                    {
                        "id": "alice",
                        "name": "Alice",
                        "email": "alice@example.com"
                    }
                    """)));

        // when
        User user = client.getUser("alice").block();

        // then
        assertNotNull(user);
        assertEquals("alice", user.getId());
        assertEquals("Alice", user.getName());

        // WireMock 요청 검증
        verify(getRequestedFor(urlPathEqualTo("/api/users/alice"))
            .withHeader("Accept", equalTo("application/json")));
    }

    @Test
    void getUser_shouldThrow_whenNotFound() {
        // given
        stubFor(get(urlPathEqualTo("/api/users/nonexistent"))
            .willReturn(aResponse().withStatus(404)));

        // when / then
        assertThrows(UserNotFoundException.class,
            () -> client.getUser("nonexistent").block());
    }
}

// @SpringBootTest: 전체 애플리케이션 컨텍스트 로드 (통합 테스트)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class FullIntegrationTest {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    void fullFlowTest() {
        ResponseEntity<UserResponse> response = restTemplate.postForEntity(
            "/api/users",
            new CreateUserRequest("Alice", "alice@example.com", 30),
            UserResponse.class
        );
        assertEquals(HttpStatus.CREATED, response.getStatusCode());
    }
}

// @WebMvcTest: Web 레이어만 (Controller, Filter, Interceptor)
@WebMvcTest(UserController.class)
class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean  // Spring Context에 Mock 등록
    private UserService userService;

    @Autowired
    private ObjectMapper objectMapper;

    @Test
    @DisplayName("사용자 생성 API는 201을 반환해야 한다")
    void createUser_shouldReturn201() throws Exception {
        // given
        CreateUserRequest request = new CreateUserRequest("Alice", "alice@example.com", 30);
        UserResponse response = new UserResponse("user-1", "Alice", "alice@example.com",
            LocalDateTime.now());

        when(userService.createUser(any())).thenReturn(response);

        // when / then
        mockMvc.perform(post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(request)))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.id").value("user-1"))
            .andExpect(jsonPath("$.name").value("Alice"))
            .andExpect(jsonPath("$.email").value("alice@example.com"))
            .andDo(print()); // 요청/응답 출력
    }

    @Test
    void createUser_shouldReturn400_whenRequestIsInvalid() throws Exception {
        CreateUserRequest invalidRequest = new CreateUserRequest("", "invalid-email", -1);

        mockMvc.perform(post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(invalidRequest)))
            .andExpect(status().isBadRequest())
            .andExpect(jsonPath("$.errors").isArray());
    }
}

// @DataJpaTest: JPA 관련 컴포넌트만 (Repository, Entity)
@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private TestEntityManager entityManager;

    @Test
    @Transactional
    void findByEmail_shouldReturnUser_whenExists() {
        // given - 테스트 데이터 직접 저장
        User user = entityManager.persist(new User(null, "Alice", "alice@example.com"));
        entityManager.flush();

        // when
        Optional<User> found = userRepository.findByEmail("alice@example.com");

        // then
        assertTrue(found.isPresent());
        assertEquals("Alice", found.get().getName());
    }
}

@SpringBootTest
class MockBeanVsSpyBeanTest {

    @MockBean
    private PaymentGateway paymentGateway;
    // 완전히 모의 객체로 교체 (모든 메서드 기본값 반환)

    @SpyBean
    private NotificationService notificationService;
    // 실제 빈을 spy로 감싸기 (실제 메서드 호출, 일부만 스텁)

    @Test
    void paymentWithSpyNotification() {
        // PaymentGateway는 완전 Mock
        when(paymentGateway.charge(any(), any())).thenReturn(PaymentResult.success("txn-123"));

        // NotificationService는 실제 동작하되 sendSms만 스텁
        doNothing().when(notificationService).sendSms(anyString(), anyString());

        orderService.placeOrder(userId, cartId);

        verify(paymentGateway).charge(eq(userId), any(Money.class));
        verify(notificationService).sendEmail(eq(userId), anyString());
        verify(notificationService).sendSms(eq(userId), anyString());
    }
}

@DataJpaTest
class OrderRepositoryTest {

    @Autowired
    private OrderRepository orderRepository;

    @Test
    @Sql("/test-data/insert-orders.sql")
    @Sql(scripts = "/test-data/cleanup.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)
    void findActiveOrders_shouldReturnCorrectCount() {
        List<Order> activeOrders = orderRepository.findByStatus(OrderStatus.ACTIVE);
        assertEquals(3, activeOrders.size());
    }
}

@SpringBootTest
@Testcontainers
class UserServiceIntegrationTest {

    @Container
    @ServiceConnection  // Spring Boot 3.1+: 자동 설정
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test");

    @Container
    static RedisContainer redis = new RedisContainer("redis:7")
        .withExposedPorts(6379);

    @Autowired
    private UserService userService;

    @Autowired
    private UserRepository userRepository;

    @Test
    @Transactional
    void createUser_shouldPersistToDatabase() {
        // given
        CreateUserRequest request = new CreateUserRequest("Alice", "alice@example.com", 30);

        // when
        UserResponse response = userService.createUser(request);

        // then - 실제 PostgreSQL에서 조회
        Optional<User> persisted = userRepository.findById(response.id());
        assertTrue(persisted.isPresent());
        assertEquals("Alice", persisted.get().getName());
    }
}

// 재사용 가능한 컨테이너 (속도 향상)
public abstract class AbstractIntegrationTest {

    static final PostgreSQLContainer<?> POSTGRES;

    static {
        POSTGRES = new PostgreSQLContainer<>("postgres:16")
            .withReuse(true); // 컨테이너 재사용
        POSTGRES.start();
    }

    @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);
    }
}

@SpringBootTest
@Testcontainers
class OrderEventPublisherTest {

    @Container
    static KafkaContainer kafka = new KafkaContainer(
        DockerImageName.parse("confluentinc/cp-kafka:7.6.0")
    );

    @DynamicPropertySource
    static void kafkaProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.kafka.bootstrap-servers", kafka::getBootstrapServers);
    }

    @Autowired
    private OrderService orderService;

    @Autowired
    private KafkaTemplate<String, OrderEvent> kafkaTemplate;

    @Test
    void orderCreation_shouldPublishEvent() throws Exception {
        // given
        CountDownLatch latch = new CountDownLatch(1);
        AtomicReference<OrderEvent> receivedEvent = new AtomicReference<>();

        // Kafka Consumer 설정
        KafkaConsumer<String, OrderEvent> consumer = createTestConsumer();
        consumer.subscribe(List.of("order-events"));

        // when
        orderService.createOrder(userId, items);

        // then - Kafka 이벤트 수신 확인
        assertTrue(latch.await(10, TimeUnit.SECONDS));
        OrderEvent event = receivedEvent.get();
        assertNotNull(event);
        assertEquals(OrderEventType.CREATED, event.getType());
    }
}

// Step 1: 실패하는 테스트 작성 (RED)
class OrderServiceTest {

    private final OrderRepository orderRepository = new InMemoryOrderRepository();
    private final ProductRepository productRepository = new InMemoryProductRepository();
    private final OrderService orderService = new OrderService(orderRepository, productRepository);

    @BeforeEach
    void setUp() {
        productRepository.save(new Product("prod-1", "노트북", 1_500_000, 10));
        productRepository.save(new Product("prod-2", "마우스", 50_000, 5));
    }

    @Test
    @DisplayName("주문 생성: 재고가 충분할 때 주문이 생성된다")
    void createOrder_shouldSucceed_whenStockIsSufficient() {
        // given
        List<OrderItem> items = List.of(new OrderItem("prod-1", 2));

        // when
        Order order = orderService.createOrder("user-1", items);

        // then
        assertNotNull(order.getId());
        assertEquals(OrderStatus.PENDING, order.getStatus());
        assertEquals(3_000_000, order.getTotalAmount());
        assertEquals(8, productRepository.findById("prod-1").get().getStock());
    }

    @Test
    @DisplayName("주문 생성: 재고 부족 시 예외 발생")
    void createOrder_shouldThrow_whenStockInsufficient() {
        List<OrderItem> items = List.of(new OrderItem("prod-2", 10)); // 재고: 5

        assertThrows(InsufficientStockException.class,
            () -> orderService.createOrder("user-1", items));
    }

    @Test
    @DisplayName("주문 취소: PENDING 상태에서 취소 가능")
    void cancelOrder_shouldSucceed_whenPending() {
        Order order = orderService.createOrder("user-1",
            List.of(new OrderItem("prod-1", 1)));

        orderService.cancelOrder(order.getId(), "user-1");

        Order cancelled = orderRepository.findById(order.getId()).orElseThrow();
        assertEquals(OrderStatus.CANCELLED, cancelled.getStatus());
        assertEquals(10, productRepository.findById("prod-1").get().getStock()); // 재고 복구
    }
}

// Step 2: 최소한의 구현 (GREEN)
public class OrderService {
    private final OrderRepository orderRepository;
    private final ProductRepository productRepository;

    public OrderService(OrderRepository orderRepository, ProductRepository productRepository) {
        this.orderRepository = orderRepository;
        this.productRepository = productRepository;
    }

    public Order createOrder(String userId, List<OrderItem> items) {
        // 재고 확인 및 차감
        for (OrderItem item : items) {
            Product product = productRepository.findById(item.productId())
                .orElseThrow(() -> new ResourceNotFoundException("Product", item.productId()));

            if (product.getStock() < item.quantity()) {
                throw new InsufficientStockException(item.productId(), item.quantity(), product.getStock());
            }
        }

        // 재고 차감 (도메인 로직)
        int totalAmount = 0;
        for (OrderItem item : items) {
            Product product = productRepository.findById(item.productId()).orElseThrow();
            productRepository.save(product.decreaseStock(item.quantity()));
            totalAmount += product.getPrice() * item.quantity();
        }

        // 주문 생성 및 저장
        Order order = new Order(null, userId, items, totalAmount, OrderStatus.PENDING, LocalDateTime.now());
        return orderRepository.save(order);
    }

    public void cancelOrder(String orderId, String userId) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new ResourceNotFoundException("Order", orderId));

        if (!order.getUserId().equals(userId)) throw new UnauthorizedException("Not your order");
        if (order.getStatus() != OrderStatus.PENDING) throw new InvalidOrderStateException("Cannot cancel");

        // 재고 복구
        for (OrderItem item : order.getItems()) {
            Product product = productRepository.findById(item.productId()).orElseThrow();
            productRepository.save(product.increaseStock(item.quantity()));
        }

        orderRepository.save(order.withStatus(OrderStatus.CANCELLED));
    }
}

import com.tngtech.archunit.junit.AnalyzeClasses;
import com.tngtech.archunit.junit.ArchTest;
import com.tngtech.archunit.lang.ArchRule;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.*;
import static com.tngtech.archunit.library.Architectures.layeredArchitecture;

@AnalyzeClasses(packages = "com.example.app")
class ArchitectureTest {

    @ArchTest
    static final ArchRule layerDependencies = layeredArchitecture()
        .consideringAllDependencies()
        .layer("Controller").definedBy("..controller..")
        .layer("Service").definedBy("..service..")
        .layer("Repository").definedBy("..repository..")
        .layer("Domain").definedBy("..domain..")
        .whereLayer("Controller").mayOnlyBeAccessedByLayers("Controller")
        .whereLayer("Service").mayOnlyBeAccessedByLayers("Controller", "Service")
        .whereLayer("Repository").mayOnlyBeAccessedByLayers("Service")
        .whereLayer("Domain").mayOnlyBeAccessedByLayers("Controller", "Service", "Repository");

    @ArchTest
    static final ArchRule servicesShouldNotDependOnControllers =
        noClasses().that().resideInAPackage("..service..")
            .should().dependOnClassesThat().resideInAPackage("..controller..");

    @ArchTest
    static final ArchRule repositoriesShouldBeInterfaces =
        classes().that().resideInAPackage("..repository..")
            .and().haveSimpleNameEndingWith("Repository")
            .should().beInterfaces();

    @ArchTest
    static final ArchRule servicesShouldBeAnnotated =
        classes().that().resideInAPackage("..service.impl..")
            .should().beAnnotatedWith(Service.class);

    @ArchTest
    static final ArchRule noCyclicDependencies =
        slices().matching("com.example.app.(*)..")
            .should().beFreeOfCycles();
}