Print Integer as expected type if String is given

everit-org · Oct 18, 2020 · 92f92a4 · 92f92a4
1 parent 853c936
commit 92f92a4
Show file tree

Hide file tree

Showing 6 changed files with 62 additions and 23 deletions.
diff --git a/core/src/main/java/org/everit/json/schema/NumberSchema.java b/core/src/main/java/org/everit/json/schema/NumberSchema.java
@@ -150,7 +150,7 @@ public boolean requiresInteger() {
         return requiresInteger;
     }
 
-    public boolean isRequiresNumber() {
+    public boolean requiresNumber() {
         return requiresNumber;
     }
 

diff --git a/core/src/main/java/org/everit/json/schema/NumberSchemaValidatingVisitor.java b/core/src/main/java/org/everit/json/schema/NumberSchemaValidatingVisitor.java
@@ -9,10 +9,8 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
-class NumberSchemaValidatingVisitor extends Visitor {
 
-    private static final List<Class<?>> INTEGRAL_TYPES = Arrays.asList(Integer.class, Long.class, BigInteger.class,
-            AtomicInteger.class, AtomicLong.class);
+class NumberSchemaValidatingVisitor extends Visitor {
 
     private final Object subject;
 
@@ -26,25 +24,25 @@ class NumberSchemaValidatingVisitor extends Visitor {
 
     NumberSchemaValidatingVisitor(Object subject, ValidatingVisitor owner) {
         this.subject = subject;
-        this.owner= owner;
+        this.owner = owner;
     }
 
-    @Override void visitNumberSchema(NumberSchema numberSchema) {
-        if (owner.passesTypeCheck(Number.class, numberSchema.isRequiresNumber(), numberSchema.isNullable())) {
-            if (!INTEGRAL_TYPES.contains(subject.getClass()) && numberSchema.requiresInteger()) {
-                owner.failure(Integer.class, subject);
-            } else {
-                this.numberSubject = ((Number) subject).doubleValue();
-                super.visitNumberSchema(numberSchema);
-            }
+    @Override
+    void visitNumberSchema(NumberSchema numberSchema) {
+        Class expectedType = numberSchema.requiresInteger() ? Integer.class : Number.class;
+        if (owner.passesTypeCheck(expectedType, numberSchema.requiresInteger() || numberSchema.requiresNumber(), numberSchema.isNullable())) {
+            this.numberSubject = ((Number) subject).doubleValue();
+            super.visitNumberSchema(numberSchema);
         }
     }
 
-    @Override void visitExclusiveMinimum(boolean exclusiveMinimum) {
+    @Override
+    void visitExclusiveMinimum(boolean exclusiveMinimum) {
         this.exclusiveMinimum = exclusiveMinimum;
     }
 
-    @Override void visitMinimum(Number minimum) {
+    @Override
+    void visitMinimum(Number minimum) {
         if (minimum == null) {
             return;
         }
@@ -55,15 +53,17 @@ class NumberSchemaValidatingVisitor extends Visitor {
         }
     }
 
-    @Override void visitExclusiveMinimumLimit(Number exclusiveMinimumLimit) {
+    @Override
+    void visitExclusiveMinimumLimit(Number exclusiveMinimumLimit) {
         if (exclusiveMinimumLimit != null) {
             if (numberSubject <= exclusiveMinimumLimit.doubleValue()) {
                 owner.failure(subject + " is not greater than " + exclusiveMinimumLimit, "exclusiveMinimum");
             }
         }
     }
 
-    @Override void visitMaximum(Number maximum) {
+    @Override
+    void visitMaximum(Number maximum) {
         if (maximum == null) {
             return;
         }
@@ -74,22 +74,25 @@ class NumberSchemaValidatingVisitor extends Visitor {
         }
     }
 
-    @Override void visitExclusiveMaximum(boolean exclusiveMaximum) {
+    @Override
+    void visitExclusiveMaximum(boolean exclusiveMaximum) {
         this.exclusiveMaximum = exclusiveMaximum;
     }
 
-    @Override void visitExclusiveMaximumLimit(Number exclusiveMaximumLimit) {
+    @Override
+    void visitExclusiveMaximumLimit(Number exclusiveMaximumLimit) {
         if (exclusiveMaximumLimit != null) {
             if (numberSubject >= exclusiveMaximumLimit.doubleValue()) {
                 owner.failure(subject + " is not less than " + exclusiveMaximumLimit, "exclusiveMaximum");
             }
         }
     }
 
-    @Override void visitMultipleOf(Number multipleOf) {
+    @Override
+    void visitMultipleOf(Number multipleOf) {
         if (multipleOf != null) {
             BigDecimal remainder = BigDecimal.valueOf(numberSubject).remainder(
-                    BigDecimal.valueOf(multipleOf.doubleValue()));
+                BigDecimal.valueOf(multipleOf.doubleValue()));
             if (remainder.compareTo(BigDecimal.ZERO) != 0) {
                 owner.failure(subject + " is not a multiple of " + multipleOf, "multipleOf");
             }

diff --git a/core/src/main/java/org/everit/json/schema/ToStringVisitor.java b/core/src/main/java/org/everit/json/schema/ToStringVisitor.java
@@ -154,7 +154,7 @@ void visitBooleanSchema(BooleanSchema schema) {
         printInJsonObject(() -> {
             if (schema.requiresInteger()) {
                 writer.key("type").value("integer");
-            } else if (schema.isRequiresNumber()) {
+            } else if (schema.requiresNumber()) {
                 writer.key("type").value("number");
             }
             writer.ifPresent("minimum", schema.getMinimum());

diff --git a/core/src/main/java/org/everit/json/schema/TypeChecker.java b/core/src/main/java/org/everit/json/schema/TypeChecker.java
@@ -0,0 +1,21 @@
+package org.everit.json.schema;
+
+import java.math.BigInteger;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+
+public class TypeChecker  {
+    private static final List<Class<?>> INTEGRAL_TYPES = Arrays.asList(Integer.class, Long.class, BigInteger.class,
+        AtomicInteger.class, AtomicLong.class);
+
+    static boolean isAssignableFrom(Class<?> class1, Class<?> class2) {
+        if (class1.equals(Integer.class)) {
+            return INTEGRAL_TYPES.contains(class2);
+        }
+        return class1.isAssignableFrom(class2);
+    }
+}
+
diff --git a/core/src/main/java/org/everit/json/schema/ValidatingVisitor.java b/core/src/main/java/org/everit/json/schema/ValidatingVisitor.java
@@ -6,9 +6,14 @@
 import static java.util.stream.Collectors.joining;
 import static org.everit.json.schema.EnumSchema.toJavaValue;
 
+import java.math.BigInteger;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 
 import org.everit.json.schema.event.CombinedSchemaMatchEvent;
 import org.everit.json.schema.event.CombinedSchemaMismatchEvent;
@@ -217,7 +222,7 @@ boolean passesTypeCheck(Class<?> expectedType, boolean schemaRequiresType, Boole
             }
             return false;
         }
-        if (expectedType.isAssignableFrom(subject.getClass())) {
+        if (TypeChecker.isAssignableFrom(expectedType, subject.getClass())) {
             return true;
         }
         if (schemaRequiresType) {

diff --git a/core/src/test/java/org/everit/json/schema/NumberSchemaTest.java b/core/src/test/java/org/everit/json/schema/NumberSchemaTest.java
@@ -134,6 +134,16 @@ public void requiresIntegerFailure() {
         TestSupport.expectFailure(subject, 10.2f);
     }
 
+    @Test
+    public void requiresIntegerStringGivenFailure() {
+        NumberSchema subject = buildWithLocation(NumberSchema.builder().requiresInteger(true));
+        TestSupport.failureOf(subject)
+            .input(1.3d)
+            .expectedPointer("#")
+            .expectedMessageFragment("expected type: Integer, found: String")
+            .expect();
+    }
+
     @Test
     public void requiresIntegerSuccess() {
         NumberSchema.builder().requiresInteger(true).build().validate(10);