How to Compare a JSON File with a JSON Response

In API testing, comparing a JSON file with a JSON response is a common requirement to ensure the API returns data as expected. This task is especially important when validating the integrity of data against predefined baselines. Let's explore how to compare a JSON file with a JSON response using Java, popular libraries, and best practices.

Why Compare JSON File with JSON Response?

  1. Data Validation: Ensures the API response matches the expected structure and values.
  2. Regression Testing: Detects unintended changes in API behavior.
  3. Error Debugging: Identifies discrepancies between expected and actual results.

Prerequisites

  1. Java installed on your system.
  2. A testing framework like TestNG or JUnit.
  3. JSON processing libraries such as:
    • Jackson: For reading JSON files and serializing/deserializing JSON data.
    • org.json or JSONAssert: For comparing JSON objects.
    • Gson (alternative to Jackson).

Steps to Compare JSON File with JSON Response

  1. Load the JSON File: Read the expected JSON file into a string or a JSON object.
  2. Fetch the API Response: Use an HTTP client like REST Assured to get the JSON response.
  3. Parse JSON Data: Convert the JSON strings to comparable JSON objects.
  4. Perform Comparison: Compare the JSON objects and highlight any differences.

Implementation

Here’s an example of how to perform the comparison using Java, Jackson, and JSONAssert.

Dependencies

Add the following dependencies to your pom.xml if you're using Maven:

<dependencies>

    <!-- REST Assured for API calls -->

    <dependency>

        <groupId>io.rest-assured</groupId>

        <artifactId>rest-assured</artifactId>

        <version>5.3.0</version>

    </dependency>

    <!-- Jackson for JSON processing -->

    <dependency>

        <groupId>com.fasterxml.jackson.core</groupId>

        <artifactId>jackson-databind</artifactId>

        <version>2.15.2</version>

    </dependency>

    <!-- JSONAssert for JSON comparison -->

    <dependency>

        <groupId>org.skyscreamer</groupId>

        <artifactId>jsonassert</artifactId>

        <version>1.5.1</version>

    </dependency>

</dependencies>

Code Example

import io.restassured.RestAssured;

import io.restassured.response.Response;

import com.fasterxml.jackson.databind.ObjectMapper;

import org.json.JSONObject;

import org.skyscreamer.jsonassert.JSONAssert;


import java.io.File;

import java.io.IOException;


public class JsonComparisonTest {


    public static void main(String[] args) {

        try {

            // Step 1: Load the expected JSON from a file

            ObjectMapper objectMapper = new ObjectMapper();

            File jsonFile = new File("src/test/resources/expected.json");

            String expectedJson = objectMapper.writeValueAsString(objectMapper.readTree(jsonFile));


            // Step 2: Fetch the API response

            Response response = RestAssured.get("https://api.example.com/data");

            String actualJson = response.getBody().asString();


            // Step 3: Compare the JSON objects

            JSONAssert.assertEquals(expectedJson, actualJson, true);

            System.out.println("JSONs match!");


        } catch (IOException e) {

            System.err.println("Error reading JSON file: " + e.getMessage());

        } catch (AssertionError e) {

            System.err.println("JSON comparison failed: " + e.getMessage());

        }

    }

}

Explanation of Code

  1. Loading JSON File:

    • Jackson's ObjectMapper reads the JSON file and converts it into a comparable string or object.

  2. Fetching API Response:

    • REST Assured sends a GET request and retrieves the JSON response body as a string.

  3. Comparing JSONs:

    • JSONAssert.assertEquals compares the two JSONs.
    • The third parameter (true) ensures a strict comparison, including the order of fields.

Best Practices

  1. Prettify JSON: Use tools like Jackson's ObjectMapper.writerWithDefaultPrettyPrinter() to make JSON human-readable before logging.
  2. Ignore Unimportant Fields: Use annotations like @JsonIgnore (Jackson) or @SerializedName (Gson) to ignore fields in the expected JSON.
  3. Handle Nested Objects: Ensure deep comparison for complex JSON structures.
  4. Automate Test Cases: Integrate this comparison logic with your CI/CD pipeline for consistent validation.

Advanced Scenarios

1. Partial Matching:

    • Compare only a subset of the JSON response by extracting specific fields.

JSONAssert.assertEquals("{\"key\":\"value\"}", actualJson, false);

2. Dynamic Values:

  • Ignore dynamic values (e.g., timestamps) by excluding them during the comparison.

Followers