Merge pull request #118 from adyach/gather-valations-numberschema

Collect all violations while validating NumberSchema

Author: erosb

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

@@ -4,12 +4,15 @@
 import org.json.JSONException;
 
 import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Objects;
 
 import static java.lang.String.format;
 
 /**
  * Number schema validator.
+ * @ThreadSafe
  */
 public class NumberSchema extends Schema {
 
@@ -131,42 +134,43 @@ public NumberSchema(final Builder builder) {
         this.exclusiveMaximumLimit = builder.exclusiveMaximumLimit;
     }
 
-    private void checkMaximum(final double subject) {
+    private void checkMaximum(final double subject, final List<ValidationException> validationExceptions) {
         if (maximum != null) {
             if (exclusiveMaximum && maximum.doubleValue() <= subject) {
-                throw failure(subject + " is not less than " + maximum, "exclusiveMaximum");
+                validationExceptions.add(failure(subject + " is not less than " + maximum, "exclusiveMaximum"));
             } else if (maximum.doubleValue() < subject) {
-                throw failure(subject + " is not less or equal to " + maximum, "maximum");
+                validationExceptions.add(failure(subject + " is not less or equal to " + maximum, "maximum"));
             }
         }
         if (exclusiveMaximumLimit != null) {
             if (subject >= exclusiveMaximumLimit.doubleValue()) {
-                throw failure(format("is not less than " + exclusiveMaximumLimit), "exclusiveMaximum");
+                validationExceptions.add(
+                        failure(format("is not less than " + exclusiveMaximumLimit),"exclusiveMaximum"));
             }
         }
     }
 
-    private void checkMinimum(final double subject) {
+    private void checkMinimum(final double subject, final List<ValidationException> validationExceptions) {
         if (minimum != null) {
             if (exclusiveMinimum && subject <= minimum.doubleValue()) {
-                throw failure(subject + " is not greater than " + minimum, "exclusiveMinimum");
+                validationExceptions.add(failure(subject + " is not greater than " + minimum, "exclusiveMinimum"));
             } else if (subject < minimum.doubleValue()) {
-                throw failure(subject + " is not greater or equal to " + minimum, "minimum");
+                validationExceptions.add(failure(subject + " is not greater or equal to " + minimum, "minimum"));
             }
         }
         if (exclusiveMinimumLimit != null) {
             if (subject <= exclusiveMinimumLimit.doubleValue()) {
-                throw failure(subject + " is not greater than " + exclusiveMinimumLimit, "exclusiveMinimum");
+                validationExceptions.add(failure(subject + " is not greater than " + exclusiveMinimumLimit, "exclusiveMinimum"));
             }
         }
     }
 
-    private void checkMultipleOf(final double subject) {
+    private void checkMultipleOf(final double subject, final List<ValidationException> validationExceptions) {
         if (multipleOf != null) {
             BigDecimal remainder = BigDecimal.valueOf(subject).remainder(
                     BigDecimal.valueOf(multipleOf.doubleValue()));
             if (remainder.compareTo(BigDecimal.ZERO) != 0) {
-                throw failure(subject + " is not a multiple of " + multipleOf, "multipleOf");
+                validationExceptions.add(failure(subject + " is not a multiple of " + multipleOf, "multipleOf"));
             }
         }
     }
@@ -206,9 +210,11 @@ public void validate(final Object subject) {
                 throw failure(Integer.class, subject);
             }
             double intSubject = ((Number) subject).doubleValue();
-            checkMinimum(intSubject);
-            checkMaximum(intSubject);
-            checkMultipleOf(intSubject);
+            final List<ValidationException> validationExceptions = new ArrayList<>();
+            checkMinimum(intSubject, validationExceptions);
+            checkMaximum(intSubject, validationExceptions);
+            checkMultipleOf(intSubject, validationExceptions);
+            ValidationException.throwFor(this, validationExceptions);
         }
     }
 

core/src/test/java/org/everit/json/schema/NumberSchemaTest.java

@@ -15,19 +15,18 @@
  */
 package org.everit.json.schema;
 
+import nl.jqno.equalsverifier.EqualsVerifier;
+import nl.jqno.equalsverifier.Warning;
+import org.everit.json.schema.loader.SchemaLoader;
+import org.json.JSONObject;
+import org.junit.Test;
+
 import static org.everit.json.schema.TestSupport.buildWithLocation;
 import static org.everit.json.schema.TestSupport.loadAsV6;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
-import org.everit.json.schema.loader.SchemaLoader;
-import org.json.JSONObject;
-import org.junit.Test;
-
-import nl.jqno.equalsverifier.EqualsVerifier;
-import nl.jqno.equalsverifier.Warning;
-
 public class NumberSchemaTest {
 
     private final ResourceLoader loader = new ResourceLoader("/org/everit/jsonvalidator/tostring/");
@@ -104,6 +103,20 @@ public void multipleOfFailure() {
                 .expect();
     }
 
+    @Test
+    public void shouldListAllViolationsWhenThereIsMoreThanOne() {
+        try {
+            NumberSchema.builder()
+                    .multipleOf(10).minimum(10.0).maximum(15.0)
+                    .build()
+                    .validate(3);
+        } catch (ValidationException ve) {
+            assertEquals(2, ve.getViolationCount());
+            assertEquals("minimum", ve.getCausingExceptions().get(0).getKeyword());
+            assertEquals("multipleOf", ve.getCausingExceptions().get(1).getKeyword());
+        }
+    }
+
     @Test
     public void notRequiresNumber() {
         NumberSchema.builder().requiresNumber(false).build().validate("foo");