imprv: jackson exceptions: JsonParseException and InvalidDefinitionEx… (#17)

* imprv: jackson exceptions: JsonParseException and InvalidDefinitionException

* imprv: increase coverage

* imprv: increase coverage

* Use with to improve readability

Author: ruibritopt

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

@@ -4,6 +4,8 @@ import com.amazonaws.services.lambda.runtime.Context
 import com.amazonaws.services.lambda.runtime.RequestHandler
 import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent
 import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent
+import com.fasterxml.jackson.core.JsonParseException
+import com.fasterxml.jackson.databind.exc.InvalidDefinitionException
 import com.fasterxml.jackson.databind.exc.InvalidFormatException
 import com.fasterxml.jackson.module.kotlin.MissingKotlinParameterException
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
@@ -122,6 +124,8 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
      */
     open fun createUnprocessableEntityErrorBody(errors: List<UnprocessableEntityError>): Any = errors
 
+    private fun createUnprocessableEntityErrorBody(error: UnprocessableEntityError): Any = createUnprocessableEntityErrorBody(listOf(error))
+
     open fun createApiExceptionErrorResponse(contentType: MediaType, input: APIGatewayProxyRequestEvent, ex: ApiException): APIGatewayProxyResponseEvent =
         createErrorBody(ex.toApiError()).let {
             APIGatewayProxyResponseEvent()
@@ -138,19 +142,39 @@ abstract class RequestHandler : RequestHandler<APIGatewayProxyRequestEvent, APIG
 
     open fun createUnexpectedErrorResponse(contentType: MediaType, input: APIGatewayProxyRequestEvent, ex: Exception): APIGatewayProxyResponseEvent =
         when (ex) {
+            is JsonParseException -> createResponse(contentType, input,
+                ResponseEntity(422, createUnprocessableEntityErrorBody(
+                    UnprocessableEntityError(
+                        message = "INVALID_ENTITY",
+                        code = "ENTITY",
+                        path = "",
+                        details = mapOf(
+                            "payload" to ex.requestPayloadAsString.orEmpty(),
+                            "message" to ex.message.orEmpty()
+                        )))))
+            is InvalidDefinitionException -> createResponse(contentType, input,
+                ResponseEntity(422, createUnprocessableEntityErrorBody(
+                    UnprocessableEntityError(
+                        message = "INVALID_FIELD_FORMAT",
+                        code = "FIELD",
+                        path = ex.path.last().fieldName.orEmpty(),
+                        details = mapOf(
+                            "cause" to ex.cause?.message.orEmpty(),
+                            "message" to ex.message.orEmpty()
+                        )))))
             is InvalidFormatException ->
                 createResponse(contentType, input,
-                    ResponseEntity(422, createUnprocessableEntityErrorBody(listOf(
+                    ResponseEntity(422, createUnprocessableEntityErrorBody(
                         UnprocessableEntityError(
                         message = "INVALID_FIELD_FORMAT",
                         code = "FIELD",
-                        path = ex.path.last().fieldName.orEmpty())))))
+                        path = ex.path.last().fieldName.orEmpty()))))
             is MissingKotlinParameterException ->
                 createResponse(contentType, input,
-                    ResponseEntity(422, createUnprocessableEntityErrorBody(listOf(UnprocessableEntityError(
+                    ResponseEntity(422, createUnprocessableEntityErrorBody(UnprocessableEntityError(
                         message = "MISSING_REQUIRED_FIELDS",
                         code = "FIELD",
-                        path = ex.parameter.name.orEmpty())))))
+                        path = ex.parameter.name.orEmpty()))))
             else -> createResponse(contentType, input,
                 ResponseEntity(500, createErrorBody(ApiError(ex.message.orEmpty(), "INTERNAL_SERVER_ERROR"))))
         }

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

@@ -7,15 +7,18 @@ import assertk.assertions.isNotNull
 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
 import org.junit.jupiter.api.Test
+import java.time.LocalDate
 
 class RequestHandlerTest {
 
     private val testRequestHandler = TestRequestHandler()
+    private val mapper = testRequestHandler.objectMapper
 
     @Test
     fun `should match request`() {
@@ -197,6 +200,62 @@ class RequestHandlerTest {
                 .withBody("""{"greeting": "hello","age": "a"}"""), mockk()
         )
         assert(response.statusCode).isEqualTo(422)
+        val body = mapper.readValue<List<UnprocessableEntityError>>(response.body)
+        assert(body.size).isEqualTo(1)
+        with(body.first()) {
+            assert(code).isEqualTo("FIELD")
+            assert(message).isEqualTo("INVALID_FIELD_FORMAT")
+            assert(path).isEqualTo("age")
+            assert(details.isNotEmpty()).isEqualTo(false)
+        }
+    }
+
+    @Test
+    fun `should handle deserialization error, when field can not be parsed to class`() {
+
+        val response = testRequestHandler.handleRequest(
+            POST("/some")
+                .withHeaders(
+                    mapOf(
+                        "Accept" to "application/json",
+                        "Content-Type" to "application/json"
+                    )
+                )
+                .withBody("""{"greeting": "hello","age": 1, "bday": "2000-01-AA"}"""), mockk()
+        )
+        assert(response.statusCode).isEqualTo(422)
+        val body = mapper.readValue<List<UnprocessableEntityError>>(response.body)
+        assert(body.size).isEqualTo(1)
+        with(body.first()) {
+            assert(code).isEqualTo("FIELD")
+            assert(message).isEqualTo("INVALID_FIELD_FORMAT")
+            assert(path).isEqualTo("bday")
+            assert(details.isNotEmpty()).isEqualTo(true)
+        }
+    }
+
+    @Test
+    fun `should handle deserialization error, when json can not be parsed`() {
+
+        val response = testRequestHandler.handleRequest(
+            POST("/some")
+                .withHeaders(
+                    mapOf(
+                        "Accept" to "application/json",
+                        "Content-Type" to "application/json"
+                    )
+                )
+                .withBody("""{"greeting": "hello", bday: "2000-01-01"}"""), mockk()
+        )
+        assert(response.statusCode).isEqualTo(422)
+        val body = mapper.readValue<List<UnprocessableEntityError>>(response.body)
+        assert(body.size).isEqualTo(1)
+        with(body.first()) {
+            assert(code).isEqualTo("ENTITY")
+            assert(message).isEqualTo("INVALID_ENTITY")
+            assert(path).isEqualTo("")
+            assert(details.isNotEmpty()).isEqualTo(true)
+        }
     }
 
     @Test
@@ -458,7 +517,7 @@ class RequestHandlerTest {
     class TestRequestHandler : RequestHandler() {
 
         data class TestResponse(val greeting: String)
-        data class TestRequest(val greeting: String, val age: Int = 0)
+        data class TestRequest(val greeting: String, val age: Int = 0, val bday: LocalDate = LocalDate.now())
 
         override val router = router {
             GET("/some") { _: Request<Unit> ->