Spring Boot Testing

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {

    @Mock
    private OrderRepository orderRepository;

    @Mock
    private PaymentGateway paymentGateway;

    @Mock
    private InventoryService inventoryService;

    @InjectMocks
    private OrderService orderService;

    @Test
    void should_createOrder_when_paymentSucceeds() {
        // Given
        OrderRequest request = new OrderRequest("user-1", List.of("SKU-001", "SKU-002"), 
            new BigDecimal("149.99"));
        when(inventoryService.checkAvailability(anyList())).thenReturn(true);
        when(paymentGateway.authorize(any(), any()))
            .thenReturn(new PaymentResult("pay-123", PaymentStatus.AUTHORIZED));
        when(orderRepository.save(any(Order.class)))
            .thenAnswer(inv -> {
                Order o = inv.getArgument(0);
                o.setId("order-001");
                return o;
            });

        // When
        Order result = orderService.createOrder(request);

        // Then
        assertThat(result.getId()).isEqualTo("order-001");
        assertThat(result.getStatus()).isEqualTo(OrderStatus.CONFIRMED);
        verify(paymentGateway).authorize(eq("user-1"), eq(new BigDecimal("149.99")));
        verify(inventoryService).reserve(eq(List.of("SKU-001", "SKU-002")));
    }

    @Test
    void should_throwException_when_paymentDeclined() {
        // Given
        OrderRequest request = new OrderRequest("user-1", List.of("SKU-001"), BigDecimal.TEN);
        when(inventoryService.checkAvailability(anyList())).thenReturn(true);
        when(paymentGateway.authorize(any(), any()))
            .thenReturn(new PaymentResult(null, PaymentStatus.DECLINED));

        // When / Then
        assertThatThrownBy(() -> orderService.createOrder(request))
            .isInstanceOf(PaymentDeclinedException.class)
            .hasMessageContaining("Payment declined for user: user-1");

        verify(orderRepository, never()).save(any());
        verify(inventoryService, never()).reserve(anyList());
    }

    @Test
    void should_throwException_when_itemsOutOfStock() {
        // Given
        OrderRequest request = new OrderRequest("user-1", List.of("SKU-999"), BigDecimal.TEN);
        when(inventoryService.checkAvailability(List.of("SKU-999"))).thenReturn(false);

        // When / Then
        assertThatThrownBy(() -> orderService.createOrder(request))
            .isInstanceOf(OutOfStockException.class);

        verify(paymentGateway, never()).authorize(any(), any());
    }
}

@Test
void should_saveOrderWithCorrectTimestamp() {
    // Given
    OrderRequest request = new OrderRequest("user-1", List.of("SKU-001"), BigDecimal.TEN);
    when(inventoryService.checkAvailability(anyList())).thenReturn(true);
    when(paymentGateway.authorize(any(), any()))
        .thenReturn(new PaymentResult("pay-1", PaymentStatus.AUTHORIZED));
    when(orderRepository.save(any())).thenAnswer(inv -> inv.getArgument(0));

    ArgumentCaptor<Order> orderCaptor = ArgumentCaptor.forClass(Order.class);

    // When
    orderService.createOrder(request);

    // Then
    verify(orderRepository).save(orderCaptor.capture());
    Order savedOrder = orderCaptor.getValue();
    assertThat(savedOrder.getCreatedAt()).isCloseTo(Instant.now(), within(1, ChronoUnit.SECONDS));
    assertThat(savedOrder.getUserId()).isEqualTo("user-1");
    assertThat(savedOrder.getItems()).containsExactly("SKU-001");
}

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@ActiveProfiles("test")
class OrderFlowIntegrationTest {

    @Autowired
    private TestRestTemplate restTemplate;

    @Autowired
    private OrderRepository orderRepository;

    @BeforeEach
    void cleanup() {
        orderRepository.deleteAll();
    }

    @Test
    void should_createAndRetrieveOrder_fullFlow() {
        // Create order
        OrderRequest request = new OrderRequest("user-1", List.of("SKU-001"), 
            new BigDecimal("29.99"));

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

        assertThat(createResponse.getStatusCode()).isEqualTo(HttpStatus.CREATED);
        assertThat(createResponse.getBody().getId()).isNotNull();

        // Retrieve order
        String orderId = createResponse.getBody().getId();
        ResponseEntity<Order> getResponse = restTemplate.getForEntity(
            "/api/orders/" + orderId, Order.class);

        assertThat(getResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
        assertThat(getResponse.getBody().getAmount()).isEqualByComparingTo("29.99");
        assertThat(getResponse.getBody().getStatus()).isEqualTo(OrderStatus.CONFIRMED);
    }
}

@WebMvcTest(OrderController.class)
class OrderControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private OrderService orderService;

    // --- Happy Path ---

    @Test
    void should_returnOrder_when_exists() throws Exception {
        Order order = new Order("order-1", "user-1", new BigDecimal("49.99"));
        order.setStatus(OrderStatus.CONFIRMED);
        when(orderService.findById("order-1")).thenReturn(order);

        mockMvc.perform(get("/api/orders/order-1")
                .accept(MediaType.APPLICATION_JSON))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.id").value("order-1"))
            .andExpect(jsonPath("$.userId").value("user-1"))
            .andExpect(jsonPath("$.amount").value(49.99))
            .andExpect(jsonPath("$.status").value("CONFIRMED"));
    }

    @Test
    void should_returnPaginatedOrders_when_queryParams() throws Exception {
        Page<Order> page = new PageImpl<>(
            List.of(new Order("o-1", "user-1", BigDecimal.TEN)),
            PageRequest.of(0, 20), 1);
        when(orderService.findByUser(eq("user-1"), any(Pageable.class))).thenReturn(page);

        mockMvc.perform(get("/api/orders")
                .param("userId", "user-1")
                .param("page", "0")
                .param("size", "20"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.content").isArray())
            .andExpect(jsonPath("$.content.length()").value(1))
            .andExpect(jsonPath("$.totalElements").value(1));
    }

    // --- Validation ---

    @Test
    void should_return400_when_requestBodyInvalid() throws Exception {
        String invalidBody = """
            {
                "userId": "",
                "items": [],
                "amount": -5
            }
            """;

        mockMvc.perform(post("/api/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content(invalidBody))
            .andExpect(status().isBadRequest())
            .andExpect(jsonPath("$.errors.userId").value("must not be blank"))
            .andExpect(jsonPath("$.errors.items").value("must not be empty"))
            .andExpect(jsonPath("$.errors.amount").value("must be greater than 0"));
    }

    // --- Error Handling ---

    @Test
    void should_return404_when_orderNotFound() throws Exception {
        when(orderService.findById("nope"))
            .thenThrow(new OrderNotFoundException("nope"));

        mockMvc.perform(get("/api/orders/nope"))
            .andExpect(status().isNotFound())
            .andExpect(jsonPath("$.message").value("Order not found: nope"))
            .andExpect(jsonPath("$.timestamp").exists());
    }

    @Test
    void should_return409_when_duplicateOrder() throws Exception {
        String body = """
            {"userId":"user-1","items":["SKU-001"],"amount":10.00}
            """;
        when(orderService.createOrder(any()))
            .thenThrow(new DuplicateOrderException("Idempotency key already used"));

        mockMvc.perform(post("/api/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content(body)
                .header("Idempotency-Key", "key-123"))
            .andExpect(status().isConflict());
    }

    // --- Response Headers ---

    @Test
    void should_returnLocationHeader_when_orderCreated() throws Exception {
        String body = """
            {"userId":"user-1","items":["SKU-001"],"amount":29.99}
            """;
        when(orderService.createOrder(any()))
            .thenReturn(new Order("order-new", "user-1", new BigDecimal("29.99")));

        mockMvc.perform(post("/api/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content(body))
            .andExpect(status().isCreated())
            .andExpect(header().string("Location", "/api/orders/order-new"));
    }
}

@DataJpaTest
@ActiveProfiles("test")
class OrderRepositoryTest {

    @Autowired
    private OrderRepository orderRepository;

    @Autowired
    private TestEntityManager entityManager;

    @Test
    void should_findOrdersByUserId() {
        // Given
        entityManager.persist(new Order(null, "user-1", new BigDecimal("10.00"), OrderStatus.CONFIRMED));
        entityManager.persist(new Order(null, "user-1", new BigDecimal("20.00"), OrderStatus.SHIPPED));
        entityManager.persist(new Order(null, "user-2", new BigDecimal("30.00"), OrderStatus.CONFIRMED));
        entityManager.flush();

        // When
        List<Order> orders = orderRepository.findByUserId("user-1");

        // Then
        assertThat(orders).hasSize(2);
        assertThat(orders).extracting(Order::getUserId).containsOnly("user-1");
    }

    @Test
    void should_findHighValueOrdersByStatus() {
        // Given — testing a custom @Query
        entityManager.persist(new Order(null, "user-1", new BigDecimal("500.00"), OrderStatus.CONFIRMED));
        entityManager.persist(new Order(null, "user-2", new BigDecimal("50.00"), OrderStatus.CONFIRMED));
        entityManager.persist(new Order(null, "user-3", new BigDecimal("1000.00"), OrderStatus.CANCELLED));
        entityManager.flush();

        // When
        List<Order> highValue = orderRepository.findByAmountGreaterThanAndStatus(
            new BigDecimal("100.00"), OrderStatus.CONFIRMED);

        // Then
        assertThat(highValue).hasSize(1);
        assertThat(highValue.get(0).getAmount()).isEqualByComparingTo("500.00");
    }

    @Test
    void should_enforceUniqueConstraint() {
        // Given
        entityManager.persist(new Order(null, "user-1", BigDecimal.TEN, OrderStatus.CONFIRMED));
        entityManager.flush();

        // When / Then — duplicate order reference
        Order duplicate = new Order(null, "user-1", BigDecimal.TEN, OrderStatus.CONFIRMED);
        duplicate.setReferenceId("REF-001"); // same as first order (set in @PrePersist)

        assertThatThrownBy(() -> {
            entityManager.persist(duplicate);
            entityManager.flush();
        }).isInstanceOf(PersistenceException.class);
    }
}

@DataJpaTest
@Sql(scripts = "/sql/orders-test-data.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD)
@Sql(scripts = "/sql/cleanup.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)
class OrderReportRepositoryTest {

    @Autowired
    private OrderRepository orderRepository;

    @Test
    void should_calculateRevenueByMonth() {
        // Test data loaded from SQL script — complex scenarios easier in SQL
        BigDecimal januaryRevenue = orderRepository.calculateRevenueForMonth(2025, 1);
        assertThat(januaryRevenue).isEqualByComparingTo("15249.97");
    }
}

@SpringBootTest
@Testcontainers
@ActiveProfiles("test")
class OrderServicePostgresTest {

    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16-alpine")
        .withDatabaseName("orders_test")
        .withUsername("test")
        .withPassword("test");

    @DynamicPropertySource
    static void configureDataSource(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 OrderService orderService;

    @Autowired
    private OrderRepository orderRepository;

    @Test
    void should_persistJsonbMetadata() {
        // This would FAIL on H2 — JSONB is Postgres-specific
        Order order = orderService.createOrderWithMetadata(
            new OrderRequest("user-1", List.of("SKU-001"), BigDecimal.TEN),
            Map.of("source", "mobile", "campaign", "summer-sale"));

        Order found = orderRepository.findById(order.getId()).orElseThrow();
        assertThat(found.getMetadata()).containsEntry("source", "mobile");
        assertThat(found.getMetadata()).containsEntry("campaign", "summer-sale");
    }

    @Test
    void should_handleConcurrentUpdates() {
        // Testing optimistic locking with real Postgres — H2 behaves differently
        Order order = orderRepository.save(
            new Order(null, "user-1", BigDecimal.TEN, OrderStatus.CONFIRMED));

        assertThatThrownBy(() -> orderService.concurrentUpdate(order.getId()))
            .isInstanceOf(OptimisticLockingFailureException.class);
    }
}

public abstract class AbstractIntegrationTest {

    static final PostgreSQLContainer<?> POSTGRES;
    static final GenericContainer<?> REDIS;

    static {
        POSTGRES = new PostgreSQLContainer<>("postgres:16-alpine")
            .withDatabaseName("testdb")
            .withUsername("test")
            .withPassword("test");
        POSTGRES.start();

        REDIS = new GenericContainer<>("redis:7-alpine")
            .withExposedPorts(6379);
        REDIS.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);
        registry.add("spring.data.redis.host", REDIS::getHost);
        registry.add("spring.data.redis.port", () -> REDIS.getMappedPort(6379));
    }
}

// All test classes extend this — containers started once, reused everywhere
@SpringBootTest
class OrderServiceTest extends AbstractIntegrationTest { ... }

@SpringBootTest
class PaymentServiceTest extends AbstractIntegrationTest { ... }

@SpringBootTest
@Testcontainers
class OrderEventPublisherTest {

    @Container
    static KafkaContainer kafka = new KafkaContainer(
        DockerImageName.parse("confluentinc/cp-kafka:7.5.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 should_publishOrderCreatedEvent() {
        // Given
        Consumer<String, OrderEvent> consumer = createConsumer();
        consumer.subscribe(List.of("order-events"));

        // When
        orderService.createOrder(new OrderRequest("user-1", List.of("SKU-001"), BigDecimal.TEN));

        // Then
        ConsumerRecords<String, OrderEvent> records = consumer.poll(Duration.ofSeconds(10));
        assertThat(records).hasSize(1);
        assertThat(records.iterator().next().value().getType()).isEqualTo("ORDER_CREATED");
    }
}

// @Mock — Unit test, no Spring
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
    @Mock private PaymentGateway paymentGateway;
    @InjectMocks private OrderService orderService;
}

// @MockBean — Replace a real bean in Spring context
@WebMvcTest(OrderController.class)
class OrderControllerTest {
    @MockBean private OrderService orderService; // replaces real OrderService
}

// @SpyBean — Wrap real bean, selectively override
@SpringBootTest
class NotificationTest {
    @SpyBean private EmailService emailService; // real bean, but can verify/stub

    @Test
    void should_sendEmail_when_orderCreated() {
        orderService.createOrder(request);
        verify(emailService).sendOrderConfirmation(any()); // verify real bean was called
    }
}

@SpringBootTest(webEnvironment = RANDOM_PORT)
@WireMockTest(httpPort = 8089)
class PaymentIntegrationTest {

    @Test
    void should_handlePaymentGatewayTimeout() {
        // Simulate external service timeout
        stubFor(post(urlPathEqualTo("/api/payments/authorize"))
            .willReturn(aResponse()
                .withStatus(200)
                .withFixedDelay(5000))); // 5 second delay

        assertThatThrownBy(() -> orderService.createOrder(request))
            .isInstanceOf(PaymentTimeoutException.class);
    }

    @Test
    void should_retryOnGatewayError() {
        // First call fails, second succeeds
        stubFor(post(urlPathEqualTo("/api/payments/authorize"))
            .inScenario("retry")
            .whenScenarioStateIs(STARTED)
            .willReturn(aResponse().withStatus(503))
            .willSetStateTo("RECOVERED"));

        stubFor(post(urlPathEqualTo("/api/payments/authorize"))
            .inScenario("retry")
            .whenScenarioStateIs("RECOVERED")
            .willReturn(aResponse()
                .withStatus(200)
                .withBody("""
                    {"transactionId":"tx-123","status":"AUTHORIZED"}
                    """)));

        Order order = orderService.createOrder(request);
        assertThat(order.getPaymentId()).isEqualTo("tx-123");
    }
}

@WebMvcTest(OrderController.class)
class OrderSecurityTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private OrderService orderService;

    @Test
    @WithMockUser(username = "admin", roles = {"ADMIN"})
    void should_allowAdmin_toDeleteOrder() throws Exception {
        mockMvc.perform(delete("/api/orders/order-1"))
            .andExpect(status().isNoContent());
    }

    @Test
    @WithMockUser(username = "user", roles = {"USER"})
    void should_forbidUser_fromDeletingOrder() throws Exception {
        mockMvc.perform(delete("/api/orders/order-1"))
            .andExpect(status().isForbidden());
    }

    @Test
    void should_return401_when_unauthenticated() throws Exception {
        mockMvc.perform(get("/api/orders"))
            .andExpect(status().isUnauthorized());
    }

    @Test
    @WithMockUser(username = "user-1")
    void should_onlyReturnOwnOrders() throws Exception {
        // Testing method-level security: @PreAuthorize("#userId == authentication.name")
        when(orderService.findByUser("user-1", any())).thenReturn(Page.empty());

        mockMvc.perform(get("/api/orders").param("userId", "user-1"))
            .andExpect(status().isOk());

        mockMvc.perform(get("/api/orders").param("userId", "user-2"))
            .andExpect(status().isForbidden());
    }
}

@SpringBootTest(webEnvironment = RANDOM_PORT)
class JwtSecurityTest {

    @Autowired
    private WebTestClient webTestClient;

    @Autowired
    private JwtEncoder jwtEncoder;

    @Test
    void should_acceptValidJwt() {
        String token = generateToken("user-1", "ROLE_USER");

        webTestClient.get().uri("/api/orders")
            .header("Authorization", "Bearer " + token)
            .exchange()
            .expectStatus().isOk();
    }

    @Test
    void should_reject_expiredJwt() {
        String expiredToken = generateExpiredToken("user-1");

        webTestClient.get().uri("/api/orders")
            .header("Authorization", "Bearer " + expiredToken)
            .exchange()
            .expectStatus().isUnauthorized();
    }

    private String generateToken(String subject, String... roles) {
        JwtClaimsSet claims = JwtClaimsSet.builder()
            .subject(subject)
            .claim("roles", List.of(roles))
            .issuedAt(Instant.now())
            .expiresAt(Instant.now().plus(1, ChronoUnit.HOURS))
            .build();
        return jwtEncoder.encode(JwtEncoderParameters.from(claims)).getTokenValue();
    }
}

@Retention(RetentionPolicy.RUNTIME)
@WithSecurityContext(factory = WithMockCustomUserSecurityContextFactory.class)
public @interface WithMockCustomUser {
    String username() default "testuser";
    String[] roles() default {"USER"};
    String tenant() default "default";
}

public class WithMockCustomUserSecurityContextFactory 
        implements WithSecurityContextFactory<WithMockCustomUser> {

    @Override
    public SecurityContext createSecurityContext(WithMockCustomUser annotation) {
        SecurityContext context = SecurityContextHolder.createEmptyContext();
        CustomUserPrincipal principal = new CustomUserPrincipal(
            annotation.username(), annotation.tenant());
        Authentication auth = new UsernamePasswordAuthenticationToken(
            principal, null, 
            Arrays.stream(annotation.roles())
                .map(r -> new SimpleGrantedAuthority("ROLE_" + r))
                .toList());
        context.setAuthentication(auth);
        return context;
    }
}

// Usage
@Test
@WithMockCustomUser(username = "admin", roles = {"ADMIN"}, tenant = "acme-corp")
void should_accessTenantData() throws Exception {
    mockMvc.perform(get("/api/tenant/orders"))
        .andExpect(status().isOk());
}

@SpringBootTest
class AsyncOrderProcessingTest {

    @Autowired
    private OrderService orderService;

    @Autowired
    private OrderRepository orderRepository;

    @Test
    void should_processOrderAsynchronously() {
        // Given
        Order order = orderRepository.save(
            new Order(null, "user-1", BigDecimal.TEN, OrderStatus.PENDING));

        // When — triggers @Async processing
        orderService.processOrderAsync(order.getId());

        // Then — poll until the async operation completes
        await()
            .atMost(Duration.ofSeconds(10))
            .pollInterval(Duration.ofMillis(500))
            .untilAsserted(() -> {
                Order processed = orderRepository.findById(order.getId()).orElseThrow();
                assertThat(processed.getStatus()).isEqualTo(OrderStatus.PROCESSED);
                assertThat(processed.getProcessedAt()).isNotNull();
            });
    }

    @Test
    void should_handleAsyncFailureGracefully() {
        // Given — order with invalid payment that will fail async processing
        Order order = orderRepository.save(
            new Order(null, "user-invalid", BigDecimal.TEN, OrderStatus.PENDING));

        // When
        orderService.processOrderAsync(order.getId());

        // Then
        await()
            .atMost(Duration.ofSeconds(10))
            .untilAsserted(() -> {
                Order failed = orderRepository.findById(order.getId()).orElseThrow();
                assertThat(failed.getStatus()).isEqualTo(OrderStatus.FAILED);
                assertThat(failed.getErrorMessage()).contains("Payment validation failed");
            });
    }
}

@ExtendWith(MockitoExtension.class)
class AsyncServiceTest {

    @Mock
    private ExternalApiClient apiClient;

    @InjectMocks
    private AsyncPricingService pricingService;

    @Test
    void should_aggregatePricesFromMultipleSources() throws Exception {
        // Given
        when(apiClient.fetchPrice("source-1"))
            .thenReturn(CompletableFuture.completedFuture(new BigDecimal("99.99")));
        when(apiClient.fetchPrice("source-2"))
            .thenReturn(CompletableFuture.completedFuture(new BigDecimal("89.99")));
        when(apiClient.fetchPrice("source-3"))
            .thenReturn(CompletableFuture.failedFuture(new TimeoutException()));

        // When
        CompletableFuture<PriceResult> result = pricingService.getBestPrice("SKU-001");

        // Then
        PriceResult priceResult = result.get(5, TimeUnit.SECONDS);
        assertThat(priceResult.getBestPrice()).isEqualByComparingTo("89.99");
        assertThat(priceResult.getSourcesChecked()).isEqualTo(2); // one failed
    }
}

@TestConfiguration
public class TestSecurityConfig {

    @Bean
    @Primary
    public PasswordEncoder testPasswordEncoder() {
        // Fast encoder for tests (bcrypt is intentionally slow)
        return NoOpPasswordEncoder.getInstance();
    }
}

@TestConfiguration
public class TestClockConfig {

    @Bean
    @Primary
    public Clock fixedClock() {
        return Clock.fixed(
            Instant.parse("2025-06-01T10:00:00Z"), 
            ZoneOffset.UTC);
    }
}

// Usage
@SpringBootTest
@Import({TestSecurityConfig.class, TestClockConfig.class})
class TimeBasedOrderTest {
    // tests run with fixed time — deterministic assertions
}

// BAD — tests implementation details
@Test
void should_callRepositorySaveThenPublishEvent() {
    orderService.createOrder(request);
    InOrder inOrder = inOrder(orderRepository, eventPublisher);
    inOrder.verify(orderRepository).save(any());
    inOrder.verify(eventPublisher).publish(any());
    // What if we refactor to use @TransactionalEventListener? Test breaks.
}

// GOOD — tests observable behavior
@Test
void should_persistOrderAndNotifyUser() {
    Order result = orderService.createOrder(request);

    assertThat(orderRepository.findById(result.getId())).isPresent();
    assertThat(notificationService.getNotificationsFor("user-1")).hasSize(1);
}

@Test
void should_applyDiscount_when_orderExceedsThreshold() {
    // Given — setup
    OrderRequest request = OrderRequest.builder()
        .userId("user-1")
        .items(List.of("SKU-EXPENSIVE"))
        .amount(new BigDecimal("500.00"))
        .build();
    when(discountService.getActiveDiscount(any())).thenReturn(Optional.of(PERCENT_10));

    // When — action
    Order order = orderService.createOrder(request);

    // Then — assertion
    assertThat(order.getDiscount()).isEqualByComparingTo("50.00");
    assertThat(order.getFinalAmount()).isEqualByComparingTo("450.00");
}

// Pattern: should_expectedBehavior_when_stateOrCondition
void should_createOrder_when_allItemsInStock()
void should_throwPaymentException_when_cardDeclined()
void should_applyFreeShipping_when_orderAbove100()
void should_return404_when_orderNotFound()
void should_retryPayment_when_gatewayTimesOut()

@JsonTest
class OrderJsonTest {

    @Autowired
    private JacksonTester<Order> json;

    @Test
    void should_serializeOrder() throws Exception {
        Order order = new Order("order-1", "user-1", new BigDecimal("29.99"));
        order.setStatus(OrderStatus.CONFIRMED);
        order.setCreatedAt(Instant.parse("2025-06-01T10:00:00Z"));

        JsonContent<Order> result = json.write(order);

        assertThat(result).extractingJsonPathStringValue("$.id").isEqualTo("order-1");
        assertThat(result).extractingJsonPathNumberValue("$.amount").isEqualTo(29.99);
        assertThat(result).extractingJsonPathStringValue("$.status").isEqualTo("CONFIRMED");
        assertThat(result).extractingJsonPathStringValue("$.createdAt")
            .isEqualTo("2025-06-01T10:00:00Z");
        // Verify sensitive fields are NOT serialized
        assertThat(result).doesNotHaveJsonPath("$.internalNotes");
    }

    @Test
    void should_deserializeOrder() throws Exception {
        String content = """
            {
                "id": "order-1",
                "userId": "user-1",
                "amount": 29.99,
                "status": "CONFIRMED"
            }
            """;

        Order order = json.parse(content).getObject();
        assertThat(order.getId()).isEqualTo("order-1");
        assertThat(order.getAmount()).isEqualByComparingTo("29.99");
    }

    @Test
    void should_handleUnknownFieldsGracefully() throws Exception {
        // API evolution — client sends fields we don't know about
        String content = """
            {
                "id": "order-1",
                "userId": "user-1",
                "amount": 29.99,
                "newFieldFromV2": "something"
            }
            """;

        assertThatCode(() -> json.parse(content))
            .doesNotThrowAnyException();
    }
}

@RestClientTest(PaymentGatewayClient.class)
class PaymentGatewayClientTest {

    @Autowired
    private PaymentGatewayClient client;

    @Autowired
    private MockRestServiceServer server;

    @Test
    void should_authorizePayment() {
        server.expect(requestTo("/api/payments/authorize"))
            .andExpect(method(HttpMethod.POST))
            .andExpect(jsonPath("$.amount").value(29.99))
            .andRespond(withSuccess("""
                {"transactionId":"tx-123","status":"AUTHORIZED"}
                """, MediaType.APPLICATION_JSON));

        PaymentResult result = client.authorize("user-1", new BigDecimal("29.99"));

        assertThat(result.getTransactionId()).isEqualTo("tx-123");
        assertThat(result.getStatus()).isEqualTo(PaymentStatus.AUTHORIZED);
        server.verify();
    }

    @Test
    void should_handleGatewayError() {
        server.expect(requestTo("/api/payments/authorize"))
            .andRespond(withServerError());

        assertThatThrownBy(() -> client.authorize("user-1", BigDecimal.TEN))
            .isInstanceOf(PaymentGatewayException.class);
    }
}

@SpringBootTest
@Transactional  // every test rolls back — clean DB for each test
class OrderServiceTransactionTest {

    @Autowired
    private OrderService orderService;

    @Autowired
    private OrderRepository orderRepository;

    @Test
    void should_persistOrder() {
        Order order = orderService.createOrder(request);
        // Visible within same transaction
        assertThat(orderRepository.findById(order.getId())).isPresent();
    }
    // Automatically rolled back — no data leaks to next test
}

@DataJpaTest
@Sql(scripts = "/sql/insert-orders.sql", executionPhase = BEFORE_TEST_METHOD)
@Sql(scripts = "/sql/cleanup.sql", executionPhase = AFTER_TEST_METHOD)
class OrderReportTest {

    @Autowired
    private OrderRepository orderRepository;

    @Test
    void should_calculateMonthlyRevenue() {
        BigDecimal revenue = orderRepository.sumAmountByMonth(2025, 6);
        assertThat(revenue).isEqualByComparingTo("15249.97");
    }
}