🧪 Testing Microservices

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {

    @Mock private OrderRepository orderRepository;
    @Mock private InventoryClient inventoryClient;
    @InjectMocks private OrderService orderService;

    @Test
    void shouldRejectOrderWhenOutOfStock() {
        when(inventoryClient.checkStock("ITEM-1")).thenReturn(new StockResponse(0));

        assertThatThrownBy(() -> orderService.placeOrder(new OrderRequest("ITEM-1", 5)))
            .isInstanceOf(OutOfStockException.class)
            .hasMessageContaining("ITEM-1");

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

@SpringBootTest(webEnvironment = RANDOM_PORT)
@Testcontainers
@ActiveProfiles("test")
class OrderServiceComponentTest {

    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16");

    @DynamicPropertySource
    static void configure(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
    }

    @Autowired private TestRestTemplate rest;

    @MockBean private InventoryClient inventoryClient;  // Mock external dependency

    @Test
    void fullOrderFlow() {
        // Mock external service
        when(inventoryClient.checkStock("ITEM-1")).thenReturn(new StockResponse(10));

        // Create order via REST API
        var request = new OrderRequest("user-1", "ITEM-1", 2);
        var response = rest.postForEntity("/api/orders", request, OrderResponse.class);

        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
        assertThat(response.getBody().status()).isEqualTo("CONFIRMED");

        // Verify via GET
        var getResponse = rest.getForEntity(
            "/api/orders/" + response.getBody().id(), OrderResponse.class);
        assertThat(getResponse.getBody().status()).isEqualTo("CONFIRMED");
    }
}

@ExtendWith(PactConsumerTestExt.class)
@PactTestFor(providerName = "user-service")
class UserClientContractTest {

    @Pact(consumer = "order-service")
    public V4Pact getUserPact(PactDslWithProvider builder) {
        return builder
            .given("user 1 exists")
            .uponReceiving("get user by id")
            .path("/api/users/1")
            .method("GET")
            .willRespondWith()
            .status(200)
            .body(new PactDslJsonBody()
                .integerType("id", 1)
                .stringType("name", "John")
                .stringType("email", "john@example.com"))
            .toPact(V4Pact.class);
    }

    @Test
    @PactTestFor(pactMethod = "getUserPact")
    void shouldGetUser(MockServer mockServer) {
        UserClient client = new UserClient(mockServer.getUrl());
        UserResponse user = client.getUser(1L);

        assertThat(user.name()).isEqualTo("John");
        assertThat(user.email()).isEqualTo("john@example.com");
    }
}

@SpringBootTest(webEnvironment = RANDOM_PORT)
@Provider("user-service")
@PactBroker(url = "http://pact-broker:9292")
class UserServiceProviderTest {

    @TestTemplate
    @ExtendWith(PactVerificationInvocationContextProvider.class)
    void verifyPact(PactVerificationContext context) {
        context.verifyInteraction();
    }

    @State("user 1 exists")
    void setupUser1() {
        userRepository.save(new User(1L, "John", "john@example.com"));
    }
}

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

    @Test
    void shouldHandlePaymentGatewayTimeout() {
        // Simulate payment gateway timeout
        stubFor(post("/api/charge")
            .willReturn(aResponse()
                .withStatus(200)
                .withFixedDelay(5000)));  // 5 second delay

        assertThatThrownBy(() -> paymentService.charge("order-1", BigDecimal.TEN))
            .isInstanceOf(PaymentTimeoutException.class);
    }

    @Test
    void shouldProcessPaymentSuccessfully() {
        stubFor(post("/api/charge")
            .withRequestBody(matchingJsonPath("$.amount", equalTo("49.99")))
            .willReturn(okJson("""
                { "transactionId": "txn-123", "status": "SUCCESS" }
                """)));

        PaymentResult result = paymentService.charge("order-1", new BigDecimal("49.99"));
        assertThat(result.transactionId()).isEqualTo("txn-123");
    }
}

@SpringBootTest
@Testcontainers
class E2EOrderFlowTest {

    @Container static DockerComposeContainer<?> env = new DockerComposeContainer<>(
        new File("src/test/resources/docker-compose-test.yml"))
        .withExposedService("order-service", 8080)
        .withExposedService("payment-service", 8081)
        .withExposedService("kafka", 9092)
        .waitingFor("order-service", Wait.forHttp("/actuator/health"));

    @Test
    void fullOrderToPaymentFlow() {
        String orderUrl = "http://localhost:" + env.getServicePort("order-service", 8080);

        // Place order
        var response = RestAssured.given()
            .contentType("application/json")
            .body("""
                { "userId": "user-1", "items": ["item-1"], "amount": 29.99 }
                """)
            .post(orderUrl + "/api/orders")
            .then()
            .statusCode(201)
            .extract().as(OrderResponse.class);

        // Wait for async payment processing
        await().atMost(10, SECONDS).untilAsserted(() -> {
            OrderResponse order = RestAssured.get(orderUrl + "/api/orders/" + response.id())
                .as(OrderResponse.class);
            assertThat(order.status()).isEqualTo("PAID");
        });
    }
}