微服务契约测试（Pact 与 Spring Cloud Contract）

// Consumer 端契约测试：定义对账户服务的调用期望
@PactTestFor(providerName = "account-service", port = "8080")
@ExtendWith(PactConsumerTestExt.class)
class AccountConsumerPactTest {
 
    // 定义契约：当请求 /accounts/1 时，期望返回账户详情
    @Pact(consumer = "subscription-service")
    RequestResponsePact getAccountByIdPact(PactDslWithProvider builder) {
        return builder
            .given("账户 1 已存在")                          // Provider 端的状态前置条件
            .uponReceiving("查询账户 1 的信息")
                .path("/accounts/1")
                .method("GET")
            .willRespondWith()
                .status(200)
                .headers(Map.of("Content-Type", "application/json"))
                .body(new PactDslJsonBody()
                    .integerType("id", 1)                   // 字段类型匹配，避免硬编码
                    .stringType("name")
                    .numberType("balance"))
            .toPact();
    }
 
    @Test
    @PactTestFor(pactMethod = "getAccountByIdPact")
    void shouldParseAccount_whenApiReturns200(AccountClient client) {
        // 调用真实的 Consumer 业务代码，底层 HTTP 走 Pact Mock
        Account account = client.findById(1L);
        assertThat(account.getId()).isEqualTo(1L);
        assertThat(account.getName()).isNotBlank();
    }
}

# Consumer 端契约测试：定义对账户服务的调用期望
from pact import Consumer, Provider
 
pact = Consumer("subscription-service").has_pact_with(
    Provider("account-service"),
    pact_dir="./pacts",                 # 契约文件输出目录
)
 
@pact.given("账户 1 已存在")
@pact.upon_receiving("查询账户 1 的信息")
@pact.with_request(method="GET", path="/accounts/1")
@pact.will_respond_with(
    status=200,
    headers={"Content-Type": "application/json"},
    body={"id": 1, "name": like("Alice"), "balance": like(1000.0)},
)
def test_find_account_by_id():
    # Mock 启动期间，AccountClient 应正确解析响应
    with pact:
        client = AccountClient(base_url=pact.uri)
        account = client.find_by_id(1)
        assert account.id == 1

// Provider 端契约验证：重放契约请求并校验响应
@Provider("account-service")
@PactBroker                              // 从 Pact Broker 拉取契约
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class AccountProviderPactTest {
 
    @TestTemplate
    @ExtendWith(PactVerificationInvocationContextProvider.class)
    void verifyPact(PactVerificationContext context) {
        context.verifyInteraction();    // 重放每一条契约交互
    }
 
    @BeforeEach
    void setup(PactVerificationContext context) {
        context.setTarget(new HttpTestTarget("localhost", port));
    }
 
    @State("账户 1 已存在")               // 对应 Consumer 端的 given 注解
    void prepareAccount1() {
        accountRepository.save(new Account(1L, "Alice", new BigDecimal("1000.00")));
    }
}

# .github/workflows/consumer-pact.yml
name: Consumer Pact Pipeline
on: [push, pull_request]
 
jobs:
  pact:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with: { java-version: '21', distribution: 'temurin' }
      - run: ./mvnw test -Ppact-consumer        # 执行 Consumer 契约测试，生成 pacts/*.json
      # 将契约发布到 PactFlow，附带 git 提交号与分支标签
      - name: Publish pacts
        run: |
          docker run --rm \
            -e PACT_BROKER_BASE_URL=${{ secrets.PACTFLOW_URL }} \
            -e PACT_BROKER_TOKEN=${{ secrets.PACTFLOW_TOKEN }} \
            -v ${{ github.workspace }}/pacts:/pacts \
            pactfoundation/pact-cli:latest \
            publish /pacts \
            --consumer-app-version ${{ github.sha }} \
            --branch ${{ github.ref_name }}
      # 部署前询问 Broker：当前 Consumer 版本是否已被所有 Provider 验证
      - name: can-i-deploy
        run: |
          docker run --rm \
            -e PACT_BROKER_BASE_URL=${{ secrets.PACTFLOW_URL }} \
            -e PACT_BROKER_TOKEN=${{ secrets.PACTFLOW_TOKEN }} \
            pactfoundation/pact-cli:latest \
            broker can-i-deploy \
            --pacticipant subscription-service \
            --version ${{ github.sha }} \
            --to-environment production

// contracts/shouldReturnAccount.groovy
// Provider 端定义契约：描述请求与期望响应
org.springframework.cloud.contract.spec.Contract.make {
    request {
        method 'GET'
        url '/accounts/1'
        headers { header('Accept', 'application/json') }
    }
    response {
        status 200
        body([
            id     : $(anyInteger()),
            name   : $(anyNonBlankString()),
            balance: $(anyNumber())
        ])
        headers { header('Content-Type', 'application/json') }
    }
}

// Provider 基类：契约请求通过 MockMvc 命中真实 Controller
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
@AutoConfigureMockMvc
abstract class AccountContractBase {
 
    @Autowired
    MockMvc mockMvc;
 
    @BeforeEach
    void prepareData() {
        // 契约中的数据前置：插入账户 1
        accountRepository.save(new Account(1, "Alice", new BigDecimal("1000.00")));
    }
}

// Consumer 端通过 StubRunner 拉取 Provider 的 stubs JAR 并启动 Mock
@AutoConfigureStubRunner(
    ids = "com.example:account-service:+:stubs:8080",
    stubsMode = StubRunnerProperties.StubsMode.REMOTE
)
@SpringBootTest
class SubscriptionServiceTest {
 
    @Autowired
    SubscriptionService subscriptionService;
 
    @Test
    void shouldCreateSubscription_whenAccountExists() {
        // 调用真实业务代码，HTTP 由 Stub 自动响应契约内容
        Subscription sub = subscriptionService.createSubscription(1L);
        assertThat(sub.getStatus()).isEqualTo("ACTIVE");
    }
}

// Consumer 端：定义对账户事件消息的期望
@PactTestFor(providerName = "account-event-producer", providerType = ProviderType.ASYNCH)
class AccountEventConsumerPactTest {
 
    @Pact(consumer = "notification-service")
    V4Pact accountCreatedEventPact(MessagingPactBuilder builder) {
        return builder
            .expectsToReceive("账户创建事件")
            .withContent(new PactDslJsonBody()
                .stringValue("eventType", "AccountCreated")
                .integerType("accountId")
                .datetime("createdAt", "yyyy-MM-dd'T'HH:mm:ssZ"))
            .toPact();
    }
 
    @Test
    @PactTestFor(pactMethod = "accountCreatedEventPact")
    void shouldHandleAccountCreatedEvent(PactDslJsonBody message) {
        // 把契约消息喂给 Consumer 的消息处理逻辑
        notificationService.handle(message);
        verify(emailSender).sendWelcomeMail(anyLong());
    }
}