The contract can contain some dynamic properties - timestamps / ids etc. You don’t want to enforce the consumers to stub their
+clocks to always return the same value of time so that it gets matched by the stub. That’s why we allow you to provide the dynamic
+parts in your contracts in two ways. One is to pass them directly in the
+body and one to set them in a separate section called testMatchers and stubMatchers.
Dynamic properties inside the body
You can set the properties inside the body either via the value method
value(consumer(...), producer(...))
+value(c(...), p(...))
+value(stub(...), test(...))
+value(client(...), server(...))
or if you’re using the Groovy map notation for body you can use the $() method
$(consumer(...), producer(...))
+$(c(...), p(...))
+$(stub(...), test(...))
+$(client(...), server(...))
All of the aforementioned approaches are equal. That means that stub and client methods are aliases over the consumer
+method. Let’s take a closer look at what we can do with those values in the subsequent sections.
You can use regular expressions to write your requests in Contract DSL. It is particularly useful when you want to indicate that a given response
+should be provided for requests that follow a given pattern. Also, you can use it when you need to use patterns and not exact values both
+for your test and your server side tests.
Please see the example below:
org.springframework.cloud.contract.spec.Contract.make {
+ request {
+ method('GET')
+ url $(consumer(~/\/[0-9]{2}/), producer('/12'))
+ }
+ response {
+ status 200
+ body(
+ id: $(anyNumber()),
+ surname: $(
+ consumer('Kowalsky'),
+ producer(regex('[a-zA-Z]+'))
+ ),
+ name: 'Jan',
+ created: $(consumer('2014-02-02 12:23:43'), producer(execute('currentDate(it)'))),
+ correlationId: value(consumer('5d1f9fef-e0dc-4f3d-a7e4-72d2220dd827'),
+ producer(regex('[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}'))
+ )
+ )
+ headers {
+ header 'Content-Type': 'text/plain'
+ }
+ }
+}You can also provide only one side of the communication using a regular expression. If you do that then automatically we’ll
+provide the generated string that matches the provided regular expression. For example:
org.springframework.cloud.contract.spec.Contract.make {
+ request {
+ method 'PUT'
+ url value(consumer(regex('/foo/[0-9]{5}')))
+ body([
+ requestElement: $(consumer(regex('[0-9]{5}')))
+ ])
+ headers {
+ header('header', $(consumer(regex('application\\/vnd\\.fraud\\.v1\\+json;.*'))))
+ }
+ }
+ response {
+ status 200
+ body([
+ responseElement: $(producer(regex('[0-9]{7}')))
+ ])
+ headers {
+ contentType("application/vnd.fraud.v1+json")
+ }
+ }
+}In this example for request and response the opposite side of the communication will have the respective data generated.
Spring Cloud Contract comes with a series of predefined regular expressions that you can use in your contracts.
protected static final Pattern TRUE_OR_FALSE = Pattern.compile(/(true|false)/)
+protected static final Pattern ONLY_ALPHA_UNICODE = Pattern.compile(/[\p{L}]*/)
+protected static final Pattern NUMBER = Pattern.compile('-?\\d*(\\.\\d+)?')
+protected static final Pattern IP_ADDRESS = Pattern.compile('([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])')
+protected static final Pattern HOSTNAME_PATTERN = Pattern.compile('((http[s]?|ftp):/)/?([^:/\\s]+)(:[0-9]{1,5})?')
+protected static final Pattern EMAIL = Pattern.compile('[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,6}')
+protected static final Pattern URL = UrlHelper.URL
+protected static final Pattern UUID = Pattern.compile('[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}')
+protected static final Pattern ANY_DATE = Pattern.compile('(\\d\\d\\d\\d)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])')
+protected static final Pattern ANY_DATE_TIME = Pattern.compile('([0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])')
+protected static final Pattern ANY_TIME = Pattern.compile('(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])')
+protected static final Pattern NON_EMPTY = Pattern.compile(/.+/)
+protected static final Pattern NON_BLANK = Pattern.compile(/.*(\S+|\R).*|!^\R*$/)
+protected static final Pattern ISO8601_WITH_OFFSET = Pattern.compile(/([0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(\.\d{3})?(Z|[+-][01]\d:[0-5]\d)/)
+
+protected static Pattern anyOf(String... values){
+ return Pattern.compile(values.collect({"^$it\$"}).join("|"))
+}
+
+String onlyAlphaUnicode() {
+ return ONLY_ALPHA_UNICODE.pattern()
+}
+
+String number() {
+ return NUMBER.pattern()
+}
+
+String anyBoolean() {
+ return TRUE_OR_FALSE.pattern()
+}
+
+String ipAddress() {
+ return IP_ADDRESS.pattern()
+}
+
+String hostname() {
+ return HOSTNAME_PATTERN.pattern()
+}
+
+String email() {
+ return EMAIL.pattern()
+}
+
+String url() {
+ return URL.pattern()
+}
+
+String uuid(){
+ return UUID.pattern()
+}
+
+String isoDate() {
+ return ANY_DATE.pattern()
+}
+
+String isoDateTime() {
+ return ANY_DATE_TIME.pattern()
+}
+
+String isoTime() {
+ return ANY_TIME.pattern()
+}
+
+String iso8601WithOffset() {
+ return ISO8601_WITH_OFFSET.pattern()
+}
+
+String nonEmpty() {
+ return NON_EMPTY.pattern()
+}
+
+String nonBlank() {
+ return NON_BLANK.pattern()
+}so in your contract you can use it like this
Contract dslWithOptionalsInString = Contract.make {
+ priority 1
+ request {
+ method POST()
+ url '/users/password'
+ headers {
+ contentType(applicationJson())
+ }
+ body(
+ email: $(consumer(optional(regex(email()))), producer('abc@abc.com')),
+ callback_url: $(consumer(regex(hostname())), producer('http://partners.com'))
+ )
+ }
+ response {
+ status 404
+ headers {
+ contentType(applicationJson())
+ }
+ body(
+ code: value(consumer("123123"), producer(optional("123123"))),
+ message: "User not found by email = [${value(producer(regex(email())), consumer('not.existing@user.com'))}]"
+ )
+ }
+}Passing optional parameters
It is possible to provide optional parameters in your contract. It’s only possible to have optional parameter for the:
- STUB side of the Request
- TEST side of the Response
Example:
org.springframework.cloud.contract.spec.Contract.make {
+ priority 1
+ request {
+ method 'POST'
+ url '/users/password'
+ headers {
+ contentType(applicationJson())
+ }
+ body(
+ email: $(consumer(optional(regex(email()))), producer('abc@abc.com')),
+ callback_url: $(consumer(regex(hostname())), producer('http://partners.com'))
+ )
+ }
+ response {
+ status 404
+ headers {
+ header 'Content-Type': 'application/json'
+ }
+ body(
+ code: value(consumer("123123"), producer(optional("123123")))
+ )
+ }
+}By wrapping a part of the body with the optional() method you are in fact creating a regular expression that should be present 0 or more times.
That way for the example above the following test would be generated if you pick Spock:
"""
+ given:
+ def request = given()
+ .header("Content-Type", "application/json")
+ .body('''{"email":"abc@abc.com","callback_url":"http://partners.com"}''')
+
+ when:
+ def response = given().spec(request)
+ .post("/users/password")
+
+ then:
+ response.statusCode == 404
+ response.header('Content-Type') == 'application/json'
+ and:
+ DocumentContext parsedJson = JsonPath.parse(response.body.asString())
+ assertThatJson(parsedJson).field("['code']").matches("(123123)?")
+"""and the following stub:
'''
+{
+ "request" : {
+ "url" : "/users/password",
+ "method" : "POST",
+ "bodyPatterns" : [ {
+ "matchesJsonPath" : "$[?(@.['email'] =~ /([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\\\.[a-zA-Z]{2,6})?/)]"
+ }, {
+ "matchesJsonPath" : "$[?(@.['callback_url'] =~ /((http[s]?|ftp):\\\\/)\\\\/?([^:\\\\/\\\\s]+)(:[0-9]{1,5})?/)]"
+ } ],
+ "headers" : {
+ "Content-Type" : {
+ "equalTo" : "application/json"
+ }
+ }
+ },
+ "response" : {
+ "status" : 404,
+ "body" : "{\\"code\\":\\"123123\\",\\"message\\":\\"User not found by email == [not.existing@user.com]\\"}",
+ "headers" : {
+ "Content-Type" : "application/json"
+ }
+ },
+ "priority" : 1
+}
+'''Executing custom methods on server side
It is also possible to define a method call to be executed on the server side during the test. Such a method can be added to the class defined as "baseClassForTests"
+in the configuration. Example:
Contract
org.springframework.cloud.contract.spec.Contract.make {
+ request {
+ method 'PUT'
+ url $(consumer(regex('^/api/[0-9]{2}$')), producer('/api/12'))
+ headers {
+ header 'Content-Type': 'application/json'
+ }
+ body '''\
+ [{
+ "text": "Gonna see you at Warsaw"
+ }]
+ '''
+ }
+ response {
+ body (
+ path: $(consumer('/api/12'), producer(regex('^/api/[0-9]{2}$'))),
+ correlationId: $(consumer('1223456'), producer(execute('isProperCorrelationId($it)')))
+ )
+ status 200
+ }
+}Base class
abstract class BaseMockMvcSpec extends Specification {
+
+ def setup() {
+ RestAssuredMockMvc.standaloneSetup(new PairIdController())
+ }
+
+ void isProperCorrelationId(Integer correlationId) {
+ assert correlationId == 123456
+ }
+
+ void isEmpty(String value) {
+ assert value == null
+ }
+
+}![[Important]](images/important.png) | Important |
|---|
You can’t use both a String and execute to perform concatenation. E.g. calling
+header('Authorization', 'Bearer ' + execute('authToken()')) will lead to improper results.
+To make this work just call header('Authorization', execute('authToken()')) and ensure that
+the authToken() method returns everything that you need. |
The type of the object read from the JSON can be one of the followings depending on the
+JSON path:
String if you point to a String value in a JSONJSONArray if you point to a List in a JSONMap if you point to a Map in a JSON- proper
Number if you point to Integer, Double etc. in a JSON Boolean if you point to a Boolean in a JSON
In the request part of the contract you can specify that the body should be
+taken from a method.
| Important |
|---|
You have to provide both the consumer and the producer side
+and the execute part can be applied for the whole body. Not for parts of it! |
Example:
Contract contractDsl = Contract.make {
+ request {
+ method 'GET'
+ url '/something'
+ body(
+ $(c("foo"), p(execute("hashCode()")))
+ )
+ }
+ response {
+ status 200
+ }
+}This will result in calling the hashCode() method in the request body.
+It would more or less like this:
+ MockMvcRequestSpecification request = given()
+ .body(hashCode());
+
+
+ ResponseOptions response = given().spec(request)
+ .get("/something");
+
+
+ assertThat(response.statusCode()).isEqualTo(200);Referencing request from response
The best situation is to provide fixed values but sometimes you need to reference a request in your response.
+In order to do this you can profit from the fromRequest() method that allows you to reference a bunch
+of elements from the HTTP request. You can use the following options:
fromRequest().url() - return the request URLfromRequest().query(String key) - return the first query parameter with a given namefromRequest().query(String key, int index) - return the nth query parameter with a given namefromRequest().header(String key) - return the first header with a given namefromRequest().header(String key, int index) - return the nth header with a given namefromRequest().body() - return the full request bodyfromRequest().body(String jsonPath) - return the element from the request that matches the JSON Path
Let’s take a look at the following contract
Contract contractDsl = Contract.make {
+ request {
+ method 'GET'
+ url('/api/v1/xxxx') {
+ queryParameters {
+ parameter("foo", "bar")
+ parameter("foo", "bar2")
+ }
+ }
+ headers {
+ header(authorization(), "secret")
+ header(authorization(), "secret2")
+ }
+ body(foo: "bar", baz: 5)
+ }
+ response {
+ status 200
+ headers {
+ header(authorization(), "foo ${fromRequest().header(authorization())} bar")
+ }
+ body(
+ url: fromRequest().url(),
+ param: fromRequest().query("foo"),
+ paramIndex: fromRequest().query("foo", 1),
+ authorization: fromRequest().header("Authorization"),
+ authorization2: fromRequest().header("Authorization", 1),
+ fullBody: fromRequest().body(),
+ responseFoo: fromRequest().body('$.foo'),
+ responseBaz: fromRequest().body('$.baz'),
+ responseBaz2: "Bla bla ${fromRequest().body('$.foo')} bla bla"
+ )
+ }
+}Running a JUnit test generation will lead in creation of a test looking more or less like this
+ MockMvcRequestSpecification request = given()
+ .header("Authorization", "secret")
+ .header("Authorization", "secret2")
+ .body("{\"foo\":\"bar\",\"baz\":5}");
+
+
+ ResponseOptions response = given().spec(request)
+ .queryParam("foo","bar")
+ .queryParam("foo","bar2")
+ .get("/api/v1/xxxx");
+
+
+ assertThat(response.statusCode()).isEqualTo(200);
+ assertThat(response.header("Authorization")).isEqualTo("foo secret bar");
+
+ DocumentContext parsedJson = JsonPath.parse(response.getBody().asString());
+ assertThatJson(parsedJson).field("url").isEqualTo("/api/v1/xxxx");
+ assertThatJson(parsedJson).field("fullBody").isEqualTo("{\"foo\":\"bar\",\"baz\":5}");
+ assertThatJson(parsedJson).field("paramIndex").isEqualTo("bar2");
+ assertThatJson(parsedJson).field("responseFoo").isEqualTo("bar");
+ assertThatJson(parsedJson).field("authorization2").isEqualTo("secret2");
+ assertThatJson(parsedJson).field("responseBaz").isEqualTo(5);
+ assertThatJson(parsedJson).field("responseBaz2").isEqualTo("Bla bla bar bla bla");
+ assertThatJson(parsedJson).field("param").isEqualTo("bar");
+ assertThatJson(parsedJson).field("authorization").isEqualTo("secret");As you can see elements from the request have been properly referenced in the response.
The generated WireMock stub will look more or less like this:
{
+ "request" : {
+ "urlPath" : "/api/v1/xxxx",
+ "method" : "POST",
+ "headers" : {
+ "Authorization" : {
+ "equalTo" : "secret2"
+ }
+ },
+ "queryParameters" : {
+ "foo" : {
+ "equalTo" : "bar2"
+ }
+ },
+ "bodyPatterns" : [ {
+ "matchesJsonPath" : "$[?(@.baz == 5)]"
+ }, {
+ "matchesJsonPath" : "$[?(@.foo == 'bar')]"
+ } ]
+ },
+ "response" : {
+ "status" : 200,
+ "body" : "{\"url\":\"{{{request.url}}}\",\"param\":\"{{{request.query.foo.[0]}}}\",\"paramIndex\":\"{{{request.query.foo.[1]}}}\",\"authorization\":\"{{{request.headers.Authorization.[0]}}}\",\"authorization2\":\"{{{request.headers.Authorization.[1]}}}\",\"fullBody\":\"{{{escapejsonbody}}}\",\"responseFoo\":\"{{{jsonpath this '$.foo'}}}\",\"responseBaz\":{{{jsonpath this '$.baz'}}} ,\"responseBaz2\":\"Bla bla {{{jsonpath this '$.foo'}}} bla bla\"}",
+ "headers" : {
+ "Authorization" : "{{{request.headers.Authorization.[0]}}}"
+ },
+ "transformers" : [ "response-template" ]
+ }
+}So sending a request as the one presented in the request part of the contract will lead in sending the following
+response body
{
+ "url" : "/api/v1/xxxx?foo=bar&foo=bar2",
+ "param" : "bar",
+ "paramIndex" : "bar2",
+ "authorization" : "secret",
+ "authorization2" : "secret2",
+ "fullBody" : "{\"foo\":\"bar\",\"baz\":5}",
+ "responseFoo" : "bar",
+ "responseBaz" : 5,
+ "responseBaz2" : "Bla bla bar bla bla"
+} | Important |
|---|
This feature will work only with WireMock having version greater or equal to 2.5.1. We’re using WireMock’s
+response-template response transformer. It’s using Handlebars to convert the Mustache {{{ }}} templates into
+proper values. Additionally we’re registering 2 helper functions. escapejsonbody - that escapes the request
+body in a format that can be embedded in a JSON. Another is jsonpath that for a given parameter knows how to
+find an object in the request body. |
Dynamic properties in matchers sections
If you’ve been working with Pact this might seem familiar. Quite a few users
+are used to having a separation between the body and setting dynamic parts of your contract.
That’s why you can profit from two separate sections. One is called stubMatchers where you can
+define the dynamic values that should end up in a stub. You can set it in the request or inputMessage
+part of your contract. The other is called testMatchers which is present in the response or
+outputMessage side of the contract.
Currently we support only JSON Path based matchers with the following matching possibilities.
+For stubMatchers:
byEquality() - the value taken from the response via the provided JSON Path needs
+to be equal to the provided value in the contractbyRegex(…) - the value taken from the response via the provided JSON Path needs
+to match the regexbyDate() - the value taken from the response via the provided JSON Path needs to
+match the regex for ISO DatebyTimestamp() - the value taken from the response via the provided JSON Path needs
+to match the regex for ISO DateTimebyTime() - the value taken from the response via the provided JSON Path needs to
+match the regex for ISO Time
For testMatchers:
Let’s take a look at the following example:
Contract contractDsl = Contract.make {
+ request {
+ method 'GET'
+ urlPath '/get'
+ body([
+ duck: 123,
+ alpha: "abc",
+ number: 123,
+ aBoolean: true,
+ date: "2017-01-01",
+ dateTime: "2017-01-01T01:23:45",
+ time: "01:02:34",
+ valueWithoutAMatcher: "foo",
+ valueWithTypeMatch: "string",
+ key: [
+ 'complex.key' : 'foo'
+ ]
+ ])
+ stubMatchers {
+ jsonPath('$.duck', byRegex("[0-9]{3}"))
+ jsonPath('$.duck', byEquality())
+ jsonPath('$.alpha', byRegex(onlyAlphaUnicode()))
+ jsonPath('$.alpha', byEquality())
+ jsonPath('$.number', byRegex(number()))
+ jsonPath('$.aBoolean', byRegex(anyBoolean()))
+ jsonPath('$.date', byDate())
+ jsonPath('$.dateTime', byTimestamp())
+ jsonPath('$.time', byTime())
+ jsonPath("\$.['key'].['complex.key']", byEquality())
+ }
+ headers {
+ contentType(applicationJson())
+ }
+ }
+ response {
+ status 200
+ body([
+ duck: 123,
+ alpha: "abc",
+ number: 123,
+ aBoolean: true,
+ date: "2017-01-01",
+ dateTime: "2017-01-01T01:23:45",
+ time: "01:02:34",
+ valueWithoutAMatcher: "foo",
+ valueWithTypeMatch: "string",
+ valueWithMin: [
+ 1,2,3
+ ],
+ valueWithMax: [
+ 1,2,3
+ ],
+ valueWithMinMax: [
+ 1,2,3
+ ],
+ valueWithMinEmpty: [],
+ valueWithMaxEmpty: [],
+ key: [
+ 'complex.key' : 'foo'
+ ]
+ ])
+ testMatchers {
+
+ jsonPath('$.duck', byRegex("[0-9]{3}"))
+
+ jsonPath('$.duck', byEquality())
+
+ jsonPath('$.alpha', byRegex(onlyAlphaUnicode()))
+ jsonPath('$.alpha', byEquality())
+ jsonPath('$.number', byRegex(number()))
+ jsonPath('$.aBoolean', byRegex(anyBoolean()))
+
+ jsonPath('$.date', byDate())
+ jsonPath('$.dateTime', byTimestamp())
+ jsonPath('$.time', byTime())
+
+ jsonPath('$.valueWithTypeMatch', byType())
+ jsonPath('$.valueWithMin', byType {
+
+ minOccurrence(1)
+ })
+ jsonPath('$.valueWithMax', byType {
+
+ maxOccurrence(3)
+ })
+ jsonPath('$.valueWithMinMax', byType {
+
+ minOccurrence(1)
+ maxOccurrence(3)
+ })
+ jsonPath('$.valueWithMinEmpty', byType {
+
+ minOccurrence(0)
+ })
+ jsonPath('$.valueWithMaxEmpty', byType {
+
+ maxOccurrence(0)
+ })
+
+ jsonPath('$.duck', byCommand('assertThatValueIsANumber($it)'))
+ jsonPath("\$.['key'].['complex.key']", byEquality())
+ }
+ headers {
+ contentType(applicationJson())
+ }
+ }
+}In this example we’re providing the dynamic portions of the contract in the matchers sections.
+ For the request part you can see that for all fields but valueWithoutAMatcher we’re setting
+ explicitly the values of regular expressions we’d like the stub to contain. For the valueWithoutAMatcher
+ the verification will take place in the same way as without the usage of matchers - the test
+ will perform an equality check in this case.
For the response side in the testMatchers section we’re defining all the dynamic parts
+ in a similar manner. The only difference is that we have the byType matchers too. In that
+ case we’re checking 4 fields in the way that we’re verifying whether the response from the test
+ has a value whose JSON path matching the given field is of the same type as the one defined in the response body and:
- for
$.valueWithTypeMatch - we’re just checking the whether the type is the same - for
$.valueWithMin - we’re checking the type and assert if the size is greater or equal to the min occurrence - for
$.valueWithMax - we’re checking the type and assert if the size is smaller or equal to the max occurrence - for
$.valueWithMinMax - we’re checking the type and assert if the size is between the min and max occurrence
The resulting test would look more or less like this (note that we’re separating the autogenerated
+assertions and the one from matchers with an and section):
+ MockMvcRequestSpecification request = given()
+ .header("Content-Type", "application/json")
+ .body("{\"duck\":123,\"alpha\":\"abc\",\"number\":123,\"aBoolean\":true,\"date\":\"2017-01-01\",\"dateTime\":\"2017-01-01T01:23:45\",\"time\":\"01:02:34\",\"valueWithoutAMatcher\":\"foo\",\"valueWithTypeMatch\":\"string\"}");
+
+
+ ResponseOptions response = given().spec(request)
+ .get("/get");
+
+
+ assertThat(response.statusCode()).isEqualTo(200);
+ assertThat(response.header("Content-Type")).matches("application/json.*");
+
+ DocumentContext parsedJson = JsonPath.parse(response.getBody().asString());
+ assertThatJson(parsedJson).field("valueWithoutAMatcher").isEqualTo("foo");
+
+ assertThat(parsedJson.read("$.duck", String.class)).matches("[0-9]{3}");
+ assertThat(parsedJson.read("$.duck", Integer.class)).isEqualTo(123);
+ assertThat(parsedJson.read("$.alpha", String.class)).matches("[\\p{L}]*");
+ assertThat(parsedJson.read("$.alpha", String.class)).isEqualTo("abc");
+ assertThat(parsedJson.read("$.number", String.class)).matches("-?\\d*(\\.\\d+)?");
+ assertThat(parsedJson.read("$.aBoolean", String.class)).matches("(true|false)");
+ assertThat(parsedJson.read("$.date", String.class)).matches("(\\d\\d\\d\\d)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])");
+ assertThat(parsedJson.read("$.dateTime", String.class)).matches("([0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])");
+ assertThat(parsedJson.read("$.time", String.class)).matches("(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])");
+ assertThat((Object) parsedJson.read("$.valueWithTypeMatch")).isInstanceOf(java.lang.String.class);
+ assertThat((Object) parsedJson.read("$.valueWithMin")).isInstanceOf(java.util.List.class);
+ assertThat((java.lang.Iterable) parsedJson.read("$.valueWithMin", java.util.Collection.class)).hasSizeGreaterThanOrEqualTo(1);
+ assertThat((Object) parsedJson.read("$.valueWithMax")).isInstanceOf(java.util.List.class);
+ assertThat((java.lang.Iterable) parsedJson.read("$.valueWithMax", java.util.Collection.class)).hasSizeLessThanOrEqualTo(3);
+ assertThat((Object) parsedJson.read("$.valueWithMinMax")).isInstanceOf(java.util.List.class);
+ assertThat((java.lang.Iterable) parsedJson.read("$.valueWithMinMax", java.util.Collection.class)).hasSizeBetween(1, 3);
+ assertThat((Object) parsedJson.read("$.valueWithMinEmpty")).isInstanceOf(java.util.List.class);
+ assertThat((java.lang.Iterable) parsedJson.read("$.valueWithMinEmpty", java.util.Collection.class)).hasSizeGreaterThanOrEqualTo(0);
+ assertThat((Object) parsedJson.read("$.valueWithMaxEmpty")).isInstanceOf(java.util.List.class);
+ assertThat((java.lang.Iterable) parsedJson.read("$.valueWithMaxEmpty", java.util.Collection.class)).hasSizeLessThanOrEqualTo(0);
+ assertThatValueIsANumber(parsedJson.read("$.duck")); | Important |
|---|
Notice that for the byCommand method we are calling the assertThatValueIsANumber. This method needs
+to be defined in the test base class or should be statically imported to your tests.
+Notice that the byCommand call was converted to assertThatValueIsANumber(parsedJson.read("$.duck"));. That means
+that we took the method name and passed the proper JSON path as a parameter to it. |
and the WireMock stub like this:
'''
+{
+ "request" : {
+ "urlPath" : "/get",
+ "method" : "POST",
+ "headers" : {
+ "Content-Type" : {
+ "matches" : "application/json.*"
+ }
+ },
+ "bodyPatterns" : [ {
+ "matchesJsonPath" : "$[?(@.['valueWithoutAMatcher'] == 'foo')]"
+ }, {
+ "matchesJsonPath" : "$[?(@.['valueWithTypeMatch'] == 'string')]"
+ }, {
+ "matchesJsonPath" : "$.['list'].['some'].['nested'][?(@.['anothervalue'] == 4)]"
+ }, {
+ "matchesJsonPath" : "$.['list'].['someother'].['nested'][?(@.['anothervalue'] == 4)]"
+ }, {
+ "matchesJsonPath" : "$.['list'].['someother'].['nested'][?(@.['json'] == 'with value')]"
+ }, {
+ "matchesJsonPath" : "$[?(@.duck =~ /([0-9]{3})/)]"
+ }, {
+ "matchesJsonPath" : "$[?(@.duck == 123)]"
+ }, {
+ "matchesJsonPath" : "$[?(@.alpha =~ /([\\\\p{L}]*)/)]"
+ }, {
+ "matchesJsonPath" : "$[?(@.alpha == 'abc')]"
+ }, {
+ "matchesJsonPath" : "$[?(@.number =~ /(-?\\\\d*(\\\\.\\\\d+)?)/)]"
+ }, {
+ "matchesJsonPath" : "$[?(@.aBoolean =~ /((true|false))/)]"
+ }, {
+ "matchesJsonPath" : "$[?(@.date =~ /((\\\\d\\\\d\\\\d\\\\d)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01]))/)]"
+ }, {
+ "matchesJsonPath" : "$[?(@.dateTime =~ /(([0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9]))/)]"
+ }, {
+ "matchesJsonPath" : "$[?(@.time =~ /((2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9]))/)]"
+ }, {
+ "matchesJsonPath" : "$.list.some.nested[?(@.json =~ /(.*)/)]"
+ } ]
+ },
+ "response" : {
+ "status" : 200,
+ "body" : "{\\"duck\\":123,\\"alpha\\":\\"abc\\",\\"number\\":123,\\"aBoolean\\":true,\\"date\\":\\"2017-01-01\\",\\"dateTime\\":\\"2017-01-01T01:23:45\\",\\"time\\":\\"01:02:34\\",\\"valueWithoutAMatcher\\":\\"foo\\",\\"valueWithTypeMatch\\":\\"string\\",\\"valueWithMin\\":[1,2,3],\\"valueWithMax\\":[1,2,3],\\"valueWithMinMax\\":[1,2,3]}",
+ "headers" : {
+ "Content-Type" : "application/json"
+ }
+ }
+}
+''' | Important |
|---|
If you use a matcher then the part of the request / response that the matcher is addressing
+via the JSON Path will get removed from assertion. In case of verifying a collection you have to create
+matchers for all elements of the collection. |
Let’s look at the following example:
Contract.make {
+ request {
+ method 'GET'
+ url("/foo")
+ }
+ response {
+ status 200
+ body(events: [[
+ operation : 'EXPORT',
+ eventId : '16f1ed75-0bcc-4f0d-a04d-3121798faf99',
+ status : 'OK'
+ ], [
+ operation : 'INPUT_PROCESSING',
+ eventId : '3bb4ac82-6652-462f-b6d1-75e424a0024a',
+ status : 'OK'
+ ]
+ ]
+ )
+ testMatchers {
+ jsonPath('$.events[0].operation', byRegex('.+'))
+ jsonPath('$.events[0].eventId', byRegex('^([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12})$'))
+ jsonPath('$.events[0].status', byRegex('.+'))
+ }
+ }
+}This will lead in creating the following test (showing just the assertion section)
and:
+ DocumentContext parsedJson = JsonPath.parse(response.body.asString())
+ assertThatJson(parsedJson).array("['events']").contains("['eventId']").isEqualTo("16f1ed75-0bcc-4f0d-a04d-3121798faf99")
+ assertThatJson(parsedJson).array("['events']").contains("['operation']").isEqualTo("EXPORT")
+ assertThatJson(parsedJson).array("['events']").contains("['operation']").isEqualTo("INPUT_PROCESSING")
+ assertThatJson(parsedJson).array("['events']").contains("['eventId']").isEqualTo("3bb4ac82-6652-462f-b6d1-75e424a0024a")
+ assertThatJson(parsedJson).array("['events']").contains("['status']").isEqualTo("OK")
+and:
+ assertThat(parsedJson.read("\$.events[0].operation", String.class)).matches(".+")
+ assertThat(parsedJson.read("\$.events[0].eventId", String.class)).matches("^([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12})\$")
+ assertThat(parsedJson.read("\$.events[0].status", String.class)).matches(".+")As you can see the assertion is malformed. That’s because only the first element of the array got asserted.
+In order to fix this it’s best to apply the assertion to the whole $.events collection and assert it
+via the byCommand(…) method.
![[Tip]](images/tip.png)
![[Note]](images/note.png)
![[Warning]](images/warning.png)
