add LocalDate wrapper (#84)

extensions/protokt-extensions-simple/src/main/kotlin/com/toasttab/protokt/ext/LocalDateConverter.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2020 Toast Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.toasttab.protokt.ext
+
+import com.google.auto.service.AutoService
+import java.time.LocalDate
+
+@AutoService(Converter::class)
+object LocalDateConverter : Converter<LocalDate, String> {
+    override val wrapper = LocalDate::class
+
+    override val wrapped = String::class
+
+    override fun wrap(unwrapped: String): LocalDate =
+        LocalDate.parse(unwrapped)
+
+    override fun unwrap(wrapped: LocalDate) =
+        wrapped.toString()
+}

testing/options/src/main/proto/com/toasttab/protokt/testing/options/wrapper_types.proto

@@ -54,6 +54,10 @@ message Wrappers {
     (.protokt.property).wrap = "java.time.Duration",
     (.protokt.property).non_null = true
   ];
+
+  string local_date = 8 [
+    (.protokt.property).wrap = "java.time.LocalDate"
+  ];
 }
 
 message OneofWrappers {
@@ -76,12 +80,20 @@ message OneofWrappers {
       (.protokt.property).wrap = "CachingId"
     ];
 
-    google.protobuf.Timestamp instant_oneof = 5 [
+    .protokt.ext.InetSocketAddress socket_address_oneof = 5 [
+      (.protokt.property).wrap = "java.net.InetSocketAddress"
+    ];
+
+    google.protobuf.Timestamp instant_oneof = 6 [
       (.protokt.property).wrap = "java.time.Instant"
     ];
 
-    .protokt.ext.InetSocketAddress socket_address_oneof = 6 [
-      (.protokt.property).wrap = "java.net.InetSocketAddress"
+    google.protobuf.Duration duration_oneof = 7 [
+      (.protokt.property).wrap = "java.time.Duration"
+    ];
+
+    string local_date_oneof = 8 [
+      (.protokt.property).wrap = "java.time.LocalDate"
     ];
   }
 }

testing/options/src/test/kotlin/com/toasttab/protokt/testing/options/WrapperTypesTest.kt

@@ -16,10 +16,12 @@
 package com.toasttab.protokt.testing.options
 
 import com.google.common.truth.Truth.assertThat
+import com.toasttab.protokt.testing.options.OneofWrappers.WrappedOneof
 import java.net.InetAddress
 import java.net.InetSocketAddress
 import java.time.Duration
 import java.time.Instant
+import java.time.LocalDate
 import java.util.UUID
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
@@ -34,6 +36,7 @@ class WrapperTypesTest {
             socketAddress = InetSocketAddress(InetAddress.getLocalHost(), 8080)
             instant = Instant.now()
             duration = Duration.ofSeconds(5)
+            localDate = LocalDate.of(1950, 10, 4)
         }
 
     @Test
@@ -84,70 +87,116 @@ class WrapperTypesTest {
     }
 
     @Test
-    fun `round trip should preserve generic wrapper oneof`() {
+    fun `round trip should preserve localdate`() {
+        val deserialized = Wrappers.deserialize(model.serialize())
+
+        assertThat(deserialized.localDate).isEqualTo(model.localDate)
+    }
+
+    @Test
+    fun `round trip should preserve id oneof`() {
         val deserialized = OneofWrappers.deserialize(
             OneofWrappers {
-                wrappedOneof = OneofWrappers.WrappedOneof.IdOneof(model.id)
+                wrappedOneof = WrappedOneof.IdOneof(model.id)
             }.serialize()
         )
 
         assertThat(
-            (deserialized.wrappedOneof as OneofWrappers.WrappedOneof.IdOneof).idOneof
+            (deserialized.wrappedOneof as WrappedOneof.IdOneof).idOneof
         ).isEqualTo(model.id)
     }
 
     @Test
     fun `round trip should preserve uuid oneof`() {
         val deserialized = OneofWrappers.deserialize(
             OneofWrappers {
-                wrappedOneof = OneofWrappers.WrappedOneof.UuidOneof(model.uuid)
+                wrappedOneof = WrappedOneof.UuidOneof(model.uuid)
             }.serialize()
         )
 
         assertThat(
-            (deserialized.wrappedOneof as OneofWrappers.WrappedOneof.UuidOneof).uuidOneof
+            (deserialized.wrappedOneof as WrappedOneof.UuidOneof).uuidOneof
         ).isEqualTo(model.uuid)
     }
 
     @Test
     fun `round trip should preserve ip address oneof`() {
         val deserialized = OneofWrappers.deserialize(
             OneofWrappers {
-                wrappedOneof = OneofWrappers.WrappedOneof.IpAddressOneof(model.ipAddress)
+                wrappedOneof = WrappedOneof.IpAddressOneof(model.ipAddress)
             }.serialize()
         )
 
         assertThat(
-            (deserialized.wrappedOneof as OneofWrappers.WrappedOneof.IpAddressOneof).ipAddressOneof
+            (deserialized.wrappedOneof as WrappedOneof.IpAddressOneof).ipAddressOneof
         ).isEqualTo(model.ipAddress)
     }
 
     @Test
-    fun `round trip should preserve instant oneof`() {
+    fun `round trip should preserve caching id oneof`() {
         val deserialized = OneofWrappers.deserialize(
             OneofWrappers {
-                wrappedOneof = OneofWrappers.WrappedOneof.InstantOneof(model.instant)
+                wrappedOneof = WrappedOneof.CachingIdOneof(model.cachingId)
             }.serialize()
         )
 
         assertThat(
-            (deserialized.wrappedOneof as OneofWrappers.WrappedOneof.InstantOneof).instantOneof
-        ).isEqualTo(model.instant)
+            (deserialized.wrappedOneof as WrappedOneof.CachingIdOneof).cachingIdOneof
+        ).isEqualTo(model.cachingId)
     }
 
     @Test
     fun `round trip should preserve socket address oneof`() {
         val deserialized = OneofWrappers.deserialize(
             OneofWrappers {
-                wrappedOneof = OneofWrappers.WrappedOneof.SocketAddressOneof(model.socketAddress)
+                wrappedOneof = WrappedOneof.SocketAddressOneof(model.socketAddress)
             }.serialize()
         )
 
         assertThat(
-            (deserialized.wrappedOneof as OneofWrappers.WrappedOneof.SocketAddressOneof).socketAddressOneof
+            (deserialized.wrappedOneof as WrappedOneof.SocketAddressOneof).socketAddressOneof
         ).isEqualTo(model.socketAddress)
     }
 
+    @Test
+    fun `round trip should preserve instant oneof`() {
+        val deserialized = OneofWrappers.deserialize(
+            OneofWrappers {
+                wrappedOneof = WrappedOneof.InstantOneof(model.instant)
+            }.serialize()
+        )
+
+        assertThat(
+            (deserialized.wrappedOneof as WrappedOneof.InstantOneof).instantOneof
+        ).isEqualTo(model.instant)
+    }
+
+    @Test
+    fun `round trip should preserve duration oneof`() {
+        val deserialized = OneofWrappers.deserialize(
+            OneofWrappers {
+                wrappedOneof = WrappedOneof.DurationOneof(model.duration)
+            }.serialize()
+        )
+
+        assertThat(
+            (deserialized.wrappedOneof as WrappedOneof.DurationOneof).durationOneof
+        ).isEqualTo(model.duration)
+    }
+
+    @Test
+    fun `round trip should preserve localdate oneof`() {
+        val deserialized = OneofWrappers.deserialize(
+            OneofWrappers {
+                wrappedOneof = WrappedOneof.LocalDateOneof(model.localDate)
+            }.serialize()
+        )
+
+        assertThat(
+            (deserialized.wrappedOneof as WrappedOneof.LocalDateOneof).localDateOneof
+        ).isEqualTo(model.localDate)
+    }
+
     @Test
     fun `wrapped message should not be nullable`() {
         val thrown = assertThrows<IllegalArgumentException> {