SOAPUI 断言 json 响应如果等于 json

Question

我在我的测试用例 'CheckResult' 中调用我的服务，我有一组 36 个相同的部分，如下所示：

{
 "data": [
    {
        "idCalculation": 111,
        "idCalculationResult": 707,
        "exchangeRate": 120.3,
        "interestRate": 4.2,
        "anuityDomesticCurrencyAmount": 165669.9171,
        "anuityForeignCurrencyAmount": 1377.1397,
        "totalDomesticCurrencyAmount": 11554978.0125,
        "totalForeignCurrencyAmount": 96051.355,
        "dti": 0.6036
    },
    {
        "idCalculation": 111,
        "idCalculationResult": 708,
        "exchangeRate": 120.3,
        "interestRate": 4.7,
        "anuityDomesticCurrencyAmount": 183875.1364,
        "anuityForeignCurrencyAmount": 1528.4716,
        "totalDomesticCurrencyAmount": 11991903.275,
        "totalForeignCurrencyAmount": 99683.3189,
        "dti": 0.5438
    },
    {
        "idCalculation": 111,
        "idCalculationResult": 709,
        "exchangeRate": 120.3,
        "interestRate": 5.2,
        "anuityDomesticCurrencyAmount": 202349.3784,
        "anuityForeignCurrencyAmount": 1682.0397,
        "totalDomesticCurrencyAmount": 12435285.0834,
        "totalForeignCurrencyAmount": 103368.9533,
        "dti": 0.4941
    },
}
 ... and 33 others
 ]
}

我想用我的控件 json（也是 35 个对象）检查前 35 个对象（最后一个对象被排除在断言之外）。我想检查值以及属性是否有每个对象中的确切数字。

我已经开始了这样的事情：

import groovy.json.JsonSlurper
import groovy.json.JsonOutput

def slurper = new JsonSlurper()
def writeResponse = slurper.parseText(messageExchange.responseContent)

def data0 = writeResponse.data[0]
def data1 = writeResponse.data[1]
def data2 = writeResponse.data[2]
def data3 = writeResponse.data[3]

//for(i=0, i<36, i++){
//if(data[i].idCalculation == 111) return true
//if(data[i].idCalculationResult == 707) return true
//}


log.info(data0)

当然，在 soapui 中比较两个 json "files" 有更简洁的方法吗？

Answer 1

像这样？

...
def writeResponse = slurper.parseText(messageExchange.responseContent)
writeResponse.data.eachWithIndex{dat, idx->
    if(idx<35){
        assert dat.idCalculation == 111
        assert dat.idCalculationResult == 707
    }
}

Answer 2

我会 JsonSlurpify 两个 JSON 文件。（同样的格式，对吧？）

假设结果在两个地方的排序方式相同，您应该能够简单地遍历条目。类似于：

def jsonFile1 = slurper.parseText(messageExchange.responseContent)
def jsonFile2 = slurper.parseText([whereEverYouHaveYourControlJsonFile])
for (def x=0; x<35; x++) {
    assert jsonFile1.data[x].idCalculation == jsonFile2.data[x].idCalculation
    assert jsonFile1.data[x].idCalculationResult== jsonFile2.data[x].idCalculationResult
    // etc... Repeat for each variable
}

Answer 3

您是否需要在文档之间进行精确匹配（除了最终元素）还是只确保 JSON 有效负载符合特定模式？如果是后者，那么您可以使用 JSON 架构来验证您的有效负载。这将检查您的有效负载的结构（包括必需元素和可选元素）和值（不一定是精确值，但值是否符合特定模式）。

例如，验证有效负载的最小 JSON 架构为：

{
    "$schema": "http://json-schema.org/draft-04/schema#",
    "title": "Stack Overflow",
    "description": "Minimal JSON schema",
    "type": "object",
    "properties": {
        "data": {
            "type": "array",
            "items": [
                {
                    "type": "object",
                    "properties": {
                        "idCalculation": {
                            "minimum": 0,
                            "maximum": 1000,
                            "type": "integer"
                        },
                        "idCalculationResult": {
                            "minimum": 0,
                            "maximum": 1000,
                            "type": "integer"
                        },
                        "exchangeRate": {
                            "type": "number",
                            "minimum": 0,
                            "pattern": "^[0-9]{3}.[0-9]{1}$"
                        },
                        "interestRate": {
                            "type": "number",
                            "minimum": 0,
                            "pattern": "^[0-9]{1,2}.[0-9]{1,2}$"
                        },
                        "anuityDomesticCurrencyAmount": {
                            "type": "number",
                            "minimum": 0
                        },
                        "anuityForeignCurrencyAmount": {
                            "type": "number",
                            "minimum": 0
                        },
                        "totalDomesticCurrencyAmount": {
                            "type": "number",
                            "minimum": 0,
                            "exclusiveMinimum": true
                        },
                        "totalForeignCurrencyAmount": {
                            "type": "number",
                            "minimum": 0
                        },
                        "dti": {
                            "type": "number",
                            "minimum": 0
                        }
                    },
                    "required": [
                        "idCalculation",
                        "idCalculationResult",
                        "exchangeRate",
                        "interestRate",
                        "anuityDomesticCurrencyAmount",
                        "anuityForeignCurrencyAmount",
                        "totalDomesticCurrencyAmount",
                        "totalForeignCurrencyAmount",
                        "dti"
                    ]
                }
            ]
        }
    },
    "required": ["data"]
}

这取决于您如何准确地使用模式来验证有效载荷的内容。有关 JSON 架构的更多详细信息，请参阅 Understanding JSON Schema。

如果您有 Ready API，则有一个内置 JSON Schema Compliance Assertion where you can use this schema. If you have soapUI, you can call out to Groovy or Java to perform the schema validation for you. I use json-schema-validator，在我的测试用例中，比较归结为：

assert JsonValidatorUtils.isJsonValid(schemaFile, jsonPayload)

所有这一切看起来工作量很大，但如果您预先投入时间，您最终可能会得到一个可以重复使用的通用解决方案。

SOAPUI 断言 json 响应如果等于 json

SOAPUI assert json response if equals to json

groovy

json

soapui