是否为可能的空数组定义合同？

Question

org.springframework.cloud.contract.spec.Contract.make {
    request {
        method 'GET'
        url $(client(~/\/categories\?publication=[a-zA-Z-_]+?/), server('/categories?publication=DMO'))
    }
    response {
        status 200
        headers {
            header('Content-Type', 'application/json;charset=UTF-8')
        }
        body """\
            [{
                "code": "${value(client('DagKrant'), server(~/[a-zA-Z0-9_-]*/))}",
                "name": "${value(client('De Morgen Krant'), server(~/[a-zA-Z0-9_\- ]*/))}",
                "sections" : []
            },
            {
                "code": "${value(client('WeekendKrant'), server(~/[a-zA-Z0-9_-]*/))}",
                "name": "${value(client('De Morgen Weekend'), server(~/[a-zA-Z0-9_\- ]*/))}",
                "sections" : [
                    {
                    "id" : "${value(client('a984e824'), server(~/[0-9a-f]{8}/))}",
                    "name" : "${value(client('Binnenland'), server(~/[a-zA-Z0-9_\- ]*/))}"
                    }
                ]
            }]
        """
    }
}

DocumentContext parsedJson = JsonPath.parse(response.getBody().asString());
assertThatJson(parsedJson).array().contains("code").matches("[a-zA-Z0-9_-]*");
assertThatJson(parsedJson).array().array("sections").contains("id").matches("([0-9a-f]{8})?");
assertThatJson(parsedJson).array().array("sections").contains("name").matches("[a-zA-Z0-9_\\- ]*");
assertThatJson(parsedJson).array().contains("name").matches("[a-zA-Z0-9_\\- ]*");

Parsed JSON [[{"code":"WeekendKrant","name":"De Morgen Weekend","sections":[]}]] 
doesn't match the JSON path [$[*].sections[*][?(@.id =~ /([0-9a-f]{8})?/)]]

我还尝试使用了optional()，但唯一的区别是regex包含了一个‘？’在最后。JSON断言仍然失败。

在存根中，两个结果都返回，但对于测试，我希望测试也能成功。测试断言纯粹是在每个属性的最后一次出现时生成的吗？难道没有可能在数组上使用类似'optional()'的东西吗？

Answer 1

在版本1.0.3之前，不可能进行类似的额外检查。由于该版本，您可以提供更多的匹配器-http://cloud.spring.io/spring-cloud-static/spring-cloud-contract/1.0.3.release/#_dynamic_properties_in_matchers_sections。您可以使用与大小相关的附加检查来匹配bytype。

摘自文件：

目前，我们只支持具有以下匹配可能性的基于JSON路径的匹配器。对于Stubmatchers：

byTimestamp（）-通过提供的JSON路径从响应中获取的值需要与ISO日期时间的regex匹配

byTime（）-通过提供的JSON路径从响应中获取的值需要匹配ISO时间的regex

对于TestMatchers：

byTimestamp（）-通过提供的JSON路径从响应中获取的值需要与ISO日期时间的regex匹配

byTime（）-通过提供的JSON路径从响应中获取的值需要匹配ISO时间的regex

byType（）-通过提供的JSON路径从响应中获取的值需要与契约中的响应正文中定义的类型相同。byType可以在其中设置minEccurrence和maxEccurrence。这样就可以断言集合的大小。

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"
    ])
    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())
    }
    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
            ],
    ])
    testMatchers {
        // asserts the jsonpath value against manual regex
        jsonPath('$.duck', byRegex("[0-9]{3}"))
        // asserts the jsonpath value against the provided value
        jsonPath('$.duck', byEquality())
        // asserts the jsonpath value against some default regex
        jsonPath('$.alpha', byRegex(onlyAlphaUnicode()))
        jsonPath('$.alpha', byEquality())
        jsonPath('$.number', byRegex(number()))
        jsonPath('$.aBoolean', byRegex(anyBoolean()))
        // asserts vs inbuilt time related regex
        jsonPath('$.date', byDate())
        jsonPath('$.dateTime', byTimestamp())
        jsonPath('$.time', byTime())
        // asserts that the resulting type is the same as in response body
        jsonPath('$.valueWithTypeMatch', byType())
        jsonPath('$.valueWithMin', byType {
            // results in verification of size of array (min 1)
            minOccurrence(1)
        })
        jsonPath('$.valueWithMax', byType {
            // results in verification of size of array (max 3)
            maxOccurrence(3)
        })
        jsonPath('$.valueWithMinMax', byType {
            // results in verification of size of array (min 1 & max 3)
            minOccurrence(1)
            maxOccurrence(3)
        })
    }
    headers {
        contentType(applicationJson())
    }
}
}

assertThat((Object) parsedJson.read("$.valueWithMin")).isInstanceOf(java.util.List.class);
assertThat(parsedJson.read("$.valueWithMin", java.util.Collection.class).size()).isGreaterThanOrEqualTo(1);
assertThat((Object) parsedJson.read("$.valueWithMax")).isInstanceOf(java.util.List.class);
assertThat(parsedJson.read("$.valueWithMax", java.util.Collection.class).size()).isLessThanOrEqualTo(3);
assertThat((Object) parsedJson.read("$.valueWithMinMax")).isInstanceOf(java.util.List.class);
assertThat(parsedJson.read("$.valueWithMinMax", java.util.Collection.class).size()).isStrictlyBetween(1, 3);