dependencies {
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.beans.factory.annotation.Autowired;

@SpringBootTest
@AutoConfigureMockMvc
class PurchaseControllerTest {

    @Autowired
    private MockMvc mockMvc; // API 테스트를 위한 핵심 객체
    
    @Autowired
    private ObjectMapper objectMapper; // 객체를 JSON 문자열로 변환하기 위한 객체

    // ... 테스트 메서드 작성
}

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.sparta.bootcamp.java_2_example.domain.purchase.dto.PurchaseProductRequestTest;
import com.sparta.bootcamp.java_2_example.domain.purchase.dto.PurchaseRequestTest;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.MediaType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

@SpringBootTest
@AutoConfigureMockMvc
class PurchaseControllerTest {

  @Autowired
  private MockMvc mockMvc; // API 테스트를 위한 핵심 객체

  @Autowired
  private ObjectMapper objectMapper; // 객체를 JSON 문자열로 변환하기 위한 객체

  // 구매 생성 성공 테스트
  @Test
  void testCreatePurchase_Success() throws Exception {
  
    // given: 테스트에 사용할 요청 DTO와 JSON Body 준비
    List<PurchaseProductRequestTest> purchaseProductRequestTests = new ArrayList<>();
    PurchaseProductRequestTest purchaseProductRequestTest = new PurchaseProductRequestTest(1L, 10);
    purchaseProductRequestTests.add(purchaseProductRequestTest);

    PurchaseRequestTest request = new PurchaseRequestTest(1L, purchaseProductRequestTests);

    String requestBody = new ObjectMapper().writeValueAsString(request);

    // when & then: API를 호출하고 응답을 검증
    mockMvc.perform(post("/api/purchases")                          // 1. HTTP POST 요청을 /api/purchases 로 보냄
            .contentType(MediaType.APPLICATION_JSON.toString())     // 2. 요청의 Content-Type을 JSON으로 설정
            .content(requestBody)                                   // 3. 요청 Body에 JSON 데이터 추가
            .accept(MediaType.APPLICATION_JSON.toString()))         // 4. 클라이언트가 JSON 응답을 기대함을 명시
        .andExpect(status().is(200))                                // 5. 응답 상태 코드가 200 Created 인지 검증
        .andExpect(jsonPath("$.result").value(true));               // 6. 응답 Body의 result 필드가 true인지 검증
  }
}

  @Test
  void testCreatePurchase_Fail_MissingUserId() throws Exception {
    // given: userId가 null인 요청 DTO
    List<PurchaseProductRequestTest> purchaseProductRequestTests = new ArrayList<>();
    PurchaseProductRequestTest purchaseProductRequestTest = new PurchaseProductRequestTest(1L, 10);
    purchaseProductRequestTests.add(purchaseProductRequestTest);

    PurchaseRequestTest request = new PurchaseRequestTest(10L, null);

    String requestBody = new ObjectMapper().writeValueAsString(request);

    // when & then
    mockMvc.perform(post("/api/purchases")
            .contentType(MediaType.APPLICATION_JSON.toString())
            .content(requestBody))
        .andExpect(jsonPath("$.error.errorCode").value("NOT_FOUND_USER"));
  }

  @Test
  void testCreatePurchase_Fail_InsufficientStock() throws Exception {
    // given: 재고(예: 5개)보다 많은 수량(예: 10개)을 주문하는 DTO
    List<PurchaseProductRequestTest> purchaseProductRequestTests = new ArrayList<>();
    PurchaseProductRequestTest purchaseProductRequestTest = new PurchaseProductRequestTest(1L,
        1000);
    purchaseProductRequestTests.add(purchaseProductRequestTest);

    PurchaseRequestTest request = new PurchaseRequestTest(1L, purchaseProductRequestTests);

    String requestBody = new ObjectMapper().writeValueAsString(request);

    // when & then
    mockMvc.perform(post("/api/purchases")
            .contentType(MediaType.APPLICATION_JSON.toString())
            .content(requestBody))
        .andExpect(jsonPath("$.error.errorCode").value("OUT_OF_STOCK_PRODUCT"));
  }

dependencies {
    testImplementation 'io.rest-assured:rest-assured:5.4.0'
}

import io.restassured.RestAssured;
import org.junit.jupiter.api.BeforeEach;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.server.LocalServerPort;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class PurchaseControllerRestAssuredTest {

    @LocalServerPort
    private int port; // 실행된 서버의 포트 번호를 주입받음

    @BeforeEach
    void setUp() {
        // 모든 테스트 실행 전, Rest Assured가 요청을 보낼 포트를 설정
        RestAssured.port = port;
    }
    
    // ... 테스트 메서드 작성
}

  @Test
  void testCreatePurchase_Success() {
    // given: 요청 Body 준비
    String requestBody = """
        {
            "userId": 1,
            "products": [
                {
                    "productId": 1,
                    "quantity": 5
                }
            ]
        }
        """;

    // when & then
    RestAssured.given().log().all()                 // (요청 로깅)
        .contentType(ContentType.JSON)              // 요청 헤더의 Content-Type 설정
        .body(requestBody)                          // 요청 Body 데이터 추가
        .when()
        .post("/api/purchases")                     // POST 요청 실행
        .then().log().all()                         // (응답 로깅)
        .statusCode(200)                            // 응답 상태 코드가 200 인지 검증
        .body("result", equalTo(true));             // 응답 Body의 'result' 필드 값이 true인지 검증
  }

  @Test
  void testCreatePurchase_Fail_MissingUserId() {
    // given: userId가 없는 요청 Body
    String requestBody = """
        {
            "userId": null,
            "products": [
                {
                    "productId": 1,
                    "quantity": 5
                }
            ]
        }
        """;

    // when & then
    RestAssured.given()
        .contentType(ContentType.JSON)
        .body(requestBody)
        .when()
        .post("/api/purchases")
        .then()
        .statusCode(400) // 400 Bad Request 검증
        .body("error.errorCode", equalTo("VALIDATE_ERROR"));
  }

 @Test
  void testCreatePurchase_Fail_InsufficientStock() {
    // given: 재고보다 많은 수량을 주문하는 요청 Body
    String requestBody = """
        {
            "userId": 1,
            "products": [
                {
                    "productId": 1,
                    "quantity": 100000
                }
            ]
        }
        """;

    // when & then
    RestAssured.given()
        .contentType(ContentType.JSON)
        .body(requestBody)
        .when()
        .post("/api/purchases")
        .then()
        .statusCode(200)
        .body("error.errorCode", equalTo("OUT_OF_STOCK_PRODUCT"));
  }

  @Test
  @DisplayName("재고가 충분한 상품을 구매하면 재고가 감소하고 구매가 성공한다")
  void process_should_decreaseStockAndSucceed_when_productInStock_aaa() {
    // Arrange
    PurchaseProductRequest purchaseItem = new PurchaseProductRequest();
    ReflectionTestUtils.setField(purchaseItem, "productId", 1L);
    ReflectionTestUtils.setField(purchaseItem, "quantity", 2);

    List<PurchaseProductRequest> purchaseItems = List.of(purchaseItem);

    when(productRepository.findById(1L)).thenReturn(Optional.of(testProduct));
    when(purchaseRepository.save(any(Purchase.class))).thenReturn(testPurchase);
    when(purchaseProductRepository.saveAll(anyList())).thenReturn(Collections.emptyList());

    // Act
    Purchase result = purchaseProcessService.process(testUser, purchaseItems);

    // Assert
    assertThat(result).isNotNull();
    assertThat(result.getTotalPrice()).isEqualTo(new BigDecimal("2000000")); // 1,000,000 * 2
    assertThat(testProduct.getStock()).isEqualTo(8); // 10 - 2

    verify(productRepository).findById(1L);
    verify(purchaseRepository).save(any(Purchase.class));
    verify(purchaseProductRepository).saveAll(anyList());
  }

  @Test
  @DisplayName("재고가 충분한 상품을 구매하면 재고가 감소하고 구매가 성공한다")
  void process_should_decreaseStockAndSucceed_when_productInStock_gwt() {
    // Given
    PurchaseProductRequest purchaseItem = new PurchaseProductRequest();
    ReflectionTestUtils.setField(purchaseItem, "productId", 1L);
    ReflectionTestUtils.setField(purchaseItem, "quantity", 2);

    List<PurchaseProductRequest> purchaseItems = List.of(purchaseItem);

    when(productRepository.findById(1L)).thenReturn(Optional.of(testProduct));
    when(purchaseRepository.save(any(Purchase.class))).thenReturn(testPurchase);
    when(purchaseProductRepository.saveAll(anyList())).thenReturn(Collections.emptyList());

    // When
    Purchase result = purchaseProcessService.process(testUser, purchaseItems);

    // Then
    assertThat(result).isNotNull();
    assertThat(result.getTotalPrice()).isEqualTo(new BigDecimal("2000000")); // 1,000,000 * 2
    assertThat(testProduct.getStock()).isEqualTo(8); // 10 - 2

    verify(productRepository).findById(1L);
    verify(purchaseRepository).save(any(Purchase.class));
    verify(purchaseProductRepository).saveAll(anyList());
  }

dependencies {
    // spring-boot-starter-test가 mockito-core를 포함
    testImplementation 'org.springframework.boot:spring-boot-starter-test' 

    // JUnit 5와 Mockito를 통합해주는 라이브러리 (권장)
    testImplementation 'org.mockito:mockito-junit-jupiter:5.12.0' // 최신 버전 사용 권장
}

import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)  // @SpringBootTest 대신 사용
class PurchaseProcessServiceTest {

  @InjectMocks
  private PurchaseProcessService purchaseProcessService;

  @Mock
  private PurchaseRepository purchaseRepository;

  @Mock
  private ProductRepository productRepository;

  @Mock
  private PurchaseProductRepository purchaseProductRepository;

    // ... 테스트 메서드 작성
}

@Service
@RequiredArgsConstructor
public class PurchaseProcessService {

  private final PurchaseRepository purchaseRepository;
  private final ProductRepository productRepository;
  private final PurchaseProductRepository purchaseProductRepository;
  private final UserRepository userRepository;

  @Transactional
  public Purchase process(User user, List<PurchaseProductRequest> purchaseItems) {
    // 이제 purchase 메서드는 "무엇을 하는지" 명확히 보여준다.
    Purchase purchase = createAndSavePurchase(user);
    List<PurchaseProduct> purchaseProducts = createAndProcessPurchaseProducts(purchaseItems,
        purchase);
    BigDecimal totalPrice = calculateTotalPrice(purchaseProducts);

    purchase.setTotalPrice(totalPrice);
    return purchase;
  }
  
//...  

}

ReflectionTestUtils.setField(testUser, "id", 1L);

testProduct = Product.builder()
    .name("노트북")
    .price(new BigDecimal("1000000"))
    .stock(10)
    .build();

ReflectionTestUtils.setField(testProduct, "id", 1L);

testPurchase = Purchase.builder()
    .user(testUser)
    .totalPrice(BigDecimal.ZERO)
    .status(PurchaseStatus.PENDING)
    .build();

ReflectionTestUtils.setField(testPurchase, "id", 1L);   } } ~~~ **테스트 1: 재고가 충분한 상품을 구매하면 재고가 감소하고 구매가 성공한다**