//消費(fèi)者期望從提供者處獲得的User數(shù)據(jù)類
data class User(
        val name: String,
        val lastName: String,
        val age: String,
)

//消費(fèi)者處調(diào)用提供者獲取User對(duì)象的客戶端類
@Service
class UserClient {
    fun getUser(): User {
        return RestTemplate().exchange(
                providerBaseUrl + "/user",
                HttpMethod.GET,
                HttpEntity(Headers()),
                User::class.java

@PactFolder("target/pacts") //存儲(chǔ)pact文件的位置
@ExtendWith(PactConsumerTestExt::class, SpringExtension::class)
class ConsumerContractTest {

    //@Pact接受提供者名稱、消費(fèi)者名稱兩個(gè)參數(shù)
    @Pact(provider = "user-provider-service", consumer = "user-consume-service") 
    fun userPact(builder: PactDslWithProvider): RequestResponsePact {
        //使用pact DSL創(chuàng)建一個(gè)期望的響應(yīng)體樣本
        val responseBody = LambdaDsl.newJsonBody { user ->
            user.stringType("name", "someName")
            user.stringType("age", "20")
            user.stringType("lastName", "someLastName")
        }

        //使用pact DSL構(gòu)建請(qǐng)求流。當(dāng)提供者接收到GET /user請(qǐng)求時(shí)，使用上面定義的樣本進(jìn)行響應(yīng)
        return builder
                .given("a user is present") //定義提供者狀態(tài)
                .uponReceiving("a request to get user")
                .pathFromProviderState("/user", "/user")
                .method("GET")
                .willRespondWith()
                .body(responseBody.build())
                .toPact()
    }
    
    //測(cè)試
    //使用者向提供者M(jìn)ockServer發(fā)起請(qǐng)求，并對(duì)響應(yīng)體進(jìn)行斷言
    @Test
    fun `should return user`(mockServer: MockServer) {
        val url = mockServer.getUrl() + "/user"

        val user = UserClient().getUser(url)

        //斷言key，而不是value，提升健壯性
        assertTrue(user.hasProperty("age")) 
        assertTrue(user.hasProperty("name"))
        assertTrue(user.hasProperty("lastName"))
    }
}

{
  "provider": {
    "name": "user-provider-service"
  },
  "consumer": {
    "name": "user-consume-service"
  },
  "interactions": [
    {
      "description": "a request to get user",
      "request": {
        "method": "GET",
        "path": "/user",
        "generators": {
          "path": {
            "type": "ProviderState",
            "expression": "/user",
            "dataType": "STRING"
          }
        }
      },
      "response": {
        "status": 200,
        "headers": {
          "Content-Type": "application/json; charset=UTF-8"
        },
        "body": {
          "lastName": "someLastName",
          "name": "someName",
          "age": "20"
        },
        "matchingRules": {
          "body": {
            "$.name": {
              "matchers": [
                {
                  "match": "type"
                }
              ],
              "combine": "AND"
            },
            "$.age": {
              "matchers": [
                {
                  "match": "type"
                }
              ],
              "combine": "AND"
            },
            "$.lastName": {
              "matchers": [
                {
                  "match": "type"
                }
              ],
              "combine": "AND"
            }
          },
          "header": {
            "Content-Type": {
              "matchers": [
                {
                  "match": "regex",
                  "regex": "application/json(;\\s?charset=[\\w\\-]+)?"
                }
              ],
              "combine": "AND"
            }
          }
        }
      },
      "providerStates": [
        {
          "name": "a user is present"
        }
      ]
    }
  ],
  "metadata": {
    "pactSpecification": {
      "version": "3.0.0"
    },
    "pact-jvm": {
      "version": "4.1.9"
    }
  }
}

version: '3'

services:
  postgres:
    image: postgres
    healthcheck:
      test: psql postgres --command "select 1" -U postgres
    ports:
      - "5432"
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: password
      POSTGRES_DB: postgres

  broker_app:
    image: dius/pact-broker
    ports:
      - "80:80"
    links:
      - postgres
    environment:
      PACT_BROKER_DATABASE_USERNAME: postgres
      PACT_BROKER_DATABASE_PASSWORD: password
      PACT_BROKER_DATABASE_HOST: postgres
      PACT_BROKER_DATABASE_NAME: postgres
      PACT_BROKER_LOG_LEVEL: DEBUG

pact {
   publish {
      pactBrokerUrl = "http://localhost:80"
      pactDirectory = "target/pacts"
   }
}

./gradlew pactPublish

@RestController
class UserService {
    @GetMapping("/user")
    fun getUser(): Map<String, String> {
        return mapOf(
                "name" to "Foo",
                "lastName" to "Bar",
                "age" to "22"
        )
    }
}

@RunWith(SpringRestPactRunner::class)
@Provider("user-provider-service") //提供者名稱
@PactBroker(
        host = "localhost",
        port = "80",
        scheme = "http",
        consumers = ["user-consume-service"],
) //Pact Broker及消費(fèi)者信息
@SpringBootTest(classes = [PactproviderApplication::class], webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT, properties = ["server.port=8080"])
class UserServiceProviderTests {
    @TestTarget
    val target: HttpTarget = HttpTarget("localhost", 8080)

    @MockkBean
    lateinit var userService: UserService

    @Before
    fun setup() {
        //如下配置用于讓 pact 在測(cè)試完成后，將測(cè)試結(jié)果發(fā)送到 broker
        System.setProperty("pact.verifier.publishResults", "true")
    }

    @Test
    @State("a user is present") //對(duì)應(yīng)于契約中的提供者狀態(tài)，以及消費(fèi)者測(cè)試中的 given
    fun `should have a customer`() {
        //以下用于定義 userService 的 mock 行為
        every { userService.getUser() } returns mapOf(
                "name" to "someName",
                "lastName" to "someLastName",
                "age" to "22"
        )
    }
}

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-contract-verifier</artifactId>
  <scope>test</scope>
</dependency>

<plugin>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-contract-maven-plugin</artifactId>
  <extensions>true</extensions>
</plugin>

request:
  method: PUT
  url: /customers
  body:
    name: John Don
    Phone: 1234567890
  headers:
    Content-Type: application/json
  matchers:
    body:
      - path: $.['name']
        type: by_regex
        regexType: as_string
      - path: $.['phone']
        type: by_regex
        value: "[0-9]{10}"
response:
  status: 200
  body:
    reference: 1122334455
  headers:
    Content-Type: application/json
  matchers:
    body:
      - path: $.['reference']
        type: by_regex
        value: "[0-9]{5}"

public class BaseTestClass {
    @BeforeEach
    public void setup(){
        RestAssuredMockMvc.standaloneSetup(new CustomerRestController());
    }
}

@Test
void validate_shouldCreateCustomer() throws Exception {
    // given:
        MockMvcRequestSpecification request = given()
                .header("Content-Type", "application/json")
                .body("{\"name\":\"John Don\",\"phone\":1234567890}");

    // when:
        ResponseOptions response = given().spec(request)
                .put("/customers");

    // then:
        assertThat(response.statusCode()).isEqualTo(200);
        assertThat(response.header("Content-Type")).matches("application/json.*");
    // and:
        DocumentContext parsedJson = JsonPath.parse(response.getBody().asString());
        assertThatJson(parsedJson).field("['reference']").matches("[0-9]{5}");
}

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-contract-stub-runner</artifactId>
  <scope>test</scope>
</dependency>

@SpringJUnitConfig(CustomerClient.class)
@AutoConfigureStubRunner(ids = {"space.gavinklfong.demo:customer-service:+:stubs:6565"},
        stubsMode = StubRunnerProperties.StubsMode.LOCAL)
public class CustomerClientIntegrationTests {
    
   private CustomerClient customerClient;
   @BeforeEach
   void setup(){
      customerClient = new CustomerClient(“http://localhost:6565”);
   }

   @Test
   void testCustomerCreation(){
      Customer customer = new Customer(“Peter Pan”, 2233445566);
      String ref = customerClient.create(customer);
      assertNotNull(ref);
      assertEquals(5, ref.length());
      assertTrue(isNumeric(ref));
   }

}