December 21, 2023December 21, 2023 vibssingh

Compare JSON Arrays using JSONAssert Library

In this tutorial, we’ll have a look at the JSONAssert library – a library focused on understanding JSON data.

Add the below-mentioned dependency in pom.xml.

  <dependency>
      <groupId>org.skyscreamer</groupId>
      <artifactId>jsonassert</artifactId>
      <version>1.5.1</version>
      <scope>test</scope>
    </dependency>

Table of Contents

There are two modes, strict and non-strict in JSONAssert. In most cases, you will probably want to set strict to false, since that will make the tests less brittle.
Strict tests require all the elements requested to be returned, and only those elements (ie, the tests are non-extensible). Arrays of elements must be returned to the same order as expected.

In Lenient mode, extensibility will be allowed, and no strict ordering will be checked. Let’s see example programs for comparing JSON Arrays.

Comparing two Exact same JSON Arrays – LENIENT Mode

import org.json.JSONArray;
import org.junit.Test;
import org.skyscreamer.jsonassert.JSONAssert;
import org.skyscreamer.jsonassert.JSONCompareMode;

public class JsonArrayAssertDemo {

    @Test
    public void sameArray() {

        // same no of elements, values and in same order
        String jsonArray1 = "[\"Vibha\",\"Abha\",\"Nysha\"]";
        String jsonArray2 = "[\"Vibha\",\"Abha\",\"Nysha\"]";

        JSONAssert.assertEquals(jsonArray1, jsonArray2, JSONCompareMode.LENIENT);
   }
}

The output of the above program is

Comparing two JSON Arrays with the same fields but different in order – Lenient

    @Test
    public void sameArrayDifferentOrder() {

        // Same no of elements but different order
        String jsonArray1 = "[\"Vibha\",\"Abha\",\"Nysha\"]";
        String jsonArray2 = "[\"Nysha\",\"Vibha\",\"Abha\"]";

        JSONAssert.assertEquals(jsonArray1, jsonArray2, JSONCompareMode.LENIENT);
    }

The output of the above program is

LENIENT mode does not care about the order of the fields in the JSON.

Comparing two JSON Arrays with the same fields but different in order – Strict

    @Test
    public void sameArrayDifferentOrder_Strict() {

        // same no of elements, values and in same order
        String jsonArray1 = "[\"Vibha\",\"Abha\",\"Nysha\"]";
        String jsonArray2 = "[\"Nysha\",\"Vibha\",\"Abha\"]";

        JSONAssert.assertEquals(jsonArray1, jsonArray2, JSONCompareMode.STRICT);
    }

The output of the above program is

STRICT mode cares about the order of the fields in the JSON Array.

Comparing two JSON Arrays with the same fields but different values

    @Test
    public void sameArrayDifferentValue() {

        // Same no of elements but different values
        String jsonArray1 = "[\"Vibha Singh\",\"Abha\",\"Nysha\"]";
        String jsonArray2 = "[\"Vibha\",\"Abha\",\"Nysha\"]";

        JSONAssert.assertEquals(jsonArray1, jsonArray2, JSONCompareMode.LENIENT);
    }

The output of the above program is

In this scenario assertEquals() will fail as a value is not matching.

Comparing two JSON Arrays with the case sensitivity

   @Test
    public void sameArrayCaseSensitive() {

        // case sensitive
        String jsonArray1 = "[\"VIbha\",\"Abha\",\"Nysha\"]";
        String jsonArray2 = "[\"Vibha\",\"Abha\",\"Nysha\"]";

        JSONAssert.assertEquals(jsonArray1, jsonArray2, JSONCompareMode.LENIENT);
    }

The output of the above program is

Comparing two JSON Arrays with the same fields but different datatype of values

    @Test
    public void sameJsonArrayWithDifferentDataType() {

        String jsonArray1 = "[\"Vibha\",\"Abha\",\"145000\"]";
        String jsonArray2 = "[\"Vibha\",\"Abha\",145000]";


        JSONAssert.assertEquals(jsonArray1, jsonArray2, JSONCompareMode.LENIENT);
    }

The output of the above program is

Here, 145000 is a string in the first and an integer in the second one. These are not the same. So, the test fails.

Comparing two JSON Arrays by adding one more attribute to the second JSON – Lenient

   @Test
    public void sameArrayDifferentNumber() {
        
        String jsonArray1 = "[\"Vibha\",\"Abha\",\"Nysha\", \"Pooja\"]";
        String jsonArray2 = "[\"Vibha\",\"Abha\",\"Nysha\"]";

        JSONAssert.assertEquals(jsonArray1, jsonArray2, JSONCompareMode.LENIENT);
    }

The output of the above program is

Here, both the JSON Arrays have the same structure, but we have added one more attribute to the second one. In this case, the assertion fails as it counts the number of items in the arrays.

Comparing two JSON Arrays with the addition – STRICT mode

    @Test
    public void sameArrayDifferentNumber() {

        String jsonArray1 = "[\"Vibha\",\"Abha\",\"Nysha\", \"Pooja\"]";
        String jsonArray2 = "[\"Vibha\",\"Abha\",\"Nysha\"]";

        JSONAssert.assertEquals(jsonArray1, jsonArray2, JSONCompareMode.STRICT);
    }

The output of the above program is

The compare mode can also be defined by using an overloaded method that takes boolean instead of JSONCompareMode where LENIENT = false and STRICT = true.

        JSONAssert.assertEquals(jsonArray1, jsonArray2, JSONCompareMode.LENIENT);
        JSONAssert.assertEquals(jsonArray1, jsonArray2, false);

        JSONAssert.assertEquals(jsonArray1, jsonArray2, JSONCompareMode.STRICT);
        JSONAssert.assertEquals(jsonArray1, jsonArray2, true);

Comparing two JSON Arrays

 @Test
    public void jsonArray() {

        JSONObject data1 = new JSONObject();
        data1.put("first_name", "Vibha");
        data1.put("last_name", "Singh");

        JSONObject data2 = new JSONObject();
        data2.put("first_name", "Nysha");
        data2.put("last_name", "Verma");


        // Creating JSON array to add both JSON objects
        JSONArray array1 = new JSONArray();
        array1.put(data1);
        array1.put(data2);

        System.out.println("JSON Array :" + array1);

       //Second JSON Array

        JSONObject data3 = new JSONObject();
        data3.put("first_name", "Nysha");
        data3.put("last_name", "Verma");

        JSONObject data4 = new JSONObject();
        data4.put("first_name", "Vibha");
        data4.put("last_name", "Singh");

        // Creating JSON array to add both JSON objects
        JSONArray array2 = new JSONArray();
        array2.put(data3);
        array2.put(data4);

        System.out.println("JSON Array :" + array2);

        JSONAssert.assertEquals(array1, array2, JSONCompareMode.STRICT);
    }

The output of the above program is

In the above example, we have changed the order of the objects in the JSON Array. So, the test has failed.

Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!! Cheers!!

December 19, 2023December 19, 2023 vibssingh

Compare JSON Objects using JSONAssert Library

In this tutorial, we’ll have a look at the J SONAssert library – a library focused on understanding JSON data.

Table of Contents

Add the below-mentioned dependency in pom.xml.

  <dependency>
      <groupId>org.skyscreamer</groupId>
      <artifactId>jsonassert</artifactId>
      <version>1.5.1</version>
      <scope>test</scope>
    </dependency>

There are two modes, strict and non-strict in JSONAssert. In most cases, you will probably want to set strict to false, since that will make the tests less brittle.
Strict tests require all the elements requested to be returned, and only those elements (ie, the tests are non-extensible). Arrays of elements must be returned to the same order as expected.

In Lenient mode extensibility will be allowed and no strict ordering will be checked. Let’s see example programs for comparing JSONs.

Comparing two Exact same JSON Objects – LENIENT Mode

import org.json.JSONObject;
import org.junit.Test;
import org.skyscreamer.jsonassert.JSONAssert;
import org.skyscreamer.jsonassert.JSONCompareMode;

public class JsonAssertDemo {

    @Test
    public void exactSameJson() {

        String jsonObject1 = "{ " +
                "\"first_name\" : \"Vibha\"," +
                "\"last_name\": \"Singh\"" +
                "}";

        String jsonObject2 = "{ " +
                "\"first_name\" : \"Vibha\"," +
                "\"last_name\": \"Singh\"" +
                "}";

        // Lenient mode - extensible and no strict ordering
        JSONAssert.assertEquals(jsonObject1, jsonObject2, JSONCompareMode.LENIENT);
    }

The output of the above program is

Comparing two JSONs with the same fields but different in order – LENIENT Mode

   @Test
    public void sameJsonWithDifferentOrder() {

        String jsonObject1 = "{ " +
                "\"first_name\" : \"Vibha\"," +
                "\"last_name\": \"Singh\"" +
                "}";

        String jsonObject2 = "{ " +
                "\"last_name\": \"Singh\"," +
                "\"first_name\" : \"Vibha\"" +
                "}";

      
        JSONAssert.assertEquals(jsonObject1, jsonObject2, JSONCompareMode.LENIENT);
    }

The output of the above program is

LENIENT as well as STRICT mode does not care about the order of the fields in the JSON.

Comparing two JSONs with the same fields but different values – LENIENT Mode

    @Test
    public void sameJsonWithDifferentValues() {

        String jsonObject1 = "{ " +
                "\"first_name\" : \"Vibha\"," +
                "\"last_name\": \"Singh\"" +
                "}";

        String jsonObject2 = "{ " +
                "\"first_name\" : \"Vibha\"," +
                "\"last_name\": \"Verma\"" +
                "}";

        JSONAssert.assertEquals(jsonObject1, jsonObject2, JSONCompareMode.LENIENT);
    }

The output of the above program is

In this scenario assertEquals() will fail as a value is not matching.

Comparing two JSONs with the same fields but different datatype of values – LENIENT Mode

  @Test
    public void sameJsonWithDifferentDataType() {

        String jsonObject1 = "{ " +
                "\"first_name\" : \"Vibha\"," +
                "\"last_name\": \"Singh\"," +
                "\"salary\": 115000" +
                "}";

        String jsonObject2 ="{ " +
                "\"first_name\" : \"Vibha\"," +
                "\"last_name\": \"Singh\"," +
                "\"salary\": \"115000\"" +
                "}";

        JSONAssert.assertEquals(jsonObject1, jsonObject2, JSONCompareMode.LENIENT);
    }

The output of the above program is

Here, 115000 is an integer in the first string and a string in the second one. These are not the same. So, the test fails.

Comparing two JSONs by adding one more attribute to the second JSON – LENIENT Mode

 @Test
    public void differentJson() {

        String jsonObject1 = "{ " +
                "\"first_name\" : \"Vibha\"," +
                "\"last_name\": \"Singh\"" +
                "}";

        String jsonObject2 ="{ " +
                "\"first_name\" : \"Vibha\"," +
                "\"last_name\": \"Singh\"," +
                "\"salary\": \"115000\"" +
                "}";

        JSONAssert.assertEquals(jsonObject1, jsonObject2, JSONCompareMode.LENIENT);
    }

The output of the above program is

Here, both the JSONs have the same structure, but we have added one more attribute to the second one. In this case, the assertion matches the first string with the second one and it looks the same. So, the test passes.

Let us reverse the assertion now. We are comparing the jsonObject2 which has 3 attributes with jsonObject1 which has 2 attributes. So, salary is not present in jsonObject1. In this case, the test fails.

    @Test
    public void differentJson() {

        String jsonObject1 = "{ " +
                "\"first_name\" : \"Vibha\"," +
                "\"last_name\": \"Singh\"" +
                "}";

        String jsonObject2 ="{ " +
                "\"first_name\" : \"Vibha\"," +
                "\"last_name\": \"Singh\"," +
                "\"salary\": \"115000\"" +
                "}";

        JSONAssert.assertEquals(jsonObject2, jsonObject1, JSONCompareMode.LENIENT);
    }

The output of the above program is

Comparing two JSONs with the addition – STRICT mode

  @Test
    public void differentJsonWithStrict() {

        String jsonObject1 = "{ " +
                "\"first_name\" : \"Vibha\"," +
                "\"last_name\": \"Singh\"" +
                "}";

        String jsonObject2 ="{ " +
                "\"first_name\" : \"Vibha\"," +
                "\"last_name\": \"Singh\"," +
                "\"salary\": \"115000\"" +
                "}";

        JSONAssert.assertEquals("JSONs are not equal",jsonObject1, jsonObject2, JSONCompareMode.STRICT);
    }

The output of the above program is

The compare mode can also be defined by using an overloaded method that takes boolean instead of JSONCompareMode where LENIENT = false and STRICT = true.

        JSONAssert.assertEquals(jsonObject2, jsonObject1, JSONCompareMode.LENIENT);
        JSONAssert.assertEquals(jsonObject2, jsonObject1, false);

        JSONAssert.assertEquals(jsonObject2, jsonObject1, JSONCompareMode.STRICT);
        JSONAssert.assertEquals(jsonObject2, jsonObject1, true);

Comparing two JSONObjects – LENIENT Mode

 @Test
    public void matchJsonObject()  {

        JSONObject jsonObject1 = new JSONObject();
        jsonObject1.put("first_name", "Vibha");
        jsonObject1.put("last_name", "Singh");

        JSONObject jsonObject2 = new JSONObject();
        jsonObject2.put("first_name", "Vibha");
        jsonObject2.put("last_name", "Verma");

        JSONAssert.assertEquals("JSONs are not equal", jsonObject1, jsonObject2, false);
    }

The output of the above program is

Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!! Cheers!!