我们如何断言JSON响应字段类型（如果是字符串或INT）？

Question

我们如何断言JSON响应字段类型？

{
  "Data" : [
     "Id" : 1,
     "Name" : "ABC"
  ]
}

有什么方法可以验证ID应该包含int和名称应该是String？我不想验证值。

Answer 1

概述

您询问如何检查JSON文档结构。
JSON文档验证针对JSON模式（JSON Schema验证）是执行此类检查的一种方式。

简介

让我们将以下版本视为当前版本：

• 请放心：5.1.1。
• junit：5.8.2。

解决

方案保证支持JSON模式验证。

• usage> usage：示例：示例：json Schema验证休息的维基。
• JSonschemavalidator（JSON-SCHEMA-VALIDATOR 5.1.1 API）。

草稿示例单元测试

单元测试类包含两个测试：成功和失败。

以下消息：

java.lang.AssertionError: 1 expectation failed.
Response body doesn't match expectation.
Expected: The content to match the given JSON schema.
error: instance type (object) does not match any allowed primitive type (allowed: ["string"])
    level: "error"
    schema: {"loadingURI":"file:/<the-project-path>/target/test-classes/schema.json#","pointer":"/properties/Data/items/0/properties/Name"}
    instance: {"pointer":"/Data/0/Name"}
    domain: "validation"
    keyword: "type"
    found: "object"
    expected: ["string"]

  Actual: {
  "Data": [
    {
      "Id": 1,
      "Name": {
        "FirstName": "First",
        "LastName": "Last"
      }
    }
  ]
}

maven项目（pom.xml）

<properties>
    <restassured.version>5.1.1</restassured.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.8.2</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>io.rest-assured</groupId>
        <artifactId>rest-assured</artifactId>
        <version>${restassured.version}</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>io.rest-assured</groupId>
        <artifactId>json-schema-validator</artifactId>
        <version>${restassured.version}</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>com.github.tomakehurst</groupId>
        <artifactId>wiremock-jre8</artifactId>
        <version>2.33.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

的测试失败了

{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "Data": {
      "type": "array",
      "items": [
        {
          "type": "object",
          "properties": {
            "Id": {
              "type": "integer"
            },
            "Name": {
              "type": "string"
            }
          },
          "required": [
            "Id",
            "Name"
          ]
        }
      ]
    }
  },
  "required": [
    "Data"
  ]
}

失败 /test/resources/__ files/data.json ）

{
  "Data": [
    {
      "Id": 1,
      "Name": "ABC"
    }
  ]
}

测试数据（src/test/test/resources/__文件/data-invalid.json）

{
  "Data": [
    {
      "Id": 1,
      "Name": {
        "FirstName": "First",
        "LastName": "Last"
      }
    }
  ]
}

单元测试类（src/test/java/info/brunov/stackoverflow/Question72903880/dataserviceTest.java）

package info.brunov.stackoverflow.question72903880;

import com.github.tomakehurst.wiremock.WireMockServer;
import com.github.tomakehurst.wiremock.client.WireMock;
import com.github.tomakehurst.wiremock.core.WireMockConfiguration;
import io.restassured.RestAssured;
import io.restassured.builder.RequestSpecBuilder;
import io.restassured.filter.log.LogDetail;
import io.restassured.module.jsv.JsonSchemaValidator;
import io.restassured.specification.RequestSpecification;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;

public final class DataServiceTest {
    private final WireMockServer server;
    private final RequestSpecification requestSpecification;

    public DataServiceTest() {
        server = new WireMockServer(
            WireMockConfiguration.wireMockConfig().dynamicPort()
        );
        server.stubFor(
            WireMock.get("/data")
                .willReturn(
                    WireMock.aResponse().withBodyFile("data.json")
                )
        );
        server.stubFor(
            WireMock.get("/data-invalid")
                .willReturn(
                    WireMock.aResponse().withBodyFile("data-invalid.json")
                )
        );
        server.start();

        final RequestSpecBuilder requestSpecBuilder = new RequestSpecBuilder();
        requestSpecBuilder.setPort(server.port());
        requestSpecification = requestSpecBuilder.build();
    }

    @AfterEach
    void tearDown() {
        server.stop();
    }

    @Test
    public void getData_responseConformsSchema_success() {
        RestAssured.given()
            .spec(requestSpecification)
            .get("/data")
            .then()
            .log().ifValidationFails(LogDetail.ALL)
            .assertThat()
            .statusCode(200)
            .body(JsonSchemaValidator.matchesJsonSchemaInClasspath("schema.json"));
    }

    // NOTE: Deliberately failing test.
    @Test
    public void getInvalidData_responseConformSchema_fail() {
        RestAssured.given()
            .spec(requestSpecification)
            .get("/data-invalid")
            .then()
            .log().ifValidationFails(LogDetail.ALL)
            .assertThat()
            .statusCode(200)
            .body(JsonSchemaValidator.matchesJsonSchemaInClasspath("schema.json"));
    }
}