finished reworking ObjectSchema to new ValidationException handling (might need further improvements)

Author: erosb

core/src/main/java/org/everit/json/schema/ObjectSchema.java

@@ -306,78 +306,94 @@ private List<ValidationException> testPatternProperties(final JSONObject subject
       for (String propName : propNames) {
         if (entry.getKey().matcher(propName).find()) {
           ifFails(entry.getValue(), subject.get(propName))
-              .map(exc -> exc.prepend(propName, exc.getViolatedSchema()))
+              .map(exc -> exc.prepend(propName))
               .ifPresent(rval::add);
         }
       }
     }
     return rval;
   }
 
-  private void testProperties(final JSONObject subject) {
+  private List<ValidationException> testProperties(final JSONObject subject) {
     if (propertySchemas != null) {
+      List<ValidationException> rval = new ArrayList<>();
       for (Entry<String, Schema> entry : propertySchemas.entrySet()) {
         String key = entry.getKey();
         if (subject.has(key)) {
-          entry.getValue().validate(subject.get(key));
+          ifFails(entry.getValue(), subject.get(key))
+              .map(exc -> exc.prepend(key))
+              .ifPresent(rval::add);
         }
       }
+      return rval;
     }
+    return Collections.emptyList();
   }
 
-  private void testPropertyDependencies(final JSONObject subject) {
-    propertyDependencies.keySet().stream()
-    .filter(subject::has)
-    .flatMap(ifPresent -> propertyDependencies.get(ifPresent).stream())
-    .filter(mustBePresent -> !subject.has(mustBePresent))
-    .findFirst()
-    .ifPresent(missing -> failure("property [%s] is required", missing));
+  private List<ValidationException> testPropertyDependencies(final JSONObject subject) {
+    return propertyDependencies.keySet().stream()
+        .filter(subject::has)
+        .flatMap(ifPresent -> propertyDependencies.get(ifPresent).stream())
+        .filter(mustBePresent -> !subject.has(mustBePresent))
+        .map(missingKey -> String.format("property [%s] is required", missingKey))
+        .map(excMessage -> new ValidationException(this, excMessage))
+        .collect(Collectors.toList());
   }
 
-  private void testRequiredProperties(final JSONObject subject) {
-    requiredProperties.stream()
-    .filter(key -> !subject.has(key))
-    .findFirst()
-    .ifPresent(missing -> failure("required key [%s] not found", missing));
+  private List<ValidationException> testRequiredProperties(final JSONObject subject) {
+    return requiredProperties.stream()
+        .filter(key -> !subject.has(key))
+        .map(missingKey -> String.format("required key [%s] not found", missingKey))
+        .map(excMessage -> new ValidationException(this, excMessage))
+        .collect(Collectors.toList());
   }
 
-  private void testSchemaDependencies(final JSONObject subject) {
-    schemaDependencies.keySet().stream()
-    .filter(subject::has)
-    .map(schemaDependencies::get)
-    .forEach(schema -> schema.validate(subject));
+  private List<ValidationException> testSchemaDependencies(final JSONObject subject) {
+    List<ValidationException> rval = new ArrayList<>();
+    for (Map.Entry<String, Schema> schemaDep : schemaDependencies.entrySet()) {
+      String propName = schemaDep.getKey();
+      if (subject.has(propName)) {
+        ifFails(schemaDep.getValue(), subject).ifPresent(rval::add);
+      }
+    }
+    return rval;
   }
 
-  private void testSize(final JSONObject subject) {
+  private List<ValidationException> testSize(final JSONObject subject) {
     int actualSize = subject.length();
     if (minProperties != null && actualSize < minProperties.intValue()) {
-      throw new ValidationException(this, String.format("minimum size: [%d], found: [%d]",
-          minProperties, actualSize));
+      return Arrays
+          .asList(new ValidationException(this, String.format("minimum size: [%d], found: [%d]",
+              minProperties, actualSize)));
     }
     if (maxProperties != null && actualSize > maxProperties.intValue()) {
-      throw new ValidationException(this, String.format("maximum size: [%d], found: [%d]",
-          maxProperties, actualSize));
+      return Arrays
+          .asList(new ValidationException(this, String.format("maximum size: [%d], found: [%d]",
+              maxProperties, actualSize)));
     }
+    return Collections.emptyList();
   }
 
   @Override
   public void validate(final Object subject) {
     if (!(subject instanceof JSONObject)) {
       if (requiresObject) {
-        throw new ValidationException(JSONObject.class, subject);
+        throw new ValidationException(this, JSONObject.class, subject);
       }
     } else {
       List<ValidationException> failures = new ArrayList<>();
       JSONObject objSubject = (JSONObject) subject;
-      testProperties(objSubject);
-      testRequiredProperties(objSubject);
+      failures.addAll(testProperties(objSubject));
+      failures.addAll(testRequiredProperties(objSubject));
       failures.addAll(testAdditionalProperties(objSubject));
-      testSize(objSubject);
-      testPropertyDependencies(objSubject);
-      testSchemaDependencies(objSubject);
+      failures.addAll(testSize(objSubject));
+      failures.addAll(testPropertyDependencies(objSubject));
+      failures.addAll(testSchemaDependencies(objSubject));
       failures.addAll(testPatternProperties(objSubject));
       if (failures.size() == 1) {
         throw failures.get(0);
+      } else if (failures.size() > 1) {
+        throw ValidationException.multipleFailures(this, failures);
       }
     }
   }

core/src/main/java/org/everit/json/schema/ValidationException.java

@@ -15,6 +15,9 @@
  */
 package org.everit.json.schema;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 import java.util.Objects;
 
 /**
@@ -23,10 +26,17 @@
 public class ValidationException extends RuntimeException {
   private static final long serialVersionUID = 6192047123024651924L;
 
+  public static final ValidationException multipleFailures(final Schema rootFailingSchema,
+      final List<ValidationException> causingExceptions) {
+    return new ValidationException(rootFailingSchema, new ArrayList<>(causingExceptions));
+  }
+
   private final StringBuilder pointerToViolation;
 
   private final Schema violatedSchema;
 
+  private final List<ValidationException> causingExceptions;
+
   /**
    * Deprecated, use {@code ValidationException(Schema, Class<?>, Object)} instead.
    *
@@ -40,14 +50,30 @@ public ValidationException(final Class<?> expectedType, final Object actualValue
 
   public ValidationException(final Schema violatedSchema, final Class<?> expectedType,
       final Object actualValue) {
-    this(violatedSchema, "expected type: " + expectedType.getSimpleName() + ", found: "
-        + (actualValue == null ? "null" : actualValue.getClass().getSimpleName()));
+    this(violatedSchema, new StringBuilder("#"),
+        "expected type: " + expectedType.getSimpleName() + ", found: "
+            + (actualValue == null ? "null" : actualValue.getClass().getSimpleName()),
+        Collections.emptyList());
+  }
+
+  private ValidationException(final Schema rootFailingSchema,
+      final List<ValidationException> causingExceptions) {
+    this(rootFailingSchema, new StringBuilder("#"),
+        causingExceptions.size() + " schema violations found",
+        causingExceptions);
   }
 
   public ValidationException(final Schema violatedSchema, final String message) {
+    this(violatedSchema, new StringBuilder("#"), message, Collections.emptyList());
+  }
+
+  public ValidationException(final Schema violatedSchema, final StringBuilder pointerToViolation,
+      final String message,
+      final List<ValidationException> causingExceptions) {
     super(message);
     this.violatedSchema = violatedSchema;
-    this.pointerToViolation = new StringBuilder("#");
+    this.pointerToViolation = pointerToViolation;
+    this.causingExceptions = Collections.unmodifiableList(causingExceptions);
   }
 
   /**
@@ -58,15 +84,17 @@ public ValidationException(final Schema violatedSchema, final String message) {
    */
   @Deprecated
   public ValidationException(final String message) {
-    this((Schema) null, message);
+    this((Schema) null, new StringBuilder("#"), message, Collections.emptyList());
   }
 
   private ValidationException(final StringBuilder pointerToViolation,
       final Schema violatedSchema,
       final ValidationException original) {
-    super(original.getMessage());
-    this.violatedSchema = violatedSchema;
-    this.pointerToViolation = pointerToViolation;
+    this(violatedSchema, pointerToViolation, original.getMessage(), original.causingExceptions);
+  }
+
+  public List<ValidationException> getCausingExceptions() {
+    return causingExceptions;
   }
 
   public String getPointerToViolation() {
@@ -77,10 +105,14 @@ public Schema getViolatedSchema() {
     return violatedSchema;
   }
 
-  public ValidationException prepend(final String fragment, final Schema violatingSchema) {
+  public ValidationException prepend(final String fragment) {
+    return prepend(fragment, this.violatedSchema);
+  }
+
+  public ValidationException prepend(final String fragment, final Schema violatedSchema) {
     Objects.requireNonNull(fragment, "fragment cannot be null");
-    return new ValidationException(this.pointerToViolation.insert(1, '/').insert(2, fragment),
-        violatingSchema, this);
+    StringBuilder newPointer = this.pointerToViolation.insert(1, '/').insert(2, fragment);
+    return new ValidationException(newPointer, violatedSchema, this);
   }
 
 }