add Temporal types Instant, LocalTime, OffsetTime, Year, YearMonth and ZonedDateTime

Author: ThoSap

src/main/java/it/aboutbits/springboot/testing/validation/source/FutureValueSource.java

@@ -2,10 +2,17 @@
 
 import it.aboutbits.springboot.testing.validation.core.ValueSource;
 
+import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.Month;
 import java.time.OffsetDateTime;
+import java.time.OffsetTime;
+import java.time.Year;
+import java.time.YearMonth;
 import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.function.Function;
@@ -14,10 +21,17 @@
 public class FutureValueSource implements ValueSource {
     private static final Map<Class<?>, Function<Object[], Stream<?>>> TYPE_SOURCES = new HashMap<>();
 
+    // https://jakarta.ee/specifications/bean-validation/3.0/apidocs/jakarta/validation/constraints/future
     static {
+        TYPE_SOURCES.put(Instant.class, FutureValueSource::getInstantStream);
+        TYPE_SOURCES.put(LocalTime.class, FutureValueSource::getLocalTimeStream);
         TYPE_SOURCES.put(LocalDate.class, FutureValueSource::getLocalDateStream);
-        TYPE_SOURCES.put(LocalDateTime.class, FutureValueSource::getLocalDatetimeStream);
+        TYPE_SOURCES.put(LocalDateTime.class, FutureValueSource::getLocalDateTimeStream);
+        TYPE_SOURCES.put(OffsetTime.class, FutureValueSource::getOffsetTimeStream);
         TYPE_SOURCES.put(OffsetDateTime.class, FutureValueSource::getOffsetDateTimeStream);
+        TYPE_SOURCES.put(Year.class, FutureValueSource::getYearStream);
+        TYPE_SOURCES.put(YearMonth.class, FutureValueSource::getYearMonthStream);
+        TYPE_SOURCES.put(ZonedDateTime.class, FutureValueSource::getZonedDateTimeStream);
     }
 
     @SuppressWarnings("unused")
@@ -36,24 +50,66 @@ public <T> Stream<T> values(Class<T> propertyClass, Object... args) {
         throw new IllegalArgumentException("Property class not supported!");
     }
 
+    private static Stream<Instant> getInstantStream(Object[] args) {
+        var currentInstant = Instant.now();
+        var largestInstant = Instant.MAX;
+
+        return Stream.of(currentInstant.plusSeconds(1L), largestInstant);
+    }
+
+    private static Stream<LocalTime> getLocalTimeStream(Object[] args) {
+        var currentLocalTime = LocalTime.now();
+        var largestLocalTime = LocalTime.MAX;
+
+        return Stream.of(currentLocalTime.plusSeconds(1L), largestLocalTime);
+    }
+
     private static Stream<LocalDate> getLocalDateStream(Object[] args) {
         var currentDate = LocalDate.now();
         var largestDate = LocalDate.MAX;
 
-        return Stream.of(currentDate.plusDays(1), largestDate);
+        return Stream.of(currentDate.plusDays(1L), largestDate);
     }
 
-    private static Stream<LocalDateTime> getLocalDatetimeStream(Object[] args) {
+    private static Stream<LocalDateTime> getLocalDateTimeStream(Object[] args) {
         var currentDateTime = LocalDateTime.now();
         var largestDateTime = LocalDateTime.MAX;
 
-        return Stream.of(currentDateTime.plusSeconds(1), largestDateTime);
+        return Stream.of(currentDateTime.plusSeconds(1L), largestDateTime);
+    }
+
+    private static Stream<OffsetTime> getOffsetTimeStream(Object[] args) {
+        var currentOffsetTime = OffsetTime.now(ZoneOffset.UTC);
+        var largestOffsetTime = OffsetTime.MAX;
+
+        return Stream.of(currentOffsetTime.plusSeconds(1L), largestOffsetTime);
     }
 
     private static Stream<OffsetDateTime> getOffsetDateTimeStream(Object[] args) {
         var currentOffsetDateTime = OffsetDateTime.now(ZoneOffset.UTC);
         var largestOffsetDateTime = OffsetDateTime.MAX;
 
-        return Stream.of(currentOffsetDateTime.plusSeconds(1), largestOffsetDateTime);
+        return Stream.of(currentOffsetDateTime.plusSeconds(1L), largestOffsetDateTime);
+    }
+
+    private static Stream<Year> getYearStream(Object[] args) {
+        var currentYear = Year.now();
+        var largestYear = Year.of(Year.MAX_VALUE);
+
+        return Stream.of(currentYear.plusYears(1L), largestYear);
+    }
+
+    private static Stream<YearMonth> getYearMonthStream(Object[] args) {
+        var currentYearMonth = YearMonth.now();
+        var largestYearMonth = YearMonth.of(Year.MAX_VALUE, Month.DECEMBER);
+
+        return Stream.of(currentYearMonth.plusMonths(1L), largestYearMonth);
+    }
+
+    private static Stream<ZonedDateTime> getZonedDateTimeStream(Object[] args) {
+        var currentZonedDateTime = ZonedDateTime.now(ZoneOffset.UTC);
+        var largestZonedDateTime = LocalDateTime.MAX.atZone(ZoneOffset.MIN);
+
+        return Stream.of(currentZonedDateTime.plusSeconds(1L), largestZonedDateTime);
     }
 }

src/main/java/it/aboutbits/springboot/testing/validation/source/PastValueSource.java

@@ -2,10 +2,17 @@
 
 import it.aboutbits.springboot.testing.validation.core.ValueSource;
 
+import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.Month;
 import java.time.OffsetDateTime;
+import java.time.OffsetTime;
+import java.time.Year;
+import java.time.YearMonth;
 import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.function.Function;
@@ -14,10 +21,17 @@
 public class PastValueSource implements ValueSource {
     private static final Map<Class<?>, Function<Object[], Stream<?>>> TYPE_SOURCES = new HashMap<>();
 
+    // https://jakarta.ee/specifications/bean-validation/3.0/apidocs/jakarta/validation/constraints/past
     static {
+        TYPE_SOURCES.put(Instant.class, PastValueSource::getInstantStream);
+        TYPE_SOURCES.put(LocalTime.class, PastValueSource::getLocalTimeStream);
         TYPE_SOURCES.put(LocalDate.class, PastValueSource::getLocalDateStream);
-        TYPE_SOURCES.put(LocalDateTime.class, PastValueSource::getLocalDatetimeStream);
+        TYPE_SOURCES.put(LocalDateTime.class, PastValueSource::getLocalDateTimeStream);
+        TYPE_SOURCES.put(OffsetTime.class, PastValueSource::getOffsetTimeStream);
         TYPE_SOURCES.put(OffsetDateTime.class, PastValueSource::getOffsetDateTimeStream);
+        TYPE_SOURCES.put(Year.class, PastValueSource::getYearStream);
+        TYPE_SOURCES.put(YearMonth.class, PastValueSource::getYearMonthStream);
+        TYPE_SOURCES.put(ZonedDateTime.class, PastValueSource::getZonedDateTimeStream);
     }
 
     @SuppressWarnings("unused")
@@ -36,25 +50,66 @@ public <T> Stream<T> values(Class<T> propertyClass, Object... args) {
         throw new IllegalArgumentException("Property class not supported!");
     }
 
+    private static Stream<Instant> getInstantStream(Object[] args) {
+        var currentInstant = Instant.now();
+        var smallestInstant = Instant.MIN;
+
+        return Stream.of(smallestInstant, currentInstant.minusSeconds(1L));
+    }
+
+    private static Stream<LocalTime> getLocalTimeStream(Object[] args) {
+        var currentLocalTime = LocalTime.now();
+        var smallestLocalTime = LocalTime.MIN;
+
+        return Stream.of(smallestLocalTime, currentLocalTime.minusSeconds(1L));
+    }
 
     private static Stream<LocalDate> getLocalDateStream(Object[] args) {
         var currentDate = LocalDate.now();
         var smallestDate = LocalDate.MIN;
 
-        return Stream.of(smallestDate, currentDate.minusDays(1));
+        return Stream.of(smallestDate, currentDate.minusDays(1L));
     }
 
-    private static Stream<LocalDateTime> getLocalDatetimeStream(Object[] args) {
+    private static Stream<LocalDateTime> getLocalDateTimeStream(Object[] args) {
         var currentDateTime = LocalDateTime.now();
         var smallestDateTime = LocalDateTime.MIN;
 
-        return Stream.of(smallestDateTime, currentDateTime.minusSeconds(1));
+        return Stream.of(smallestDateTime, currentDateTime.minusSeconds(1L));
+    }
+
+    private static Stream<OffsetTime> getOffsetTimeStream(Object[] args) {
+        var currentOffsetTime = OffsetTime.now(ZoneOffset.UTC);
+        var smallestOffsetTime = OffsetTime.MIN;
+
+        return Stream.of(smallestOffsetTime, currentOffsetTime.minusSeconds(1L));
     }
 
     private static Stream<OffsetDateTime> getOffsetDateTimeStream(Object[] args) {
         var currentOffsetDateTime = OffsetDateTime.now(ZoneOffset.UTC);
         var smallestOffsetDateTime = OffsetDateTime.MIN;
 
-        return Stream.of(smallestOffsetDateTime, currentOffsetDateTime.minusSeconds(1));
+        return Stream.of(smallestOffsetDateTime, currentOffsetDateTime.minusSeconds(1L));
+    }
+
+    private static Stream<Year> getYearStream(Object[] args) {
+        var currentYear = Year.now();
+        var smallestYear = Year.of(Year.MIN_VALUE);
+
+        return Stream.of(smallestYear, currentYear.minusYears(1L));
+    }
+
+    private static Stream<YearMonth> getYearMonthStream(Object[] args) {
+        var currentYearMonth = YearMonth.now();
+        var smallestYearMonth = YearMonth.of(Year.MIN_VALUE, Month.JANUARY);
+
+        return Stream.of(smallestYearMonth, currentYearMonth.minusMonths(1L));
+    }
+
+    private static Stream<ZonedDateTime> getZonedDateTimeStream(Object[] args) {
+        var currentZonedDateTime = ZonedDateTime.now(ZoneOffset.UTC);
+        var smallestZonedDateTime = LocalDateTime.MIN.atZone(ZoneOffset.MAX);
+
+        return Stream.of(smallestZonedDateTime, currentZonedDateTime.minusSeconds(1L));
     }
 }