Merge pull request #186 from networknt/issue185

Issue185

Author: stevehu

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

@@ -36,6 +36,10 @@ public abstract class BaseJsonValidator implements JsonValidator {
      */
     protected SchemaValidatorsConfig config;
 
+    /**
+     * ThreadLocal to allow to pass state in recursive validator calls
+     */
+    protected final static ThreadLocal<ValidatorState> validatorState = new ThreadLocal<ValidatorState>();
 
     public BaseJsonValidator(String schemaPath, JsonNode schemaNode, JsonSchema parentSchema,
                              ValidatorTypeCode validatorType, ValidationContext validationContext) {

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

@@ -131,31 +131,46 @@ public OneOfValidator(String schemaPath, JsonNode schemaNode, JsonSchema parentS
     public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String at) {
         debug(logger, node, rootNode, at);
 
-        // this validator considers a missing node as an error
-        // set it here to true, however re-set it to its original value upon finishing the validation
-        boolean missingNodeAsError = config.isMissingNodeAsError();
-        config.setMissingNodeAsError(true);
+        // this is a complex validator, we set the flag to true
+        ValidatorState state = new ValidatorState();
+        state.setComplexValidator(true);
+        validatorState.set(state);
 
         int numberOfValidSchema = 0;
         Set<ValidationMessage> errors = new LinkedHashSet<ValidationMessage>();
 
+        // validate that only a single element has been received in the oneOf node
+        // validation should not continue, as it contradicts the oneOf requirement of only one
+        if(node.isObject() && node.size()>1) {
+        	errors = Collections.singleton(buildValidationMessage(at, ""));
+        	return Collections.unmodifiableSet(errors);
+        }
+        	
         for (ShortcutValidator validator : schemas) {
             if (!validator.allConstantsMatch(node)) {
                 // take a shortcut: if there is any constant that does not match,
-                // we can bail out
+                // we can bail out of the validation
                 continue;
             }
+            
+            // get the current validator
             JsonSchema schema = validator.schema;
-        	    Set<ValidationMessage> schemaErrors = schema.validate(node, rootNode, at);
+        	Set<ValidationMessage> schemaErrors = schema.validate(node, rootNode, at);
+        	
+        	// check if any validation errors have occurred
             if (schemaErrors.isEmpty()) {
+            	// check whether there are no errors HOWEVER we have validated the exact validator
+            	if(!state.hasMatchedNode())
+            		continue;
+            	
                 numberOfValidSchema++;
                 errors = new LinkedHashSet<ValidationMessage>();
-            }
-            if(numberOfValidSchema == 0){
-                errors.addAll(schemaErrors);
-        	}
+            } else {
+            	errors.addAll(schemaErrors);
+            }                	
         }
 
+        // no valid schema has been found after validating all schema validators
         if (numberOfValidSchema == 0) {
             for (Iterator<ValidationMessage> it = errors.iterator(); it.hasNext();) {
                 ValidationMessage msg = it.next();
@@ -168,14 +183,18 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String
                 // ensure there is always an error reported if number of valid schemas is 0
                 errors.add(buildValidationMessage(at, ""));
             }
+        } else {
+        	errors.clear();
         }
+        
+        // validated upfront
         if (numberOfValidSchema > 1) {
             errors = Collections.singleton(buildValidationMessage(at, ""));
         }
 
-        // reset the flag for error handling
-        config.setMissingNodeAsError(missingNodeAsError);
-
+        // reset the ValidatorState object in the ThreadLocal
+        validatorState.remove();
+        
         return Collections.unmodifiableSet(errors);
     }
 

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

@@ -41,20 +41,48 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String
 
         Set<ValidationMessage> errors = new LinkedHashSet<ValidationMessage>();
 
+        // get the Validator state object storing validation data
+        ValidatorState state = validatorState.get();
+        if(state == null) {
+        	// if one has not been created, instantiate one
+        	state = new ValidatorState();
+        	validatorState.set(state);
+        }
+        
         for (Map.Entry<String, JsonSchema> entry : schemas.entrySet()) {
             JsonSchema propertySchema = entry.getValue();
             JsonNode propertyNode = node.get(entry.getKey());
 
             if (propertyNode != null) {
+            	// check whether this is a complex validator. save the state
+            	boolean isComplex = state.isComplexValidator();
+            	// if this is a complex validator, the node has matched, and all it's child elements, if available, are to be validated
+            	if(state.isComplexValidator()) {
+            		state.setMatchedNode(true);
+            	}
+            	// reset the complex validator for child element validation, and reset it after the return from the recursive call
+            	state.setComplexValidator(false);
+            	
+            	//validate the child element(s)
                 errors.addAll(propertySchema.validate(propertyNode, rootNode, at + "." + entry.getKey()));
+                
+                // reset the complex flag to the original value before the recursive call
+                state.setComplexValidator(isComplex);
+                // if this was a complex validator, the node has matched and has been validated
+            	if(state.isComplexValidator()) {
+            		state.setMatchedNode(true);
+            	}
             } else {
-            	// if a node could not be found, treat is as error/continue, depending on the SchemaValidatorsConfig
-            	if(config.isMissingNodeAsError()) {
-            		if(getParentSchema().hasRequiredValidator())
-                		errors.addAll(getParentSchema().getRequiredValidator().validate(node,  rootNode, at));     
-            		else 
-                		errors.add(buildValidationMessage(at, node.toString()));
+            	// decide which behavior to eomploy when validator has not matched
+            	if(state.isComplexValidator()) {
+            		// this was a complex validator (ex oneOf) and the node has not been matched
+            		state.setMatchedNode(false);
+            		return Collections.unmodifiableSet(new LinkedHashSet<ValidationMessage>());
             	}
+            		
+            	// check whether the node which has not matched was mandatory or not
+        		if(getParentSchema().hasRequiredValidator())
+            		errors.addAll(getParentSchema().getRequiredValidator().validate(node,  rootNode, at));     
             }
         }
 

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

@@ -25,12 +25,6 @@ public class SchemaValidatorsConfig {
      */
     private boolean typeLoose;
 
-    /**
-     * if IS_MISSING_NODE_AS_ERROR = true, the validator will ignore the missing node.
-     * if set to false, then the validator will report an error
-     */
-    private boolean missingNodeAsError = false;
-
     /**
      * Map of public, normally internet accessible schema URLs to alternate locations; this allows for offline
      * validation of schemas that refer to public URLs. This is merged with any mappings the {@link JsonSchemaFactory} 
@@ -65,14 +59,6 @@ public void setUriMappings(Map<String, String> uriMappings) {
         this.uriMappings = uriMappings;
     }
 
-    public boolean isMissingNodeAsError() {
-    	return missingNodeAsError;
-    }
-    
-    public void setMissingNodeAsError(boolean missingNodeAsError) {
-    	this.missingNodeAsError = missingNodeAsError;
-    }
-
     public boolean isHandleNullableField() {
 		return handleNullableField;
 	}

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

@@ -0,0 +1,33 @@
+package com.networknt.schema;
+
+public class ValidatorState {
+	/**
+	 * Flag set when a node has matched Works in conjunction with the next flag:
+	 * isComplexValidator, to be used for complex validators such as oneOf, for ex
+	 */
+    private boolean matchedNode = true;
+
+	/**
+	 * Flag set if complex validators such as oneOf, for ex, neeed to have their
+	 * properties validated. The PropertiesValidator is not aware generally of a
+	 * complex validator is being validated or a simple poperty tree
+	 */
+    private boolean isComplexValidator = false;
+
+    public void setMatchedNode(boolean matchedNode) {
+        this.matchedNode = matchedNode;
+    }
+
+    public boolean hasMatchedNode() {
+        return matchedNode;
+    }
+
+    public boolean isComplexValidator() {
+        return isComplexValidator;
+    }
+
+    public void setComplexValidator(boolean isComplexValidator) {
+        this.isComplexValidator = isComplexValidator;
+    }
+
+}