Skip to content
BranchesTags

Repository files navigation

JsonUnit Build StatusMaven Central

JsonUnit is a library that simplifies JSON comparison in unit tests. The usage is simple:

importstaticnet.javacrumbs.jsonunit.JsonAssert.*;
importstaticnet.javacrumbs.jsonunit.core.Option.*;
...
// compares two JSON documentsassertJsonEquals("{\"test\":1}", "{\n\"test\": 1\n}");
// compares only partassertJsonPartEquals("2", "{\"test\":[{\"value\":1},{\"value\":2}]}",
"test[1].value");
// extra options can be specifiedassertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null}}",
when(TREATING_NULL_AS_ABSENT));
// compares only the structure, not the valuesassertJsonEquals("[{\"test\":1}, {\"test\":2}]",
"[{\n\"test\": 1\n}, {\"TEST\": 4}]", when(IGNORING_VALUES))
// Lenient parsing of expected valueassertJsonEquals("{//Look ma, no quotation marks\n test:'value'}", "{\n\"test\": \"value\"\n}");

When the values are compared, order of elements and whitespaces are ignored.

Hamcrests matchers

You use Hamcrest matchers in the following way

importstaticnet.javacrumbs.jsonunit.JsonMatchers.*;
importstaticorg.junit.Assert.*;
importstaticnet.javacrumbs.jsonunit.core.util.ResourceUtils.resource;
...
assertThat("{\"test\":1}", jsonEquals("{\"test\": 1}"));
assertThat("{\"test\":1}", jsonPartEquals("test", 1));
assertThat("{\"test\":[1, 2, 3]}", jsonPartEquals("test[0]", 1));
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
// Can use other Hamcrest matchers tooassertThat("{\"test\":1}", jsonPartMatches("test", is(valueOf(1))))
assertThat("{\"test\":1}", jsonEquals(resource("test.json")));

Fluent assertions

Fluent (FEST or AssertJ like) assertions are supported by a special module json-unit-fluent

importstaticnet.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
...
// compares entire documentsassertThatJson("{\"test\":1}").isEqualTo("{\"test\":2}");
// compares only parts of the documentassertThatJson("{\"test1\":2, \"test2\":1}")
.node("test1").isEqualTo(2)
.node("test2").isEqualTo(2);
// compare node indexed from start of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[0]").isEqualTo(1);
// compare node indexed from end of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[-1]").isEqualTo(3);
// compares only the structureassertThatJson("{\"test\":1}")
// Options have to be specified before the assertion
.when(IGNORING_VALUES)
.isEqualTo("{\"test\":21}");
// ignores a valueassertThatJson("{\"test\":1}").isEqualTo("{\"test\":\"${json-unit.ignore}\"}");
// ignores extra fieldsassertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
// Options have to be specified before the assertion
.when(IGNORING_EXTRA_FIELDS)
.isEqualTo("{\"test\":{\"b\":2}}");
// array length comparisonassertThatJson("{\"test\":[1,2,3]}").node("test")
.isArray().ofLength(2);
// array contains nodeassertThatJson("{\"test\":[{\"id\":36},{\"id\":37}]}").node("test")
.isArray().thatContains("{\"id\":37}");
// using Hamcrest matcherassertThatJson("{\"test\":\"one\"}").node("test")
.matches(equalTo("one"));
importstaticjava.math.BigDecimal.valueOf;
...
// Numbers sent to matchers are BigDecimals.assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));

Hamcrest matchers in fluent assertions

It is possible to combine fluent assertions with hamcrest matchers using matches method. For example

assertThatJson("{\"test\":[1,2,3]}").node("test").matches(hasItem(valueOf(1)));
assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));

Spring MVC assertions

Since version 1.7.0 JsonUnit supports Spring MVC test assertions. For example

importstaticnet.javacrumbs.jsonunit.spring.JsonUnitResultMatchers.json;
...
this.mockMvc.perform(get("/sample").andExpect(
json().isEqualTo("{\"result\":{\"string\":\"stringValue\", \"array\":[1, 2, 3],\"decimal\":1.00001}}")
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.string2").isAbsent()
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").when(Option.IGNORING_ARRAY_ORDER).isEqualTo(newint[]{3, 2, 1})
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").matches(everyItem(lessThanOrEqualTo(valueOf(4))))
);

Ignoring values

Sometimes you need to ignore certain values when comparing. It is possible to use ${json-unit.ignore} placeholder like this

assertJsonEquals("{\"test\":\"${json-unit.ignore}\"}",
"{\n\"test\": {\"object\" : {\"another\" : 1}}}");

Regular expressions

It is also possible to use regular expressions to compare string values

assertJsonEquals("{\"test\": \"${json-unit.regex}[A-Z]+\"}", "{\"test\": \"ABCD\"}");

Type placeholders

If you want to assert just a type, but you do not care about the exact value, you can use any-* placehloder like this

assertThatJson("{\"test\":\"value\"}")
.isEqualTo("{test:'${json-unit.any-string}'}");
assertThatJson("{\"test\":true}")
.isEqualTo("{\"test\":\"${json-unit.any-boolean}\"}");
assertThatJson("{\"test\":1.1}")
.isEqualTo("{\"test\":\"${json-unit.any-number}\"}");

Options

There are multiple options how you can configure the comparison

TREATING_NULL_AS_ABSENT - fields with null values are equivalent to absent fields. For example, this test passes

assertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null, \"c\": null}}",
when(TREATING_NULL_AS_ABSENT));

IGNORING_ARRAY_ORDER - ignores order in arrays

assertJsonEquals("{\"test\":[1,2,3]}", "{\"test\":[3,2,1]}",
when(IGNORING_ARRAY_ORDER));

IGNORING_EXTRA_ARRAY_ITEMS - ignores unexpected array items

assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[1,2,3,4]}",
when(IGNORING_EXTRA_ARRAY_ITEMS));
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[5,5,4,4,3,3,2,2,1,1]}",
when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER));

IGNORING_EXTRA_FIELDS - ignores extra fileds in the compared value

assertJsonEquals("{\"test\":{\"b\":2}}", "{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
when(IGNORING_EXTRA_FIELDS));

IGNORE_VALUES - ignores values and compares only types

assertJsonEquals("{\"test\":{\"a\":1,\"b\":2,\"c\":3}}", "{\"test\":{\"a\":3,\"b\":2,\"c\":1}}",
when(IGNORING_VALUES));

It is possible to combine options.

assertJsonEquals("{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}", "{\"test\":[{\"key\":3},{\"key\":2, \"extraField\":2},{\"key\":1}]}",
when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS));

In Hamcrest assertion you can set the option like this

assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));

For standard asserts and Hamcrest matchers, it is possible to set the configuration globally

JsonAssert.setOptions(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS);

In fluent assertion, you can set options in the following way

assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
.when(IGNORING_EXTRA_FIELDS).isEqualTo("{\"test\":{\"b\":2}}");

Please note that when method has to be called before the actual comparison.

Numeric comparison

Numbers are by default compared in the following way:

  • If the type differs, the number is different. So 1 and 1.0 are different (int vs. float)
  • Floating number comparison is exact

You can change this behavior by setting tolerance

assertJsonEquals("1", "\n1.009\n", withTolerance(0.01));

or globally

JsonAssert.setTolerance(0.01);

or for fluent assertions

assertThatJson("{\"test\":1.00001}").node("test").withTolerance(0.001).isEqualTo(1);

Or you can use Hamcrest matcher

importstaticjava.math.BigDecimal.valueOf;
...
assertThatJson("{\"test\":1.10001}").node("test")
.matches(closeTo(valueOf(1.1), valueOf(0.001)));

Logging

Although the differences are printed out by the assert statement, sometimes you use JsonUnit with other libraries like Jadler that do not print the differences between documents. In such case, you can switch on the logging. JsonUnit uses SLF4J. The only thing you need to do is to configure your logging framework to log net.javacrumbs.jsonunit.difference on DEBUG level.

Selecting underlying library

JsonUnit is trying to cleverly match which JSON library to use. In case you need to change the default behavior, you can use json-unit.libraries system property. For example -Djson-unit.libraries=jackson2,gson or System.setProperty("json-unit.libraries", "jackson1");. Supported values are gson, json.org, jackson1, jackson2

Maven dependency

JsonUnit is accessible in Maven central repository. In order for it to work, you need either, Jackson 1.x, Jackson 2.x, Gson or JSONObject on the classpath.

<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>

To use fluent assertions:

<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-fluent</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>

To use Spring MVC assertions:

<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-spring</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>

Licence

JsonUnit is licensed under Apache 2.0 licence.

Release notes

1.19.0

  • isArray().thatContains(...) fluent assert added

1.18.0

  • Resource reading helper added

1.17.0

  • System property to specify JSON libraries to be used

1.16.1

  • Array pattern accepts non-word characters

1.16.0

  • isAbsent and isPresent checks take TREAT_NULL_AS_ABSENT into account

1.15.0

  • Dependency on slf4j made optional

1.14.1

  • Preferring org.json library to process JSONArray

1.14.0

  • Support for org.json library
  • Fix: Element out of array bounds is treated as missing

1.13.0

  • Support for any-* placeholders

1.12.1

  • Single quote values in expected String allowed

1.12.0

  • Lenient parsing of expected values

1.11.0

  • Option setting methods made deprecated if called after assertion in JsonFluentAssert
  • JsonFluentAssert constructors made private. Please file an issue if you need them.

1.10.0

  • Added support for IGNORING_EXTRA_ARRAY_ITEMS

1.9.0

  • Made compatible with Jackson 1.4

1.8.0

  • OSGi support thanks to @amergey

1.7.0

  • Support for Spring MVC tests assertions

1.6.1

  • Gson nodes are not reconverted

1.6.0

  • Added support for Hamcrest matchers

1.5.6

  • Fixed handling of empty value in the expected parameter

1.5.5

  • Support for dot in node name

1.5.4

  • Added isObject method to fluent assertions

1.5.3

  • Jackson 1 is preferred if the serialized class contains Jackson1 annotation

1.5.2

  • Added support for regular expressions

1.5.1

  • isStringEqualTo() added to fluent assertions
  • isArray added to fluent assertions

1.5.0

  • One runtime now supports Jackson 1.x, Jackson 2.x and Gson
  • Internal JsonUnit class changed in backwards incompatible way

1.3.0 + 0.3.0

  • Options renamed
  • assertJsonNot* asserts added
  • Support for online configuration in Hamcrest and standard asserts added

1.2.0 + 0.2.0

  • Error messages changed a bit when comparing structures
  • Refactoring of internal classes
  • Support for ignoring array order
  • Support for ignoring values
  • Support for ignoring extra fields

1.1.6 + 0.1.6

  • Treat null as absent added

1.1.5 + 0.1.5

  • Absence/presence tests added

1.1.4 + 0.1.4

  • Path to array in root fixed

1.1.3 + 0.1.3

  • Numeric comparison tolerance added

1.1.2 + 0.1.2

  • jsonStringEquals and jsonStringPartEquals added

1.1.1 + 0.1.1

  • Generics in JsonMatchers fixed

1.1.0 + 0.1.0

  • Simplified API
  • Invalid JSONs in String comparison quoted
  • Runtime incompatible (compile-time compatible) changes

1.0.0

  • Switched to Jackson 2.x
  • Fluent JsonAssert renamed to JsonFluentAssert

0.0.16

  • Fluent assertions made framework independent.

0.0.15

  • Switched from FEST to AssertJ

0.0.14

  • Modules refactored
  • Added support for FEST assert

0.0.13

  • Logging categories changed

0.0.12

  • Added logging

0.0.11

  • Ignore placeholder "${json-unit.ignore}" added

0.0.10

  • Text differences are closed in quotes

0.0.9

  • Matchers added

0.0.7

  • Made Java 5 compatible

0.0.6

  • assertJsonPartStructureEquals added

0.0.5

  • assertJsonPartEquals added

0.0.4

  • Better error messages in case of different types

0.0.3

  • Support for array types and other oddities in root

0.0.2

  • Support for nulls

About

Compare JSON in your Unit Tests

Resources

Readme
Apache-2.0 license
Activity

Stars

0 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - roxspring/JsonUnit: Compare JSON in your Unit Tests · GitHub
Skip to content
BranchesTags
Repository files navigation
JsonUnit Build StatusMaven Central
JsonUnit is a library that simplifies JSON comparison in unit tests. The usage is
simple:
importstaticnet.javacrumbs.jsonunit.JsonAssert.*;
importstaticnet.javacrumbs.jsonunit.core.Option.*;
...
// compares two JSON documentsassertJsonEquals("{\"test\":1}", "{\n\"test\": 1\n}");
// compares only partassertJsonPartEquals("2", "{\"test\":[{\"value\":1},{\"value\":2}]}",
"test[1].value");
// extra options can be specifiedassertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null}}",
when(TREATING_NULL_AS_ABSENT));
// compares only the structure, not the valuesassertJsonEquals("[{\"test\":1}, {\"test\":2}]",
"[{\n\"test\": 1\n}, {\"TEST\": 4}]", when(IGNORING_VALUES))
// Lenient parsing of expected valueassertJsonEquals("{//Look ma, no quotation marks\n test:'value'}", "{\n\"test\": \"value\"\n}");
When the values are compared, order of elements and whitespaces are ignored.
Hamcrests matchers
You use Hamcrest matchers in the following way
importstaticnet.javacrumbs.jsonunit.JsonMatchers.*;
importstaticorg.junit.Assert.*;
importstaticnet.javacrumbs.jsonunit.core.util.ResourceUtils.resource;
...
assertThat("{\"test\":1}", jsonEquals("{\"test\": 1}"));
assertThat("{\"test\":1}", jsonPartEquals("test", 1));
assertThat("{\"test\":[1, 2, 3]}", jsonPartEquals("test[0]", 1));
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
// Can use other Hamcrest matchers tooassertThat("{\"test\":1}", jsonPartMatches("test", is(valueOf(1))))
assertThat("{\"test\":1}", jsonEquals(resource("test.json")));
Fluent assertions
Fluent (FEST or AssertJ like) assertions are supported by a special module json-unit-fluent
importstaticnet.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
...
// compares entire documentsassertThatJson("{\"test\":1}").isEqualTo("{\"test\":2}");
// compares only parts of the documentassertThatJson("{\"test1\":2, \"test2\":1}")
.node("test1").isEqualTo(2)
.node("test2").isEqualTo(2);
// compare node indexed from start of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[0]").isEqualTo(1);
// compare node indexed from end of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[-1]").isEqualTo(3);
// compares only the structureassertThatJson("{\"test\":1}")
// Options have to be specified before the assertion
.when(IGNORING_VALUES)
.isEqualTo("{\"test\":21}");
// ignores a valueassertThatJson("{\"test\":1}").isEqualTo("{\"test\":\"${json-unit.ignore}\"}");
// ignores extra fieldsassertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
// Options have to be specified before the assertion
.when(IGNORING_EXTRA_FIELDS)
.isEqualTo("{\"test\":{\"b\":2}}");
// array length comparisonassertThatJson("{\"test\":[1,2,3]}").node("test")
.isArray().ofLength(2);
// array contains nodeassertThatJson("{\"test\":[{\"id\":36},{\"id\":37}]}").node("test")
.isArray().thatContains("{\"id\":37}");
// using Hamcrest matcherassertThatJson("{\"test\":\"one\"}").node("test")
.matches(equalTo("one"));
importstaticjava.math.BigDecimal.valueOf;
...
// Numbers sent to matchers are BigDecimals.assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
Hamcrest matchers in fluent assertions
It is possible to combine fluent assertions with hamcrest matchers using matches method. For example
assertThatJson("{\"test\":[1,2,3]}").node("test").matches(hasItem(valueOf(1)));
assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
Spring MVC assertions
Since version 1.7.0 JsonUnit supports Spring MVC test assertions. For example
importstaticnet.javacrumbs.jsonunit.spring.JsonUnitResultMatchers.json;
...
this.mockMvc.perform(get("/sample").andExpect(
json().isEqualTo("{\"result\":{\"string\":\"stringValue\", \"array\":[1, 2, 3],\"decimal\":1.00001}}")
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.string2").isAbsent()
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").when(Option.IGNORING_ARRAY_ORDER).isEqualTo(newint[]{3, 2, 1})
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").matches(everyItem(lessThanOrEqualTo(valueOf(4))))
);
Ignoring values
Sometimes you need to ignore certain values when comparing. It is possible to use ${json-unit.ignore}
placeholder like this
assertJsonEquals("{\"test\":\"${json-unit.ignore}\"}",
"{\n\"test\": {\"object\" : {\"another\" : 1}}}");
Regular expressions
It is also possible to use regular expressions to compare string values
assertJsonEquals("{\"test\": \"${json-unit.regex}[A-Z]+\"}", "{\"test\": \"ABCD\"}");
Type placeholders
If you want to assert just a type, but you do not care about the exact value, you can use any-* placehloder like this
assertThatJson("{\"test\":\"value\"}")
.isEqualTo("{test:'${json-unit.any-string}'}");
assertThatJson("{\"test\":true}")
.isEqualTo("{\"test\":\"${json-unit.any-boolean}\"}");
assertThatJson("{\"test\":1.1}")
.isEqualTo("{\"test\":\"${json-unit.any-number}\"}");
Options
There are multiple options how you can configure the comparison
TREATING_NULL_AS_ABSENT - fields with null values are equivalent to absent fields. For example, this test passes
assertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null, \"c\": null}}",
when(TREATING_NULL_AS_ABSENT));
IGNORING_ARRAY_ORDER - ignores order in arrays
assertJsonEquals("{\"test\":[1,2,3]}", "{\"test\":[3,2,1]}",
when(IGNORING_ARRAY_ORDER));
IGNORING_EXTRA_ARRAY_ITEMS - ignores unexpected array items
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[1,2,3,4]}",
when(IGNORING_EXTRA_ARRAY_ITEMS));
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[5,5,4,4,3,3,2,2,1,1]}",
when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER));
IGNORING_EXTRA_FIELDS - ignores extra fileds in the compared value
assertJsonEquals("{\"test\":{\"b\":2}}", "{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
when(IGNORING_EXTRA_FIELDS));
IGNORE_VALUES - ignores values and compares only types
assertJsonEquals("{\"test\":{\"a\":1,\"b\":2,\"c\":3}}", "{\"test\":{\"a\":3,\"b\":2,\"c\":1}}",
when(IGNORING_VALUES));
It is possible to combine options.
assertJsonEquals("{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}", "{\"test\":[{\"key\":3},{\"key\":2, \"extraField\":2},{\"key\":1}]}",
when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS));
In Hamcrest assertion you can set the option like this
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
For standard asserts and Hamcrest matchers, it is possible to set the configuration globally
JsonAssert.setOptions(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS);
In fluent assertion, you can set options in the following way
assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
.when(IGNORING_EXTRA_FIELDS).isEqualTo("{\"test\":{\"b\":2}}");
Please note that when method has to be called before the actual comparison.
Numeric comparison
Numbers are by default compared in the following way:
  • If the type differs, the number is different. So 1 and 1.0 are different (int vs. float)
  • Floating number comparison is exact
You can change this behavior by setting tolerance
assertJsonEquals("1", "\n1.009\n", withTolerance(0.01));
or globally
JsonAssert.setTolerance(0.01);
or for fluent assertions
assertThatJson("{\"test\":1.00001}").node("test").withTolerance(0.001).isEqualTo(1);
Or you can use Hamcrest matcher
importstaticjava.math.BigDecimal.valueOf;
...
assertThatJson("{\"test\":1.10001}").node("test")
.matches(closeTo(valueOf(1.1), valueOf(0.001)));
Logging
Although the differences are printed out by the assert statement, sometimes you use JsonUnit with other libraries like
Jadler that do not print the differences between documents. In such case, you can switch on the
logging. JsonUnit uses SLF4J. The only thing you need to do is to configure your logging
framework to log net.javacrumbs.jsonunit.difference on DEBUG level.
Selecting underlying library
JsonUnit is trying to cleverly match which JSON library to use. In case you need to change the default behavior, you can use
json-unit.libraries system property. For example -Djson-unit.libraries=jackson2,gson or System.setProperty("json-unit.libraries", "jackson1");. Supported values are gson, json.org, jackson1, jackson2
Maven dependency
JsonUnit is accessible in Maven central repository. In order for it to work, you need either, Jackson 1.x,
Jackson 2.x, Gson or JSONObject on the classpath.
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
To use fluent assertions:
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-fluent</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
To use Spring MVC assertions:
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-spring</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
Licence
JsonUnit is licensed under Apache 2.0 licence.
Release notes
1.19.0
  • isArray().thatContains(...) fluent assert added
1.18.0
  • Resource reading helper added
1.17.0
  • System property to specify JSON libraries to be used
1.16.1
  • Array pattern accepts non-word characters
1.16.0
  • isAbsent and isPresent checks take TREAT_NULL_AS_ABSENT into account
1.15.0
  • Dependency on slf4j made optional
1.14.1
  • Preferring org.json library to process JSONArray
1.14.0
  • Support for org.json library
  • Fix: Element out of array bounds is treated as missing
1.13.0
  • Support for any-* placeholders
1.12.1
  • Single quote values in expected String allowed
1.12.0
  • Lenient parsing of expected values
1.11.0
  • Option setting methods made deprecated if called after assertion in JsonFluentAssert
  • JsonFluentAssert constructors made private. Please file an issue if you need them.
1.10.0
  • Added support for IGNORING_EXTRA_ARRAY_ITEMS
1.9.0
  • Made compatible with Jackson 1.4
1.8.0
  • OSGi support thanks to @amergey
1.7.0
  • Support for Spring MVC tests assertions
1.6.1
  • Gson nodes are not reconverted
1.6.0
  • Added support for Hamcrest matchers
1.5.6
  • Fixed handling of empty value in the expected parameter
1.5.5
  • Support for dot in node name
1.5.4
  • Added isObject method to fluent assertions
1.5.3
  • Jackson 1 is preferred if the serialized class contains Jackson1 annotation
1.5.2
  • Added support for regular expressions
1.5.1
  • isStringEqualTo() added to fluent assertions
  • isArray added to fluent assertions
1.5.0
  • One runtime now supports Jackson 1.x, Jackson 2.x and Gson
  • Internal JsonUnit class changed in backwards incompatible way
1.3.0 + 0.3.0
  • Options renamed
  • assertJsonNot* asserts added
  • Support for online configuration in Hamcrest and standard asserts added
1.2.0 + 0.2.0
  • Error messages changed a bit when comparing structures
  • Refactoring of internal classes
  • Support for ignoring array order
  • Support for ignoring values
  • Support for ignoring extra fields
1.1.6 + 0.1.6
  • Treat null as absent added
1.1.5 + 0.1.5
  • Absence/presence tests added
1.1.4 + 0.1.4
  • Path to array in root fixed
1.1.3 + 0.1.3
  • Numeric comparison tolerance added
1.1.2 + 0.1.2
  • jsonStringEquals and jsonStringPartEquals added
1.1.1 + 0.1.1
  • Generics in JsonMatchers fixed
1.1.0 + 0.1.0
  • Simplified API
  • Invalid JSONs in String comparison quoted
  • Runtime incompatible (compile-time compatible) changes
1.0.0
  • Switched to Jackson 2.x
  • Fluent JsonAssert renamed to JsonFluentAssert
0.0.16
  • Fluent assertions made framework independent.
0.0.15
  • Switched from FEST to AssertJ
0.0.14
  • Modules refactored
  • Added support for FEST assert
0.0.13
  • Logging categories changed
0.0.12
  • Added logging
0.0.11
  • Ignore placeholder "${json-unit.ignore}" added
0.0.10
  • Text differences are closed in quotes
0.0.9
  • Matchers added
0.0.7
  • Made Java 5 compatible
0.0.6
  • assertJsonPartStructureEquals added
0.0.5
  • assertJsonPartEquals added
0.0.4
  • Better error messages in case of different types
0.0.3
  • Support for array types and other oddities in root
0.0.2
  • Support for nulls
About
Compare JSON in your Unit Tests
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - roxspring/JsonUnit: Compare JSON in your Unit Tests · GitHub
Skip to content
BranchesTags
Repository files navigation
JsonUnit Build StatusMaven Central
JsonUnit is a library that simplifies JSON comparison in unit tests. The usage is
simple:
importstaticnet.javacrumbs.jsonunit.JsonAssert.*;
importstaticnet.javacrumbs.jsonunit.core.Option.*;
...
// compares two JSON documentsassertJsonEquals("{\"test\":1}", "{\n\"test\": 1\n}");
// compares only partassertJsonPartEquals("2", "{\"test\":[{\"value\":1},{\"value\":2}]}",
"test[1].value");
// extra options can be specifiedassertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null}}",
when(TREATING_NULL_AS_ABSENT));
// compares only the structure, not the valuesassertJsonEquals("[{\"test\":1}, {\"test\":2}]",
"[{\n\"test\": 1\n}, {\"TEST\": 4}]", when(IGNORING_VALUES))
// Lenient parsing of expected valueassertJsonEquals("{//Look ma, no quotation marks\n test:'value'}", "{\n\"test\": \"value\"\n}");
When the values are compared, order of elements and whitespaces are ignored.
Hamcrests matchers
You use Hamcrest matchers in the following way
importstaticnet.javacrumbs.jsonunit.JsonMatchers.*;
importstaticorg.junit.Assert.*;
importstaticnet.javacrumbs.jsonunit.core.util.ResourceUtils.resource;
...
assertThat("{\"test\":1}", jsonEquals("{\"test\": 1}"));
assertThat("{\"test\":1}", jsonPartEquals("test", 1));
assertThat("{\"test\":[1, 2, 3]}", jsonPartEquals("test[0]", 1));
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
// Can use other Hamcrest matchers tooassertThat("{\"test\":1}", jsonPartMatches("test", is(valueOf(1))))
assertThat("{\"test\":1}", jsonEquals(resource("test.json")));
Fluent assertions
Fluent (FEST or AssertJ like) assertions are supported by a special module json-unit-fluent
importstaticnet.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
...
// compares entire documentsassertThatJson("{\"test\":1}").isEqualTo("{\"test\":2}");
// compares only parts of the documentassertThatJson("{\"test1\":2, \"test2\":1}")
.node("test1").isEqualTo(2)
.node("test2").isEqualTo(2);
// compare node indexed from start of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[0]").isEqualTo(1);
// compare node indexed from end of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[-1]").isEqualTo(3);
// compares only the structureassertThatJson("{\"test\":1}")
// Options have to be specified before the assertion
.when(IGNORING_VALUES)
.isEqualTo("{\"test\":21}");
// ignores a valueassertThatJson("{\"test\":1}").isEqualTo("{\"test\":\"${json-unit.ignore}\"}");
// ignores extra fieldsassertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
// Options have to be specified before the assertion
.when(IGNORING_EXTRA_FIELDS)
.isEqualTo("{\"test\":{\"b\":2}}");
// array length comparisonassertThatJson("{\"test\":[1,2,3]}").node("test")
.isArray().ofLength(2);
// array contains nodeassertThatJson("{\"test\":[{\"id\":36},{\"id\":37}]}").node("test")
.isArray().thatContains("{\"id\":37}");
// using Hamcrest matcherassertThatJson("{\"test\":\"one\"}").node("test")
.matches(equalTo("one"));
importstaticjava.math.BigDecimal.valueOf;
...
// Numbers sent to matchers are BigDecimals.assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
Hamcrest matchers in fluent assertions
It is possible to combine fluent assertions with hamcrest matchers using matches method. For example
assertThatJson("{\"test\":[1,2,3]}").node("test").matches(hasItem(valueOf(1)));
assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
Spring MVC assertions
Since version 1.7.0 JsonUnit supports Spring MVC test assertions. For example
importstaticnet.javacrumbs.jsonunit.spring.JsonUnitResultMatchers.json;
...
this.mockMvc.perform(get("/sample").andExpect(
json().isEqualTo("{\"result\":{\"string\":\"stringValue\", \"array\":[1, 2, 3],\"decimal\":1.00001}}")
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.string2").isAbsent()
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").when(Option.IGNORING_ARRAY_ORDER).isEqualTo(newint[]{3, 2, 1})
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").matches(everyItem(lessThanOrEqualTo(valueOf(4))))
);
Ignoring values
Sometimes you need to ignore certain values when comparing. It is possible to use ${json-unit.ignore}
placeholder like this
assertJsonEquals("{\"test\":\"${json-unit.ignore}\"}",
"{\n\"test\": {\"object\" : {\"another\" : 1}}}");
Regular expressions
It is also possible to use regular expressions to compare string values
assertJsonEquals("{\"test\": \"${json-unit.regex}[A-Z]+\"}", "{\"test\": \"ABCD\"}");
Type placeholders
If you want to assert just a type, but you do not care about the exact value, you can use any-* placehloder like this
assertThatJson("{\"test\":\"value\"}")
.isEqualTo("{test:'${json-unit.any-string}'}");
assertThatJson("{\"test\":true}")
.isEqualTo("{\"test\":\"${json-unit.any-boolean}\"}");
assertThatJson("{\"test\":1.1}")
.isEqualTo("{\"test\":\"${json-unit.any-number}\"}");
Options
There are multiple options how you can configure the comparison
TREATING_NULL_AS_ABSENT - fields with null values are equivalent to absent fields. For example, this test passes
assertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null, \"c\": null}}",
when(TREATING_NULL_AS_ABSENT));
IGNORING_ARRAY_ORDER - ignores order in arrays
assertJsonEquals("{\"test\":[1,2,3]}", "{\"test\":[3,2,1]}",
when(IGNORING_ARRAY_ORDER));
IGNORING_EXTRA_ARRAY_ITEMS - ignores unexpected array items
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[1,2,3,4]}",
when(IGNORING_EXTRA_ARRAY_ITEMS));
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[5,5,4,4,3,3,2,2,1,1]}",
when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER));
IGNORING_EXTRA_FIELDS - ignores extra fileds in the compared value
assertJsonEquals("{\"test\":{\"b\":2}}", "{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
when(IGNORING_EXTRA_FIELDS));
IGNORE_VALUES - ignores values and compares only types
assertJsonEquals("{\"test\":{\"a\":1,\"b\":2,\"c\":3}}", "{\"test\":{\"a\":3,\"b\":2,\"c\":1}}",
when(IGNORING_VALUES));
It is possible to combine options.
assertJsonEquals("{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}", "{\"test\":[{\"key\":3},{\"key\":2, \"extraField\":2},{\"key\":1}]}",
when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS));
In Hamcrest assertion you can set the option like this
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
For standard asserts and Hamcrest matchers, it is possible to set the configuration globally
JsonAssert.setOptions(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS);
In fluent assertion, you can set options in the following way
assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
.when(IGNORING_EXTRA_FIELDS).isEqualTo("{\"test\":{\"b\":2}}");
Please note that when method has to be called before the actual comparison.
Numeric comparison
Numbers are by default compared in the following way:
  • If the type differs, the number is different. So 1 and 1.0 are different (int vs. float)
  • Floating number comparison is exact
You can change this behavior by setting tolerance
assertJsonEquals("1", "\n1.009\n", withTolerance(0.01));
or globally
JsonAssert.setTolerance(0.01);
or for fluent assertions
assertThatJson("{\"test\":1.00001}").node("test").withTolerance(0.001).isEqualTo(1);
Or you can use Hamcrest matcher
importstaticjava.math.BigDecimal.valueOf;
...
assertThatJson("{\"test\":1.10001}").node("test")
.matches(closeTo(valueOf(1.1), valueOf(0.001)));
Logging
Although the differences are printed out by the assert statement, sometimes you use JsonUnit with other libraries like
Jadler that do not print the differences between documents. In such case, you can switch on the
logging. JsonUnit uses SLF4J. The only thing you need to do is to configure your logging
framework to log net.javacrumbs.jsonunit.difference on DEBUG level.
Selecting underlying library
JsonUnit is trying to cleverly match which JSON library to use. In case you need to change the default behavior, you can use
json-unit.libraries system property. For example -Djson-unit.libraries=jackson2,gson or System.setProperty("json-unit.libraries", "jackson1");. Supported values are gson, json.org, jackson1, jackson2
Maven dependency
JsonUnit is accessible in Maven central repository. In order for it to work, you need either, Jackson 1.x,
Jackson 2.x, Gson or JSONObject on the classpath.
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
To use fluent assertions:
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-fluent</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
To use Spring MVC assertions:
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-spring</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
Licence
JsonUnit is licensed under Apache 2.0 licence.
Release notes
1.19.0
  • isArray().thatContains(...) fluent assert added
1.18.0
  • Resource reading helper added
1.17.0
  • System property to specify JSON libraries to be used
1.16.1
  • Array pattern accepts non-word characters
1.16.0
  • isAbsent and isPresent checks take TREAT_NULL_AS_ABSENT into account
1.15.0
  • Dependency on slf4j made optional
1.14.1
  • Preferring org.json library to process JSONArray
1.14.0
  • Support for org.json library
  • Fix: Element out of array bounds is treated as missing
1.13.0
  • Support for any-* placeholders
1.12.1
  • Single quote values in expected String allowed
1.12.0
  • Lenient parsing of expected values
1.11.0
  • Option setting methods made deprecated if called after assertion in JsonFluentAssert
  • JsonFluentAssert constructors made private. Please file an issue if you need them.
1.10.0
  • Added support for IGNORING_EXTRA_ARRAY_ITEMS
1.9.0
  • Made compatible with Jackson 1.4
1.8.0
  • OSGi support thanks to @amergey
1.7.0
  • Support for Spring MVC tests assertions
1.6.1
  • Gson nodes are not reconverted
1.6.0
  • Added support for Hamcrest matchers
1.5.6
  • Fixed handling of empty value in the expected parameter
1.5.5
  • Support for dot in node name
1.5.4
  • Added isObject method to fluent assertions
1.5.3
  • Jackson 1 is preferred if the serialized class contains Jackson1 annotation
1.5.2
  • Added support for regular expressions
1.5.1
  • isStringEqualTo() added to fluent assertions
  • isArray added to fluent assertions
1.5.0
  • One runtime now supports Jackson 1.x, Jackson 2.x and Gson
  • Internal JsonUnit class changed in backwards incompatible way
1.3.0 + 0.3.0
  • Options renamed
  • assertJsonNot* asserts added
  • Support for online configuration in Hamcrest and standard asserts added
1.2.0 + 0.2.0
  • Error messages changed a bit when comparing structures
  • Refactoring of internal classes
  • Support for ignoring array order
  • Support for ignoring values
  • Support for ignoring extra fields
1.1.6 + 0.1.6
  • Treat null as absent added
1.1.5 + 0.1.5
  • Absence/presence tests added
1.1.4 + 0.1.4
  • Path to array in root fixed
1.1.3 + 0.1.3
  • Numeric comparison tolerance added
1.1.2 + 0.1.2
  • jsonStringEquals and jsonStringPartEquals added
1.1.1 + 0.1.1
  • Generics in JsonMatchers fixed
1.1.0 + 0.1.0
  • Simplified API
  • Invalid JSONs in String comparison quoted
  • Runtime incompatible (compile-time compatible) changes
1.0.0
  • Switched to Jackson 2.x
  • Fluent JsonAssert renamed to JsonFluentAssert
0.0.16
  • Fluent assertions made framework independent.
0.0.15
  • Switched from FEST to AssertJ
0.0.14
  • Modules refactored
  • Added support for FEST assert
0.0.13
  • Logging categories changed
0.0.12
  • Added logging
0.0.11
  • Ignore placeholder "${json-unit.ignore}" added
0.0.10
  • Text differences are closed in quotes
0.0.9
  • Matchers added
0.0.7
  • Made Java 5 compatible
0.0.6
  • assertJsonPartStructureEquals added
0.0.5
  • assertJsonPartEquals added
0.0.4
  • Better error messages in case of different types
0.0.3
  • Support for array types and other oddities in root
0.0.2
  • Support for nulls
About
Compare JSON in your Unit Tests
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - roxspring/JsonUnit: Compare JSON in your Unit Tests · GitHub
Skip to content
BranchesTags
Repository files navigation
JsonUnit Build StatusMaven Central
JsonUnit is a library that simplifies JSON comparison in unit tests. The usage is
simple:
importstaticnet.javacrumbs.jsonunit.JsonAssert.*;
importstaticnet.javacrumbs.jsonunit.core.Option.*;
...
// compares two JSON documentsassertJsonEquals("{\"test\":1}", "{\n\"test\": 1\n}");
// compares only partassertJsonPartEquals("2", "{\"test\":[{\"value\":1},{\"value\":2}]}",
"test[1].value");
// extra options can be specifiedassertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null}}",
when(TREATING_NULL_AS_ABSENT));
// compares only the structure, not the valuesassertJsonEquals("[{\"test\":1}, {\"test\":2}]",
"[{\n\"test\": 1\n}, {\"TEST\": 4}]", when(IGNORING_VALUES))
// Lenient parsing of expected valueassertJsonEquals("{//Look ma, no quotation marks\n test:'value'}", "{\n\"test\": \"value\"\n}");
When the values are compared, order of elements and whitespaces are ignored.
Hamcrests matchers
You use Hamcrest matchers in the following way
importstaticnet.javacrumbs.jsonunit.JsonMatchers.*;
importstaticorg.junit.Assert.*;
importstaticnet.javacrumbs.jsonunit.core.util.ResourceUtils.resource;
...
assertThat("{\"test\":1}", jsonEquals("{\"test\": 1}"));
assertThat("{\"test\":1}", jsonPartEquals("test", 1));
assertThat("{\"test\":[1, 2, 3]}", jsonPartEquals("test[0]", 1));
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
// Can use other Hamcrest matchers tooassertThat("{\"test\":1}", jsonPartMatches("test", is(valueOf(1))))
assertThat("{\"test\":1}", jsonEquals(resource("test.json")));
Fluent assertions
Fluent (FEST or AssertJ like) assertions are supported by a special module json-unit-fluent
importstaticnet.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
...
// compares entire documentsassertThatJson("{\"test\":1}").isEqualTo("{\"test\":2}");
// compares only parts of the documentassertThatJson("{\"test1\":2, \"test2\":1}")
.node("test1").isEqualTo(2)
.node("test2").isEqualTo(2);
// compare node indexed from start of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[0]").isEqualTo(1);
// compare node indexed from end of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[-1]").isEqualTo(3);
// compares only the structureassertThatJson("{\"test\":1}")
// Options have to be specified before the assertion
.when(IGNORING_VALUES)
.isEqualTo("{\"test\":21}");
// ignores a valueassertThatJson("{\"test\":1}").isEqualTo("{\"test\":\"${json-unit.ignore}\"}");
// ignores extra fieldsassertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
// Options have to be specified before the assertion
.when(IGNORING_EXTRA_FIELDS)
.isEqualTo("{\"test\":{\"b\":2}}");
// array length comparisonassertThatJson("{\"test\":[1,2,3]}").node("test")
.isArray().ofLength(2);
// array contains nodeassertThatJson("{\"test\":[{\"id\":36},{\"id\":37}]}").node("test")
.isArray().thatContains("{\"id\":37}");
// using Hamcrest matcherassertThatJson("{\"test\":\"one\"}").node("test")
.matches(equalTo("one"));
importstaticjava.math.BigDecimal.valueOf;
...
// Numbers sent to matchers are BigDecimals.assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
Hamcrest matchers in fluent assertions
It is possible to combine fluent assertions with hamcrest matchers using matches method. For example
assertThatJson("{\"test\":[1,2,3]}").node("test").matches(hasItem(valueOf(1)));
assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
Spring MVC assertions
Since version 1.7.0 JsonUnit supports Spring MVC test assertions. For example
importstaticnet.javacrumbs.jsonunit.spring.JsonUnitResultMatchers.json;
...
this.mockMvc.perform(get("/sample").andExpect(
json().isEqualTo("{\"result\":{\"string\":\"stringValue\", \"array\":[1, 2, 3],\"decimal\":1.00001}}")
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.string2").isAbsent()
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").when(Option.IGNORING_ARRAY_ORDER).isEqualTo(newint[]{3, 2, 1})
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").matches(everyItem(lessThanOrEqualTo(valueOf(4))))
);
Ignoring values
Sometimes you need to ignore certain values when comparing. It is possible to use ${json-unit.ignore}
placeholder like this
assertJsonEquals("{\"test\":\"${json-unit.ignore}\"}",
"{\n\"test\": {\"object\" : {\"another\" : 1}}}");
Regular expressions
It is also possible to use regular expressions to compare string values
assertJsonEquals("{\"test\": \"${json-unit.regex}[A-Z]+\"}", "{\"test\": \"ABCD\"}");
Type placeholders
If you want to assert just a type, but you do not care about the exact value, you can use any-* placehloder like this
assertThatJson("{\"test\":\"value\"}")
.isEqualTo("{test:'${json-unit.any-string}'}");
assertThatJson("{\"test\":true}")
.isEqualTo("{\"test\":\"${json-unit.any-boolean}\"}");
assertThatJson("{\"test\":1.1}")
.isEqualTo("{\"test\":\"${json-unit.any-number}\"}");
Options
There are multiple options how you can configure the comparison
TREATING_NULL_AS_ABSENT - fields with null values are equivalent to absent fields. For example, this test passes
assertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null, \"c\": null}}",
when(TREATING_NULL_AS_ABSENT));
IGNORING_ARRAY_ORDER - ignores order in arrays
assertJsonEquals("{\"test\":[1,2,3]}", "{\"test\":[3,2,1]}",
when(IGNORING_ARRAY_ORDER));
IGNORING_EXTRA_ARRAY_ITEMS - ignores unexpected array items
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[1,2,3,4]}",
when(IGNORING_EXTRA_ARRAY_ITEMS));
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[5,5,4,4,3,3,2,2,1,1]}",
when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER));
IGNORING_EXTRA_FIELDS - ignores extra fileds in the compared value
assertJsonEquals("{\"test\":{\"b\":2}}", "{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
when(IGNORING_EXTRA_FIELDS));
IGNORE_VALUES - ignores values and compares only types
assertJsonEquals("{\"test\":{\"a\":1,\"b\":2,\"c\":3}}", "{\"test\":{\"a\":3,\"b\":2,\"c\":1}}",
when(IGNORING_VALUES));
It is possible to combine options.
assertJsonEquals("{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}", "{\"test\":[{\"key\":3},{\"key\":2, \"extraField\":2},{\"key\":1}]}",
when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS));
In Hamcrest assertion you can set the option like this
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
For standard asserts and Hamcrest matchers, it is possible to set the configuration globally
JsonAssert.setOptions(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS);
In fluent assertion, you can set options in the following way
assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
.when(IGNORING_EXTRA_FIELDS).isEqualTo("{\"test\":{\"b\":2}}");
Please note that when method has to be called before the actual comparison.
Numeric comparison
Numbers are by default compared in the following way:
  • If the type differs, the number is different. So 1 and 1.0 are different (int vs. float)
  • Floating number comparison is exact
You can change this behavior by setting tolerance
assertJsonEquals("1", "\n1.009\n", withTolerance(0.01));
or globally
JsonAssert.setTolerance(0.01);
or for fluent assertions
assertThatJson("{\"test\":1.00001}").node("test").withTolerance(0.001).isEqualTo(1);
Or you can use Hamcrest matcher
importstaticjava.math.BigDecimal.valueOf;
...
assertThatJson("{\"test\":1.10001}").node("test")
.matches(closeTo(valueOf(1.1), valueOf(0.001)));
Logging
Although the differences are printed out by the assert statement, sometimes you use JsonUnit with other libraries like
Jadler that do not print the differences between documents. In such case, you can switch on the
logging. JsonUnit uses SLF4J. The only thing you need to do is to configure your logging
framework to log net.javacrumbs.jsonunit.difference on DEBUG level.
Selecting underlying library
JsonUnit is trying to cleverly match which JSON library to use. In case you need to change the default behavior, you can use
json-unit.libraries system property. For example -Djson-unit.libraries=jackson2,gson or System.setProperty("json-unit.libraries", "jackson1");. Supported values are gson, json.org, jackson1, jackson2
Maven dependency
JsonUnit is accessible in Maven central repository. In order for it to work, you need either, Jackson 1.x,
Jackson 2.x, Gson or JSONObject on the classpath.
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
To use fluent assertions:
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-fluent</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
To use Spring MVC assertions:
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-spring</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
Licence
JsonUnit is licensed under Apache 2.0 licence.
Release notes
1.19.0
  • isArray().thatContains(...) fluent assert added
1.18.0
  • Resource reading helper added
1.17.0
  • System property to specify JSON libraries to be used
1.16.1
  • Array pattern accepts non-word characters
1.16.0
  • isAbsent and isPresent checks take TREAT_NULL_AS_ABSENT into account
1.15.0
  • Dependency on slf4j made optional
1.14.1
  • Preferring org.json library to process JSONArray
1.14.0
  • Support for org.json library
  • Fix: Element out of array bounds is treated as missing
1.13.0
  • Support for any-* placeholders
1.12.1
  • Single quote values in expected String allowed
1.12.0
  • Lenient parsing of expected values
1.11.0
  • Option setting methods made deprecated if called after assertion in JsonFluentAssert
  • JsonFluentAssert constructors made private. Please file an issue if you need them.
1.10.0
  • Added support for IGNORING_EXTRA_ARRAY_ITEMS
1.9.0
  • Made compatible with Jackson 1.4
1.8.0
  • OSGi support thanks to @amergey
1.7.0
  • Support for Spring MVC tests assertions
1.6.1
  • Gson nodes are not reconverted
1.6.0
  • Added support for Hamcrest matchers
1.5.6
  • Fixed handling of empty value in the expected parameter
1.5.5
  • Support for dot in node name
1.5.4
  • Added isObject method to fluent assertions
1.5.3
  • Jackson 1 is preferred if the serialized class contains Jackson1 annotation
1.5.2
  • Added support for regular expressions
1.5.1
  • isStringEqualTo() added to fluent assertions
  • isArray added to fluent assertions
1.5.0
  • One runtime now supports Jackson 1.x, Jackson 2.x and Gson
  • Internal JsonUnit class changed in backwards incompatible way
1.3.0 + 0.3.0
  • Options renamed
  • assertJsonNot* asserts added
  • Support for online configuration in Hamcrest and standard asserts added
1.2.0 + 0.2.0
  • Error messages changed a bit when comparing structures
  • Refactoring of internal classes
  • Support for ignoring array order
  • Support for ignoring values
  • Support for ignoring extra fields
1.1.6 + 0.1.6
  • Treat null as absent added
1.1.5 + 0.1.5
  • Absence/presence tests added
1.1.4 + 0.1.4
  • Path to array in root fixed
1.1.3 + 0.1.3
  • Numeric comparison tolerance added
1.1.2 + 0.1.2
  • jsonStringEquals and jsonStringPartEquals added
1.1.1 + 0.1.1
  • Generics in JsonMatchers fixed
1.1.0 + 0.1.0
  • Simplified API
  • Invalid JSONs in String comparison quoted
  • Runtime incompatible (compile-time compatible) changes
1.0.0
  • Switched to Jackson 2.x
  • Fluent JsonAssert renamed to JsonFluentAssert
0.0.16
  • Fluent assertions made framework independent.
0.0.15
  • Switched from FEST to AssertJ
0.0.14
  • Modules refactored
  • Added support for FEST assert
0.0.13
  • Logging categories changed
0.0.12
  • Added logging
0.0.11
  • Ignore placeholder "${json-unit.ignore}" added
0.0.10
  • Text differences are closed in quotes
0.0.9
  • Matchers added
0.0.7
  • Made Java 5 compatible
0.0.6
  • assertJsonPartStructureEquals added
0.0.5
  • assertJsonPartEquals added
0.0.4
  • Better error messages in case of different types
0.0.3
  • Support for array types and other oddities in root
0.0.2
  • Support for nulls
About
Compare JSON in your Unit Tests
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - roxspring/JsonUnit: Compare JSON in your Unit Tests · GitHub
Skip to content
BranchesTags
Repository files navigation
JsonUnit Build StatusMaven Central
JsonUnit is a library that simplifies JSON comparison in unit tests. The usage is
simple:
importstaticnet.javacrumbs.jsonunit.JsonAssert.*;
importstaticnet.javacrumbs.jsonunit.core.Option.*;
...
// compares two JSON documentsassertJsonEquals("{\"test\":1}", "{\n\"test\": 1\n}");
// compares only partassertJsonPartEquals("2", "{\"test\":[{\"value\":1},{\"value\":2}]}",
"test[1].value");
// extra options can be specifiedassertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null}}",
when(TREATING_NULL_AS_ABSENT));
// compares only the structure, not the valuesassertJsonEquals("[{\"test\":1}, {\"test\":2}]",
"[{\n\"test\": 1\n}, {\"TEST\": 4}]", when(IGNORING_VALUES))
// Lenient parsing of expected valueassertJsonEquals("{//Look ma, no quotation marks\n test:'value'}", "{\n\"test\": \"value\"\n}");
When the values are compared, order of elements and whitespaces are ignored.
Hamcrests matchers
You use Hamcrest matchers in the following way
importstaticnet.javacrumbs.jsonunit.JsonMatchers.*;
importstaticorg.junit.Assert.*;
importstaticnet.javacrumbs.jsonunit.core.util.ResourceUtils.resource;
...
assertThat("{\"test\":1}", jsonEquals("{\"test\": 1}"));
assertThat("{\"test\":1}", jsonPartEquals("test", 1));
assertThat("{\"test\":[1, 2, 3]}", jsonPartEquals("test[0]", 1));
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
// Can use other Hamcrest matchers tooassertThat("{\"test\":1}", jsonPartMatches("test", is(valueOf(1))))
assertThat("{\"test\":1}", jsonEquals(resource("test.json")));
Fluent assertions
Fluent (FEST or AssertJ like) assertions are supported by a special module json-unit-fluent
importstaticnet.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
...
// compares entire documentsassertThatJson("{\"test\":1}").isEqualTo("{\"test\":2}");
// compares only parts of the documentassertThatJson("{\"test1\":2, \"test2\":1}")
.node("test1").isEqualTo(2)
.node("test2").isEqualTo(2);
// compare node indexed from start of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[0]").isEqualTo(1);
// compare node indexed from end of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[-1]").isEqualTo(3);
// compares only the structureassertThatJson("{\"test\":1}")
// Options have to be specified before the assertion
.when(IGNORING_VALUES)
.isEqualTo("{\"test\":21}");
// ignores a valueassertThatJson("{\"test\":1}").isEqualTo("{\"test\":\"${json-unit.ignore}\"}");
// ignores extra fieldsassertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
// Options have to be specified before the assertion
.when(IGNORING_EXTRA_FIELDS)
.isEqualTo("{\"test\":{\"b\":2}}");
// array length comparisonassertThatJson("{\"test\":[1,2,3]}").node("test")
.isArray().ofLength(2);
// array contains nodeassertThatJson("{\"test\":[{\"id\":36},{\"id\":37}]}").node("test")
.isArray().thatContains("{\"id\":37}");
// using Hamcrest matcherassertThatJson("{\"test\":\"one\"}").node("test")
.matches(equalTo("one"));
importstaticjava.math.BigDecimal.valueOf;
...
// Numbers sent to matchers are BigDecimals.assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
Hamcrest matchers in fluent assertions
It is possible to combine fluent assertions with hamcrest matchers using matches method. For example
assertThatJson("{\"test\":[1,2,3]}").node("test").matches(hasItem(valueOf(1)));
assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
Spring MVC assertions
Since version 1.7.0 JsonUnit supports Spring MVC test assertions. For example
importstaticnet.javacrumbs.jsonunit.spring.JsonUnitResultMatchers.json;
...
this.mockMvc.perform(get("/sample").andExpect(
json().isEqualTo("{\"result\":{\"string\":\"stringValue\", \"array\":[1, 2, 3],\"decimal\":1.00001}}")
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.string2").isAbsent()
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").when(Option.IGNORING_ARRAY_ORDER).isEqualTo(newint[]{3, 2, 1})
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").matches(everyItem(lessThanOrEqualTo(valueOf(4))))
);
Ignoring values
Sometimes you need to ignore certain values when comparing. It is possible to use ${json-unit.ignore}
placeholder like this
assertJsonEquals("{\"test\":\"${json-unit.ignore}\"}",
"{\n\"test\": {\"object\" : {\"another\" : 1}}}");
Regular expressions
It is also possible to use regular expressions to compare string values
assertJsonEquals("{\"test\": \"${json-unit.regex}[A-Z]+\"}", "{\"test\": \"ABCD\"}");
Type placeholders
If you want to assert just a type, but you do not care about the exact value, you can use any-* placehloder like this
assertThatJson("{\"test\":\"value\"}")
.isEqualTo("{test:'${json-unit.any-string}'}");
assertThatJson("{\"test\":true}")
.isEqualTo("{\"test\":\"${json-unit.any-boolean}\"}");
assertThatJson("{\"test\":1.1}")
.isEqualTo("{\"test\":\"${json-unit.any-number}\"}");
Options
There are multiple options how you can configure the comparison
TREATING_NULL_AS_ABSENT - fields with null values are equivalent to absent fields. For example, this test passes
assertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null, \"c\": null}}",
when(TREATING_NULL_AS_ABSENT));
IGNORING_ARRAY_ORDER - ignores order in arrays
assertJsonEquals("{\"test\":[1,2,3]}", "{\"test\":[3,2,1]}",
when(IGNORING_ARRAY_ORDER));
IGNORING_EXTRA_ARRAY_ITEMS - ignores unexpected array items
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[1,2,3,4]}",
when(IGNORING_EXTRA_ARRAY_ITEMS));
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[5,5,4,4,3,3,2,2,1,1]}",
when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER));
IGNORING_EXTRA_FIELDS - ignores extra fileds in the compared value
assertJsonEquals("{\"test\":{\"b\":2}}", "{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
when(IGNORING_EXTRA_FIELDS));
IGNORE_VALUES - ignores values and compares only types
assertJsonEquals("{\"test\":{\"a\":1,\"b\":2,\"c\":3}}", "{\"test\":{\"a\":3,\"b\":2,\"c\":1}}",
when(IGNORING_VALUES));
It is possible to combine options.
assertJsonEquals("{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}", "{\"test\":[{\"key\":3},{\"key\":2, \"extraField\":2},{\"key\":1}]}",
when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS));
In Hamcrest assertion you can set the option like this
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
For standard asserts and Hamcrest matchers, it is possible to set the configuration globally
JsonAssert.setOptions(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS);
In fluent assertion, you can set options in the following way
assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
.when(IGNORING_EXTRA_FIELDS).isEqualTo("{\"test\":{\"b\":2}}");
Please note that when method has to be called before the actual comparison.
Numeric comparison
Numbers are by default compared in the following way:
  • If the type differs, the number is different. So 1 and 1.0 are different (int vs. float)
  • Floating number comparison is exact
You can change this behavior by setting tolerance
assertJsonEquals("1", "\n1.009\n", withTolerance(0.01));
or globally
JsonAssert.setTolerance(0.01);
or for fluent assertions
assertThatJson("{\"test\":1.00001}").node("test").withTolerance(0.001).isEqualTo(1);
Or you can use Hamcrest matcher
importstaticjava.math.BigDecimal.valueOf;
...
assertThatJson("{\"test\":1.10001}").node("test")
.matches(closeTo(valueOf(1.1), valueOf(0.001)));
Logging
Although the differences are printed out by the assert statement, sometimes you use JsonUnit with other libraries like
Jadler that do not print the differences between documents. In such case, you can switch on the
logging. JsonUnit uses SLF4J. The only thing you need to do is to configure your logging
framework to log net.javacrumbs.jsonunit.difference on DEBUG level.
Selecting underlying library
JsonUnit is trying to cleverly match which JSON library to use. In case you need to change the default behavior, you can use
json-unit.libraries system property. For example -Djson-unit.libraries=jackson2,gson or System.setProperty("json-unit.libraries", "jackson1");. Supported values are gson, json.org, jackson1, jackson2
Maven dependency
JsonUnit is accessible in Maven central repository. In order for it to work, you need either, Jackson 1.x,
Jackson 2.x, Gson or JSONObject on the classpath.
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
To use fluent assertions:
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-fluent</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
To use Spring MVC assertions:
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-spring</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
Licence
JsonUnit is licensed under Apache 2.0 licence.
Release notes
1.19.0
  • isArray().thatContains(...) fluent assert added
1.18.0
  • Resource reading helper added
1.17.0
  • System property to specify JSON libraries to be used
1.16.1
  • Array pattern accepts non-word characters
1.16.0
  • isAbsent and isPresent checks take TREAT_NULL_AS_ABSENT into account
1.15.0
  • Dependency on slf4j made optional
1.14.1
  • Preferring org.json library to process JSONArray
1.14.0
  • Support for org.json library
  • Fix: Element out of array bounds is treated as missing
1.13.0
  • Support for any-* placeholders
1.12.1
  • Single quote values in expected String allowed
1.12.0
  • Lenient parsing of expected values
1.11.0
  • Option setting methods made deprecated if called after assertion in JsonFluentAssert
  • JsonFluentAssert constructors made private. Please file an issue if you need them.
1.10.0
  • Added support for IGNORING_EXTRA_ARRAY_ITEMS
1.9.0
  • Made compatible with Jackson 1.4
1.8.0
  • OSGi support thanks to @amergey
1.7.0
  • Support for Spring MVC tests assertions
1.6.1
  • Gson nodes are not reconverted
1.6.0
  • Added support for Hamcrest matchers
1.5.6
  • Fixed handling of empty value in the expected parameter
1.5.5
  • Support for dot in node name
1.5.4
  • Added isObject method to fluent assertions
1.5.3
  • Jackson 1 is preferred if the serialized class contains Jackson1 annotation
1.5.2
  • Added support for regular expressions
1.5.1
  • isStringEqualTo() added to fluent assertions
  • isArray added to fluent assertions
1.5.0
  • One runtime now supports Jackson 1.x, Jackson 2.x and Gson
  • Internal JsonUnit class changed in backwards incompatible way
1.3.0 + 0.3.0
  • Options renamed
  • assertJsonNot* asserts added
  • Support for online configuration in Hamcrest and standard asserts added
1.2.0 + 0.2.0
  • Error messages changed a bit when comparing structures
  • Refactoring of internal classes
  • Support for ignoring array order
  • Support for ignoring values
  • Support for ignoring extra fields
1.1.6 + 0.1.6
  • Treat null as absent added
1.1.5 + 0.1.5
  • Absence/presence tests added
1.1.4 + 0.1.4
  • Path to array in root fixed
1.1.3 + 0.1.3
  • Numeric comparison tolerance added
1.1.2 + 0.1.2
  • jsonStringEquals and jsonStringPartEquals added
1.1.1 + 0.1.1
  • Generics in JsonMatchers fixed
1.1.0 + 0.1.0
  • Simplified API
  • Invalid JSONs in String comparison quoted
  • Runtime incompatible (compile-time compatible) changes
1.0.0
  • Switched to Jackson 2.x
  • Fluent JsonAssert renamed to JsonFluentAssert
0.0.16
  • Fluent assertions made framework independent.
0.0.15
  • Switched from FEST to AssertJ
0.0.14
  • Modules refactored
  • Added support for FEST assert
0.0.13
  • Logging categories changed
0.0.12
  • Added logging
0.0.11
  • Ignore placeholder "${json-unit.ignore}" added
0.0.10
  • Text differences are closed in quotes
0.0.9
  • Matchers added
0.0.7
  • Made Java 5 compatible
0.0.6
  • assertJsonPartStructureEquals added
0.0.5
  • assertJsonPartEquals added
0.0.4
  • Better error messages in case of different types
0.0.3
  • Support for array types and other oddities in root
0.0.2
  • Support for nulls
About
Compare JSON in your Unit Tests
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - roxspring/JsonUnit: Compare JSON in your Unit Tests · GitHub
Skip to content
BranchesTags
Repository files navigation
JsonUnit Build StatusMaven Central
JsonUnit is a library that simplifies JSON comparison in unit tests. The usage is
simple:
importstaticnet.javacrumbs.jsonunit.JsonAssert.*;
importstaticnet.javacrumbs.jsonunit.core.Option.*;
...
// compares two JSON documentsassertJsonEquals("{\"test\":1}", "{\n\"test\": 1\n}");
// compares only partassertJsonPartEquals("2", "{\"test\":[{\"value\":1},{\"value\":2}]}",
"test[1].value");
// extra options can be specifiedassertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null}}",
when(TREATING_NULL_AS_ABSENT));
// compares only the structure, not the valuesassertJsonEquals("[{\"test\":1}, {\"test\":2}]",
"[{\n\"test\": 1\n}, {\"TEST\": 4}]", when(IGNORING_VALUES))
// Lenient parsing of expected valueassertJsonEquals("{//Look ma, no quotation marks\n test:'value'}", "{\n\"test\": \"value\"\n}");
When the values are compared, order of elements and whitespaces are ignored.
Hamcrests matchers
You use Hamcrest matchers in the following way
importstaticnet.javacrumbs.jsonunit.JsonMatchers.*;
importstaticorg.junit.Assert.*;
importstaticnet.javacrumbs.jsonunit.core.util.ResourceUtils.resource;
...
assertThat("{\"test\":1}", jsonEquals("{\"test\": 1}"));
assertThat("{\"test\":1}", jsonPartEquals("test", 1));
assertThat("{\"test\":[1, 2, 3]}", jsonPartEquals("test[0]", 1));
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
// Can use other Hamcrest matchers tooassertThat("{\"test\":1}", jsonPartMatches("test", is(valueOf(1))))
assertThat("{\"test\":1}", jsonEquals(resource("test.json")));
Fluent assertions
Fluent (FEST or AssertJ like) assertions are supported by a special module json-unit-fluent
importstaticnet.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
...
// compares entire documentsassertThatJson("{\"test\":1}").isEqualTo("{\"test\":2}");
// compares only parts of the documentassertThatJson("{\"test1\":2, \"test2\":1}")
.node("test1").isEqualTo(2)
.node("test2").isEqualTo(2);
// compare node indexed from start of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[0]").isEqualTo(1);
// compare node indexed from end of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[-1]").isEqualTo(3);
// compares only the structureassertThatJson("{\"test\":1}")
// Options have to be specified before the assertion
.when(IGNORING_VALUES)
.isEqualTo("{\"test\":21}");
// ignores a valueassertThatJson("{\"test\":1}").isEqualTo("{\"test\":\"${json-unit.ignore}\"}");
// ignores extra fieldsassertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
// Options have to be specified before the assertion
.when(IGNORING_EXTRA_FIELDS)
.isEqualTo("{\"test\":{\"b\":2}}");
// array length comparisonassertThatJson("{\"test\":[1,2,3]}").node("test")
.isArray().ofLength(2);
// array contains nodeassertThatJson("{\"test\":[{\"id\":36},{\"id\":37}]}").node("test")
.isArray().thatContains("{\"id\":37}");
// using Hamcrest matcherassertThatJson("{\"test\":\"one\"}").node("test")
.matches(equalTo("one"));
importstaticjava.math.BigDecimal.valueOf;
...
// Numbers sent to matchers are BigDecimals.assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
Hamcrest matchers in fluent assertions
It is possible to combine fluent assertions with hamcrest matchers using matches method. For example
assertThatJson("{\"test\":[1,2,3]}").node("test").matches(hasItem(valueOf(1)));
assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
Spring MVC assertions
Since version 1.7.0 JsonUnit supports Spring MVC test assertions. For example
importstaticnet.javacrumbs.jsonunit.spring.JsonUnitResultMatchers.json;
...
this.mockMvc.perform(get("/sample").andExpect(
json().isEqualTo("{\"result\":{\"string\":\"stringValue\", \"array\":[1, 2, 3],\"decimal\":1.00001}}")
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.string2").isAbsent()
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").when(Option.IGNORING_ARRAY_ORDER).isEqualTo(newint[]{3, 2, 1})
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").matches(everyItem(lessThanOrEqualTo(valueOf(4))))
);
Ignoring values
Sometimes you need to ignore certain values when comparing. It is possible to use ${json-unit.ignore}
placeholder like this
assertJsonEquals("{\"test\":\"${json-unit.ignore}\"}",
"{\n\"test\": {\"object\" : {\"another\" : 1}}}");
Regular expressions
It is also possible to use regular expressions to compare string values
assertJsonEquals("{\"test\": \"${json-unit.regex}[A-Z]+\"}", "{\"test\": \"ABCD\"}");
Type placeholders
If you want to assert just a type, but you do not care about the exact value, you can use any-* placehloder like this
assertThatJson("{\"test\":\"value\"}")
.isEqualTo("{test:'${json-unit.any-string}'}");
assertThatJson("{\"test\":true}")
.isEqualTo("{\"test\":\"${json-unit.any-boolean}\"}");
assertThatJson("{\"test\":1.1}")
.isEqualTo("{\"test\":\"${json-unit.any-number}\"}");
Options
There are multiple options how you can configure the comparison
TREATING_NULL_AS_ABSENT - fields with null values are equivalent to absent fields. For example, this test passes
assertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null, \"c\": null}}",
when(TREATING_NULL_AS_ABSENT));
IGNORING_ARRAY_ORDER - ignores order in arrays
assertJsonEquals("{\"test\":[1,2,3]}", "{\"test\":[3,2,1]}",
when(IGNORING_ARRAY_ORDER));
IGNORING_EXTRA_ARRAY_ITEMS - ignores unexpected array items
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[1,2,3,4]}",
when(IGNORING_EXTRA_ARRAY_ITEMS));
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[5,5,4,4,3,3,2,2,1,1]}",
when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER));
IGNORING_EXTRA_FIELDS - ignores extra fileds in the compared value
assertJsonEquals("{\"test\":{\"b\":2}}", "{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
when(IGNORING_EXTRA_FIELDS));
IGNORE_VALUES - ignores values and compares only types
assertJsonEquals("{\"test\":{\"a\":1,\"b\":2,\"c\":3}}", "{\"test\":{\"a\":3,\"b\":2,\"c\":1}}",
when(IGNORING_VALUES));
It is possible to combine options.
assertJsonEquals("{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}", "{\"test\":[{\"key\":3},{\"key\":2, \"extraField\":2},{\"key\":1}]}",
when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS));
In Hamcrest assertion you can set the option like this
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
For standard asserts and Hamcrest matchers, it is possible to set the configuration globally
JsonAssert.setOptions(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS);
In fluent assertion, you can set options in the following way
assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
.when(IGNORING_EXTRA_FIELDS).isEqualTo("{\"test\":{\"b\":2}}");
Please note that when method has to be called before the actual comparison.
Numeric comparison
Numbers are by default compared in the following way:
  • If the type differs, the number is different. So 1 and 1.0 are different (int vs. float)
  • Floating number comparison is exact
You can change this behavior by setting tolerance
assertJsonEquals("1", "\n1.009\n", withTolerance(0.01));
or globally
JsonAssert.setTolerance(0.01);
or for fluent assertions
assertThatJson("{\"test\":1.00001}").node("test").withTolerance(0.001).isEqualTo(1);
Or you can use Hamcrest matcher
importstaticjava.math.BigDecimal.valueOf;
...
assertThatJson("{\"test\":1.10001}").node("test")
.matches(closeTo(valueOf(1.1), valueOf(0.001)));
Logging
Although the differences are printed out by the assert statement, sometimes you use JsonUnit with other libraries like
Jadler that do not print the differences between documents. In such case, you can switch on the
logging. JsonUnit uses SLF4J. The only thing you need to do is to configure your logging
framework to log net.javacrumbs.jsonunit.difference on DEBUG level.
Selecting underlying library
JsonUnit is trying to cleverly match which JSON library to use. In case you need to change the default behavior, you can use
json-unit.libraries system property. For example -Djson-unit.libraries=jackson2,gson or System.setProperty("json-unit.libraries", "jackson1");. Supported values are gson, json.org, jackson1, jackson2
Maven dependency
JsonUnit is accessible in Maven central repository. In order for it to work, you need either, Jackson 1.x,
Jackson 2.x, Gson or JSONObject on the classpath.
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
To use fluent assertions:
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-fluent</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
To use Spring MVC assertions:
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-spring</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
Licence
JsonUnit is licensed under Apache 2.0 licence.
Release notes
1.19.0
  • isArray().thatContains(...) fluent assert added
1.18.0
  • Resource reading helper added
1.17.0
  • System property to specify JSON libraries to be used
1.16.1
  • Array pattern accepts non-word characters
1.16.0
  • isAbsent and isPresent checks take TREAT_NULL_AS_ABSENT into account
1.15.0
  • Dependency on slf4j made optional
1.14.1
  • Preferring org.json library to process JSONArray
1.14.0
  • Support for org.json library
  • Fix: Element out of array bounds is treated as missing
1.13.0
  • Support for any-* placeholders
1.12.1
  • Single quote values in expected String allowed
1.12.0
  • Lenient parsing of expected values
1.11.0
  • Option setting methods made deprecated if called after assertion in JsonFluentAssert
  • JsonFluentAssert constructors made private. Please file an issue if you need them.
1.10.0
  • Added support for IGNORING_EXTRA_ARRAY_ITEMS
1.9.0
  • Made compatible with Jackson 1.4
1.8.0
  • OSGi support thanks to @amergey
1.7.0
  • Support for Spring MVC tests assertions
1.6.1
  • Gson nodes are not reconverted
1.6.0
  • Added support for Hamcrest matchers
1.5.6
  • Fixed handling of empty value in the expected parameter
1.5.5
  • Support for dot in node name
1.5.4
  • Added isObject method to fluent assertions
1.5.3
  • Jackson 1 is preferred if the serialized class contains Jackson1 annotation
1.5.2
  • Added support for regular expressions
1.5.1
  • isStringEqualTo() added to fluent assertions
  • isArray added to fluent assertions
1.5.0
  • One runtime now supports Jackson 1.x, Jackson 2.x and Gson
  • Internal JsonUnit class changed in backwards incompatible way
1.3.0 + 0.3.0
  • Options renamed
  • assertJsonNot* asserts added
  • Support for online configuration in Hamcrest and standard asserts added
1.2.0 + 0.2.0
  • Error messages changed a bit when comparing structures
  • Refactoring of internal classes
  • Support for ignoring array order
  • Support for ignoring values
  • Support for ignoring extra fields
1.1.6 + 0.1.6
  • Treat null as absent added
1.1.5 + 0.1.5
  • Absence/presence tests added
1.1.4 + 0.1.4
  • Path to array in root fixed
1.1.3 + 0.1.3
  • Numeric comparison tolerance added
1.1.2 + 0.1.2
  • jsonStringEquals and jsonStringPartEquals added
1.1.1 + 0.1.1
  • Generics in JsonMatchers fixed
1.1.0 + 0.1.0
  • Simplified API
  • Invalid JSONs in String comparison quoted
  • Runtime incompatible (compile-time compatible) changes
1.0.0
  • Switched to Jackson 2.x
  • Fluent JsonAssert renamed to JsonFluentAssert
0.0.16
  • Fluent assertions made framework independent.
0.0.15
  • Switched from FEST to AssertJ
0.0.14
  • Modules refactored
  • Added support for FEST assert
0.0.13
  • Logging categories changed
0.0.12
  • Added logging
0.0.11
  • Ignore placeholder "${json-unit.ignore}" added
0.0.10
  • Text differences are closed in quotes
0.0.9
  • Matchers added
0.0.7
  • Made Java 5 compatible
0.0.6
  • assertJsonPartStructureEquals added
0.0.5
  • assertJsonPartEquals added
0.0.4
  • Better error messages in case of different types
0.0.3
  • Support for array types and other oddities in root
0.0.2
  • Support for nulls
About
Compare JSON in your Unit Tests
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - roxspring/JsonUnit: Compare JSON in your Unit Tests · GitHub
Skip to content
BranchesTags
Repository files navigation
JsonUnit Build StatusMaven Central
JsonUnit is a library that simplifies JSON comparison in unit tests. The usage is
simple:
importstaticnet.javacrumbs.jsonunit.JsonAssert.*;
importstaticnet.javacrumbs.jsonunit.core.Option.*;
...
// compares two JSON documentsassertJsonEquals("{\"test\":1}", "{\n\"test\": 1\n}");
// compares only partassertJsonPartEquals("2", "{\"test\":[{\"value\":1},{\"value\":2}]}",
"test[1].value");
// extra options can be specifiedassertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null}}",
when(TREATING_NULL_AS_ABSENT));
// compares only the structure, not the valuesassertJsonEquals("[{\"test\":1}, {\"test\":2}]",
"[{\n\"test\": 1\n}, {\"TEST\": 4}]", when(IGNORING_VALUES))
// Lenient parsing of expected valueassertJsonEquals("{//Look ma, no quotation marks\n test:'value'}", "{\n\"test\": \"value\"\n}");
When the values are compared, order of elements and whitespaces are ignored.
Hamcrests matchers
You use Hamcrest matchers in the following way
importstaticnet.javacrumbs.jsonunit.JsonMatchers.*;
importstaticorg.junit.Assert.*;
importstaticnet.javacrumbs.jsonunit.core.util.ResourceUtils.resource;
...
assertThat("{\"test\":1}", jsonEquals("{\"test\": 1}"));
assertThat("{\"test\":1}", jsonPartEquals("test", 1));
assertThat("{\"test\":[1, 2, 3]}", jsonPartEquals("test[0]", 1));
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
// Can use other Hamcrest matchers tooassertThat("{\"test\":1}", jsonPartMatches("test", is(valueOf(1))))
assertThat("{\"test\":1}", jsonEquals(resource("test.json")));
Fluent assertions
Fluent (FEST or AssertJ like) assertions are supported by a special module json-unit-fluent
importstaticnet.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
...
// compares entire documentsassertThatJson("{\"test\":1}").isEqualTo("{\"test\":2}");
// compares only parts of the documentassertThatJson("{\"test1\":2, \"test2\":1}")
.node("test1").isEqualTo(2)
.node("test2").isEqualTo(2);
// compare node indexed from start of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[0]").isEqualTo(1);
// compare node indexed from end of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[-1]").isEqualTo(3);
// compares only the structureassertThatJson("{\"test\":1}")
// Options have to be specified before the assertion
.when(IGNORING_VALUES)
.isEqualTo("{\"test\":21}");
// ignores a valueassertThatJson("{\"test\":1}").isEqualTo("{\"test\":\"${json-unit.ignore}\"}");
// ignores extra fieldsassertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
// Options have to be specified before the assertion
.when(IGNORING_EXTRA_FIELDS)
.isEqualTo("{\"test\":{\"b\":2}}");
// array length comparisonassertThatJson("{\"test\":[1,2,3]}").node("test")
.isArray().ofLength(2);
// array contains nodeassertThatJson("{\"test\":[{\"id\":36},{\"id\":37}]}").node("test")
.isArray().thatContains("{\"id\":37}");
// using Hamcrest matcherassertThatJson("{\"test\":\"one\"}").node("test")
.matches(equalTo("one"));
importstaticjava.math.BigDecimal.valueOf;
...
// Numbers sent to matchers are BigDecimals.assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
Hamcrest matchers in fluent assertions
It is possible to combine fluent assertions with hamcrest matchers using matches method. For example
assertThatJson("{\"test\":[1,2,3]}").node("test").matches(hasItem(valueOf(1)));
assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
Spring MVC assertions
Since version 1.7.0 JsonUnit supports Spring MVC test assertions. For example
importstaticnet.javacrumbs.jsonunit.spring.JsonUnitResultMatchers.json;
...
this.mockMvc.perform(get("/sample").andExpect(
json().isEqualTo("{\"result\":{\"string\":\"stringValue\", \"array\":[1, 2, 3],\"decimal\":1.00001}}")
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.string2").isAbsent()
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").when(Option.IGNORING_ARRAY_ORDER).isEqualTo(newint[]{3, 2, 1})
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").matches(everyItem(lessThanOrEqualTo(valueOf(4))))
);
Ignoring values
Sometimes you need to ignore certain values when comparing. It is possible to use ${json-unit.ignore}
placeholder like this
assertJsonEquals("{\"test\":\"${json-unit.ignore}\"}",
"{\n\"test\": {\"object\" : {\"another\" : 1}}}");
Regular expressions
It is also possible to use regular expressions to compare string values
assertJsonEquals("{\"test\": \"${json-unit.regex}[A-Z]+\"}", "{\"test\": \"ABCD\"}");
Type placeholders
If you want to assert just a type, but you do not care about the exact value, you can use any-* placehloder like this
assertThatJson("{\"test\":\"value\"}")
.isEqualTo("{test:'${json-unit.any-string}'}");
assertThatJson("{\"test\":true}")
.isEqualTo("{\"test\":\"${json-unit.any-boolean}\"}");
assertThatJson("{\"test\":1.1}")
.isEqualTo("{\"test\":\"${json-unit.any-number}\"}");
Options
There are multiple options how you can configure the comparison
TREATING_NULL_AS_ABSENT - fields with null values are equivalent to absent fields. For example, this test passes
assertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null, \"c\": null}}",
when(TREATING_NULL_AS_ABSENT));
IGNORING_ARRAY_ORDER - ignores order in arrays
assertJsonEquals("{\"test\":[1,2,3]}", "{\"test\":[3,2,1]}",
when(IGNORING_ARRAY_ORDER));
IGNORING_EXTRA_ARRAY_ITEMS - ignores unexpected array items
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[1,2,3,4]}",
when(IGNORING_EXTRA_ARRAY_ITEMS));
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[5,5,4,4,3,3,2,2,1,1]}",
when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER));
IGNORING_EXTRA_FIELDS - ignores extra fileds in the compared value
assertJsonEquals("{\"test\":{\"b\":2}}", "{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
when(IGNORING_EXTRA_FIELDS));
IGNORE_VALUES - ignores values and compares only types
assertJsonEquals("{\"test\":{\"a\":1,\"b\":2,\"c\":3}}", "{\"test\":{\"a\":3,\"b\":2,\"c\":1}}",
when(IGNORING_VALUES));
It is possible to combine options.
assertJsonEquals("{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}", "{\"test\":[{\"key\":3},{\"key\":2, \"extraField\":2},{\"key\":1}]}",
when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS));
In Hamcrest assertion you can set the option like this
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
For standard asserts and Hamcrest matchers, it is possible to set the configuration globally
JsonAssert.setOptions(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS);
In fluent assertion, you can set options in the following way
assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
.when(IGNORING_EXTRA_FIELDS).isEqualTo("{\"test\":{\"b\":2}}");
Please note that when method has to be called before the actual comparison.
Numeric comparison
Numbers are by default compared in the following way:
  • If the type differs, the number is different. So 1 and 1.0 are different (int vs. float)
  • Floating number comparison is exact
You can change this behavior by setting tolerance
assertJsonEquals("1", "\n1.009\n", withTolerance(0.01));
or globally
JsonAssert.setTolerance(0.01);
or for fluent assertions
assertThatJson("{\"test\":1.00001}").node("test").withTolerance(0.001).isEqualTo(1);
Or you can use Hamcrest matcher
importstaticjava.math.BigDecimal.valueOf;
...
assertThatJson("{\"test\":1.10001}").node("test")
.matches(closeTo(valueOf(1.1), valueOf(0.001)));
Logging
Although the differences are printed out by the assert statement, sometimes you use JsonUnit with other libraries like
Jadler that do not print the differences between documents. In such case, you can switch on the
logging. JsonUnit uses SLF4J. The only thing you need to do is to configure your logging
framework to log net.javacrumbs.jsonunit.difference on DEBUG level.
Selecting underlying library
JsonUnit is trying to cleverly match which JSON library to use. In case you need to change the default behavior, you can use
json-unit.libraries system property. For example -Djson-unit.libraries=jackson2,gson or System.setProperty("json-unit.libraries", "jackson1");. Supported values are gson, json.org, jackson1, jackson2
Maven dependency
JsonUnit is accessible in Maven central repository. In order for it to work, you need either, Jackson 1.x,
Jackson 2.x, Gson or JSONObject on the classpath.
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
To use fluent assertions:
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-fluent</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
To use Spring MVC assertions:
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-spring</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
Licence
JsonUnit is licensed under Apache 2.0 licence.
Release notes
1.19.0
  • isArray().thatContains(...) fluent assert added
1.18.0
  • Resource reading helper added
1.17.0
  • System property to specify JSON libraries to be used
1.16.1
  • Array pattern accepts non-word characters
1.16.0
  • isAbsent and isPresent checks take TREAT_NULL_AS_ABSENT into account
1.15.0
  • Dependency on slf4j made optional
1.14.1
  • Preferring org.json library to process JSONArray
1.14.0
  • Support for org.json library
  • Fix: Element out of array bounds is treated as missing
1.13.0
  • Support for any-* placeholders
1.12.1
  • Single quote values in expected String allowed
1.12.0
  • Lenient parsing of expected values
1.11.0
  • Option setting methods made deprecated if called after assertion in JsonFluentAssert
  • JsonFluentAssert constructors made private. Please file an issue if you need them.
1.10.0
  • Added support for IGNORING_EXTRA_ARRAY_ITEMS
1.9.0
  • Made compatible with Jackson 1.4
1.8.0
  • OSGi support thanks to @amergey
1.7.0
  • Support for Spring MVC tests assertions
1.6.1
  • Gson nodes are not reconverted
1.6.0
  • Added support for Hamcrest matchers
1.5.6
  • Fixed handling of empty value in the expected parameter
1.5.5
  • Support for dot in node name
1.5.4
  • Added isObject method to fluent assertions
1.5.3
  • Jackson 1 is preferred if the serialized class contains Jackson1 annotation
1.5.2
  • Added support for regular expressions
1.5.1
  • isStringEqualTo() added to fluent assertions
  • isArray added to fluent assertions
1.5.0
  • One runtime now supports Jackson 1.x, Jackson 2.x and Gson
  • Internal JsonUnit class changed in backwards incompatible way
1.3.0 + 0.3.0
  • Options renamed
  • assertJsonNot* asserts added
  • Support for online configuration in Hamcrest and standard asserts added
1.2.0 + 0.2.0
  • Error messages changed a bit when comparing structures
  • Refactoring of internal classes
  • Support for ignoring array order
  • Support for ignoring values
  • Support for ignoring extra fields
1.1.6 + 0.1.6
  • Treat null as absent added
1.1.5 + 0.1.5
  • Absence/presence tests added
1.1.4 + 0.1.4
  • Path to array in root fixed
1.1.3 + 0.1.3
  • Numeric comparison tolerance added
1.1.2 + 0.1.2
  • jsonStringEquals and jsonStringPartEquals added
1.1.1 + 0.1.1
  • Generics in JsonMatchers fixed
1.1.0 + 0.1.0
  • Simplified API
  • Invalid JSONs in String comparison quoted
  • Runtime incompatible (compile-time compatible) changes
1.0.0
  • Switched to Jackson 2.x
  • Fluent JsonAssert renamed to JsonFluentAssert
0.0.16
  • Fluent assertions made framework independent.
0.0.15
  • Switched from FEST to AssertJ
0.0.14
  • Modules refactored
  • Added support for FEST assert
0.0.13
  • Logging categories changed
0.0.12
  • Added logging
0.0.11
  • Ignore placeholder "${json-unit.ignore}" added
0.0.10
  • Text differences are closed in quotes
0.0.9
  • Matchers added
0.0.7
  • Made Java 5 compatible
0.0.6
  • assertJsonPartStructureEquals added
0.0.5
  • assertJsonPartEquals added
0.0.4
  • Better error messages in case of different types
0.0.3
  • Support for array types and other oddities in root
0.0.2
  • Support for nulls
About
Compare JSON in your Unit Tests
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - roxspring/JsonUnit: Compare JSON in your Unit Tests · GitHub
Skip to content
BranchesTags
Repository files navigation
JsonUnit Build StatusMaven Central
JsonUnit is a library that simplifies JSON comparison in unit tests. The usage is
simple:
importstaticnet.javacrumbs.jsonunit.JsonAssert.*;
importstaticnet.javacrumbs.jsonunit.core.Option.*;
...
// compares two JSON documentsassertJsonEquals("{\"test\":1}", "{\n\"test\": 1\n}");
// compares only partassertJsonPartEquals("2", "{\"test\":[{\"value\":1},{\"value\":2}]}",
"test[1].value");
// extra options can be specifiedassertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null}}",
when(TREATING_NULL_AS_ABSENT));
// compares only the structure, not the valuesassertJsonEquals("[{\"test\":1}, {\"test\":2}]",
"[{\n\"test\": 1\n}, {\"TEST\": 4}]", when(IGNORING_VALUES))
// Lenient parsing of expected valueassertJsonEquals("{//Look ma, no quotation marks\n test:'value'}", "{\n\"test\": \"value\"\n}");
When the values are compared, order of elements and whitespaces are ignored.
Hamcrests matchers
You use Hamcrest matchers in the following way
importstaticnet.javacrumbs.jsonunit.JsonMatchers.*;
importstaticorg.junit.Assert.*;
importstaticnet.javacrumbs.jsonunit.core.util.ResourceUtils.resource;
...
assertThat("{\"test\":1}", jsonEquals("{\"test\": 1}"));
assertThat("{\"test\":1}", jsonPartEquals("test", 1));
assertThat("{\"test\":[1, 2, 3]}", jsonPartEquals("test[0]", 1));
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
// Can use other Hamcrest matchers tooassertThat("{\"test\":1}", jsonPartMatches("test", is(valueOf(1))))
assertThat("{\"test\":1}", jsonEquals(resource("test.json")));
Fluent assertions
Fluent (FEST or AssertJ like) assertions are supported by a special module json-unit-fluent
importstaticnet.javacrumbs.jsonunit.fluent.JsonFluentAssert.assertThatJson;
...
// compares entire documentsassertThatJson("{\"test\":1}").isEqualTo("{\"test\":2}");
// compares only parts of the documentassertThatJson("{\"test1\":2, \"test2\":1}")
.node("test1").isEqualTo(2)
.node("test2").isEqualTo(2);
// compare node indexed from start of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[0]").isEqualTo(1);
// compare node indexed from end of arrayassertThatJson("{\"root\":{\"test\":[1,2,3]}}")
.node("root.test[-1]").isEqualTo(3);
// compares only the structureassertThatJson("{\"test\":1}")
// Options have to be specified before the assertion
.when(IGNORING_VALUES)
.isEqualTo("{\"test\":21}");
// ignores a valueassertThatJson("{\"test\":1}").isEqualTo("{\"test\":\"${json-unit.ignore}\"}");
// ignores extra fieldsassertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
// Options have to be specified before the assertion
.when(IGNORING_EXTRA_FIELDS)
.isEqualTo("{\"test\":{\"b\":2}}");
// array length comparisonassertThatJson("{\"test\":[1,2,3]}").node("test")
.isArray().ofLength(2);
// array contains nodeassertThatJson("{\"test\":[{\"id\":36},{\"id\":37}]}").node("test")
.isArray().thatContains("{\"id\":37}");
// using Hamcrest matcherassertThatJson("{\"test\":\"one\"}").node("test")
.matches(equalTo("one"));
importstaticjava.math.BigDecimal.valueOf;
...
// Numbers sent to matchers are BigDecimals.assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
Hamcrest matchers in fluent assertions
It is possible to combine fluent assertions with hamcrest matchers using matches method. For example
assertThatJson("{\"test\":[1,2,3]}").node("test").matches(hasItem(valueOf(1)));
assertThatJson("{\"test\":[{\"value\":1},{\"value\":2},{\"value\":3}]}")
.node("test")
.matches(everyItem(jsonPartMatches("value", lessThanOrEqualTo(valueOf(4)))));
Spring MVC assertions
Since version 1.7.0 JsonUnit supports Spring MVC test assertions. For example
importstaticnet.javacrumbs.jsonunit.spring.JsonUnitResultMatchers.json;
...
this.mockMvc.perform(get("/sample").andExpect(
json().isEqualTo("{\"result\":{\"string\":\"stringValue\", \"array\":[1, 2, 3],\"decimal\":1.00001}}")
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.string2").isAbsent()
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").when(Option.IGNORING_ARRAY_ORDER).isEqualTo(newint[]{3, 2, 1})
);
this.mockMvc.perform(get("/sample").andExpect(
json().node("result.array").matches(everyItem(lessThanOrEqualTo(valueOf(4))))
);
Ignoring values
Sometimes you need to ignore certain values when comparing. It is possible to use ${json-unit.ignore}
placeholder like this
assertJsonEquals("{\"test\":\"${json-unit.ignore}\"}",
"{\n\"test\": {\"object\" : {\"another\" : 1}}}");
Regular expressions
It is also possible to use regular expressions to compare string values
assertJsonEquals("{\"test\": \"${json-unit.regex}[A-Z]+\"}", "{\"test\": \"ABCD\"}");
Type placeholders
If you want to assert just a type, but you do not care about the exact value, you can use any-* placehloder like this
assertThatJson("{\"test\":\"value\"}")
.isEqualTo("{test:'${json-unit.any-string}'}");
assertThatJson("{\"test\":true}")
.isEqualTo("{\"test\":\"${json-unit.any-boolean}\"}");
assertThatJson("{\"test\":1.1}")
.isEqualTo("{\"test\":\"${json-unit.any-number}\"}");
Options
There are multiple options how you can configure the comparison
TREATING_NULL_AS_ABSENT - fields with null values are equivalent to absent fields. For example, this test passes
assertJsonEquals("{\"test\":{\"a\":1}}",
"{\"test\":{\"a\":1, \"b\": null, \"c\": null}}",
when(TREATING_NULL_AS_ABSENT));
IGNORING_ARRAY_ORDER - ignores order in arrays
assertJsonEquals("{\"test\":[1,2,3]}", "{\"test\":[3,2,1]}",
when(IGNORING_ARRAY_ORDER));
IGNORING_EXTRA_ARRAY_ITEMS - ignores unexpected array items
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[1,2,3,4]}",
when(IGNORING_EXTRA_ARRAY_ITEMS));
assertJsonEquals("{\"test\":[1,2,3]}",
"{\"test\":[5,5,4,4,3,3,2,2,1,1]}",
when(IGNORING_EXTRA_ARRAY_ITEMS, IGNORING_ARRAY_ORDER));
IGNORING_EXTRA_FIELDS - ignores extra fileds in the compared value
assertJsonEquals("{\"test\":{\"b\":2}}", "{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
when(IGNORING_EXTRA_FIELDS));
IGNORE_VALUES - ignores values and compares only types
assertJsonEquals("{\"test\":{\"a\":1,\"b\":2,\"c\":3}}", "{\"test\":{\"a\":3,\"b\":2,\"c\":1}}",
when(IGNORING_VALUES));
It is possible to combine options.
assertJsonEquals("{\"test\":[{\"key\":1},{\"key\":2},{\"key\":3}]}", "{\"test\":[{\"key\":3},{\"key\":2, \"extraField\":2},{\"key\":1}]}",
when(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS));
In Hamcrest assertion you can set the option like this
assertThat("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}",
jsonEquals("{\"test\":{\"b\":2}}").when(IGNORING_EXTRA_FIELDS));
For standard asserts and Hamcrest matchers, it is possible to set the configuration globally
JsonAssert.setOptions(IGNORING_ARRAY_ORDER, IGNORING_EXTRA_FIELDS);
In fluent assertion, you can set options in the following way
assertThatJson("{\"test\":{\"a\":1, \"b\":2, \"c\":3}}")
.when(IGNORING_EXTRA_FIELDS).isEqualTo("{\"test\":{\"b\":2}}");
Please note that when method has to be called before the actual comparison.
Numeric comparison
Numbers are by default compared in the following way:
  • If the type differs, the number is different. So 1 and 1.0 are different (int vs. float)
  • Floating number comparison is exact
You can change this behavior by setting tolerance
assertJsonEquals("1", "\n1.009\n", withTolerance(0.01));
or globally
JsonAssert.setTolerance(0.01);
or for fluent assertions
assertThatJson("{\"test\":1.00001}").node("test").withTolerance(0.001).isEqualTo(1);
Or you can use Hamcrest matcher
importstaticjava.math.BigDecimal.valueOf;
...
assertThatJson("{\"test\":1.10001}").node("test")
.matches(closeTo(valueOf(1.1), valueOf(0.001)));
Logging
Although the differences are printed out by the assert statement, sometimes you use JsonUnit with other libraries like
Jadler that do not print the differences between documents. In such case, you can switch on the
logging. JsonUnit uses SLF4J. The only thing you need to do is to configure your logging
framework to log net.javacrumbs.jsonunit.difference on DEBUG level.
Selecting underlying library
JsonUnit is trying to cleverly match which JSON library to use. In case you need to change the default behavior, you can use
json-unit.libraries system property. For example -Djson-unit.libraries=jackson2,gson or System.setProperty("json-unit.libraries", "jackson1");. Supported values are gson, json.org, jackson1, jackson2
Maven dependency
JsonUnit is accessible in Maven central repository. In order for it to work, you need either, Jackson 1.x,
Jackson 2.x, Gson or JSONObject on the classpath.
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
To use fluent assertions:
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-fluent</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
To use Spring MVC assertions:
<dependency>
<groupId>net.javacrumbs.json-unit</groupId>
<artifactId>json-unit-spring</artifactId>
<version>1.19.0</version>
<scope>test</scope>
</dependency>
Licence
JsonUnit is licensed under Apache 2.0 licence.
Release notes
1.19.0
  • isArray().thatContains(...) fluent assert added
1.18.0
  • Resource reading helper added
1.17.0
  • System property to specify JSON libraries to be used
1.16.1
  • Array pattern accepts non-word characters
1.16.0
  • isAbsent and isPresent checks take TREAT_NULL_AS_ABSENT into account
1.15.0
  • Dependency on slf4j made optional
1.14.1
  • Preferring org.json library to process JSONArray
1.14.0
  • Support for org.json library
  • Fix: Element out of array bounds is treated as missing
1.13.0
  • Support for any-* placeholders
1.12.1
  • Single quote values in expected String allowed
1.12.0
  • Lenient parsing of expected values
1.11.0
  • Option setting methods made deprecated if called after assertion in JsonFluentAssert
  • JsonFluentAssert constructors made private. Please file an issue if you need them.
1.10.0
  • Added support for IGNORING_EXTRA_ARRAY_ITEMS
1.9.0
  • Made compatible with Jackson 1.4
1.8.0
  • OSGi support thanks to @amergey
1.7.0
  • Support for Spring MVC tests assertions
1.6.1
  • Gson nodes are not reconverted
1.6.0
  • Added support for Hamcrest matchers
1.5.6
  • Fixed handling of empty value in the expected parameter
1.5.5
  • Support for dot in node name
1.5.4
  • Added isObject method to fluent assertions
1.5.3
  • Jackson 1 is preferred if the serialized class contains Jackson1 annotation
1.5.2
  • Added support for regular expressions
1.5.1
  • isStringEqualTo() added to fluent assertions
  • isArray added to fluent assertions
1.5.0
  • One runtime now supports Jackson 1.x, Jackson 2.x and Gson
  • Internal JsonUnit class changed in backwards incompatible way
1.3.0 + 0.3.0
  • Options renamed
  • assertJsonNot* asserts added
  • Support for online configuration in Hamcrest and standard asserts added
1.2.0 + 0.2.0
  • Error messages changed a bit when comparing structures
  • Refactoring of internal classes
  • Support for ignoring array order
  • Support for ignoring values
  • Support for ignoring extra fields
1.1.6 + 0.1.6
  • Treat null as absent added
1.1.5 + 0.1.5
  • Absence/presence tests added
1.1.4 + 0.1.4
  • Path to array in root fixed
1.1.3 + 0.1.3
  • Numeric comparison tolerance added
1.1.2 + 0.1.2
  • jsonStringEquals and jsonStringPartEquals added
1.1.1 + 0.1.1
  • Generics in JsonMatchers fixed
1.1.0 + 0.1.0
  • Simplified API
  • Invalid JSONs in String comparison quoted
  • Runtime incompatible (compile-time compatible) changes
1.0.0
  • Switched to Jackson 2.x
  • Fluent JsonAssert renamed to JsonFluentAssert
0.0.16
  • Fluent assertions made framework independent.
0.0.15
  • Switched from FEST to AssertJ
0.0.14
  • Modules refactored
  • Added support for FEST assert
0.0.13
  • Logging categories changed
0.0.12
  • Added logging
0.0.11
  • Ignore placeholder "${json-unit.ignore}" added
0.0.10
  • Text differences are closed in quotes
0.0.9
  • Matchers added
0.0.7
  • Made Java 5 compatible
0.0.6
  • assertJsonPartStructureEquals added
0.0.5
  • assertJsonPartEquals added
0.0.4
  • Better error messages in case of different types
0.0.3
  • Support for array types and other oddities in root
0.0.2
  • Support for nulls
About
Compare JSON in your Unit Tests
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages