Go back to guava MediaType (#6)

mduesterhoeft · web-flow · commit e66e855f89e9 · 2019-04-29T11:29:09.000+02:00
This is done because it can handle wildcards.
Apache http ContentType did not correctly handle multiple media types and
it could not handle wildcards.

Multiple media types in an accept header are now handled by splitting the header value.
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.4-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/router-protobuf/src/main/kotlin/io/moia/router/proto/ProtoSerializationHandler.kt b/router-protobuf/src/main/kotlin/io/moia/router/proto/ProtoSerializationHandler.kt
@@ -1,21 +1,21 @@
 package io.moia.router.proto
 
+import com.google.common.net.MediaType
 import com.google.protobuf.GeneratedMessageV3
 import io.moia.router.ResponseEntity
 import io.moia.router.SerializationHandler
-import org.apache.http.entity.ContentType
 import java.util.Base64
 
 class ProtoSerializationHandler : SerializationHandler {
 
-    private val json = ContentType.parse("application/json")
+    private val json = MediaType.parse("application/json")
 
-    override fun supports(acceptHeader: ContentType, response: ResponseEntity<*>): Boolean =
+    override fun supports(acceptHeader: MediaType, response: ResponseEntity<*>): Boolean =
         response.body is GeneratedMessageV3
 
-    override fun serialize(acceptHeader: ContentType, response: ResponseEntity<*>): String {
+    override fun serialize(acceptHeader: MediaType, response: ResponseEntity<*>): String {
         val message = response.body as GeneratedMessageV3
-        return if (json.mimeType == acceptHeader.mimeType) {
+        return if (acceptHeader.`is`(json)) {
             ProtoBufUtils.toJsonWithoutWrappers(message)
         } else {
             Base64.getEncoder().encodeToString(message.toByteArray())
diff --git a/router/build.gradle.kts b/router/build.gradle.kts
@@ -9,7 +9,7 @@ dependencies {
     compile("org.slf4j:slf4j-api:1.7.26")
     compile("com.fasterxml.jackson.core:jackson-databind:2.9.8")
     compile("com.fasterxml.jackson.module:jackson-module-kotlin:2.9.8")
-    compile("org.apache.httpcomponents:httpcore:4.4.11")
+    compile("com.google.guava:guava:23.0")
 
     testImplementation("org.junit.jupiter:junit-jupiter-engine:5.4.0")
     testImplementation("org.junit.jupiter:junit-jupiter-params:5.4.0")
diff --git a/router/src/main/kotlin/io/moia/router/DeserializationHandler.kt b/router/src/main/kotlin/io/moia/router/DeserializationHandler.kt
@@ -3,7 +3,7 @@ package io.moia.router
 import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.databind.type.TypeFactory
-import org.apache.http.entity.ContentType
+import com.google.common.net.MediaType
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
 import kotlin.reflect.full.isSubclassOf
@@ -27,10 +27,10 @@ class DeserializationHandlerChain(private val handlers: List<DeserializationHand
 
 class JsonDeserializationHandler(private val objectMapper: ObjectMapper) : DeserializationHandler {
 
-    private val json = ContentType.parse("application/json")
+    private val json = MediaType.parse("application/json")
 
     override fun supports(input: APIGatewayProxyRequestEvent) =
-            input.contentType() != null && ContentType.parse(input.contentType()).mimeType == json.mimeType
+        input.contentType() != null && MediaType.parse(input.contentType()!!).`is`(json)
 
     override fun deserialize(input: APIGatewayProxyRequestEvent, target: KType?): Any? {
         val targetClass = target?.classifier as KClass<*>
diff --git a/router/src/main/kotlin/io/moia/router/RequestHandler.kt b/router/src/main/kotlin/io/moia/router/RequestHandler.kt
@@ -6,7 +6,7 @@ import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent
 import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent
 import com.fasterxml.jackson.module.kotlin.MissingKotlinParameterException
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
-import org.apache.http.entity.ContentType
+import com.google.common.net.MediaType
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import kotlin.reflect.KClass
@@ -38,7 +38,7 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
                     val request =
                         Request(input, requestBody, routerFunction.requestPredicate.pathPattern)
                     val response = router.filter.then(handler as HandlerFunction<*, *>).invoke(request)
-                    createResponse(input, response)
+                    createResponse(routerFunction.requestPredicate.matchedAcceptType(input.acceptHeader()), input, response)
                 } catch (e: Exception) {
                     when (e) {
                         is ApiException -> createApiExceptionErrorResponse(input, e)
@@ -150,19 +150,18 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
                     .withHeaders(mapOf("Content-Type" to "application/json"))
         }
 
-    open fun <T> createResponse(input: APIGatewayProxyRequestEvent, response: ResponseEntity<T>): APIGatewayProxyResponseEvent {
+    open fun <T> createResponse(contentType: MediaType?, input: APIGatewayProxyRequestEvent, response: ResponseEntity<T>): APIGatewayProxyResponseEvent {
         // TODO add default accept type
-        val accept = ContentType.parse(input.acceptHeader())
         return when {
             // no-content response
             response.body == null && response.statusCode == 204 -> APIGatewayProxyResponseEvent()
                 .withStatusCode(204)
                 .withHeaders(response.headers)
-            serializationHandlerChain.supports(accept, response) ->
+            serializationHandlerChain.supports(contentType!!, response) ->
                 APIGatewayProxyResponseEvent()
                     .withStatusCode(response.statusCode)
-                    .withBody(serializationHandlerChain.serialize(accept, response))
-                    .withHeaders(response.headers + ("Content-Type" to accept.toString()))
+                    .withBody(serializationHandlerChain.serialize(contentType, response))
+                    .withHeaders(response.headers + ("Content-Type" to contentType.toString()))
             else -> throw IllegalArgumentException("unsupported response $response")
         }
     }
diff --git a/router/src/main/kotlin/io/moia/router/RequestPredicate.kt b/router/src/main/kotlin/io/moia/router/RequestPredicate.kt
@@ -1,7 +1,7 @@
 package io.moia.router
 
 import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent
-import org.apache.http.entity.ContentType
+import com.google.common.net.MediaType
 
 data class RequestPredicate(
     val method: String,
@@ -34,19 +34,34 @@ data class RequestPredicate(
         RequestMatchResult(
             matchPath = pathMatches(request),
             matchMethod = methodMatches(request),
-            matchAcceptType = contentTypeMatches(request.acceptHeader(), produces),
-            matchContentType = contentTypeMatches(request.contentType(), consumes)
+            matchAcceptType = acceptMatches(request.acceptHeader()),
+            matchContentType = contentTypeMatches(request.contentType())
         )
 
     private fun pathMatches(request: APIGatewayProxyRequestEvent) =
         request.path?.let { UriTemplate.from(pathPattern).matches(it) } ?: false
     private fun methodMatches(request: APIGatewayProxyRequestEvent) = method.equals(request.httpMethod, true)
-    private fun contentTypeMatches(contentType: String?, accepted: Set<String>) =
-        if (accepted.isEmpty() && contentType == null) true
-        else if (contentType == null) false
-        else accepted.any { ContentType.parse(contentType).mimeType == ContentType.parse(it).mimeType }
 
-    companion object
+    /**
+     * Find the media type that is compatible with the one the client requested out of the ones that the the handler can produce
+     * Talking into account that an accept header can contain multiple media types (e.g. application/xhtml+xml, application/json)
+     */
+    fun matchedAcceptType(acceptType: String?) =
+        if (produces.isEmpty() || acceptType == null) null
+        else produces
+            .map { MediaType.parse(it) }
+            // find the first media type that can be produced that is compatible with the requested type
+            .firstOrNull { acceptType.split(",")
+                .map { p -> p.trim() }
+                .any { m -> MediaType.parse(m).`is`(it) } }
+
+    private fun acceptMatches(contentType: String?) =
+        matchedAcceptType(contentType) != null
+
+    private fun contentTypeMatches(contentType: String?) =
+        if (consumes.isEmpty() && contentType == null) true
+        else if (contentType == null) false
+        else consumes.any { MediaType.parse(contentType).`is`(MediaType.parse(it)) }
 }
 
 internal data class RequestMatchResult(
diff --git a/router/src/main/kotlin/io/moia/router/SerializationHandler.kt b/router/src/main/kotlin/io/moia/router/SerializationHandler.kt
@@ -1,31 +1,31 @@
 package io.moia.router
 
 import com.fasterxml.jackson.databind.ObjectMapper
-import org.apache.http.entity.ContentType
+import com.google.common.net.MediaType
 
 interface SerializationHandler {
 
-    fun supports(acceptHeader: ContentType, response: ResponseEntity<*>): Boolean
+    fun supports(acceptHeader: MediaType, response: ResponseEntity<*>): Boolean
 
-    fun serialize(acceptHeader: ContentType, response: ResponseEntity<*>): String
+    fun serialize(acceptHeader: MediaType, response: ResponseEntity<*>): String
 }
 
 class SerializationHandlerChain(private val handlers: List<SerializationHandler>) :
     SerializationHandler {
 
-    override fun supports(acceptHeader: ContentType, response: ResponseEntity<*>): Boolean =
+    override fun supports(acceptHeader: MediaType, response: ResponseEntity<*>): Boolean =
         handlers.any { it.supports(acceptHeader, response) }
 
-    override fun serialize(acceptHeader: ContentType, response: ResponseEntity<*>): String =
+    override fun serialize(acceptHeader: MediaType, response: ResponseEntity<*>): String =
         handlers.first { it.supports(acceptHeader, response) }.serialize(acceptHeader, response)
 }
 
 class JsonSerializationHandler(private val objectMapper: ObjectMapper) : SerializationHandler {
 
-    private val json = ContentType.parse("application/json")
+    private val json = MediaType.parse("application/json")
 
-    override fun supports(acceptHeader: ContentType, response: ResponseEntity<*>): Boolean = acceptHeader.mimeType == json.mimeType
+    override fun supports(acceptHeader: MediaType, response: ResponseEntity<*>): Boolean = acceptHeader.`is`(json)
 
-    override fun serialize(acceptHeader: ContentType, response: ResponseEntity<*>): String =
+    override fun serialize(acceptHeader: MediaType, response: ResponseEntity<*>): String =
         objectMapper.writeValueAsString(response.body)
 }
diff --git a/router/src/test/kotlin/io/moia/router/RequestHandlerTest.kt b/router/src/test/kotlin/io/moia/router/RequestHandlerTest.kt
@@ -193,13 +193,15 @@ class RequestHandlerTest {
         val response = testRequestHandler.handleRequest(
             POST("/some")
                 .withHeaders(mapOf(
-                    "Accept" to "application/json, application/xhtml+xml, application/xml;q=0.9, image/webp, */*;q=0.8",
+                    "Accept" to "application/xhtml+xml, application/json, application/xml;q=0.9, image/webp, */*;q=0.8",
                     "Content-Type" to "application/json"
                 ))
                 .withBody("""{ "greeting": "some" }"""), mockk()
         )
 
         assert(response.statusCode).isEqualTo(200)
+        assert(response.getHeaderCaseInsensitive("content-type")).isEqualTo("application/json")
+
         assert(response.body).isEqualTo("""{"greeting":"some"}""")
     }
 
