// 订单服务的单元测试示例
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {

    @Mock
    private OrderRepository orderRepository;

    @Mock
    private InventoryClient inventoryClient;

    @Mock
    private PaymentClient paymentClient;

    @InjectMocks
    private OrderService orderService;

    @Test
    @DisplayName("创建订单 - 库存充足且支付成功")
    void createOrder_Success() {
        // Given
        CreateOrderCommand command = new CreateOrderCommand("user-1",
            List.of(new OrderItem("prod-1", 2, new Money(100, "CNY"))));

        when(inventoryClient.checkStock("prod-1", 2)).thenReturn(true);
        when(orderRepository.save(any(Order.class)))
            .thenAnswer(inv -> inv.getArgument(0));
        when(paymentClient.createPayment(any())).thenReturn(new PaymentResult("PAY-1", "SUCCESS"));

        // When
        Order order = orderService.createOrder(command);

        // Then
        assertNotNull(order.getOrderId());
        assertEquals(OrderStatus.CREATED, order.getStatus());
        verify(inventoryClient).deductStock("prod-1", 2);
        verify(paymentClient).createPayment(any());
    }

    @Test
    @DisplayName("创建订单 - 库存不足应抛出异常")
    void createOrder_InsufficientStock_ShouldThrow() {
        // Given
        when(inventoryClient.checkStock("prod-1", 2)).thenReturn(false);

        // When & Then
        assertThrows(InsufficientStockException.class,
            () -> orderService.createOrder(command));
    }
}

// 订单服务（消费者）测试商品服务接口
@Pact(consumer = "order-service", provider = "product-service")
public RequestResponsePact getProductPact(PactDslWithProvider builder) {
    return builder
        .given("product PROD-001 exists")
        .uponReceiving("get product by id")
        .path("/api/v1/products/PROD-001")
        .method("GET")
        .willRespondWith()
        .status(200)
        .body(new PactDslJsonBody()
            .stringType("id", "PROD-001")
            .stringType("name", "iPhone 15")
            .decimalType("price", 5999.00)
            .integerType("stock", 100))
        .toPact();
}

@PactTestFor(pactMethod = "getProductPact")
@Test
void testGetProduct() {
    // 调用真实的消费者代码，但 Mock 的提供者响应
    Product product = productClient.getProduct("PROD-001");

    assertEquals("PROD-001", product.getId());
    assertEquals("iPhone 15", product.getName());
    assertEquals(new BigDecimal("5999.00"), product.getPrice());
}

// 商品服务（提供者）验证
@Provider("product-service")
@PactFolder("pacts")  // 或从 Pact Broker 获取
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ProductServiceProviderTest {

    @TestTemplate
    @ExtendWith(PactVerificationInvocationContextProvider.class)
    void verifyPact(Pact pact, Interaction interaction, HttpRequest request,
                    PactVerificationContext context) {
        context.verifyInteraction();
    }

    @State("product PROD-001 exists")
    void setupProductExists() {
        // 准备测试数据
        productRepository.save(new Product("PROD-001", "iPhone 15",
            new BigDecimal("5999.00"), 100));
    }
}

@Testcontainers
class OrderRepositoryIntegrationTest {

    @Container
    static MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.0")
        .withDatabaseName("order_db")
        .withUsername("test")
        .withPassword("test");

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

    @Autowired
    private OrderRepository orderRepository;

    @Test
    void shouldSaveAndRetrieveOrder() {
        Order order = new Order("ORD-001", "USER-001", OrderStatus.CREATED);
        orderRepository.save(order);

        Order found = orderRepository.findById("ORD-001").orElseThrow();
        assertEquals("ORD-001", found.getOrderId());
        assertEquals(OrderStatus.CREATED, found.getStatus());
    }
}

# docker-compose.test.yml
version: '3.8'
services:
  user-service:
    image: user-service:latest
    ports: ["8081:8080"]
    environment:
      SPRING_PROFILES_ACTIVE: test
    depends_on: [user-db]

  order-service:
    image: order-service:latest
    ports: ["8082:8080"]
    environment:
      SPRING_PROFILES_ACTIVE: test
      USER_SERVICE_URL: http://user-service:8080
    depends_on: [order-db, kafka]

  user-db:
    image: mysql:8.0
    environment:
      MYSQL_DATABASE: user_db
      MYSQL_ROOT_PASSWORD: test

  order-db:
    image: mysql:8.0
    environment:
      MYSQL_DATABASE: order_db
      MYSQL_ROOT_PASSWORD: test

  kafka:
    image: confluentinc/cp-kafka:7.5.0
    ports: ["9092:9092"]

# 注入 Pod 故障：随机杀死订单服务的 Pod
apiVersion: chaos-mesh.org/v1alpha1
kind: PodChaos
metadata:
  name: order-service-kill
  namespace: production
spec:
  action: pod-kill
  mode: one
  selector:
    labelSelectors:
      app: order-service
  scheduler:
    cron: '@every 30m'  # 每 30 分钟杀死一个 Pod

# 注入网络延迟
apiVersion: chaos-mesh.org/v1alpha1
kind: NetworkChaos
metadata:
  name: payment-service-delay
spec:
  action: delay
  mode: all
  selector:
    labelSelectors:
      app: payment-service
  delay:
    latency: "200ms"
    jitter: "50ms"
    correlation: "50"
  duration: "5m"

// order-performance-test.js
import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 100 },  // 升压到 100 VU
    { duration: '5m', target: 100 },  // 保持 100 VU
    { duration: '2m', target: 200 },  // 升压到 200 VU
    { duration: '5m', target: 200 },  // 保持 200 VU
    { duration: '2m', target: 0 },    // 降压
  ],
  thresholds: {
    http_req_duration: ['p(99)<500'],  // P99 < 500ms
    http_req_failed: ['rate<0.01'],    // 错误率 < 1%
  },
};

export default function () {
  const payload = JSON.stringify({
    userId: `user-${__VU}`,
    items: [{ productId: 'PROD-001', quantity: 1 }]
  });

  const params = { headers: { 'Content-Type': 'application/json' } };
  const res = http.post('http://api-gateway/api/v1/orders', payload, params);

  check(res, {
    'status is 201': (r) => r.status === 201,
    'response time < 500ms': (r) => r.timings.duration < 500,
  });

  sleep(1);
}