Update OffsetDateTime Handling during Deserialization

sdk/core/azure-core/src/main/java/com/azure/core/util/serializer/DateTimeDeserializer.java

@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package com.azure.core.util.serializer;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+
+import java.io.IOException;
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.TemporalAccessor;
+import java.time.temporal.TemporalQueries;
+
+/**
+ * Custom deserializer that handles converting ISO8601 dates into {@link OffsetDateTime} objects.
+ */
+class DateTimeDeserializer extends JsonDeserializer<OffsetDateTime> {
+    private static final SimpleModule MODULE;
+
+    static {
+        MODULE = new SimpleModule().addDeserializer(OffsetDateTime.class, new DateTimeDeserializer());
+    }
+
+    /**
+     * Gets a module wrapping this deserializer as an adapter for the Jackson ObjectMapper.
+     *
+     * @return A {@link SimpleModule} to be plugged onto Jackson ObjectMapper.
+     */
+    public static SimpleModule getModule() {
+        return MODULE;
+    }
+
+    @Override
+    public OffsetDateTime deserialize(JsonParser parser, DeserializationContext context) throws IOException {
+        TemporalAccessor temporal = DateTimeFormatter.ISO_DATE_TIME
+            .parseBest(parser.getValueAsString(), OffsetDateTime::from, LocalDateTime::from);
+
+        if (temporal.query(TemporalQueries.offset()) == null) {
+            return LocalDateTime.from(temporal).atOffset(ZoneOffset.UTC);
+        } else {
+            return OffsetDateTime.from(temporal);
+        }
+    }
+}

sdk/core/azure-core/src/main/java/com/azure/core/util/serializer/DateTimeSerializer.java

@@ -18,16 +18,19 @@
  * Custom serializer for serializing {@link OffsetDateTime} object into ISO8601 formats.
  */
 final class DateTimeSerializer extends JsonSerializer<OffsetDateTime> {
+    private static final SimpleModule MODULE;
+
+    static {
+        MODULE = new SimpleModule().addSerializer(OffsetDateTime.class, new DateTimeSerializer());
+    }
+
     /**
-     * Gets a module wrapping this serializer as an adapter for the Jackson
-     * ObjectMapper.
+     * Gets a module wrapping this serializer as an adapter for the Jackson ObjectMapper.
      *
      * @return a simple module to be plugged onto Jackson ObjectMapper.
      */
     public static SimpleModule getModule() {
-        SimpleModule module = new SimpleModule();
-        module.addSerializer(OffsetDateTime.class, new DateTimeSerializer());
-        return module;
+        return MODULE;
     }
 
     @Override
@@ -41,6 +44,7 @@ public void serialize(OffsetDateTime value, JsonGenerator jgen, SerializerProvid
 
     /**
      * Convert the provided OffsetDateTime to its String representation.
+     *
      * @param offsetDateTime The OffsetDateTime to convert.
      * @return The String representation of the provided offsetDateTime.
      */

sdk/core/azure-core/src/main/java/com/azure/core/util/serializer/JacksonAdapter.java

@@ -250,6 +250,7 @@ private static <T extends ObjectMapper> T initializeObjectMapper(T mapper) {
             .registerModule(ByteArraySerializer.getModule())
             .registerModule(Base64UrlSerializer.getModule())
             .registerModule(DateTimeSerializer.getModule())
+            .registerModule(DateTimeDeserializer.getModule())
             .registerModule(DateTimeRfc1123Serializer.getModule())
             .registerModule(DurationSerializer.getModule())
             .registerModule(HttpHeadersSerializer.getModule())

sdk/core/azure-core/src/test/java/com/azure/core/util/serializer/DateTimeDeserializerTests.java

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package com.azure.core.util.serializer;
+
+import com.fasterxml.jackson.core.JsonParser;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.io.IOException;
+import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * Tests for {@link DateTimeDeserializer}.
+ */
+public class DateTimeDeserializerTests {
+    @ParameterizedTest
+    @MethodSource("deserializeOffsetDateTimeSupplier")
+    public void deserializeJson(String offsetDateTimeString, OffsetDateTime expected) throws IOException {
+        JsonParser parser = mock(JsonParser.class);
+        when(parser.getValueAsString()).thenReturn(offsetDateTimeString);
+
+        assertEquals(expected, new DateTimeDeserializer().deserialize(parser, null));
+    }
+
+    private static Stream<Arguments> deserializeOffsetDateTimeSupplier() {
+        OffsetDateTime minValue = OffsetDateTime.of(1, 1, 1, 0, 0, 0, 0, ZoneOffset.UTC);
+        OffsetDateTime unixEpoch = OffsetDateTime.of(1970, 1, 1, 0, 0, 0, 0, ZoneOffset.UTC);
+
+        return Stream.of(
+            Arguments.of("0001-01-01T00:00:00", minValue),
+            Arguments.of("0001-01-01T00:00:00Z", minValue),
+            Arguments.of("1970-01-01T00:00:00", unixEpoch),
+            Arguments.of("1970-01-01T00:00:00Z", unixEpoch)
+        );
+    }
+}

sdk/core/azure-core/src/test/java/com/azure/core/util/serializer/JacksonAdapterTests.java

@@ -7,10 +7,16 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.io.IOException;
+import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.stream.Stream;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
@@ -79,4 +85,63 @@ public String getValue() {
             return value;
         }
     }
+
+    @ParameterizedTest
+    @MethodSource("deserializeJsonSupplier")
+    public void deserializeJson(String json, OffsetDateTime expected) throws IOException {
+        DateTimeWrapper wrapper = JacksonAdapter.createDefaultSerializerAdapter()
+            .deserialize(json, DateTimeWrapper.class, SerializerEncoding.JSON);
+
+        assertEquals(expected, wrapper.getOffsetDateTime());
+    }
+
+    private static Stream<Arguments> deserializeJsonSupplier() {
+        final String jsonFormat = "{\"OffsetDateTime\":\"%s\"}";
+        OffsetDateTime minValue = OffsetDateTime.of(1, 1, 1, 0, 0, 0, 0, ZoneOffset.UTC);
+        OffsetDateTime unixEpoch = OffsetDateTime.of(1970, 1, 1, 0, 0, 0, 0, ZoneOffset.UTC);
+
+        return Stream.of(
+            Arguments.of(String.format(jsonFormat, "0001-01-01T00:00:00"), minValue),
+            Arguments.of(String.format(jsonFormat, "0001-01-01T00:00:00Z"), minValue),
+            Arguments.of(String.format(jsonFormat, "1970-01-01T00:00:00"), unixEpoch),
+            Arguments.of(String.format(jsonFormat, "1970-01-01T00:00:00Z"), unixEpoch)
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("deserializeXmlSupplier")
+    public void deserializeXml(String xml, OffsetDateTime expected) throws IOException {
+        DateTimeWrapper wrapper = JacksonAdapter.createDefaultSerializerAdapter()
+            .deserialize(xml, DateTimeWrapper.class, SerializerEncoding.XML);
+
+        assertEquals(expected, wrapper.getOffsetDateTime());
+    }
+
+    private static Stream<Arguments> deserializeXmlSupplier() {
+        final String xmlFormat = "<Wrapper><OffsetDateTime>%s</OffsetDateTime></Wrapper>";
+        OffsetDateTime minValue = OffsetDateTime.of(1, 1, 1, 0, 0, 0, 0, ZoneOffset.UTC);
+        OffsetDateTime unixEpoch = OffsetDateTime.of(1970, 1, 1, 0, 0, 0, 0, ZoneOffset.UTC);
+
+        return Stream.of(
+            Arguments.of(String.format(xmlFormat, "0001-01-01T00:00:00"), minValue),
+            Arguments.of(String.format(xmlFormat, "0001-01-01T00:00:00Z"), minValue),
+            Arguments.of(String.format(xmlFormat, "1970-01-01T00:00:00"), unixEpoch),
+            Arguments.of(String.format(xmlFormat, "1970-01-01T00:00:00Z"), unixEpoch)
+        );
+    }
+
+    @JacksonXmlRootElement(localName = "Wrapper")
+    private static class DateTimeWrapper {
+        @JsonProperty(value = "OffsetDateTime", required = true)
+        private OffsetDateTime offsetDateTime;
+
+        public DateTimeWrapper setOffsetDateTime(OffsetDateTime offsetDateTime) {
+            this.offsetDateTime = offsetDateTime;
+            return this;
+        }
+
+        public OffsetDateTime getOffsetDateTime() {
+            return offsetDateTime;
+        }
+    }
 }