fix for #461 (#462)

* fix for #461 simple implementation (aligned with one-of)

* fix for #461 simple implementation

* simplify walker as test does not depend on its logic

Author: bartoszm

src/main/java/com/networknt/schema/AnyOfValidator.java

@@ -21,6 +21,7 @@
 import org.slf4j.LoggerFactory;
 
 import java.util.*;
+import java.util.stream.Collectors;
 
 public class AnyOfValidator extends BaseJsonValidator implements JsonValidator {
     private static final Logger logger = LoggerFactory.getLogger(RequiredValidator.class);
@@ -100,13 +101,21 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String
 
     @Override
     public Set<ValidationMessage> walk(JsonNode node, JsonNode rootNode, String at, boolean shouldValidateSchema) {
-        Set<ValidationMessage> validationMessages = new LinkedHashSet<ValidationMessage>();
-
+        ArrayList<Set<ValidationMessage>> results = new ArrayList<>(schemas.size());
         for (JsonSchema schema : schemas) {
-            // Walk through the schema
-            validationMessages.addAll(schema.walk(node, rootNode, at, shouldValidateSchema));
+            results.add(schema.walk(node, rootNode, at, shouldValidateSchema));
+        }
+        if(! shouldValidateSchema) {
+            return new LinkedHashSet<>();
+        }
+        boolean atLeastOneValid = results.stream()
+                .anyMatch(Set::isEmpty);
+        if(atLeastOneValid) {
+            return new LinkedHashSet<>();
         }
-        return Collections.unmodifiableSet(validationMessages);
+        return results.stream()
+                .flatMap(Collection::stream)
+                .collect(Collectors.toCollection(LinkedHashSet::new));
     }
 
     @Override

src/test/java/com/networknt/schema/Issue451Test.java

@@ -5,7 +5,9 @@
 import com.networknt.schema.walk.JsonSchemaWalkListener;
 import com.networknt.schema.walk.WalkEvent;
 import com.networknt.schema.walk.WalkFlow;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 import java.io.InputStream;
@@ -17,6 +19,9 @@
  * Validating anyOf walker
  */
 public class Issue451Test {
+
+    private static final String COLLECTOR_ID = "collector-451";
+
     protected JsonSchema getJsonSchemaFromStreamContentV7(InputStream schemaContent) {
         JsonSchemaFactory factory = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V7);
         SchemaValidatorsConfig svc = new SchemaValidatorsConfig();
@@ -29,20 +34,46 @@ protected JsonNode getJsonNodeFromStreamContent(InputStream content) throws Exce
         return mapper.readTree(content);
     }
 
-    @SuppressWarnings("unchecked")
+    @AfterEach
+    public void cleanup() {
+        if (CollectorContext.getInstance() != null) {
+            CollectorContext.getInstance().reset();
+        }
+    }
+
+    @Test
+    public void shouldWalkAnyOfProperties() {
+        walk(null, false);
+    }
+
+    @Test
+    public void shouldWalkAnyOfPropertiesWithWithPayloadAndValidation() throws Exception {
+        JsonNode data = getJsonNodeFromStreamContent(Issue451Test.class.getResourceAsStream(
+                "/data/issue451.json"));
+        walk(data,true);
+    }
+
     @Test
-    public void shouldWalkAnyOfProperties() throws Exception {
+    public void shouldWalkAnyOfPropertiesWithWithPayload() throws Exception {
+        JsonNode data = getJsonNodeFromStreamContent(Issue451Test.class.getResourceAsStream(
+                "/data/issue451.json"));
+        walk(data, false);
+    }
+
+    @SuppressWarnings("unchecked")
+    private void walk(JsonNode data, boolean shouldValidate) {
         String schemaPath = "/schema/issue451-v7.json";
         InputStream schemaInputStream = getClass().getResourceAsStream(schemaPath);
         JsonSchema schema = getJsonSchemaFromStreamContentV7(schemaInputStream);
 
-        schema.walk(null, false);
+        schema.walk(data, shouldValidate);
 
-        Map<String, Integer> collector = (Map<String, Integer>) CollectorContext.getInstance().get("collector-451");
+        Map<String, Integer> collector = (Map<String, Integer>) CollectorContext.getInstance().get(COLLECTOR_ID);
         Assertions.assertEquals(2, collector.get("#/definitions/definition1/properties/a"));
         Assertions.assertEquals(2, collector.get("#/definitions/definition2/properties/x"));
     }
 
+
     private static class CountingWalker implements JsonSchemaWalkListener {
         @Override
         public WalkFlow onWalkStart(WalkEvent walkEvent) {
@@ -57,10 +88,10 @@ public void onWalkEnd(WalkEvent walkEvent, Set<ValidationMessage> validationMess
         }
 
         private Map<String, Integer> collector() {
-            Map<String, Integer> collector = (Map<String, Integer>) CollectorContext.getInstance().get("collector-451");
+            Map<String, Integer> collector = (Map<String, Integer>) CollectorContext.getInstance().get(COLLECTOR_ID);
             if(collector == null) {
                 collector = new HashMap<>();
-                CollectorContext.getInstance().add("collector-451", collector);
+                CollectorContext.getInstance().add(COLLECTOR_ID, collector);
             }
 
             return collector;

src/test/java/com/networknt/schema/Issue461Test.java

@@ -0,0 +1,49 @@
+package com.networknt.schema;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.networknt.schema.walk.JsonSchemaWalkListener;
+import com.networknt.schema.walk.WalkEvent;
+import com.networknt.schema.walk.WalkFlow;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Set;
+
+public class Issue461Test {
+    protected ObjectMapper mapper = new ObjectMapper();
+
+    protected JsonSchema getJsonSchemaFromStreamContentV7(URI schemaUri) {
+        JsonSchemaFactory factory = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V7);
+        SchemaValidatorsConfig svc = new SchemaValidatorsConfig();
+        svc.addKeywordWalkListener(ValidatorTypeCode.PROPERTIES.getValue(), new Walker());
+        return factory.getSchema(schemaUri, svc);
+    }
+
+    @Test
+    public void shouldWalkWithValidation() throws URISyntaxException, IOException {
+        JsonSchema schema = getJsonSchemaFromStreamContentV7(new URI("http://json-schema" +
+                ".org/draft-07/schema#"));
+        JsonNode data = mapper.readTree(Issue461Test.class.getResource("/data/issue461-v7.json"));
+        ValidationResult result = schema.walk(data, true);
+        Assertions.assertTrue(result.getValidationMessages().isEmpty());
+    }
+
+    /**
+     * Example NOP walker
+     */
+    private static class Walker implements JsonSchemaWalkListener {
+        @Override
+        public WalkFlow onWalkStart(final WalkEvent walkEvent) {
+            return WalkFlow.CONTINUE;
+        }
+
+        @Override
+        public void onWalkEnd(final WalkEvent walkEvent,
+                              final Set<ValidationMessage> validationMessages) {
+        }
+    }
+}

src/test/resources/data/issue451.json

@@ -0,0 +1,12 @@
+{
+  "allOfAttr" : {
+    "a": "foo",
+    "x": 1,
+    "y": "xx"
+  },
+  "anyOfAttr" : {
+    "a": "bar",
+    "x": 1
+  }
+
+}

src/test/resources/data/issue461-v7.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "firstName": {
+      "type": "string"
+    },
+    "lastName": {
+      "type": "string"
+    },
+    "address": {
+      "type": "object",
+      "properties": {
+        "street": {
+          "type": "string"
+        },
+        "city": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "street",
+        "city"
+      ]
+    }
+  },
+  "required": [
+    "firstName",
+    "lastName",
+    "address"
+  ]
+}