Fixes #185 Validation issue in oneOf when elements have optional fields

Author: ddobrin

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

@@ -131,10 +131,8 @@ 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(false);
+        // this is a complex validator, we set the flag to true
+        config.setComplexValidator(true);
 
         int numberOfValidSchema = 0;
         Set<ValidationMessage> errors = new LinkedHashSet<ValidationMessage>();
@@ -149,33 +147,28 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String
         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(!config.hasMatchedNode())
+            		continue;
+            	
                 numberOfValidSchema++;
                 errors = new LinkedHashSet<ValidationMessage>();
-                
-                // a valid schema has been identified, and the node was an object, break the loop
-                if(node.isObject())
-                	break;
             } else {
-                if(node.isObject()) {
-                    if(numberOfValidSchema == 0){
-                        errors.addAll(schemaErrors);
-                	}                	
-                
-                	break;
-                }
-            }
-            
-            if(numberOfValidSchema == 0){
-                errors.addAll(schemaErrors);
-        	}
+            	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();
@@ -188,16 +181,15 @@ 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);
-
         return Collections.unmodifiableSet(errors);
     }
 

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

@@ -46,15 +46,33 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String
             JsonNode propertyNode = node.get(entry.getKey());
 
             if (propertyNode != null) {
+            	// check whether this is a complex validator. save the state
+            	boolean isComplex = config.isComplexValidator();
+            	// if this is a complex validator, the node has matched, and all it's child elements, if available, are to be validated
+            	if(config.isComplexValidator()) {
+            		config.setMatchedNode(true);
+            	}
+            	// reset the complex validator for child element validation, and reset it after the return from the recursive call
+            	config.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
+                config.setComplexValidator(isComplex);
+                // if this was a complex validator, the node has matched and has been validated
+            	if(config.isComplexValidator()) {
+            		config.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(config.isComplexValidator()) {
+            		// this was a complex validator (ex oneOf) and the node has not been matched
+            		config.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

@@ -26,11 +26,17 @@ 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
+     * 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 missingNodeAsError = false;
-
+    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;
+    
     /**
      * 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 +71,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;
 	}
@@ -89,4 +87,19 @@ private void loadDefaultConfig() {
         this.typeLoose = true;
         this.uriMappings = new HashMap<String, String>();
     }
+    
+    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;
+	}
 }