Spring Cloud Contract supports out of the box 2 types of DSL. One written in
-Groovy and one written in YAML.
If you decide to write the contract in Groovy, do not be alarmed if you have not used Groovy
-before. Knowledge of the language is not really needed, as the Contract DSL uses only a
-tiny subset of it (only literals, method calls and closures). Also, the DSL is statically
-typed, to make it programmer-readable without any knowledge of the DSL itself.
The HTTP protocol requires only method and url to be specified in a request. The
-same information is mandatory in request definition of the Contract.
Groovy DSL.
-
org.springframework.cloud.contract.spec.Contract.make {
- request {
-
- method 'GET'
-
-
- urlPath('/users')
- }
-
- response {
-
- status 200
- }
-}
-
YAML.
-
method: PUT
-url: /foo
-
It is possible to specify an absolute rather than relative url, but using urlPath is
-the recommended way, as doing so makes the tests host-independent.
Groovy DSL.
-
org.springframework.cloud.contract.spec.Contract.make {
- request {
- method 'GET'
-
-
- url('http://localhost:8888/users')
- }
-
- response {
-
- status 200
- }
-}
-
YAML.
-
request:
- method: PUT
- urlPath: /foo
-
request may contain query parameters.
Groovy DSL.
-
org.springframework.cloud.contract.spec.Contract.make {
- request {
-
- method GET()
-
- urlPath('/users') {
-
-
-
-
-
- queryParameters {
-
-
-
- parameter 'limit': 100
-
-
-
- parameter 'filter': equalTo("email")
-
-
-
- parameter 'gender': value(consumer(containing("[mf]")), producer('mf'))
-
-
-
- parameter 'offset': value(consumer(matching("[0-9]+")), producer(123))
-
-
-
- parameter 'loginStartsWith': value(consumer(notMatching(".{0,2}")), producer(3))
- }
- }
-
-
- }
-
- response {
-
- status 200
- }
-}
-
YAML.
-
request:
-...
- queryParameters:
- a: b
- b: c
- headers:
- foo: bar
- fooReq: baz
- cookies:
- foo: bar
- fooReq: baz
- body:
- foo: bar
- matchers:
- body:
- - path: $.foo
- type: by_regex
- value: bar
- headers:
- - key: foo
- regex: bar
-response:
- status: 200
- fixedDelayMilliseconds: 1000
- headers:
- foo2: bar
- foo3: foo33
- fooRes: baz
- body:
- foo2: bar
- foo3: baz
- nullValue: null
- matchers:
- body:
- - path: $.foo2
- type: by_regex
- value: bar
- - path: $.foo3
- type: by_command
- value: executeMe($it)
- - path: $.nullValue
- type: by_null
- value: null
- headers:
- - key: foo2
- regex: bar
- - key: foo3
- command: andMeToo($it)
- cookies:
- - key: foo2
- regex: bar
- - key: foo3
- predefined:
-
request may contain additional request headers, as shown in the following example:
Groovy DSL.
-
org.springframework.cloud.contract.spec.Contract.make {
- request {
-
- method GET()
- url "/foo"
-
-
-
- headers {
- header 'key': 'value'
- contentType(applicationJson())
- }
-
-
- }
-
- response {
-
- status 200
- }
-}
-
YAML.
-
request:
-...
-headers:
- foo: bar
- fooReq: baz
-
request may contain additional request cookies, as shown in the following example:
Groovy DSL.
-
org.springframework.cloud.contract.spec.Contract.make {
- request {
-
- method GET()
- url "/foo"
-
-
-
- cookies {
- cookie 'key': 'value'
- cookie('another_key', 'another_value')
- }
-
-
- }
-
- response {
-
- status 200
- }
-}
-
YAML.
-
request:
-...
-cookies:
- foo: bar
- fooReq: baz
-
request may contain a request body:
Groovy DSL.
-
org.springframework.cloud.contract.spec.Contract.make {
- request {
-
- method GET()
- url "/foo"
-
-
-
- body '''{ "login" : "john", "name": "John The Contract" }'''
- }
-
- response {
-
- status 200
- }
-}
-
YAML.
-
request:
-...
-body:
- foo: bar
-
request may contain multipart elements. To include multipart elements, use the
-multipart method/section, as shown in the following examples
Groovy DSL.
-
-
YAML.
-
request:
- method: PUT
- url: /multipart
- headers:
- Content-Type: multipart/form-data;boundary=AaB03x
- multipart:
- params:
- # key (parameter name), value (parameter value) pair
- formParameter: '"formParameterValue"'
- someBooleanParameter: true
- named:
- - paramName: file
- fileName: filename.csv
- fileContent: file content
- matchers:
- multipart:
- params:
- - key: formParameter
- regex: ".+"
- - key: someBooleanParameter
- predefined: any_boolean
- named:
- - paramName: file
- fileName:
- predefined: non_empty
- fileContent:
- predefined: non_empty
-response:
- status: 200
-
In the preceding example, we define parameters in either of two ways:
Groovy DSL
- Directly, by using the map notation, where the value can be a dynamic property (such as
-
formParameter: $(consumer(…), producer(…))). - By using the
named(…) method that lets you set a named parameter. A named parameter
-can set a name and content. You can call it either via a method with two arguments,
-such as named("fileName", "fileContent"), or via a map notation, such as
-named(name: "fileName", content: "fileContent").
From this contract, the generated test is as follows:
- MockMvcRequestSpecification request = given()
- .header("Content-Type", "multipart/form-data;boundary=AaB03x")
- .param("formParameter", "\"formParameterValue\"")
- .param("someBooleanParameter", "true")
- .multiPart("file", "filename.csv", "file content".getBytes());
-
-
- ResponseOptions response = given().spec(request)
- .put("/multipart");
-
-
- assertThat(response.statusCode()).isEqualTo(200);The WireMock stub is as follows:
'''
-{
- "request" : {
- "url" : "/multipart",
- "method" : "PUT",
- "headers" : {
- "Content-Type" : {
- "matches" : "multipart/form-data;boundary=AaB03x.*"
- }
- },
- "bodyPatterns" : [ {
- "matches" : ".*--(.*)\\r\\nContent-Disposition: form-data; name=\\"formParameter\\"\\r\\n(Content-Type: .*\\r\\n)?(Content-Transfer-Encoding: .*\\r\\n)?(Content-Length: \\\\d+\\r\\n)?\\r\\n\\".+\\"\\r\\n--\\\\1.*"
- }, {
- "matches" : ".*--(.*)\\r\\nContent-Disposition: form-data; name=\\"someBooleanParameter\\"\\r\\n(Content-Type: .*\\r\\n)?(Content-Transfer-Encoding: .*\\r\\n)?(Content-Length: \\\\d+\\r\\n)?\\r\\n(true|false)\\r\\n--\\\\1.*"
- }, {
- "matches" : ".*--(.*)\\r\\nContent-Disposition: form-data; name=\\"file\\"; filename=\\"[\\\\S\\\\s]+\\"\\r\\n(Content-Type: .*\\r\\n)?(Content-Transfer-Encoding: .*\\r\\n)?(Content-Length: \\\\d+\\r\\n)?\\r\\n[\\\\S\\\\s]+\\r\\n--\\\\1.*"
- } ]
- },
- "response" : {
- "status" : 200,
- "transformers" : [ "response-template", "foo-transformer" ]
- }
-}
- '''The contract can contain some dynamic properties: timestamps, IDs, and so on. You do not
-want to force the consumers to stub their clocks to always return the same value of time
-so that it gets matched by the stub.
For Groovy DSL you can provide the dynamic parts in your contracts
-in two ways: pass them directly in the body or set them in a separate section called
-bodyMatchers.
![[Note]](images/note.png) | Note |
|---|
Before 2.0.0 these were set using testMatchers and stubMatchers,
-check out the migration guide for more information. |
For YAML you can only use the matchers section.
8.5.1 Dynamic properties inside the body
You can set the properties inside the body either with the value method or, if you use
-the Groovy map notation, with $(). The following example shows how to set dynamic
-properties with the value method:
value(consumer(...), producer(...))
-value(c(...), p(...))
-value(stub(...), test(...))
-value(client(...), server(...))
The following example shows how to set dynamic properties with $():
$(consumer(...), producer(...))
-$(c(...), p(...))
-$(stub(...), test(...))
-$(client(...), server(...))
Both approaches work equally well. stub and client methods are aliases over the consumer
-method. Subsequent sections take a closer look at what you can do with those values.
8.5.2 Regular expressions
You can use regular expressions to write your requests in Contract DSL. Doing so 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 regular expressions when you
-need to use patterns and not exact values both for your test and your server side tests.
The following example shows how to use regular expressions to write a request:
org.springframework.cloud.contract.spec.Contract.make {
- request {
- method('GET')
- url $(consumer(~/\/[0-9]{2}/), producer('/12'))
- }
- response {
- status OK()
- 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 with a regular expression. If you
-do so, then the contract engine automatically provides the generated string that matches
-the provided regular expression. The following code shows an 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 OK()
- body([
- responseElement: $(producer(regex('[0-9]{7}')))
- ])
- headers {
- contentType("application/vnd.fraud.v1+json")
- }
- }
-}In the preceding example, the opposite side of the communication has the respective data
-generated for request and response.
Spring Cloud Contract comes with a series of predefined regular expressions that you can
-use in your contracts, as shown in the following example:
protected static final Pattern TRUE_OR_FALSE = Pattern.compile(/(true|false)/)
-protected static final Pattern ALPHA_NUMERIC = Pattern.compile('[a-zA-Z0-9]+')
-protected static final Pattern ONLY_ALPHA_UNICODE = Pattern.compile(/[\p{L}]*/)
-protected static final Pattern NUMBER = Pattern.compile('-?(\\d*\\.\\d+|\\d+)')
-protected static final Pattern INTEGER = Pattern.compile('-?(\\d+)')
-protected static final Pattern POSITIVE_INT = Pattern.compile('([1-9]\\d*)')
-protected static final Pattern DOUBLE = Pattern.compile('-?(\\d*\\.\\d+)')
-protected static final Pattern HEX = Pattern.compile('[a-fA-F0-9]+')
-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 HTTPS_URL = UrlHelper.HTTPS_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(/[\S\s]+/)
-protected static final Pattern NON_BLANK = Pattern.compile(/^\s*\S[\S\s]*/)
-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("|"))
-}
-
-RegexProperty onlyAlphaUnicode() {
- return new RegexProperty(ONLY_ALPHA_UNICODE).asString()
-}
-
-RegexProperty alphaNumeric() {
- return new RegexProperty(ALPHA_NUMERIC).asString()
-}
-
-RegexProperty number() {
- return new RegexProperty(NUMBER).asDouble()
-}
-
-RegexProperty positiveInt() {
- return new RegexProperty(POSITIVE_INT).asInteger()
-}
-
-RegexProperty anyBoolean() {
- return new RegexProperty(TRUE_OR_FALSE).asBooleanType()
-}
-
-RegexProperty anInteger() {
- return new RegexProperty(INTEGER).asInteger()
-}
-
-RegexProperty aDouble() {
- return new RegexProperty(DOUBLE).asDouble()
-}
-
-RegexProperty ipAddress() {
- return new RegexProperty(IP_ADDRESS).asString()
-}
-
-RegexProperty hostname() {
- return new RegexProperty(HOSTNAME_PATTERN).asString()
-}
-
-RegexProperty email() {
- return new RegexProperty(EMAIL).asString()
-}
-
-RegexProperty url() {
- return new RegexProperty(URL).asString()
-}
-
-RegexProperty httpsUrl() {
- return new RegexProperty(HTTPS_URL).asString()
-}
-
-RegexProperty uuid() {
- return new RegexProperty(UUID).asString()
-}
-
-RegexProperty isoDate() {
- return new RegexProperty(ANY_DATE).asString()
-}
-
-RegexProperty isoDateTime() {
- return new RegexProperty(ANY_DATE_TIME).asString()
-}
-
-RegexProperty isoTime() {
- return new RegexProperty(ANY_TIME).asString()
-}
-
-RegexProperty iso8601WithOffset() {
- return new RegexProperty(ISO8601_WITH_OFFSET).asString()
-}
-
-RegexProperty nonEmpty() {
- return new RegexProperty(NON_EMPTY).asString()
-}
-
-RegexProperty nonBlank() {
- return new RegexProperty(NON_BLANK).asString()
-}In your contract, you can use it as shown in the following example:
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'))}]"
- )
- }
-}To make matters even simpler you can use a set of predefined objects that will automatically assume that you want a regular expression to be passed.
-All of those methods start with any prefix:
T anyAlphaUnicode()
-
-T anyAlphaNumeric()
-
-T anyNumber()
-
-T anyInteger()
-
-T anyPositiveInt()
-
-T anyDouble()
-
-T anyHex()
-
-T aBoolean()
-
-T anyIpAddress()
-
-T anyHostname()
-
-T anyEmail()
-
-T anyUrl()
-
-T anyHttpsUrl()
-
-T anyUuid()
-
-T anyDate()
-
-T anyDateTime()
-
-T anyTime()
-
-T anyIso8601WithOffset()
-
-T anyNonBlankString()
-
-T anyNonEmptyString()
-
-T anyOf(String... values)
and this is an example of how you can reference those methods:
Contract contractDsl = Contract.make {
- label 'trigger_event'
- input {
- triggeredBy('toString()')
- }
- outputMessage {
- sentTo 'topic.rateablequote'
- body([
- alpha : $(anyAlphaUnicode()),
- number : $(anyNumber()),
- anInteger : $(anyInteger()),
- positiveInt : $(anyPositiveInt()),
- aDouble : $(anyDouble()),
- aBoolean : $(aBoolean()),
- ip : $(anyIpAddress()),
- hostname : $(anyHostname()),
- email : $(anyEmail()),
- url : $(anyUrl()),
- httpsUrl : $(anyHttpsUrl()),
- uuid : $(anyUuid()),
- date : $(anyDate()),
- dateTime : $(anyDateTime()),
- time : $(anyTime()),
- iso8601WithOffset: $(anyIso8601WithOffset()),
- nonBlankString : $(anyNonBlankString()),
- nonEmptyString : $(anyNonEmptyString()),
- anyOf : $(anyOf('foo', 'bar'))
- ])
- }
-}8.5.3 Passing Optional Parameters
It is possible to provide optional parameters in your contract. However, you can provide
-optional parameters only for the following:
- STUB side of the Request
- TEST side of the Response
The following example shows how to provide optional parameters:
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 create a regular
-expression that must be present 0 or more times.
If you use Spock for, the following test would be generated from the previous example:
"""
- 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)?")
-"""The following stub would also be generated:
'''
-{
- "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
-}
-'''8.5.4 Executing Custom Methods on the Server Side
You can define a method call that executes on the server side during the test. Such a
-method can be added to the class defined as "baseClassForTests" in the configuration. The
-following code shows an example of the contract portion of the test case:
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 OK()
- }
-}The following code shows the base class portion of the test case:
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 cannot use both a String and execute to perform concatenation. For
-example, calling header('Authorization', 'Bearer ' + execute('authToken()')) leads to
-improper results. Instead, call header('Authorization', execute('authToken()')) and
-ensure that the authToken() method returns everything you need. |
The type of the object read from the JSON can be one of the following, depending on the
-JSON path:
String: If you point to a String value in the JSON.JSONArray: If you point to a List in the JSON.Map: If you point to a Map in the JSON.Number: If you point to Integer, Double etc. in the JSON.Boolean: If you point to a Boolean in the JSON.
In the request part of the contract, you can specify that the body should be taken from
-a method.
| Important |
|---|
You must provide both the consumer and the producer side. The execute part
-is applied for the whole body - not for parts of it. |
The following example shows how to read an object from JSON:
Contract contractDsl = Contract.make {
- request {
- method 'GET'
- url '/something'
- body(
- $(c('foo'), p(execute('hashCode()')))
- )
- }
- response {
- status OK()
- }
-}The preceding example results in calling the hashCode() method in the request body.
-It should resemble the following code:
- MockMvcRequestSpecification request = given()
- .body(hashCode());
-
-
- ResponseOptions response = given().spec(request)
- .get("/something");
-
-
- assertThat(response.statusCode()).isEqualTo(200);8.5.5 Referencing the Request from the Response
The best situation is to provide fixed values, but sometimes you need to reference a
-request in your response.
If you’re writing contracts using Groovy DSL, you can use the fromRequest() method, which lets
-you reference a bunch of elements from the HTTP request. You can use the following
-options:
fromRequest().url(): Returns the request URL and query parameters.fromRequest().query(String key): Returns the first query parameter with a given name.fromRequest().query(String key, int index): Returns the nth query parameter with a
-given name.fromRequest().path(): Returns the full path.fromRequest().path(int index): Returns the nth path element.fromRequest().header(String key): Returns the first header with a given name.fromRequest().header(String key, int index): Returns the nth header with a given name.fromRequest().body(): Returns the full request body.fromRequest().body(String jsonPath): Returns the element from the request that
-matches the JSON Path.
If you’re using the YAML contract definition you have to use the
-Handlebars {{{ }}} notation with custom, Spring Cloud Contract
- functions to achieve this.
{{{ request.url }}}: Returns the request URL and query parameters.{{{ request.query.key.[index] }}}: Returns the nth query parameter with a given name.
-E.g. for key foo, first entry {{{ request.query.foo.[0] }}}{{{ request.path }}}: Returns the full path.{{{ request.path.[index] }}}: Returns the nth path element. E.g.
-for first entry `{{{ request.path.[0] }}}{{{ request.headers.key }}}: Returns the first header with a given name.{{{ request.headers.key.[index] }}}: Returns the nth header with a given name.{{{ request.body }}}: Returns the full request body.{{{ jsonpath this 'your.json.path' }}}: Returns the element from the request that
-matches the JSON Path. E.g. for json path $.foo - {{{ jsonpath this '$.foo' }}}
Consider the following contract:
Groovy DSL.
-
-
YAML.
-
request:
- method: GET
- url: /api/v1/xxxx
- queryParameters:
- foo:
- - bar
- - bar2
- headers:
- Authorization:
- - secret
- - secret2
- body:
- foo: bar
- baz: 5
-response:
- status: 200
- headers:
- Authorization: "foo {{{ request.headers.Authorization.0 }}} bar"
- body:
- url: "{{{ request.url }}}"
- path: "{{{ request.path }}}"
- pathIndex: "{{{ request.path.1 }}}"
- param: "{{{ request.query.foo }}}"
- paramIndex: "{{{ request.query.foo.1 }}}"
- authorization: "{{{ request.headers.Authorization.0 }}}"
- authorization2: "{{{ request.headers.Authorization.1 }}"
- fullBody: "{{{ request.body }}}"
- responseFoo: "{{{ jsonpath this '$.foo' }}}"
- responseBaz: "{{{ jsonpath this '$.baz' }}}"
- responseBaz2: "Bla bla {{{ jsonpath this '$.foo' }}} bla bla"
-
Running a JUnit test generation leads to a test that resembles the following example:
- 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("['fullBody']").isEqualTo("{\"foo\":\"bar\",\"baz\":5}");
- assertThatJson(parsedJson).field("['authorization']").isEqualTo("secret");
- assertThatJson(parsedJson).field("['authorization2']").isEqualTo("secret2");
- assertThatJson(parsedJson).field("['path']").isEqualTo("/api/v1/xxxx");
- assertThatJson(parsedJson).field("['param']").isEqualTo("bar");
- assertThatJson(parsedJson).field("['paramIndex']").isEqualTo("bar2");
- assertThatJson(parsedJson).field("['pathIndex']").isEqualTo("v1");
- assertThatJson(parsedJson).field("['responseBaz']").isEqualTo(5);
- assertThatJson(parsedJson).field("['responseFoo']").isEqualTo("bar");
- assertThatJson(parsedJson).field("['url']").isEqualTo("/api/v1/xxxx?foo=bar&foo=bar2");
- assertThatJson(parsedJson).field("['responseBaz2']").isEqualTo("Bla bla bar bla bla");As you can see, elements from the request have been properly referenced in the response.
The generated WireMock stub should resemble the following example:
{
- "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" : "{\"authorization\":\"{{{request.headers.Authorization.[0]}}}\",\"path\":\"{{{request.path}}}\",\"responseBaz\":{{{jsonpath this '$.baz'}}} ,\"param\":\"{{{request.query.foo.[0]}}}\",\"pathIndex\":\"{{{request.path.[1]}}}\",\"responseBaz2\":\"Bla bla {{{jsonpath this '$.foo'}}} bla bla\",\"responseFoo\":\"{{{jsonpath this '$.foo'}}}\",\"authorization2\":\"{{{request.headers.Authorization.[1]}}}\",\"fullBody\":\"{{{escapejsonbody}}}\",\"url\":\"{{{request.url}}}\",\"paramIndex\":\"{{{request.query.foo.[1]}}}\"}",
- "headers" : {
- "Authorization" : "{{{request.headers.Authorization.[0]}}};foo"
- },
- "transformers" : [ "response-template" ]
- }
-}Sending a request such as the one presented in the request part of the contract results
-in sending the following response body:
{
- "url" : "/api/v1/xxxx?foo=bar&foo=bar2",
- "path" : "/api/v1/xxxx",
- "pathIndex" : "v1",
- "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 works only with WireMock having a version greater than or equal
-to 2.5.1. The Spring Cloud Contract Verifier uses WireMock’s
-response-template response transformer. It uses Handlebars to convert the Mustache {{{ }}} templates into
-proper values. Additionally, it registers two helper functions: |
escapejsonbody: Escapes the request body in a format that can be embedded in a JSON.jsonpath: For a given parameter, find an object in the request body.
8.5.6 Registering Your Own WireMock Extension
WireMock lets you register custom extensions. By default, Spring Cloud Contract registers
-the transformer, which lets you reference a request from a response. If you want to
-provide your own extensions, you can register an implementation of the
-org.springframework.cloud.contract.verifier.dsl.wiremock.WireMockExtensions interface.
-Since we use the spring.factories extension approach, you can create an entry in
-META-INF/spring.factories file similar to the following:
org.springframework.cloud.contract.verifier.dsl.wiremock.WireMockExtensions=\
-org.springframework.cloud.contract.stubrunner.provider.wiremock.TestWireMockExtensions
-org.springframework.cloud.contract.spec.ContractConverter=\
-org.springframework.cloud.contract.stubrunner.TestCustomYamlContractConverter
The following is an example of a custom extension:
TestWireMockExtensions.groovy.
-
-
-package org.springframework.cloud.contract.verifier.dsl.wiremock
-
-import com.github.tomakehurst.wiremock.extension.Extension
-
-/**
- * Extension that registers the default transformer and the custom one
- */
-class TestWireMockExtensions implements WireMockExtensions {
- @Override
- List<Extension> extensions() {
- return [
- new DefaultResponseTransformer(),
- new CustomExtension()
- ]
- }
-}
-
-class CustomExtension implements Extension {
-
- @Override
- String getName() {
- return "foo-transformer"
- }
-}
-
| Important |
|---|
Remember to override the applyGlobally() method and set it to false if you
-want the transformation to be applied only for a mapping that explicitly requires it. |
8.5.7 Dynamic Properties in the Matchers Sections
If you work with Pact, the following discussion may seem familiar.
-Quite a few users are used to having a separation between the body and setting the
-dynamic parts of a contract.
You can use the bodyMatchers section for two reasons:
- Define the dynamic values that should end up in a stub.
-You can set it in the
request or inputMessage part of your contract. - Verify the result of your test.
-This section is present in the
response or outputMessage side of the
-contract.
Currently, Spring Cloud Contract Verifier supports only JSON Path-based matchers with the
-following matching possibilities:
YAML. Please read the Groovy section for detailed explanation of
-what the types mean
For YAML the structure of a matcher looks like this
- path: $.foo
- type: by_regex
- value: bar
- regexType: as_string
Or if you want to use one of the predefined regular expressions
-[only_alpha_unicode, number, any_boolean, ip_address, hostname,
-email, url, uuid, iso_date, iso_date_time, iso_time, iso_8601_with_offset, non_empty, non_blank]:
- path: $.foo
- type: by_regex
- predefined: only_alpha_unicode
Below you can find the allowed list of `type`s.
For stubMatchers:
by_equalityby_regexby_dateby_timestampby_timeby_type
- there are 2 additional fields accepted:
minOccurrence and maxOccurrence.
For testMatchers:
by_equalityby_regexby_dateby_timestampby_timeby_type
- there are 2 additional fields accepted:
minOccurrence and maxOccurrence.
by_commandby_null
You can also define which type the regular expression corresponds to via the regexType field. Below you can find the allowed list of regular expression types:
- as_integer
- as_double
- as_float,
- as_long
- as_short
- as_boolean
- as_string
Consider the following example:
Groovy DSL.
-
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'
- ]
- ])
- bodyMatchers {
- jsonPath('$.duck', byRegex("[0-9]{3}").asInteger())
- jsonPath('$.duck', byEquality())
- jsonPath('$.alpha', byRegex(onlyAlphaUnicode()).asString())
- jsonPath('$.alpha', byEquality())
- jsonPath('$.number', byRegex(number()).asInteger())
- jsonPath('$.aBoolean', byRegex(anyBoolean()).asBooleanType())
- jsonPath('$.date', byDate())
- jsonPath('$.dateTime', byTimestamp())
- jsonPath('$.time', byTime())
- jsonPath("\$.['key'].['complex.key']", byEquality())
- }
- headers {
- contentType(applicationJson())
- }
- }
- response {
- status OK()
- body([
- duck : 123,
- alpha : 'abc',
- number : 123,
- positiveInteger : 1234567890,
- negativeInteger : -1234567890,
- positiveDecimalNumber: 123.4567890,
- negativeDecimalNumber: -123.4567890,
- 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'
- ],
- nullValue : null
- ])
- bodyMatchers {
-
- jsonPath('$.duck', byRegex("[0-9]{3}").asInteger())
-
- jsonPath('$.duck', byEquality())
-
- jsonPath('$.alpha', byRegex(onlyAlphaUnicode()).asString())
- jsonPath('$.alpha', byEquality())
- jsonPath('$.number', byRegex(number()).asInteger())
- jsonPath('$.positiveInteger', byRegex(anInteger()).asInteger())
- jsonPath('$.negativeInteger', byRegex(anInteger()).asInteger())
- jsonPath('$.positiveDecimalNumber', byRegex(aDouble()).asDouble())
- jsonPath('$.negativeDecimalNumber', byRegex(aDouble()).asDouble())
- jsonPath('$.aBoolean', byRegex(anyBoolean()).asBooleanType())
-
- 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())
- jsonPath('$.nullValue', byNull())
- }
- headers {
- contentType(applicationJson())
- header('Some-Header', $(c('someValue'), p(regex('[a-zA-Z]{9}'))))
- }
- }
-}
-
YAML.
-
request:
- method: GET
- urlPath: /get/1
- headers:
- Content-Type: application/json
- cookies:
- foo: 2
- bar: 3
- queryParameters:
- limit: 10
- offset: 20
- filter: 'email'
- sort: name
- search: 55
- age: 99
- name: John.Doe
- email: 'bob@email.com'
- 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'
- nullValue: null
- valueWithMin:
- - 1
- - 2
- - 3
- valueWithMax:
- - 1
- - 2
- - 3
- valueWithMinMax:
- - 1
- - 2
- - 3
- valueWithMinEmpty: []
- valueWithMaxEmpty: []
- matchers:
- url:
- regex: /get/[0-9]
- # predefined:
- # execute a method
- #command: 'equals($it)'
- queryParameters:
- - key: limit
- type: equal_to
- value: 20
- - key: offset
- type: containing
- value: 20
- - key: sort
- type: equal_to
- value: name
- - key: search
- type: not_matching
- value: '^[0-9]{2}$'
- - key: age
- type: not_matching
- value: '^\\w*$'
- - key: name
- type: matching
- value: 'John.*'
- - key: hello
- type: absent
- cookies:
- - key: foo
- regex: '[0-9]'
- - key: bar
- command: 'equals($it)'
- headers:
- - key: Content-Type
- regex: "application/json.*"
- body:
- - path: $.duck
- type: by_regex
- value: "[0-9]{3}"
- - path: $.duck
- type: by_equality
- - path: $.alpha
- type: by_regex
- predefined: only_alpha_unicode
- - path: $.alpha
- type: by_equality
- - path: $.number
- type: by_regex
- predefined: number
- - path: $.aBoolean
- type: by_regex
- predefined: any_boolean
- - path: $.date
- type: by_date
- - path: $.dateTime
- type: by_timestamp
- - path: $.time
- type: by_time
- - path: "$.['key'].['complex.key']"
- type: by_equality
- - path: $.nullvalue
- type: by_null
- - path: $.valueWithMin
- type: by_type
- minOccurrence: 1
- - path: $.valueWithMax
- type: by_type
- maxOccurrence: 3
- - path: $.valueWithMinMax
- type: by_type
- minOccurrence: 1
- maxOccurrence: 3
-response:
- status: 200
- cookies:
- foo: 1
- bar: 2
- 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'
- nulValue: null
- matchers:
- headers:
- - key: Content-Type
- regex: "application/json.*"
- cookies:
- - key: foo
- regex: '[0-9]'
- - key: bar
- command: 'equals($it)'
- body:
- - path: $.duck
- type: by_regex
- value: "[0-9]{3}"
- - path: $.duck
- type: by_equality
- - path: $.alpha
- type: by_regex
- predefined: only_alpha_unicode
- - path: $.alpha
- type: by_equality
- - path: $.number
- type: by_regex
- predefined: number
- - path: $.aBoolean
- type: by_regex
- predefined: any_boolean
- - path: $.date
- type: by_date
- - path: $.dateTime
- type: by_timestamp
- - path: $.time
- type: by_time
- - path: $.valueWithTypeMatch
- type: by_type
- - path: $.valueWithMin
- type: by_type
- minOccurrence: 1
- - path: $.valueWithMax
- type: by_type
- maxOccurrence: 3
- - path: $.valueWithMinMax
- type: by_type
- minOccurrence: 1
- maxOccurrence: 3
- - path: $.valueWithMinEmpty
- type: by_type
- minOccurrence: 0
- - path: $.valueWithMaxEmpty
- type: by_type
- maxOccurrence: 0
- - path: $.duck
- type: by_command
- value: assertThatValueIsANumber($it)
- - path: $.nullValue
- type: by_null
- value: null
- headers:
- Content-Type: application/json
-
In the preceding example, you can see the dynamic portions of the contract in the
-matchers sections. For the request part, you can see that, for all fields but
-valueWithoutAMatcher, the values of the regular expressions that the stub should
-contain are explicitly set. For the valueWithoutAMatcher, the verification takes place
-in the same way as without the use of matchers. In that case, the test performs an
-equality check.
For the response side in the bodyMatchers section, we define the dynamic parts in a
-similar manner. The only difference is that the byType matchers are also present. The
-verifier engine checks four fields to verify whether the response from the test
-has a value for which the JSON path matches the given field, is of the same type as the one
-defined in the response body, and passes the following check (based on the method being called):
- For
$.valueWithTypeMatch, the engine checks whether the type is the same. - For
$.valueWithMin, the engine check the type and asserts whether the size is greater
-than or equal to the minimum occurrence. - For
$.valueWithMax, the engine checks the type and asserts whether the size is
-smaller than or equal to the maximum occurrence. - For
$.valueWithMinMax, the engine checks the type and asserts whether the size is
-between the min and maximum occurrence.
The resulting test would resemble the following example (note that an and section
-separates the autogenerated assertions and the assertion from matchers):
- 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\",\"key\":{\"complex.key\":\"foo\"}}");
-
-
- 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+|\\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)).as("$.valueWithMin").hasSizeGreaterThanOrEqualTo(1);
- assertThat((Object) parsedJson.read("$.valueWithMax")).isInstanceOf(java.util.List.class);
- assertThat((java.lang.Iterable) parsedJson.read("$.valueWithMax", java.util.Collection.class)).as("$.valueWithMax").hasSizeLessThanOrEqualTo(3);
- assertThat((Object) parsedJson.read("$.valueWithMinMax")).isInstanceOf(java.util.List.class);
- assertThat((java.lang.Iterable) parsedJson.read("$.valueWithMinMax", java.util.Collection.class)).as("$.valueWithMinMax").hasSizeBetween(1, 3);
- assertThat((Object) parsedJson.read("$.valueWithMinEmpty")).isInstanceOf(java.util.List.class);
- assertThat((java.lang.Iterable) parsedJson.read("$.valueWithMinEmpty", java.util.Collection.class)).as("$.valueWithMinEmpty").hasSizeGreaterThanOrEqualTo(0);
- assertThat((Object) parsedJson.read("$.valueWithMaxEmpty")).isInstanceOf(java.util.List.class);
- assertThat((java.lang.Iterable) parsedJson.read("$.valueWithMaxEmpty", java.util.Collection.class)).as("$.valueWithMaxEmpty").hasSizeLessThanOrEqualTo(0);
- assertThatValueIsANumber(parsedJson.read("$.duck"));
- assertThat(parsedJson.read("$.['key'].['complex.key']", String.class)).isEqualTo("foo"); | Important |
|---|
Notice that, for the byCommand method, the example calls the
-assertThatValueIsANumber. This method must be defined in the test base class or be
-statically imported to your tests. Notice that the byCommand call was converted to
-assertThatValueIsANumber(parsedJson.read("$.duck"));. That means that the engine took
-the method name and passed the proper JSON path as a parameter to it. |
The resulting WireMock stub is in the following example:
'''
-{
- "request" : {
- "urlPath" : "/get",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "matches" : "application/json.*"
- }
- },
- "bodyPatterns" : [ {
- "matchesJsonPath" : "$.['list'].['some'].['nested'][?(@.['anothervalue'] == 4)]"
- }, {
- "matchesJsonPath" : "$[?(@.['valueWithoutAMatcher'] == 'foo')]"
- }, {
- "matchesJsonPath" : "$[?(@.['valueWithTypeMatch'] == 'string')]"
- }, {
- "matchesJsonPath" : "$.['list'].['someother'].['nested'][?(@.['json'] == 'with value')]"
- }, {
- "matchesJsonPath" : "$.['list'].['someother'].['nested'][?(@.['anothervalue'] == 4)]"
- }, {
- "matchesJsonPath" : "$[?(@.duck =~ /([0-9]{3})/)]"
- }, {
- "matchesJsonPath" : "$[?(@.duck == 123)]"
- }, {
- "matchesJsonPath" : "$[?(@.alpha =~ /([\\\\p{L}]*)/)]"
- }, {
- "matchesJsonPath" : "$[?(@.alpha == 'abc')]"
- }, {
- "matchesJsonPath" : "$[?(@.number =~ /(-?(\\\\d*\\\\.\\\\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 =~ /(.*)/)]"
- }, {
- "matchesJsonPath" : "$[?(@.valueWithMin.size() >= 1)]"
- }, {
- "matchesJsonPath" : "$[?(@.valueWithMax.size() <= 3)]"
- }, {
- "matchesJsonPath" : "$[?(@.valueWithMinMax.size() >= 1 && @.valueWithMinMax.size() <= 3)]"
- }, {
- "matchesJsonPath" : "$[?(@.valueWithOccurrence.size() >= 4 && @.valueWithOccurrence.size() <= 4)]"
- } ]
- },
- "response" : {
- "status" : 200,
- "body" : "{\\"date\\":\\"2017-01-01\\",\\"dateTime\\":\\"2017-01-01T01:23:45\\",\\"aBoolean\\":true,\\"valueWithMax\\":[1,2,3],\\"valueWithOccurrence\\":[1,2,3,4],\\"number\\":123,\\"duck\\":123,\\"alpha\\":\\"abc\\",\\"valueWithMin\\":[1,2,3],\\"time\\":\\"01:02:34\\",\\"valueWithTypeMatch\\":\\"string\\",\\"valueWithMinMax\\":[1,2,3],\\"valueWithoutAMatcher\\":\\"foo\\"}",
- "headers" : {
- "Content-Type" : "application/json"
- },
- "transformers" : [ "response-template" ]
- }
-}
-''' | Important |
|---|
If you use a matcher, then the part of the request and response that the
-matcher addresses with the JSON Path gets removed from the assertion. In the case of
-verifying a collection, you must create matchers for all the elements of the
-collection. |
Consider the following example:
Contract.make {
- request {
- method 'GET'
- url("/foo")
- }
- response {
- status OK()
- body(events: [[
- operation : 'EXPORT',
- eventId : '16f1ed75-0bcc-4f0d-a04d-3121798faf99',
- status : 'OK'
- ], [
- operation : 'INPUT_PROCESSING',
- eventId : '3bb4ac82-6652-462f-b6d1-75e424a0024a',
- status : 'OK'
- ]
- ]
- )
- bodyMatchers {
- 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('.+'))
- }
- }
-}The preceding code leads to creating the following test (the code block shows only 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. Only the first element of the array got
-asserted. In order to fix this, you should apply the assertion to the whole $.events
-collection and assert it with the byCommand(…) method.
![[Tip]](images/tip.png)
![[Warning]](images/warning.png)
