feat: use json for request/response in webapp

Author: matteobaglini

webapp/build.gradle.kts

@@ -22,6 +22,7 @@ dependencies {
     implementation("org.http4k:http4k-server-jetty")
     implementation("io.github.microutils:kotlin-logging-jvm:3.0.5")
     implementation("ch.qos.logback:logback-classic:1.4.14")
+    implementation("com.ubertob.kondor:kondor-core:2.2.2")
 
     testImplementation("org.junit.jupiter:junit-jupiter:5.10.1")
     testImplementation("io.strikt:strikt-core:0.34.1")

webapp/http_test.sh

@@ -5,10 +5,15 @@ curl http://localhost:9000/hello/ping
 echo ""
 echo ""
 
-echo "Execute mission"
-curl http://localhost:9000/rover/FF -X POST
+echo "Execute mission: FF"
+curl -H "Content-Type: application/json" -X POST -d '{"commands":"FF"}' http://localhost:9000/rover/mission
 echo ""
 echo ""
 
-echo "Execute mission (hit obstacle)"
-curl http://localhost:9000/rover/RFF -X POST
+echo "Execute mission (hit obstacle): RFF"
+curl -H "Content-Type: application/json" -X POST -d '{"commands":"RFF"}' http://localhost:9000/rover/mission
+echo ""
+echo ""
+
+echo "Execute mission (invalid command): RXFF"
+curl -H "Content-Type: application/json" -X POST -d '{"commands":"RXFF"}' http://localhost:9000/rover/mission

webapp/src/main/kotlin/io/doubleloop/Data.kt

@@ -0,0 +1,56 @@
+package io.doubleloop
+
+import com.ubertob.kondor.json.JAny
+import com.ubertob.kondor.json.bool
+import com.ubertob.kondor.json.jsonnode.JsonNodeObject
+import com.ubertob.kondor.json.num
+import com.ubertob.kondor.json.str
+
+data class RunAppHttpRequest(val commands: String)
+data class RunAppHttpResponse(
+    val positionX: Int,
+    val positionY: Int,
+    val direction: String,
+    val hitObstacle: Boolean
+)
+
+object JRunAppHttpRequest : JAny<RunAppHttpRequest>() {
+    val commands by str(RunAppHttpRequest::commands)
+
+    override fun JsonNodeObject.deserializeOrThrow(): RunAppHttpRequest? =
+        RunAppHttpRequest(commands = +commands)
+}
+
+object JRunAppHttpResponse : JAny<RunAppHttpResponse>() {
+    val positionX by num(RunAppHttpResponse::positionX)
+    val positionY by num(RunAppHttpResponse::positionY)
+    val direction by str(RunAppHttpResponse::direction)
+    val hitObstacle by bool(RunAppHttpResponse::hitObstacle)
+
+    override fun JsonNodeObject.deserializeOrThrow(): RunAppHttpResponse? =
+        RunAppHttpResponse(
+            positionX = +positionX,
+            positionY = +positionY,
+            direction = +direction,
+            hitObstacle = +hitObstacle,
+        )
+}
+
+fun RunAppHttpRequest.toRunAppRequest(): RunAppRequest =
+    RunAppRequest(this.commands)
+
+fun Rover.renderComplete() =
+    RunAppHttpResponse(
+        this.position.x,
+        this.position.y,
+        this.orientation.toString(),
+        false
+    )
+
+fun ObstacleDetected.renderObstacle() =
+    RunAppHttpResponse(
+        this.position.x,
+        this.position.y,
+        this.orientation.toString(),
+        true
+    )

webapp/src/main/kotlin/io/doubleloop/JsonUtils.kt

@@ -0,0 +1,14 @@
+package io.doubleloop
+
+import com.ubertob.kondor.json.JConverter
+import org.http4k.core.ContentType
+import org.http4k.core.Request
+import org.http4k.core.Response
+
+private const val contentTypeHeaderName = "Content-Type"
+
+fun <T : Any> Request.parseJsonBody(converter: JConverter<T>): T =
+    converter.fromJson(bodyString()).orThrow()
+
+fun <T : Any> Response.bodyAsJson(converter: JConverter<T>, value: T) =
+    body(converter.toJson(value)).header(contentTypeHeaderName, ContentType.APPLICATION_JSON.toHeaderValue())

webapp/src/main/kotlin/io/doubleloop/Parsing.kt

@@ -14,18 +14,6 @@ sealed class ParseError {
     data class InvalidCommand(val message: String) : ParseError()
 }
 
-fun runMission(
-    inputPlanet: Pair<String, String>,
-    inputRover: Pair<String, String>,
-    inputCommands: String
-): Either<ParseError, String> = either {
-    val planet = parsePlanet(inputPlanet).bind()
-    val rover = parseRover(inputRover).bind()
-    val commands = parseCommands(inputCommands).bind()
-    val result = executeAll(planet, rover, commands)
-    result.fold(::renderObstacle, ::renderComplete)
-}
-
 fun parseCommand(input: Char): Either<ParseError, Command> =
     when (input.lowercase()) {
         "f" -> MoveForward.right()
@@ -94,18 +82,9 @@ fun parsePair(separator: String, input: String): Either<Throwable, Pair<Int, Int
         Pair(first, second)
     }
 
-fun renderComplete(rover: Rover): String =
-    "${rover.position.x}:${rover.position.y}:${rover.orientation}"
-
-fun renderObstacle(rover: ObstacleDetected): String =
-    "O:${renderComplete(rover)}"
-
 fun renderError(error: ParseError): String =
     when (error) {
         is InvalidPlanet -> "Planet parsing: ${error.message}"
         is InvalidRover -> "Rover parsing: ${error.message}"
         is InvalidCommand -> "Command parsing: ${error.message}"
     }
-
-fun renderError(error: Throwable): String =
-    error.message ?: "Unknown error"

webapp/src/main/kotlin/io/doubleloop/WebappRoutes.kt

@@ -3,11 +3,9 @@ package io.doubleloop
 import arrow.core.raise.catch
 import kotlinx.coroutines.runBlocking
 import org.http4k.core.Method
-import org.http4k.core.Request
 import org.http4k.core.Response
 import org.http4k.core.Status
 import org.http4k.routing.bind
-import org.http4k.routing.path
 import org.http4k.routing.routes
 
 object WebappRoutes {
@@ -19,30 +17,24 @@ object WebappRoutes {
     )
 
     fun roverRoutes(handler: RunAppHandler) = routes(
-        "/{commands}" bind Method.POST to {
-//            // create adapters
-//            val fileMissionSource = FileMissionSource("planet.txt", "rover.txt")
-//            // create use case handler
-//            val handler = RunAppHandler(fileMissionSource)
+        "/mission" bind Method.POST to {
+            val body = it.parseJsonBody(JRunAppHttpRequest)
 
-            // run use case
             runBlocking {
                 catch({
-                    handler.handle(it.toRunAppRequest()).toResponse()
+                    handler.handle(body.toRunAppRequest()).toResponse()
                 }) { it.toResponse() }
             }
         }
     )
 
-    private fun Request.toRunAppRequest(): RunAppRequest =
-        RunAppRequest(this.path("commands") ?: "")
-
     private fun RunAppResponse.toResponse(): Response =
         this.result.fold(
-            { Response(Status.UNPROCESSABLE_ENTITY).body(renderObstacle(it)) },
-            { Response(Status.OK).body(renderComplete(it)) }
+            { Response(Status.UNPROCESSABLE_ENTITY).bodyAsJson(JRunAppHttpResponse, it.renderObstacle()) },
+            { Response(Status.OK).bodyAsJson(JRunAppHttpResponse, it.renderComplete()) }
         )
 
     private fun Throwable.toResponse() =
-        Response(Status.BAD_REQUEST).body(renderError(this))
+        Response(Status.BAD_REQUEST).body(this.message ?: "Unknown error")
+
 }

webapp/src/test/kotlin/io/doubleloop/AppTests.kt renamed to webapp/src/test/kotlin/io/doubleloop/WebAppTests.kt

@@ -12,7 +12,7 @@ import org.junit.jupiter.api.Test
 import strikt.api.expectThat
 import strikt.assertions.isEqualTo
 
-class AppTests {
+class WebAppTests {
 
     val app = createApp(Dependencies.create(Env()))
 
@@ -26,25 +26,34 @@ class AppTests {
 
     @Test
     fun `post commands`() {
-        val request = Request(POST, "/rover/FF")
+        val request = Request(POST, "/rover/mission").body("{ \"commands\": \"FF\" }")
         val response = app(request)
         expectThat(response).status.isEqualTo(OK)
-        expectThat(response).bodyString.isEqualTo("0:2:N")
+        expectThat(response).bodyString.isEqualTo("{\"positionX\": 0, \"positionY\": 2, \"direction\": \"N\", \"hitObstacle\": false}")
     }
 
     @Test
     fun `post commands (hit obstacle)`() {
-        val request = Request(POST, "/rover/RFF")
+        val request = Request(POST, "/rover/mission").body("{ \"commands\": \"RFF\" }")
         val response = app(request)
         expectThat(response).status.isEqualTo(UNPROCESSABLE_ENTITY)
-        expectThat(response).bodyString.isEqualTo("O:1:0:E")
+        expectThat(response).bodyString.isEqualTo("{\"positionX\": 1, \"positionY\": 0, \"direction\": \"E\", \"hitObstacle\": true}")
     }
 
     @Test
     fun `post invalid commands`() {
-        val request = Request(POST, "/rover/FFX")
+        val request = Request(POST, "/rover/mission").body("{ \"commands\": \"FFX\" }")
         val response = app(request)
         expectThat(response).status.isEqualTo(BAD_REQUEST)
         expectThat(response).bodyString.isEqualTo("Command parsing: invalid command: X")
     }
+
+    @Test
+    fun `convert request and response from and to json`() {
+        val jsonRequest = JRunAppHttpRequest.fromJson("{ \"commands\": \"FF\" }").orThrow()
+        expectThat(jsonRequest).isEqualTo(RunAppHttpRequest("FF"))
+
+        val jsonResponse = JRunAppHttpResponse.toJson(RunAppHttpResponse(1, 2, "N", false))
+        expectThat(jsonResponse).isEqualTo("{\"positionX\": 1, \"positionY\": 2, \"direction\": \"N\", \"hitObstacle\": false}")
+    }
 }