feat(data): add until time argument skewing

During building the Request instance via RequestBuilder,
we need to skew the time of an until argument a bit.

- For Day granularity, it's necessary to include the complete given day.
- For Second granularity, it's necessary to add second to avoid
  exclusion of elements because of micro/nanosecond timestamps in databases.
- For Lenient, we want to the complete day, too - that's why it's lenient.

Adds a test for the skewing.

Author: poikilotherm

xoai-data-provider/src/main/java/io/gdcc/xoai/dataprovider/repository/RepositoryConfiguration.java

@@ -17,9 +17,14 @@
 import io.gdcc.xoai.xml.WriterContext;
 
 import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 
 import static java.util.Arrays.asList;
 
@@ -87,6 +92,28 @@ public Granularity getGranularity() {
             throw new InternalOAIException("Granularity has not been configured");
         return granularity;
     }
+    
+    /**
+     * Skew an instant to end of day (granularity Day or Lenient) or by a second (granularity Second).
+     * This is necessary for two reasons:
+     * 1. Day granularity must be inclusive, so we can't leave an "until" at start of day.
+     * 2. Lenient granularity must work like day in this case, as we cannot be sure which is meant.
+     * 3. Second granularity needs skipping a second to avoid not returning {@link io.gdcc.xoai.dataprovider.model.Item}
+     *    from the repository that use an SQL timestamp with nanosecond granularity (so ...:00.5829 would not be
+     *    found when asking for all until ...:00.000)
+     *
+     * @param timestamp The timestamp to skew a little
+     * @return The skewed timestamp
+     */
+    public Instant skewUntil(Instant timestamp) {
+        Objects.requireNonNull(timestamp, "Skewing an 'until' date must not be used with null");
+        switch (getGranularity()) {
+            case Day:
+            case Lenient: return LocalDate.ofInstant(timestamp, ZoneId.of("UTC")).atTime(LocalTime.MAX).toInstant(ZoneOffset.UTC);
+            case Second: return timestamp.plusSeconds(1);
+            default: return timestamp;
+        }
+    }
 
     public DeletedRecord getDeleteMethod() {
         if (deleteMethod == null)

xoai-data-provider/src/test/java/io/gdcc/xoai/dataprovider/repository/RepositoryConfigurationTest.java

@@ -0,0 +1,49 @@
+package io.gdcc.xoai.dataprovider.repository;
+
+import io.gdcc.xoai.model.oaipmh.Granularity;
+import io.gdcc.xoai.services.api.DateProvider;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class RepositoryConfigurationTest {
+    
+    private static Stream<Arguments> skews() {
+        return Stream.of(
+            Arguments.of(
+                LocalDateTime.of(2022, 5, 19,10,0,0, 123).toInstant(ZoneOffset.UTC),
+                Granularity.Second,
+                "2022-05-19T10:00:01Z",
+                "2022-05-19T10:00:01Z"
+            ),
+            Arguments.of(
+                LocalDateTime.of(2022, 5, 19,10,0,0, 123).toInstant(ZoneOffset.UTC),
+                Granularity.Day,
+                "2022-05-19",
+                "2022-05-19T23:59:59Z"
+            )
+        );
+    }
+    
+    @ParameterizedTest
+    @MethodSource("skews")
+    void skewUntil(Instant timestamp, Granularity granularity, String expected, String expectedAtSecondGranularity) {
+        // given
+        RepositoryConfiguration config = RepositoryConfiguration.defaults().withGranularity(granularity);
+        
+        // when
+        Instant skewedTime = config.skewUntil(timestamp);
+        
+        // then
+        assertTrue(skewedTime.isAfter(timestamp));
+        assertEquals(expected, DateProvider.format(skewedTime, granularity));
+        assertEquals(expectedAtSecondGranularity, DateProvider.format(skewedTime, Granularity.Second));
+    }
+}