feat: Validate integer format 'int32' for 32-bit overflow

Author: thced

src/main/java/com/retailsvc/http/validate/DefaultValidator.java

@@ -36,7 +36,9 @@
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
+import java.util.function.DoublePredicate;
 import java.util.function.Function;
+import java.util.function.LongPredicate;
 import java.util.function.Predicate;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
@@ -47,6 +49,10 @@ public final class DefaultValidator implements Validator {
 
   private record FormatCheck(Predicate<String> isValid, String message) {}
 
+  private record IntegerFormatCheck(LongPredicate isValid, String message) {}
+
+  private record NumberFormatCheck(DoublePredicate isValid, String message) {}
+
   private static final Pattern EMAIL = Pattern.compile("^[^\\s@]++@[^\\s@.]++\\.[^\\s@]++$");
 
   private static final Pattern HOSTNAME =
@@ -75,6 +81,15 @@ private record FormatCheck(Predicate<String> isValid, String message) {}
           Map.entry("binary", new FormatCheck(s -> true, "not valid binary")),
           Map.entry("password", new FormatCheck(s -> true, "not valid password")));
 
+  private static final Map<String, IntegerFormatCheck> INTEGER_FORMAT_CHECKS =
+      Map.of(
+          "int32",
+          new IntegerFormatCheck(
+              n -> n >= Integer.MIN_VALUE && n <= Integer.MAX_VALUE,
+              "value does not fit in int32"));
+
+  private static final Map<String, NumberFormatCheck> NUMBER_FORMAT_CHECKS = Map.of();
+
   private final Function<String, Schema> refResolver;
   private final ConcurrentMap<String, Pattern> compiledPatterns = new ConcurrentHashMap<>();
 
@@ -154,6 +169,26 @@ private void validateStringFormat(String str, String format, String pointer) {
     }
   }
 
+  private void validateIntegerFormat(long n, String format, String pointer) {
+    IntegerFormatCheck check = INTEGER_FORMAT_CHECKS.get(format);
+    if (check == null) {
+      return;
+    }
+    if (!check.isValid().test(n)) {
+      fail(pointer, FORMAT_KEYWORD, check.message(), n);
+    }
+  }
+
+  private void validateNumberFormat(double n, String format, String pointer) {
+    NumberFormatCheck check = NUMBER_FORMAT_CHECKS.get(format);
+    if (check == null) {
+      return;
+    }
+    if (!check.isValid().test(n)) {
+      fail(pointer, FORMAT_KEYWORD, check.message(), n);
+    }
+  }
+
   private static boolean isUuid(String s) {
     try {
       UUID.fromString(s);
@@ -336,6 +371,9 @@ private void validateInteger(Object value, IntegerSchema s, String pointer) {
     if (s.multipleOf() != null && n % s.multipleOf() != 0) {
       fail(pointer, "multipleOf", "not a multiple of " + s.multipleOf(), n);
     }
+    if (s.format() != null) {
+      validateIntegerFormat(n, s.format(), pointer);
+    }
   }
 
   private void validateNumber(Object value, NumberSchema s, String pointer) {
@@ -371,6 +409,9 @@ private void validateNumber(Object value, NumberSchema s, String pointer) {
     if (s.multipleOf() != null && !isMultipleOf(n, s.multipleOf().doubleValue())) {
       fail(pointer, "multipleOf", "not a multiple of " + s.multipleOf(), n);
     }
+    if (s.format() != null) {
+      validateNumberFormat(n, s.format(), pointer);
+    }
   }
 
   /**

src/test/java/com/retailsvc/http/validate/StringIntegerNumberTest.java

@@ -241,4 +241,18 @@ void stringFormatUnknownIsIgnored() {
             Set.of(TypeName.STRING), null, null, null, "definitely-not-a-format", null);
     assertThatCode(() -> v.validate("anything", s, "/v")).doesNotThrowAnyException();
   }
+
+  @Test
+  void integerFormatInt32() {
+    IntegerSchema s =
+        new IntegerSchema(Set.of(TypeName.INTEGER), null, null, null, null, null, "int32");
+    assertThatCode(() -> v.validate(Integer.MAX_VALUE, s, "/v")).doesNotThrowAnyException();
+    assertThatCode(() -> v.validate(Integer.MIN_VALUE, s, "/v")).doesNotThrowAnyException();
+    assertThatThrownBy(() -> v.validate(Integer.MAX_VALUE + 1L, s, "/v"))
+        .extracting(t -> ((ValidationException) t).error().keyword())
+        .isEqualTo("format");
+    assertThatThrownBy(() -> v.validate(Integer.MIN_VALUE - 1L, s, "/v"))
+        .extracting(t -> ((ValidationException) t).error().keyword())
+        .isEqualTo("format");
+  }
 }