Adds support for walking dependentSchemas (#811)

Resolves #724

Co-authored-by: Faron Dutton <[email protected]>

Author: fdutton

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

@@ -22,9 +22,9 @@
 
 import java.util.*;
 
-public class DependentSchemas extends BaseJsonValidator implements JsonValidator {
+public class DependentSchemas extends BaseJsonValidator {
     private static final Logger logger = LoggerFactory.getLogger(DependentSchemas.class);
-    private final Map<String, JsonSchema> schemaDependencies = new HashMap<String, JsonSchema>();
+    private final Map<String, JsonSchema> schemaDependencies = new HashMap<>();
 
     public DependentSchemas(String schemaPath, JsonNode schemaNode, JsonSchema parentSchema, ValidationContext validationContext) {
 
@@ -34,21 +34,22 @@ public DependentSchemas(String schemaPath, JsonNode schemaNode, JsonSchema paren
             String pname = it.next();
             JsonNode pvalue = schemaNode.get(pname);
             if (pvalue.isObject() || pvalue.isBoolean()) {
-                schemaDependencies.put(pname, validationContext.newSchema(pname, pvalue, parentSchema));
+                this.schemaDependencies.put(pname, validationContext.newSchema(pname, pvalue, parentSchema));
             }
         }
 
         parseErrorCode(getValidatorType().getErrorCodeKey());
     }
 
+    @Override
     public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String at) {
         debug(logger, node, rootNode, at);
 
-        Set<ValidationMessage> errors = new LinkedHashSet<ValidationMessage>();
+        Set<ValidationMessage> errors = new LinkedHashSet<>();
 
         for (Iterator<String> it = node.fieldNames(); it.hasNext(); ) {
             String pname = it.next();
-            JsonSchema schema = schemaDependencies.get(pname);
+            JsonSchema schema = this.schemaDependencies.get(pname);
             if (schema != null) {
                 errors.addAll(schema.validate(node, rootNode, at));
             }
@@ -59,6 +60,18 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String
 
     @Override
     public void preloadJsonSchema() {
-        preloadJsonSchemas(schemaDependencies.values());
+        preloadJsonSchemas(this.schemaDependencies.values());
     }
+
+    @Override
+    public Set<ValidationMessage> walk(JsonNode node, JsonNode rootNode, String at, boolean shouldValidateSchema) {
+        if (shouldValidateSchema) {
+            return validate(node, rootNode, at);
+        }
+        for (JsonSchema schema : this.schemaDependencies.values()) {
+            schema.walk(node, rootNode, at, false);
+        }
+        return Collections.emptySet();
+    }
+
 }

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

@@ -0,0 +1,87 @@
+package com.networknt.schema;
+
+import static org.junit.jupiter.api.Assertions.assertLinesMatch;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import org.junit.jupiter.api.Test;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.networknt.schema.SpecVersion.VersionFlag;
+import com.networknt.schema.walk.JsonSchemaWalkListener;
+import com.networknt.schema.walk.WalkEvent;
+import com.networknt.schema.walk.WalkFlow;
+
+class Issue724Test {
+
+    @Test
+    void test() throws JsonProcessingException {
+        SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+        StringCollector stringCollector = new StringCollector();
+        config.addKeywordWalkListener(stringCollector);
+
+        String schema =
+            "{\n"
+                + "  \"$schema\": \"https://json-schema.org/draft/2020-12/schema\",\n"
+                + "  \"type\" : \"object\",\n"
+                + "  \"properties\" : {\n"
+                + "    \"credit_card\": {\n"
+                + "      \"type\" : \"string\"\n"
+                + "    }\n"
+                + "  },\n"
+                + "  \"dependentSchemas\": {\n"
+                + "    \"credit_card\": {\n"
+                + "      \"properties\": {\n"
+                + "        \"billing_address\": {\n"
+                + "          \"type\" : \"string\"\n"
+                + "        }\n"
+                + "      },\n"
+                + "      \"required\": [\"billing_address\"]\n"
+                + "    }\n"
+                + "  }\n"
+                + "}\n";
+        String data =
+            "{\n"
+                + "  \"credit_card\" : \"my_credit_card\",\n"
+                + "  \"billing_address\" : \"my_billing_address\"\n"
+                + "}\n";
+
+        JsonSchema jsonSchema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schema, config);
+        jsonSchema.walk(new ObjectMapper().readTree(data), /* shouldValidateSchema= */ false);
+
+        System.out.println(stringCollector.strings);
+        assertLinesMatch(Arrays.asList("my_credit_card", "my_billing_address"), stringCollector.strings);
+    }
+
+    static class StringCollector implements JsonSchemaWalkListener {
+        final List<String> strings = new ArrayList<>();
+
+        @Override
+        public WalkFlow onWalkStart(WalkEvent walkEvent) {
+            boolean isString =
+                Optional.of(walkEvent.getSchemaNode())
+                    .map(jsonNode -> jsonNode.get("type"))
+                    .map(JsonNode::asText)
+                    .map(type -> type.equals("string"))
+                    .orElse(false);
+
+            if (isString) {
+                this.strings.add(walkEvent.getNode().asText());
+            }
+
+            return WalkFlow.CONTINUE;
+        }
+
+        @Override
+        public void onWalkEnd(WalkEvent walkEvent, Set<ValidationMessage> validationMessages) {
+            // nothing to do here
+        }
+    }
+
+}