feat: allow to have equality between null and empty array

deblockt · deblockt · commit af826e88ed74 · 2026-01-01T19:17:12.000+01:00
diff --git a/src/main/java/com/deblock/jsondiff/matcher/CompositeJsonMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/CompositeJsonMatcher.java
@@ -6,32 +6,24 @@
 import tools.jackson.databind.node.ObjectNode;
 import tools.jackson.databind.node.ValueNode;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 public class CompositeJsonMatcher implements JsonMatcher {
-    private final PartialJsonMatcher<ArrayNode> jsonArrayPartialMatcher;
-    private final PartialJsonMatcher<ObjectNode> jsonObjectPartialMatcher;
-    private final PartialJsonMatcher<ValueNode> primitivePartialMatcher;
+    private final List<PartialJsonMatcher<JsonNode>> matchers;
 
-    public CompositeJsonMatcher(
-        PartialJsonMatcher<ArrayNode> jsonArrayPartialMatcher,
-        PartialJsonMatcher<ObjectNode> jsonObjectPartialMatcher,
-        PartialJsonMatcher<ValueNode> primitivePartialMatcher
-    ) {
-        this.jsonArrayPartialMatcher = jsonArrayPartialMatcher;
-        this.jsonObjectPartialMatcher = jsonObjectPartialMatcher;
-        this.primitivePartialMatcher = primitivePartialMatcher;
+    public CompositeJsonMatcher(PartialJsonMatcher<?> ...jsonArrayPartialMatcher) {
+        this.matchers = new ArrayList<>();
+        Arrays.stream(jsonArrayPartialMatcher).forEach(it -> this.matchers.add((PartialJsonMatcher<JsonNode>) it));
     }
 
     @Override
     public JsonDiff diff(Path path, JsonNode expected, JsonNode received) {
-        if (expected instanceof ObjectNode expectedObjectNode  && received instanceof ObjectNode receivedObjectNode) {
-            return this.jsonObjectPartialMatcher.jsonDiff(path, expectedObjectNode, receivedObjectNode, this);
-        } else if (expected instanceof ArrayNode expectedArrayNode && received instanceof ArrayNode receivedArrayNode) {
-            return this.jsonArrayPartialMatcher.jsonDiff(path, expectedArrayNode, receivedArrayNode, this);
-        } else if (expected instanceof ValueNode expectedValueNode && received instanceof ValueNode receivedValueNode){
-            return this.primitivePartialMatcher.jsonDiff(path, expectedValueNode, receivedValueNode, this);
-        } else {
-            return new UnMatchedPrimaryDiff(path, expected, received);
-        }
+        return this.matchers.stream()
+                .filter(matcher -> matcher.manage(expected, received))
+                .findFirst()
+                .map(matcher -> matcher.jsonDiff(path, expected, received, this))
+                .orElseGet(() -> new UnMatchedPrimaryDiff(path, expected, received));
     }
-
-}
+}
diff --git a/src/main/java/com/deblock/jsondiff/matcher/JsonMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/JsonMatcher.java
@@ -6,5 +6,4 @@
 public interface JsonMatcher {
 
     JsonDiff diff(Path path, JsonNode expected, JsonNode received);
-
 }
diff --git a/src/main/java/com/deblock/jsondiff/matcher/LenientJsonArrayPartialMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/LenientJsonArrayPartialMatcher.java
@@ -57,6 +57,11 @@ public JsonDiff jsonDiff(Path path, ArrayNode expectedArrayNode, ArrayNode recie
         return diff;
     }
 
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        return expected.isArray() && received.isArray();
+    }
+
     private double maxSimilarityRate(Map.Entry<Integer, Map<Integer, JsonDiff>> entry) {
         return entry.getValue().values().stream().mapToDouble(JsonDiff::similarityRate).max().orElse(0);
     }
@@ -137,4 +142,4 @@ public boolean containsNode(JsonNode node) {
             return nodeCounter.containsKey(node);
         }
     }
-}
+}
diff --git a/src/main/java/com/deblock/jsondiff/matcher/LenientJsonObjectPartialMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/LenientJsonObjectPartialMatcher.java
@@ -2,6 +2,7 @@
 
 import com.deblock.jsondiff.diff.JsonDiff;
 import com.deblock.jsondiff.diff.JsonObjectDiff;
+import tools.jackson.databind.JsonNode;
 import tools.jackson.databind.node.ObjectNode;
 
 public class LenientJsonObjectPartialMatcher implements PartialJsonMatcher<ObjectNode> {
@@ -26,4 +27,9 @@ public JsonDiff jsonDiff(Path path, ObjectNode expectedJson, ObjectNode received
 
         return jsonDiff;
     }
-}
+
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        return expected.isObject() && received.isObject();
+    }
+}
diff --git a/src/main/java/com/deblock/jsondiff/matcher/LenientNumberPrimitivePartialMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/LenientNumberPrimitivePartialMatcher.java
@@ -3,6 +3,7 @@
 import com.deblock.jsondiff.diff.JsonDiff;
 import com.deblock.jsondiff.diff.MatchedPrimaryDiff;
 import com.deblock.jsondiff.diff.UnMatchedPrimaryDiff;
+import tools.jackson.databind.JsonNode;
 import tools.jackson.databind.node.NumericNode;
 import tools.jackson.databind.node.ValueNode;
 
@@ -25,4 +26,9 @@ public JsonDiff jsonDiff(Path path, ValueNode expectedValue, ValueNode receivedV
 
         return delegated.jsonDiff(path, expectedValue, receivedValue, jsonMatcher);
     }
+
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        return expected.isValueNode() && received.isValueNode();
+    }
 }
diff --git a/src/main/java/com/deblock/jsondiff/matcher/NullEqualsEmptyArrayMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/NullEqualsEmptyArrayMatcher.java
@@ -0,0 +1,26 @@
+package com.deblock.jsondiff.matcher;
+
+import com.deblock.jsondiff.diff.JsonDiff;
+import com.deblock.jsondiff.diff.MatchedPrimaryDiff;
+import com.deblock.jsondiff.diff.UnMatchedPrimaryDiff;
+import tools.jackson.databind.JsonNode;
+
+public class NullEqualsEmptyArrayMatcher implements PartialJsonMatcher<JsonNode> {
+
+    @Override
+    public JsonDiff jsonDiff(Path path, JsonNode expectedJson, JsonNode receivedJson, JsonMatcher jsonMatcher) {
+        if (
+                (expectedJson.isNull() && receivedJson.isEmpty())
+                || (receivedJson.isNull() && expectedJson.isEmpty())
+        ) {
+            return new MatchedPrimaryDiff(path, expectedJson);
+        }
+        return new UnMatchedPrimaryDiff(path, expectedJson, receivedJson);
+    }
+
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        return (expected.isNull() && received.isArray())
+                 || (received.isNull() && expected.isArray());
+    }
+}
diff --git a/src/main/java/com/deblock/jsondiff/matcher/PartialJsonMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/PartialJsonMatcher.java
@@ -5,4 +5,7 @@
 
 public interface PartialJsonMatcher<T extends JsonNode> {
     JsonDiff jsonDiff(Path path, T expectedJson, T receivedJson, JsonMatcher jsonMatcher);
+
+    boolean manage(JsonNode expected, JsonNode received);
+
 }
diff --git a/src/main/java/com/deblock/jsondiff/matcher/StrictJsonArrayPartialMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/StrictJsonArrayPartialMatcher.java
@@ -2,6 +2,7 @@
 
 import com.deblock.jsondiff.diff.JsonArrayDiff;
 import com.deblock.jsondiff.diff.JsonDiff;
+import tools.jackson.databind.JsonNode;
 import tools.jackson.databind.node.ArrayNode;
 
 import java.util.Comparator;
@@ -35,4 +36,9 @@ public JsonDiff jsonDiff(Path path, ArrayNode expectedValues, ArrayNode received
         }
         return diff;
     }
+
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        return expected.isArray() && received.isArray();
+    }
 }
diff --git a/src/main/java/com/deblock/jsondiff/matcher/StrictJsonObjectPartialMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/StrictJsonObjectPartialMatcher.java
@@ -2,6 +2,7 @@
 
 import com.deblock.jsondiff.diff.JsonDiff;
 import com.deblock.jsondiff.diff.JsonObjectDiff;
+import tools.jackson.databind.JsonNode;
 import tools.jackson.databind.node.ObjectNode;
 
 public class StrictJsonObjectPartialMatcher implements PartialJsonMatcher<ObjectNode> {
@@ -37,4 +38,9 @@ public JsonDiff jsonDiff(Path path, ObjectNode expectedJson, ObjectNode received
 
         return jsonDiff;
     }
+
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        return expected.isObject() && received.isObject();
+    }
 }
diff --git a/src/main/java/com/deblock/jsondiff/matcher/StrictPrimitivePartialMatcher.java b/src/main/java/com/deblock/jsondiff/matcher/StrictPrimitivePartialMatcher.java
@@ -3,6 +3,7 @@
 import com.deblock.jsondiff.diff.JsonDiff;
 import com.deblock.jsondiff.diff.MatchedPrimaryDiff;
 import com.deblock.jsondiff.diff.UnMatchedPrimaryDiff;
+import tools.jackson.databind.JsonNode;
 import tools.jackson.databind.node.ValueNode;
 
 import java.util.Objects;
@@ -17,4 +18,9 @@ public JsonDiff jsonDiff(Path path, ValueNode expectedValue, ValueNode receivedV
             return new UnMatchedPrimaryDiff(path, expectedValue, receivedValue);
         }
     }
+
+    @Override
+    public boolean manage(JsonNode expected, JsonNode received) {
+        return expected.isValueNode() && received.isValueNode();
+    }
 }
diff --git a/src/test/java/com/deblock/jsondiff/Sample.java b/src/test/java/com/deblock/jsondiff/Sample.java
@@ -6,12 +6,13 @@
 
 public class Sample {
     public static void main(String[] args) {
-        final var expectedJson = "{\"array\": [{\"b\": [1]}, {\"a\": [1, 5]}]}";
-        final var receivedJson = "{\"array\": [{\"a\": [1]}]}";
+        final var expectedJson = "{\"array\": []}";
+        final var receivedJson = "{}";
 
         // define your matcher
         // CompositeJsonMatcher use other matcher to perform matching on objects, list or primitive
         final var jsonMatcher = new CompositeJsonMatcher(
+            new NullEqualsEmptyArrayMatcher(),
             new LenientJsonArrayPartialMatcher(), // comparing array using lenient mode (ignore array order and extra items)
             new LenientJsonObjectPartialMatcher(), // comparing object using lenient mode (ignoring extra properties)
             new LenientNumberPrimitivePartialMatcher(new StrictPrimitivePartialMatcher()) // comparing primitive types and manage numbers (100.00 == 100)

Original file line number	Diff line number	Diff line change
`@@ -6,5 +6,4 @@`
`6`	`6`	`public interface JsonMatcher {`
`7`	`7`
`8`	`8`	`JsonDiff diff(Path path, JsonNode expected, JsonNode received);`
`9`		`-`
`10`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,6 +57,11 @@ public JsonDiff jsonDiff(Path path, ArrayNode expectedArrayNode, ArrayNode recie`
`57`	`57`	`return diff;`
`58`	`58`	`}`
`59`	`59`
	`60`	`+ @Override`
	`61`	`+ public boolean manage(JsonNode expected, JsonNode received) {`
	`62`	`+ return expected.isArray() && received.isArray();`
	`63`	`+ }`
	`64`	`+`
`60`	`65`	`private double maxSimilarityRate(Map.Entry<Integer, Map<Integer, JsonDiff>> entry) {`
`61`	`66`	`return entry.getValue().values().stream().mapToDouble(JsonDiff::similarityRate).max().orElse(0);`
`62`	`67`	`}`
`@@ -137,4 +142,4 @@ public boolean containsNode(JsonNode node) {`
`137`	`142`	`return nodeCounter.containsKey(node);`
`138`	`143`	`}`
`139`	`144`	`}`
`140`		`-}`
	`145`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -5,4 +5,7 @@`
`5`	`5`
`6`	`6`	`public interface PartialJsonMatcher<T extends JsonNode> {`
`7`	`7`	`JsonDiff jsonDiff(Path path, T expectedJson, T receivedJson, JsonMatcher jsonMatcher);`
	`8`	`+`
	`9`	`+ boolean manage(JsonNode expected, JsonNode received);`
	`10`	`+`
`8`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`
`3`	`3`	`import com.deblock.jsondiff.diff.JsonArrayDiff;`
`4`	`4`	`import com.deblock.jsondiff.diff.JsonDiff;`
	`5`	`+import tools.jackson.databind.JsonNode;`
`5`	`6`	`import tools.jackson.databind.node.ArrayNode;`
`6`	`7`
`7`	`8`	`import java.util.Comparator;`
`@@ -35,4 +36,9 @@ public JsonDiff jsonDiff(Path path, ArrayNode expectedValues, ArrayNode received`
`35`	`36`	`}`
`36`	`37`	`return diff;`
`37`	`38`	`}`
	`39`	`+`
	`40`	`+ @Override`
	`41`	`+ public boolean manage(JsonNode expected, JsonNode received) {`
	`42`	`+ return expected.isArray() && received.isArray();`
	`43`	`+ }`
`38`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`
`3`	`3`	`import com.deblock.jsondiff.diff.JsonDiff;`
`4`	`4`	`import com.deblock.jsondiff.diff.JsonObjectDiff;`
	`5`	`+import tools.jackson.databind.JsonNode;`
`5`	`6`	`import tools.jackson.databind.node.ObjectNode;`
`6`	`7`
`7`	`8`	`public class StrictJsonObjectPartialMatcher implements PartialJsonMatcher<ObjectNode> {`
`@@ -37,4 +38,9 @@ public JsonDiff jsonDiff(Path path, ObjectNode expectedJson, ObjectNode received`
`37`	`38`
`38`	`39`	`return jsonDiff;`
`39`	`40`	`}`
	`41`	`+`
	`42`	`+ @Override`
	`43`	`+ public boolean manage(JsonNode expected, JsonNode received) {`
	`44`	`+ return expected.isObject() && received.isObject();`
	`45`	`+ }`
`40`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`import com.deblock.jsondiff.diff.JsonDiff;`
`4`	`4`	`import com.deblock.jsondiff.diff.MatchedPrimaryDiff;`
`5`	`5`	`import com.deblock.jsondiff.diff.UnMatchedPrimaryDiff;`
	`6`	`+import tools.jackson.databind.JsonNode;`
`6`	`7`	`import tools.jackson.databind.node.ValueNode;`
`7`	`8`
`8`	`9`	`import java.util.Objects;`
`@@ -17,4 +18,9 @@ public JsonDiff jsonDiff(Path path, ValueNode expectedValue, ValueNode receivedV`
`17`	`18`	`return new UnMatchedPrimaryDiff(path, expectedValue, receivedValue);`
`18`	`19`	`}`
`19`	`20`	`}`
	`21`	`+`
	`22`	`+ @Override`
	`23`	`+ public boolean manage(JsonNode expected, JsonNode received) {`
	`24`	`+ return expected.isValueNode() && received.isValueNode();`
	`25`	`+ }`
`20`	`26`	`}`