Full Json match with RestAssured

Question

I'm using REST-Assured to test some API. My API clearly respond with a JSON and according to the doc if this is the response:

{
    "id": "390",
    "data": {
        "leagueId": 35,
        "homeTeam": "Norway",
        "visitingTeam": "England",
    },
    "odds": [{
        "price": "1.30",
        "name": "1"
    },
    {
        "price": "5.25",
        "name": "X"
    }]
}

I could test like this:

@Test
public void givenUrl_whenSuccessOnGetsResponseAndJsonHasRequiredKV_thenCorrect() {
   get("/events?id=390")
      .then()
         .statusCode(200)
         .assertThat()
            .body("data.leagueId", equalTo(35)); 
}

Surely this is readable but I would a full comparison of the JSON (i.e.: this is the JSON response; this is a canned JSON - a resource file would be perfect - are those JSON equals?). Does REST-Assured offer something like that or I need to make it manually.

Have you looked into json schema validation: https://github.com/rest-assured/rest-assured/wiki/Usage#json-schema-validation — Andrew Nolan, Jun 23 '17 at 15:41
I don't need a schema validation. I need a _result_ validation (not only type but only value). This will be cumbersome with JSON Schema (supposing it is possible) — BAD_SEED, Jun 24 '17 at 08:45

HaC · Answer 1 · 2020-02-05T04:25:12.080

15

Use RestAssured's JsonPath to parse the json file into a Map and then compare it with Hamcrest Matchers. This way the order etc didn't matter.

import static org.hamcrest.Matchers.equalTo;
import io.restassured.path.json.JsonPath;

...

JsonPath expectedJson = new JsonPath(new File("/path/to/expected.json"));

given()
    ...
    .then()
    .body("", equalTo(expectedJson.getMap("")));

edited Feb 05 '20 at 04:25

answered Jul 26 '18 at 04:27

HaC

902
12
24

score 7 · Answer 2 · answered Jul 05 '17 at 02:57

Karate is exactly what you are looking for - you can perform a full equality match of a JSON payload in one step.

And for the cases where you have dynamic values (generated keys, timestamps) Karate provides a very elegant way for you to ignore (or just validate the format of) these keys.

One the primary motivations for creating Karate was to come up with a better alternative to REST-assured. You can refer to this document which can help you evaluate Karate and make a case for it in your organization: Karate vs REST-assured.

score 3 · Answer 3 · answered Jul 08 '17 at 14:37

3

REST Assured does not support JSON comparison, only schema and parts of the body as you have in your question. What you can do is using Hamcrest's JSON comparitorSameJSONAs in Hamcrest JSON SameJSONAs

answered Jul 08 '17 at 14:37

BigGinDaHouse

1,282
9
19

Anton Koshevyi · Answer 4 · 2020-07-13T12:20:52.033

If somebody is looking for method without parsing json-file.

You can check the body size at the beginning using Matchers.aMapWithSize(size), and then check the contents as usual.

Example:

@Test
public void getAccount_forbidden_whenUserIsAnonymous() {
    RestAssured
        .get("/account")
        .then()
        .statusCode(HttpServletResponse.SC_FORBIDDEN)
        .body("", Matchers.aMapWithSize(5),
              "timestamp", Matchers.notNullValue(),
              "status", Matchers.equalTo(HttpServletResponse.SC_FORBIDDEN),
              "error", Matchers.equalTo("Forbidden"),
              "message", Matchers.equalTo("Access Denied"),
              "path", Matchers.equalTo("/account"));
}

score 1 · Answer 5 · answered Nov 08 '20 at 06:24

You can use Validate with JSON SCHEMA in RestAssured.

Try this code:

// Base Test [BaseTest.java]

public class BaseTest {

    protected RequestSpecification requestSpecificationToMerge = new RequestSpecBuilder()
            .setBaseUri("BASE URL")
            .setContentType(ContentType.JSON)
            .build();

    @BeforeMethod
    public void setFilter() {
        RestAssured.filters(new AllureRestAssured());
    }

}

// Test [Home.java]

public class Home extends BaseTest {
    
    @Test(priority = 0)
    public void getHome() {
        
        given()
        .spec(requestSpecificationToMerge)
        .basePath("/your endpoint")
        .when()
        .get()
        .then()
        .log().body()
        .body(matchesJsonSchemaInClasspath("home.json"));
    }

// JSON SCHEMA [home.json]

{
    "type": "object",
    "required": [
        "data",
        "meta",
        "status"
    ],
    "properties": {
        "data": {
            "type": ["array", "null"],
            "items": {
                "type": "object",
                "required": [
                    "id",
                    "title",
                    "sorting"
                ],
                "properties": {
                    "id": {
                        "type": "integer"
                    },
                    "title": {
                        "type": "string"
                    },
                    "sorting": {
                        "type": "integer"
                    }
                }
            }
        },
        "meta": {
            "type": ["object", "null"],
            "required": [
                "pagination"
            ],
            "items": {
                "type": "object",
                "required": [
                    "current_page",
                    "per_page",
                    "total",
                    "total_page"
                ],
                "properties": {
                    "current_page": {
                        "type": "integer"
                    },
                    "per_page": {
                        "type": "integer"
                    },
                    "total": {
                        "type": "integer"
                    },
                    "total_page": {
                        "type": "integer"
                    }
                }
            }
        },
        "status": {
            "type": "object",
            "required": [
                "code",
                "message_client",
                "message_server"
            ],
            "properties": {
                "code": {
                    "type": "integer",
                    "enum": [
                        200,
                        404
                    ]
                },
                "message_client": {
                    "type": "string"
                },
                "message_server": {
                    "type": "string"
                }
            }
        }
    }
}

score 0 · Answer 6 · answered Jun 28 '17 at 12:56

Easy way:

String s = "{\"ip\": \"your_ip\"}";
given().log().all().contentType(ContentType.JSON).get("http://ip.jsontest.com/").then().log().all().assertThat().body(containsString(s))

Not easy way: you can create custom matcher or use jsonpath, it has options to comapre jsons.

score 0 · Answer 7 · answered Aug 03 '20 at 20:20

Apparently, rest-assured only provides capabilities to validate the schema as described here.

However, it's quite simple to make an exact comparison using jackson-databind and junit.

We should write a function that compares a body returned by rest-assured with a file in the resources directory

import org.junit.Assert;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.json.JsonMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;

void assertJsonEquals(String expectedJson, ResponseBodyExtractionOptions actualBody) throws IOException {
    Assert.assertNotNull("The request returned no body", expectedJson);

    final ObjectMapper mapper = new ObjectMapper();
    Assert.assertEquals(
            mapper.readTree(Objects.requireNonNull(getClass().getClassLoader().getResource(expectedJsonPath)).openStream().readAllBytes()),
            mapper.readTree(body.asByteArray())
    );
}

Then, use it as shown below

final ResponseBodyExtractionOptions actualBody = given()
        .accept("application/json")
        .contentType(MediaType.APPLICATION_JSON)
    .when()
        .get("...")
    .then()
        .extract().body();
assertJsonEquals("expected-payload.json", actualBody);

score 0 · Answer 8 · edited Sep 15 '22 at 10:38

0

You can make use of JSONAssert Library to match the entire JSON Response. I recently wrote a blog on how to achieve it.

Below is the basic usage on how to use the library:

    JSONAssert.assertEquals(expectedResponse, actualResponse, JSONCompareMode.LENIENT);

edited Sep 15 '22 at 10:38

halfer

19,824
17
99
186

answered Jul 02 '21 at 15:59

Ashwiinn Karaangutkar

161
3
4
13

Full Json match with RestAssured

8 Answers8

Linked