Java PactDslJsonBody类代码示例

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
@Pact(provider = "our_provider", consumer = "our_consumer")
public PactFragment createFragment(PactDslWithProvider builder) throws UnsupportedEncodingException {
  PactDslJsonBody body = new PactDslJsonBody()
      .stringType("test")
      .stringType("valid_date", DateHelper.toString(DATE_TIME))
      .eachLike("animals", 3)
      .stringType("name", "Doggy")
      .stringType("image", "dog")
      .closeObject()
      .closeArray()
      .asBody();

  return builder
      .given("data count is > 0")
      .uponReceiving("a request for json data")
      .path("/provider.json")
      .method("GET")
      .query("valid_date=" + DateHelper.encodeDate(DATE_TIME))
      .willRespondWith()
      .status(200)
      .headers(HEADERS)
      .body(body)
      .toFragment();
}
 

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
@Test
public void testStringMatcherWithExample() throws IOException {
     /*
        {
            "foo": "a0"
        }
     */

    // Old DSL
    final String pactDslJson = new PactDslJsonBody()
        .stringMatcher("foo", "[a-z][0-9]", "a0")
        .getBody().toString();

    // Lambda DSL
    final PactDslJsonBody actualPactDsl = new PactDslJsonBody();
    final LambdaDslObject object = new LambdaDslObject(actualPactDsl);
    object
        .stringMatcher("foo", "[a-z][0-9]", "a0");
    actualPactDsl.close();

    String actualJson = actualPactDsl.getBody().toString();
    assertThat(actualJson, is(pactDslJson));
    assertThat(actualPactDsl.getMatchers().allMatchingRules().size(), is(1));
    final Map matcher = actualPactDsl.getMatchers().allMatchingRules().get(0).toMap();
    assertThat(matcher.get("match"), is("regex"));
    assertThat(matcher.get("regex"), is("[a-z][0-9]"));
}
 

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
public LambdaDslObject object(final String name, final Consumer<LambdaDslObject> nestedObject) {
    final PactDslJsonBody pactObject = object.object(name);
    final LambdaDslObject dslObject = new LambdaDslObject(pactObject);
    nestedObject.accept(dslObject);
    pactObject.closeObject();
    return this;
}
 

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
@Test
public void testStringValue() throws IOException {
     /*
        {
            "bar": "Bar",
            "foo": "Foo"
        }
     */

    // Old DSL
    final String pactDslJson = new PactDslJsonBody()
        .stringValue("foo", "Foo")
        .stringValue("bar", "Bar")
        .getBody().toString();

    // Lambda DSL
    final PactDslJsonBody actualPactDsl = new PactDslJsonBody("", "", null);
    final LambdaDslObject object = new LambdaDslObject(actualPactDsl);
    object
        .stringValue("foo", "Foo")
        .stringValue("bar", "Bar");
    actualPactDsl.close();

    String actualJson = actualPactDsl.getBody().toString();
    assertThat(actualJson, is(pactDslJson));
    assertThat(actualPactDsl.getMatchers().allMatchingRules().isEmpty(), is(true));
}
 

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
@Test
public void testStringMatcher() throws IOException {
    final PactDslJsonBody actualPactDsl = new PactDslJsonBody("", "", null);
    final LambdaDslObject object = new LambdaDslObject(actualPactDsl);
    object
        .stringMatcher("foo", "[a-z][0-9]");
    actualPactDsl.close();

    String actualJson = actualPactDsl.getBody().toString().replace("\"", "'");
    assertThat(actualJson, containsString("{'foo':"));
    assertThat(actualPactDsl.getMatchers().allMatchingRules().size(), is(1));
    final Map matcher = actualPactDsl.getMatchers().allMatchingRules().get(0).toMap();
    assertThat(matcher.get("match"), is("regex"));
    assertThat(matcher.get("regex"), is("[a-z][0-9]"));
}
 

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
@Test
public void testStringType() throws IOException {
    final PactDslJsonBody actualPactDsl = new PactDslJsonBody();
    final LambdaDslObject object = new LambdaDslObject(actualPactDsl);
    object
        .stringType("foo");
    actualPactDsl.close();

    String actualJson = actualPactDsl.getBody().toString().replace("\"", "'");
    assertThat(actualJson, containsString("{'foo':"));
    assertThat(actualPactDsl.getMatchers().allMatchingRules().size(), is(1));
    final Map matcher = actualPactDsl.getMatchers().allMatchingRules().get(0).toMap();
    assertThat(matcher.get("match"), is("type"));
}
 

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
@Test
public void testStringTypeWithExample() throws IOException {
    /*
        {
            "foo": "Foo"
        }
     */

    // Old DSL
    final String pactDslJson = new PactDslJsonBody()
        .stringType("foo", "Foo")
        .getBody().toString();

    // Lambda DSL
    final PactDslJsonBody actualPactDsl = new PactDslJsonBody("", "", null);
    final LambdaDslObject object = new LambdaDslObject(actualPactDsl);
    object
        .stringType("foo", "Foo");
    actualPactDsl.close();

    String actualJson = actualPactDsl.getBody().toString();
    assertThat(actualJson, is(pactDslJson));
    assertThat(actualPactDsl.getMatchers().allMatchingRules().size(), is(1));
    final Map matcher = actualPactDsl.getMatchers().allMatchingRules().get(0).toMap();
    assertThat(matcher.get("match"), is("type"));
    System.out.println(actualJson);
}
 

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
@Test
public void testStringTypes() throws IOException {
    /*
        {
            "foo": [
                {
                    "bar": "Bar"
                }
            ]
        }
     */

    // Old DSL
    final String pactDslJson = new PactDslJsonBody()
        .stringType(new String[]{"foo", "bar"})
        .getBody().toString();

    // Lambda DSL
    final PactDslJsonBody actualPactDsl = new PactDslJsonBody();
    final LambdaDslObject object = new LambdaDslObject(actualPactDsl);
    object
        .stringType(new String[]{"foo", "bar"});
    actualPactDsl.close();

    String actualJson = actualPactDsl.getBody().toString();
    // It can't be equals because the values get generated randomly on each run
    //assertThat(actualJson, is(pactDslJson));
    assertThat(actualPactDsl.getMatchers().allMatchingRules().size(), is(2));
    assertThat(actualJson, containsString("foo"));
    assertThat(actualJson, containsString("bar"));
    Map matcher = actualPactDsl.getMatchers().allMatchingRules().get(0).toMap();
    assertThat(matcher.get("match"), is("type"));
    matcher = actualPactDsl.getMatchers().allMatchingRules().get(1).toMap();
    assertThat(matcher.get("match"), is("type"));
    System.out.println(actualJson);
}
 

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
@Pact(provider = "Product_Catalogue_Provider", consumer = "Product_Catalogue_Consumer")
public PactFragment createFragment(PactDslWithProvider builder) {
  return builder.given("products exist")
      .uponReceiving("a request for the product catalogue")
      .path("/products")
      .method("GET")
      .headers(ImmutableMap.of(ACCEPT, HAL_JSON))
      .willRespondWith()
      .headers(ImmutableMap.of(CONTENT_TYPE, HAL_JSON))
      .status(200)
      .body(new PactDslJsonBody()
          .integerType("page", 1)
          .integerType("perPage", 10)
          .integerType("totalCount", 1)
          .object("_links")
            .object("self")
              .stringType("href", "/products")
            .closeObject()
          .closeObject()
          .object("_embedded")
            .eachLike("items")
              .stringType("id", "LRPL")
              .stringMatcher("createdOn", "\\d{4}-\\d{1,2}-\\d{1,2}", "2016-2-28")
              .stringType("name", "Personal Loan")
              .stringType("description", "Low Rate Personal Loan")
              .stringType("logo", "/cdn/logos/lrpl.webp")
              .object("_links")
                .object("self")
                  .stringType("href", "/products/LRPL")
                  .stringType("title", "Personal Loan")
                .closeObject()
              .closeObject()
            .closeObject()
          .closeArray()
        .closeObject())
      .toFragment();
}
 

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
@Pact(provider = CREDIT_SCORE_SERVICE, consumer = SPECIAL_MEMBERSHIP_SERVICE)
public RequestResponsePact tonyStarkCreditScore(PactDslWithProvider pact) {
    return pact.given("There is a [email protected]")
            .uponReceiving("A credit score request for [email protected]")
            .path("/credit-scores/[email protected]").method("GET")
            .willRespondWith()
            .status(200)
            .body(new PactDslJsonBody().integerType("creditScore", 850))
            .headers(singletonMap(CONTENT_TYPE, APPLICATION_JSON))
            .toPact();
}
 

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
@Pact(consumer = WELCOME_MEMBER_EMAIL_SERVICE, provider = SPECIAL_MEMBERSHIP_SERVICE)
public MessagePact newMemberTonyStark(MessagePactBuilder builder) {
    PactDslJsonBody body = new PactDslJsonBody()
            .stringValue("@type", "memberSignedUpEvent")
            .stringMatcher("email", "[email protected]+\\..+", "[email protected]");

    Map<String, String> metadata = new HashMap<>();

    return builder.given("Tony Stark became a new member")
            .expectsToReceive("An event notifying Tony Stark's new membership")
            .withMetadata(metadata)
            .withContent(body)
            .toPact();
}
 

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
@Pact(consumer = POLICY_SERVICE, provider = SAML_ENGINE_SERVICE)
public RequestResponsePact shouldGetValidatedEidasAuthnResponseFromSamlEngine(PactDslWithProvider pact) {
    return pact
        .uponReceiving("A request to validate the Authn Response")
        .path(Urls.SamlEngineUrls.TRANSLATE_COUNTRY_AUTHN_RESPONSE_RESOURCE).method("POST")
        .headers(singletonMap(CONTENT_TYPE, APPLICATION_JSON))
        .body(
            new PactDslJsonBody()
                .stringValue("samlResponse", samlAuthnResponseContainerDto.getSamlResponse())
                .stringValue("principalIPAddressAsSeenByHub", samlAuthnResponseContainerDto.getPrincipalIPAddressAsSeenByHub())
                .stringValue("matchingServiceEntityId", TEST_RP_MS)
                .object("sessionId")
                .stringValue("sessionId", sessionId.getSessionId())
                .closeObject()
        )
        .willRespondWith()
        .status(Response.Status.OK.getStatusCode())
        .headers(singletonMap(CONTENT_TYPE, APPLICATION_JSON))
        .body(
            new PactDslJsonBody()
                .stringValue("issuer", COUNTRY_ENTITY_ID)
                .stringValue("persistentId", "UK/GB/12345")
                .stringValue("status", "Success")
                .nullValue("statusMessage")
                .stringMatcher("encryptedIdentityAssertionBlob", ".+", encryptedIdentityAssertionString)
                .stringValue("levelOfAssurance", "LEVEL_2")
        )

        .uponReceiving("A request to generate an attribute query request")
        .path(Urls.SamlEngineUrls.GENERATE_COUNTRY_ATTRIBUTE_QUERY_RESOURCE).method("POST")
        .headers(singletonMap(CONTENT_TYPE, APPLICATION_JSON))
        .body(
            new PactDslJsonBody()
                .stringMatcher("requestId", ".+", ID)
                .stringValue("assertionConsumerServiceUri", "/default-service-index")
                .stringValue("encryptedIdentityAssertion", encryptedIdentityAssertionString)
                .stringValue("authnRequestIssuerEntityId", TEST_RP)
                .stringValue("levelOfAssurance", "LEVEL_2")
                .stringValue("matchingServiceAdapterUri", MATCHING_SERVICE_URI)
                .stringValue("matchingServiceEntityId", TEST_RP_MS)
                .timestamp("matchingServiceRequestTimeOut", "yyyy-MM-dd'T'HH:mm:ss.S'Z'")
                .booleanValue("onboarding", true)
                .nullValue("cycle3Dataset")
                .nullValue("userAccountCreationAttributes")
                .timestamp("assertionExpiry", "yyyy-MM-dd'T'HH:mm:ss.S'Z'")
                .object("persistentId")
                .stringValue("nameId", "UK/GB/12345")
                .closeObject()
        )
        .willRespondWith()
        .status(Response.Status.OK.getStatusCode())
        .headers(singletonMap(CONTENT_TYPE, APPLICATION_JSON))
        .body(
            new PactDslJsonBody()
                .stringMatcher("samlRequest", "[\\s\\S]+", SAML_ATTRIBUTE_QUERY)
                .stringValue("matchingServiceUri", MATCHING_SERVICE_URI)
                .stringValue("id", ID)
                .stringValue("issuer", EIDAS_HUB_ENTITY_ID)
                .timestamp("attributeQueryClientTimeOut", "yyyy-MM-dd'T'HH:mm:ss.S'Z'")
                .booleanValue("onboarding", true)
        )
        .toPact();
}
 

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
LambdaDslObject(final PactDslJsonBody object) {
    this.object = object;
}
 

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
public static LambdaDslJsonBody newJsonBody(Consumer<LambdaDslJsonBody> array) {
    final PactDslJsonBody pactDslJsonBody = new PactDslJsonBody();
    final LambdaDslJsonBody dslBody = new LambdaDslJsonBody(pactDslJsonBody);
    array.accept(dslBody);
    return dslBody;
}
 

import au.com.dius.pact.consumer.dsl.PactDslJsonBody; //导入依赖的package包/类
LambdaDslJsonBody(final PactDslJsonBody dslPart) {
    super(dslPart);
    this.dslPart = dslPart;
}