Merged with the latest json-schema-validator.

Jake Waffle · Jake Waffle · commit d07f04ddae88 · 2019-05-17T09:34:02.000-07:00
diff --git a/README.md b/README.md
@@ -51,7 +51,7 @@ Add the following to your `pom.xml`:
 <dependency>
     <groupId>com.networknt</groupId>
     <artifactId>json-schema-validator</artifactId>
-    <version>1.0.4</version>
+    <version>1.0.7</version>
 </dependency>
 ```
 
diff --git a/src/main/java/com/networknt/schema/BaseJsonValidator.java b/src/main/java/com/networknt/schema/BaseJsonValidator.java
@@ -83,7 +83,7 @@ private static JsonSchema obtainSubSchemaNode(JsonNode schemaNode, ValidationCon
             }
             else {
                 URL url = URLFactory.toURL(node.textValue());
-                return validationContext.getJsonSchemaFactory().getSchema(url);
+                return validationContext.getJsonSchemaFactory().getSchema(url, validationContext.getConfig());
             }
         } catch (MalformedURLException e) {
             return null;
diff --git a/src/main/java/com/networknt/schema/JsonSchemaFactory.java b/src/main/java/com/networknt/schema/JsonSchemaFactory.java
@@ -29,6 +29,7 @@
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.networknt.schema.url.StandardURLFetcher;
+import com.networknt.schema.url.URLFactory;
 import com.networknt.schema.url.URLFetcher;
 
 public class JsonSchemaFactory {
@@ -41,7 +42,7 @@ public static class Builder {
         private URLFetcher urlFetcher;
         private String defaultMetaSchemaURI;
         private Map<String, JsonMetaSchema> jsonMetaSchemas = new HashMap<String, JsonMetaSchema>();
-        private Map<URL, URL> urlMap = new HashMap<URL, URL>();
+        private Map<String, String> urlMap = new HashMap<String, String>();
         
         public Builder objectMapper(ObjectMapper objectMapper) {
             this.objectMapper = objectMapper;
@@ -70,7 +71,7 @@ public Builder addMetaSchemas(Collection<? extends JsonMetaSchema> jsonMetaSchem
             return this;
         }
         
-        public Builder addUrlMappings(Map<URL, URL> map) {
+        public Builder addUrlMappings(Map<String, String> map) {
             this.urlMap.putAll(map);
             return this;
         }
@@ -91,13 +92,14 @@ public JsonSchemaFactory build() {
     private final URLFetcher urlFetcher;
     private final String defaultMetaSchemaURI;
     private final Map<String, JsonMetaSchema> jsonMetaSchemas;
-    private final Map<URL, URL> urlMap;
+    private final Map<String, String> urlMap;
 
     private JsonSchemaFactory(
             ObjectMapper mapper, 
             URLFetcher urlFetcher, 
             String defaultMetaSchemaURI, 
-            Map<String, JsonMetaSchema> jsonMetaSchemas, Map<URL, URL> urlMap) {
+            Map<String, JsonMetaSchema> jsonMetaSchemas, 
+            Map<String, String> urlMap) {
         if (mapper == null) {
             throw new IllegalArgumentException("ObjectMapper must not be null");
         }
@@ -208,9 +210,9 @@ public JsonSchema getSchema(InputStream schemaStream) {
     public JsonSchema getSchema(URL schemaURL, SchemaValidatorsConfig config) {
         try {
             InputStream inputStream = null;
-            Map<URL, URL> map = (config != null) ? config.getUrlMappings() : new HashMap<URL, URL>(urlMap);
+            Map<String, String> map = (config != null) ? config.getUrlMappings() : new HashMap<String, String>(urlMap);
             map.putAll(urlMap);
-            URL mappedURL = map.getOrDefault(schemaURL, schemaURL);
+            URL mappedURL = URLFactory.toURL(map.getOrDefault(schemaURL.toString(), schemaURL.toString()));
             try {
                 inputStream = urlFetcher.fetch(mappedURL);
                 JsonNode schemaNode = mapper.readTree(inputStream);
diff --git a/src/main/java/com/networknt/schema/SchemaValidatorsConfig.java b/src/main/java/com/networknt/schema/SchemaValidatorsConfig.java
@@ -43,7 +43,7 @@ public class SchemaValidatorsConfig {
      * validation of schemas that refer to public URLs. This is merged with any mappings the {@link JsonSchemaFactory} 
      * may have been built with.
      */
-    private Map<URL, URL> urlMappings = new HashMap<URL, URL>();
+    private Map<String, String> urlMappings = new HashMap<String, String>();
 
     public boolean isTypeLoose() {
         return typeLoose;
@@ -53,11 +53,12 @@ public void setTypeLoose(boolean typeLoose) {
         this.typeLoose = typeLoose;
     }
 
-    public Map<URL, URL> getUrlMappings() {
-        return new HashMap<URL, URL>(urlMappings);
+    public Map<String, String> getUrlMappings() {
+        // return a copy of the mappings
+        return new HashMap<String, String>(urlMappings);
     }
 
-    public void setUrlMappings(Map<URL, URL> urlMappings) {
+    public void setUrlMappings(Map<String, String> urlMappings) {
         this.urlMappings = urlMappings;
     }
     
@@ -83,6 +84,6 @@ public SchemaValidatorsConfig() {
 
     private void loadDefaultConfig() {
         this.typeLoose = true;
-        this.urlMappings = new HashMap<URL, URL>();
+        this.urlMappings = new HashMap<String, String>();
     }
 }
diff --git a/src/main/java/com/networknt/schema/TypeValidator.java b/src/main/java/com/networknt/schema/TypeValidator.java
@@ -24,14 +24,20 @@
 import java.util.Set;
 
 public class TypeValidator extends BaseJsonValidator implements JsonValidator {
+    private static final String TYPE = "type";
+    private static final String ENUM = "enum";
+    private static final String REF = "$ref";
+
     private static final Logger logger = LoggerFactory.getLogger(TypeValidator.class);
 
     private JsonType schemaType;
+    private JsonSchema parentSchema;
     private UnionTypeValidator unionTypeValidator;
 
     public TypeValidator(String schemaPath, JsonNode schemaNode, JsonSchema parentSchema, ValidationContext validationContext) {
         super(schemaPath, schemaNode, parentSchema, ValidatorTypeCode.TYPE, validationContext);
         schemaType = TypeFactory.getSchemaNodeType(schemaNode);
+        this.parentSchema = parentSchema;
 
         if (schemaType == JsonType.UNION) {
             unionTypeValidator = new UnionTypeValidator(schemaPath, schemaNode, parentSchema, validationContext);
@@ -62,6 +68,11 @@ public boolean equalsToSchemaType(JsonNode node) {
                     return true;
                 }
             }
+            // Skip the type validation when the schema is an enum object schema. Since the current type
+            // of node itself can be used for type validation.
+            if (isEnumObjectSchema(parentSchema)) {
+                return true;
+            }
             if(config.isTypeLoose()) {
                 if (nodeType == JsonType.STRING) {
                     if(schemaType == JsonType.INTEGER) {
@@ -215,4 +226,28 @@ public static boolean isNumber(JsonNode node, boolean isTypeLoose) {
         }
         return false;
     }
+
+    private static boolean isEnumObjectSchema(JsonSchema jsonSchema) {
+        // There are three conditions for enum object schema
+        // 1. The current schema contains key "type", and the value is object
+        // 2. The current schema contains key "enum", and the value is an array
+        // 3. The parent schema if refer from components, which means the corresponding enum object class would be generated
+        JsonNode typeNode = null;
+        JsonNode enumNode = null;
+        JsonNode refNode = null;
+
+        if (jsonSchema != null) {
+            if (jsonSchema.getSchemaNode() != null) {
+                typeNode = jsonSchema.getSchemaNode().get(TYPE);
+                enumNode = jsonSchema.getSchemaNode().get(ENUM);
+            }
+            if (jsonSchema.getParentSchema() != null && jsonSchema.getParentSchema().getSchemaNode() != null) {
+                refNode = jsonSchema.getParentSchema().getSchemaNode().get(REF);
+            }
+        }
+        if (typeNode != null && enumNode != null && refNode != null) {
+            return TypeFactory.getSchemaNodeType(typeNode) == JsonType.OBJECT && enumNode.isArray();
+        }
+        return false;
+    }
 }
diff --git a/src/test/java/com/networknt/schema/JsonSchemaTest.java b/src/test/java/com/networknt/schema/JsonSchemaTest.java
@@ -293,6 +293,11 @@ public void testUnionTypeValidator() throws Exception {
     public void testUniqueItemsValidator() throws Exception {
         runTestFile("tests/uniqueItems.json");
     }
+
+    @Test
+    public void testEnumObject() throws Exception {
+        runTestFile("tests/enumObject.json");
+    }
     
     @Test
     public void testIdSchemaWithUrl() throws Exception {
diff --git a/src/test/java/com/networknt/schema/UrlMappingTest.java b/src/test/java/com/networknt/schema/UrlMappingTest.java
@@ -130,11 +130,22 @@ public void testValidatorConfigExampleMappings() throws IOException {
         assertEquals(0, schema.validate(mapper.createObjectNode()).size());
     }
 
-    private Map<URL, URL> getUrlMappingsFromUrl(URL url) throws MalformedURLException, IOException {
-        HashMap<URL, URL> map = new HashMap<URL, URL>();
+    @Test
+    public void testMappingsForRef() throws IOException {
+        JsonSchemaFactory instance = JsonSchemaFactory.getInstance();
+        URL mappings = URLFactory.toURL("resource:tests/url_mapping/schema-with-ref-mapping.json");
+        SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+        config.setUrlMappings(getUrlMappingsFromUrl(mappings));
+        JsonSchema schema = instance.getSchema(URLFactory.toURL("resource:tests/url_mapping/schema-with-ref.json"),
+                config);
+        assertEquals(0, schema.validate(mapper.readTree("[]")).size());
+    }
+
+    private Map<String, String> getUrlMappingsFromUrl(URL url) throws MalformedURLException, IOException {
+        HashMap<String, String> map = new HashMap<String, String>();
         for (JsonNode mapping : mapper.readTree(url)) {
-            map.put(URLFactory.toURL(mapping.get("publicURL").asText()),
-                    URLFactory.toURL(mapping.get("localURL").asText()));
+            map.put(mapping.get("publicURL").asText(),
+                    mapping.get("localURL").asText());
         }
         return map;
     }
diff --git a/src/test/resources/tests/enumObject.json b/src/test/resources/tests/enumObject.json
@@ -0,0 +1,68 @@
+[
+  {
+    "description": "simple enum object validation",
+    "schema": {
+      "properties": {
+        "foo": {
+          "type": "object",
+          "enum": [1, 2, 3]
+        },
+        "bar": {
+          "$ref": "#/properties/foo"
+        }
+      }
+    },
+    "tests": [
+      {
+        "description": "one of the enum is valid",
+        "data": {
+          "bar": 1
+        },
+        "valid": true
+      },
+      {
+        "description": "one of the enum is valid",
+        "isTypeLoose": true,
+        "data": {
+          "bar": "1"
+        },
+        "valid": true
+      },
+      {
+        "description": "something else is invalid",
+        "isTypeLoose": false,
+        "data": {
+          "bar": "1"
+        },
+        "valid": false
+      },
+      {
+        "description": "something else is invalid",
+        "data": {
+          "bar": 4
+        },
+        "valid": false
+      }
+    ]
+  },
+  {
+    "description": "fake enum object validation",
+    "schema": {
+          "type": "object",
+          "enum": [1, 2, {"key": "value"}]
+    },
+    "tests": [
+      {
+        "description": "one of the enum is invalid",
+        "data": 1,
+        "valid": false
+      },
+      {
+        "description": "one of the enum is valid",
+        "isTypeLoose": true,
+        "data": {"key": "value"},
+        "valid": true
+      }
+    ]
+  }
+]
diff --git a/src/test/resources/tests/url_mapping/schema-with-ref-mapping.json b/src/test/resources/tests/url_mapping/schema-with-ref-mapping.json
@@ -0,0 +1,10 @@
+[
+    {
+        "publicURL": "http://json-schema.org/draft-04/schema#",
+        "localURL": "resource:/draftv4.schema.json"
+    },
+    {
+        "publicURL": "http://example.com/invalid/schema/url",
+        "localURL": "resource:/tests/url_mapping/example-schema.json"
+    }
+]
diff --git a/src/test/resources/tests/url_mapping/schema-with-ref.json b/src/test/resources/tests/url_mapping/schema-with-ref.json
@@ -0,0 +1,10 @@
+{
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "title": "json-object-with-schema",
+    "type": "array",
+    "properties": {
+        "schema": {
+            "$ref": "http://example.com/invalid/schema/url"
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ private static JsonSchema obtainSubSchemaNode(JsonNode schemaNode, ValidationCon`
`83`	`83`	`}`
`84`	`84`	`else {`
`85`	`85`	`URL url = URLFactory.toURL(node.textValue());`
`86`		`- return validationContext.getJsonSchemaFactory().getSchema(url);`
	`86`	`+ return validationContext.getJsonSchemaFactory().getSchema(url, validationContext.getConfig());`
`87`	`87`	`}`
`88`	`88`	`} catch (MalformedURLException e) {`
`89`	`89`	`return null;`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ public class SchemaValidatorsConfig {`
`43`	`43`	`* validation of schemas that refer to public URLs. This is merged with any mappings the {@link JsonSchemaFactory}`
`44`	`44`	`* may have been built with.`
`45`	`45`	`*/`
`46`		`- private Map<URL, URL> urlMappings = new HashMap<URL, URL>();`
	`46`	`+ private Map<String, String> urlMappings = new HashMap<String, String>();`
`47`	`47`
`48`	`48`	`public boolean isTypeLoose() {`
`49`	`49`	`return typeLoose;`
`@@ -53,11 +53,12 @@ public void setTypeLoose(boolean typeLoose) {`
`53`	`53`	`this.typeLoose = typeLoose;`
`54`	`54`	`}`
`55`	`55`
`56`		`- public Map<URL, URL> getUrlMappings() {`
`57`		`- return new HashMap<URL, URL>(urlMappings);`
	`56`	`+ public Map<String, String> getUrlMappings() {`
	`57`	`+ // return a copy of the mappings`
	`58`	`+ return new HashMap<String, String>(urlMappings);`
`58`	`59`	`}`
`59`	`60`
`60`		`- public void setUrlMappings(Map<URL, URL> urlMappings) {`
	`61`	`+ public void setUrlMappings(Map<String, String> urlMappings) {`
`61`	`62`	`this.urlMappings = urlMappings;`
`62`	`63`	`}`
`63`	`64`
`@@ -83,6 +84,6 @@ public SchemaValidatorsConfig() {`
`83`	`84`
`84`	`85`	`private void loadDefaultConfig() {`
`85`	`86`	`this.typeLoose = true;`
`86`		`- this.urlMappings = new HashMap<URL, URL>();`
	`87`	`+ this.urlMappings = new HashMap<String, String>();`
`87`	`88`	`}`
`88`	`89`	`}`