@SpringBootTest 심화 — 슬라이스 테스트와 통합 테스트 사이의 선택 기준

@SpringBootTest
class OrderServiceIntegrationTest {

    @Autowired
    private OrderService orderService;

    @Autowired
    private OrderRepository orderRepository;

    @Test
    void 주문_생성부터_저장까지_전체_흐름을_검증한다() {
        // 서비스 → 리포지토리 → DB까지 실제로 동작
        OrderRequest request = new OrderRequest("상품A", 2);
        Order order = orderService.createOrder(request);

        assertThat(order.getId()).isNotNull();
        assertThat(orderRepository.findById(order.getId())).isPresent();
    }
}

// 실제 서버를 띄워서 테스트 — HTTP 통신까지 검증하고 싶을 때
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class OrderApiIntegrationTest {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    void 주문_API를_호출하면_201을_반환한다() {
        OrderRequest request = new OrderRequest("상품A", 2);

        ResponseEntity<Order> response = restTemplate.postForEntity(
            "/api/orders", request, Order.class
        );

        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
    }
}

// 웹 환경이 필요 없는 서비스 계층 통합 테스트
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.NONE)
class PaymentServiceIntegrationTest {

    @Autowired
    private PaymentService paymentService;

    @Test
    void 결제_처리_흐름을_검증한다() {
        PaymentResult result = paymentService.process(new PaymentRequest(10000));
        assertThat(result.isSuccess()).isTrue();
    }
}

// 컨트롤러만 테스트 — Service는 Mock으로 대체
@WebMvcTest(OrderController.class)
class OrderControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private OrderService orderService;

    @Test
    void 주문_조회_요청이_200을_반환한다() throws Exception {
        given(orderService.findById(1L))
            .willReturn(new OrderResponse(1L, "상품A", 2));

        mockMvc.perform(get("/api/orders/1"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.productName").value("상품A"));
    }
}

// Repository만 테스트 — 내장 H2 DB 사용
@DataJpaTest
class OrderRepositoryTest {

    @Autowired
    private TestEntityManager entityManager;

    @Autowired
    private OrderRepository orderRepository;

    @Test
    void 상태별_주문을_조회한다() {
        // TestEntityManager로 테스트 데이터 직접 삽입
        entityManager.persist(new Order("상품A", OrderStatus.COMPLETED));
        entityManager.persist(new Order("상품B", OrderStatus.PENDING));
        entityManager.flush();

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

        assertThat(completed).hasSize(1);
        assertThat(completed.get(0).getProductName()).isEqualTo("상품A");
    }
}

// JSON 직렬화만 테스트
@JsonTest
class OrderResponseJsonTest {

    @Autowired
    private JacksonTester<OrderResponse> json;

    @Test
    void 주문_응답이_올바르게_직렬화된다() throws Exception {
        OrderResponse response = new OrderResponse(1L, "상품A", 2);

        assertThat(json.write(response))
            .extractingJsonPathStringValue("$.productName")
            .isEqualTo("상품A");
    }
}

// 이 두 테스트는 같은 컨텍스트를 공유한다 (설정이 동일)
@SpringBootTest
class OrderServiceTest { /* ... */ }

@SpringBootTest
class PaymentServiceTest { /* ... */ }

// 이 테스트는 새 컨텍스트를 생성한다 (프로파일이 다름)
@SpringBootTest
@ActiveProfiles("test")
class OrderServiceTest { /* ... */ }

@SpringBootTest
@ActiveProfiles("integration")  // 다른 프로파일 → 새 컨텍스트!
class PaymentServiceTest { /* ... */ }

// 나쁜 예: MockBean 조합이 달라서 컨텍스트가 각각 생성됨
@SpringBootTest
class Test1 {
    @MockBean private ServiceA serviceA;  // 컨텍스트 #1
}

@SpringBootTest
class Test2 {
    @MockBean private ServiceB serviceB;  // 컨텍스트 #2
}

// 좋은 예: 공통 베이스 클래스로 MockBean 조합 통일
@SpringBootTest
abstract class BaseIntegrationTest {
    @MockBean protected ServiceA serviceA;
    @MockBean protected ServiceB serviceB;
}

class Test1 extends BaseIntegrationTest { /* ... */ }  // 같은 컨텍스트
class Test2 extends BaseIntegrationTest { /* ... */ }  // 같은 컨텍스트

        /  E2E  \          ← 가장 적게 (Selenium, Playwright)
       /----------\
      / 통합 테스트  \       ← 적당히 (@SpringBootTest)
     /--------------\
    / 슬라이스 테스트  \     ← 많이 (@WebMvcTest, @DataJpaTest)
   /------------------\
  /    단위 테스트      \    ← 가장 많이 (Mockito, JUnit)
 /----------------------\

내가 테스트하려는 것이 뭔가?
│
├─ 순수 비즈니스 로직 → 단위 테스트 (Mockito)
│   예: 할인 계산, 유효성 검증, 상태 변환
│
├─ 컨트롤러의 요청/응답 매핑 → @WebMvcTest
│   예: URL 매핑, 유효성 검증 응답, JSON 변환
│
├─ JPA 쿼리가 의도대로 동작하는지 → @DataJpaTest
│   예: 커스텀 쿼리, @Query 메서드, 페이징
│
├─ JSON 직렬화/역직렬화 → @JsonTest
│   예: 날짜 포맷, @JsonIgnore, 커스텀 직렬화기
│
├─ 외부 API 클라이언트 → @RestClientTest
│   예: RestTemplate/WebClient 호출, 에러 처리
│
└─ 여러 계층이 함께 동작하는 흐름 → @SpringBootTest
    예: 주문 생성 → 재고 차감 → 알림 발송

// 비즈니스 로직은 단위 테스트로 충분하다
class DiscountCalculatorTest {

    private DiscountCalculator calculator = new DiscountCalculator();

    @Test
    void VIP_회원은_10퍼센트_할인을_받는다() {
        // Spring 컨텍스트 없이 순수 자바로 테스트
        Money discounted = calculator.calculate(
            Money.of(10000), MemberGrade.VIP
        );
        assertThat(discounted).isEqualTo(Money.of(9000));
    }
}

// 여러 계층의 흐름을 검증할 때만 @SpringBootTest
@SpringBootTest
@Transactional
class OrderFlowIntegrationTest {

    @Autowired private OrderService orderService;
    @Autowired private StockRepository stockRepository;

    @Test
    void 주문_생성_시_재고가_차감된다() {
        // 서비스 → 리포지토리 → DB 전체 흐름 검증
        stockRepository.save(new Stock("상품A", 10));

        orderService.createOrder(new OrderRequest("상품A", 3));

        Stock stock = stockRepository.findByProductName("상품A");
        assertThat(stock.getQuantity()).isEqualTo(7);
    }
}

// 특정 설정 클래스만 로드 — 전체보다 빠름
@SpringBootTest(classes = {OrderConfig.class, PaymentConfig.class})
class PartialContextTest { /* ... */ }

// 프로퍼티 오버라이드
@SpringBootTest(properties = {
    "spring.datasource.url=jdbc:h2:mem:testdb",
    "external.api.url=http://localhost:8089"
})
class PropertyOverrideTest { /* ... */ }

// 특정 Auto-Configuration 제외
@SpringBootTest
@EnableAutoConfiguration(exclude = SecurityAutoConfiguration.class)
class WithoutSecurityTest { /* ... */ }

주문 도메인 테스트 구성:
├── 단위 테스트 (70%)
│   ├── OrderTest.java            — 주문 엔티티 비즈니스 로직
│   ├── DiscountPolicyTest.java   — 할인 정책 계산
│   └── OrderValidatorTest.java   — 주문 유효성 검증
│
├── 슬라이스 테스트 (20%)
│   ├── OrderControllerTest.java  — @WebMvcTest
│   ├── OrderRepositoryTest.java  — @DataJpaTest
│   └── OrderResponseTest.java    — @JsonTest
│
└── 통합 테스트 (10%)
    └── OrderFlowTest.java        — @SpringBootTest