support plain text serialization and deserialization (#41)

Author: mduesterhoeft

router-protobuf/src/main/kotlin/io/moia/router/proto/ProtoEnabledRequestHandler.kt

@@ -2,18 +2,16 @@ package io.moia.router.proto
 
 import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent
 import com.google.common.net.MediaType
-import io.moia.router.JsonDeserializationHandler
-import io.moia.router.JsonSerializationHandler
 import io.moia.router.RequestHandler
 import io.moia.router.ResponseEntity
 
 abstract class ProtoEnabledRequestHandler : RequestHandler() {
 
     override fun serializationHandlers() =
-        listOf(ProtoSerializationHandler(), JsonSerializationHandler(objectMapper))
+        listOf(ProtoSerializationHandler()) + super.serializationHandlers()
 
     override fun deserializationHandlers() =
-        listOf(ProtoDeserializationHandler(), JsonDeserializationHandler(objectMapper))
+        listOf(ProtoDeserializationHandler()) + super.deserializationHandlers()
 
     override fun <T> createResponse(
         contentType: MediaType,

router/src/main/kotlin/io/moia/router/DeserializationHandler.kt

@@ -69,3 +69,15 @@ class JsonDeserializationHandler(private val objectMapper: ObjectMapper) : Deser
         }
     }
 }
+
+object PlainTextDeserializationHandler : DeserializationHandler {
+    private val text = MediaType.parse("text/*")
+    override fun supports(input: APIGatewayProxyRequestEvent): Boolean =
+        if (input.contentType() == null)
+            false
+        else
+            MediaType.parse(input.contentType()).isCompatibleWith(text)
+
+    override fun deserialize(input: APIGatewayProxyRequestEvent, target: KType?): Any? =
+        input.body
+}

router/src/main/kotlin/io/moia/router/RequestHandler.kt

@@ -105,7 +105,7 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
     }
 
     open fun serializationHandlers(): List<SerializationHandler> = listOf(
-        JsonSerializationHandler(objectMapper)
+        JsonSerializationHandler(objectMapper), PlainTextSerializationHandler()
     )
 
     open fun deserializationHandlers(): List<DeserializationHandler> = listOf(
@@ -124,6 +124,7 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
             requestType?.classifier as KClass<*> == Unit::class -> Unit
             input.body == null && requestType.isMarkedNullable -> null
             input.body == null -> throw ApiException("no request body present", "REQUEST_BODY_MISSING", 400)
+            input.body is String && requestType.classifier as KClass<*> == String::class -> input.body
             else -> deserializationHandlerChain.deserialize(input, requestType)
         }
     }

router/src/main/kotlin/io/moia/router/SerializationHandler.kt

@@ -47,4 +47,12 @@ class JsonSerializationHandler(private val objectMapper: ObjectMapper) : Seriali
 
     override fun serialize(acceptHeader: MediaType, body: Any): String =
         objectMapper.writeValueAsString(body)
+}
+
+class PlainTextSerializationHandler(val supportedAcceptTypes: List<MediaType> = listOf(MediaType.parse("text/*"))) : SerializationHandler {
+    override fun supports(acceptHeader: MediaType, body: Any): Boolean =
+        supportedAcceptTypes.any { acceptHeader.isCompatibleWith(it) }
+
+    override fun serialize(acceptHeader: MediaType, body: Any): String =
+        body.toString()
 }

router/src/test/kotlin/io/moia/router/PlainTextDeserializationHandlerTest.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2019 MOIA GmbH
+ *
+ * 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 io.moia.router
+
+import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+
+class PlainTextDeserializationHandlerTest {
+
+    @Test
+    fun `should support text`() {
+        assertTrue(PlainTextDeserializationHandler.supports(APIGatewayProxyRequestEvent()
+            .withHeader("content-type", "text/plain")))
+        assertTrue(PlainTextDeserializationHandler.supports(APIGatewayProxyRequestEvent()
+            .withHeader("content-type", "text/csv")))
+    }
+
+    @Test
+    fun `should not support anything else than text`() {
+        assertFalse(PlainTextDeserializationHandler.supports(APIGatewayProxyRequestEvent()
+            .withHeader("content-type", "image/png")))
+        assertFalse(PlainTextDeserializationHandler.supports(APIGatewayProxyRequestEvent()
+            .withHeader("content-type", "application/json")))
+    }
+    @Test
+    fun `should not support anything when content type is null`() {
+        assertFalse(PlainTextDeserializationHandler.supports(APIGatewayProxyRequestEvent()))
+    }
+
+    @Test
+    fun `should return body`() {
+        val request = APIGatewayProxyRequestEvent().withBody("some")
+        val result = PlainTextDeserializationHandler.deserialize(request, null)
+
+        assertEquals(request.body, result)
+    }
+}

router/src/test/kotlin/io/moia/router/PlainTextSerializationHandlerTest.kt

@@ -0,0 +1,27 @@
+package io.moia.router
+
+import com.google.common.net.MediaType
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+
+class PlainTextSerializationHandlerTest {
+
+    @Test
+    fun `should support text`() {
+        assertTrue(PlainTextSerializationHandler().supports(MediaType.parse("text/plain"), "some"))
+        assertTrue(PlainTextSerializationHandler(listOf(MediaType.parse("text/csv"))).supports(MediaType.parse("text/csv"), "some"))
+    }
+
+    @Test
+    fun `should not support anything else than text`() {
+        assertFalse(PlainTextSerializationHandler().supports(MediaType.parse("application/json"), "some"))
+        assertFalse(PlainTextSerializationHandler().supports(MediaType.parse("image/jpeg"), "some"))
+    }
+
+    @Test
+    fun `should serialize string`() {
+        assertEquals("some", PlainTextSerializationHandler().serialize(MediaType.parse("text/plain"), "some"))
+    }
+}

router/src/test/kotlin/io/moia/router/RequestHandlerTest.kt

@@ -24,7 +24,6 @@ import assertk.assertions.isNullOrEmpty
 import assertk.assertions.isTrue
 import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent
 import com.fasterxml.jackson.module.kotlin.readValue
-import com.google.common.net.MediaType
 import io.mockk.mockk
 import io.moia.router.Router.Companion.router
 import org.junit.jupiter.api.Assertions.assertEquals
@@ -616,6 +615,27 @@ class RequestHandlerTest {
         assert(response.statusCode).isEqualTo(200)
     }
 
+    @Test
+    fun `should deserialize plain text`() {
+        class SampleRouter : RequestHandler() {
+            override val router = router {
+                POST("/some", { r: Request<String> -> ResponseEntity.ok(r.body) })
+                    .producing("text/plain")
+                    .consuming("text/plain")
+            }
+        }
+        val request = POST("/some")
+            .withAcceptHeader("text/plain")
+            .withContentTypeHeader("text/plain")
+            .withBody("just text")
+
+        val response = SampleRouter().handleRequest(request, mockk())
+
+        assert(response.statusCode).isEqualTo(200)
+        assert(response.getHeaderCaseInsensitive("content-type")).isEqualTo("text/plain")
+        assert(response.body).isEqualTo("just text")
+    }
+
     class TestRequestHandlerAuthorization : RequestHandler() {
         override val router = router {
             GET("/some") { _: Request<Unit> ->
@@ -767,22 +787,6 @@ class RequestHandlerTest {
 
         data class CustomObject(val text: String, val number: Int)
 
-        class PlainTextSerializationHandler : SerializationHandler {
-            override fun supports(acceptHeader: MediaType, body: Any): Boolean {
-                return acceptHeader.`is`(MediaType.parse("text/plain"))
-            }
-
-            override fun serialize(acceptHeader: MediaType, body: Any): String {
-                return body.toString()
-            }
-        }
-
-        override fun serializationHandlers() =
-            listOf(JsonSerializationHandler(objectMapper), PlainTextSerializationHandler())
-
-        override fun deserializationHandlers() =
-            listOf(JsonDeserializationHandler(objectMapper))
-
         override val router = router {
             defaultConsuming = setOf("application/json", "text/plain")
             defaultProducing = setOf("application/json", "text/plain")