Merge pull request #759 from VladGaluska/KTLN-793

KTLN-793 Quick Look at Ktor Client

Author: maibin

kotlin-ktor/build.gradle.kts

@@ -14,12 +14,18 @@ dependencies {
     implementation("com.expediagroup", "graphql-kotlin-ktor-server", graphQLKotlinVersion)
     implementation("com.expediagroup", "graphql-kotlin-client-jackson", graphQLKotlinVersion)
 
+    implementation("io.ktor", "ktor-client-core", ktorVersion)
     implementation("io.ktor", "ktor-server-core", ktorVersion)
     implementation("io.ktor", "ktor-server-netty", ktorVersion)
     implementation("io.ktor", "ktor-server-websockets", ktorVersion)
+    implementation("io.ktor", "ktor-client-auth", ktorVersion)
+    implementation("io.ktor", "ktor-client-websockets", ktorVersion)
+    implementation("io.ktor", "ktor-serialization-jackson", ktorVersion)
+    implementation("io.ktor", "ktor-client-content-negotiation", ktorVersion)
 
+
+    testImplementation("io.ktor", "ktor-client-mock", ktorVersion)
     testImplementation("io.ktor", "ktor-server-tests", ktorVersion)
-    testImplementation("io.ktor", "ktor-client-content-negotiation", ktorVersion)
     testImplementation("io.ktor", "ktor-serialization-kotlinx-json", ktorVersion)
     testImplementation("org.jetbrains.kotlin", "kotlin-test-junit", "1.9.10")
 }

kotlin-ktor/src/main/java/com/baeldung/client/Data.kt

@@ -0,0 +1,31 @@
+package com.baeldung.client
+
+const val CARS = """
+    [
+        {
+            "id": 0,
+            "name": "Car 1",
+            "driver": 0
+        },
+        {
+            "id": 1,
+            "name": "Car 2",
+            "driver": 1
+        }
+    ]
+"""
+
+val DRIVERS = listOf(
+    """
+        {
+            "id": 0,
+            "name": "John"
+        }
+    """,
+    """
+        {
+            "id": 1,
+            "name": "Mike"
+        }
+    """
+)

kotlin-ktor/src/main/java/com/baeldung/client/KtorWebsocketsApplication.kt

@@ -0,0 +1,40 @@
+package com.baeldung.client
+
+import io.ktor.server.application.*
+import io.ktor.server.engine.*
+import io.ktor.server.netty.*
+import io.ktor.server.routing.*
+import io.ktor.server.websocket.*
+import io.ktor.websocket.*
+
+fun main() {
+    embeddedServer(Netty, port = 8080, module = Application::websocketsModule).start(wait = true)
+}
+
+fun Application.websocketsModule() {
+    install(WebSockets)
+    routing {
+        webSocket("/messages") {
+            send("Hi!")
+            for (frame in incoming) {
+                frame as? Frame.Text ?: continue
+                val receivedText = frame.readText()
+                if (receivedText.equals("Bye!", ignoreCase = true)) {
+                    close(CloseReason(CloseReason.Codes.NORMAL, "Client said bye!"))
+                }
+            }
+        }
+        webSocket("/driver") {
+            send("Which driver would you like to see?")
+            for (frame in incoming) {
+                frame as? Frame.Text ?: continue
+                val receivedText = frame.readText()
+                if (receivedText.equals("Bye!", ignoreCase = true)) {
+                    close(CloseReason(CloseReason.Codes.NORMAL, "Client said bye!"))
+                }
+                val receivedDriverId = receivedText.toIntOrNull() ?: continue
+                send(DRIVERS[receivedDriverId])
+            }
+        }
+    }
+}

kotlin-ktor/src/test/java/com/baeldung/client/Interfaces.kt

@@ -0,0 +1,5 @@
+package com.baeldung.client
+
+class Driver(val id: Int, val name: String)
+
+class Car(val id: Int, val name: String, val driver: Int)

kotlin-ktor/src/test/java/com/baeldung/client/Mock.kt

@@ -0,0 +1,41 @@
+package com.baeldung.client
+
+import io.ktor.client.engine.mock.*
+import io.ktor.http.*
+import io.ktor.utils.io.*
+
+val mockEngine = MockEngine {
+    request -> when {
+        request.headers["Authorization"] != "Basic YmFlbGR1bmc6YmFlbGR1bmc=" -> respond(
+            content = "Wrong credentials!",
+            status = HttpStatusCode.Unauthorized
+        )
+        request.url.fullPath == "/cars" && request.method == HttpMethod.Get -> respond(
+            content = ByteReadChannel(CARS),
+            status = HttpStatusCode.OK,
+            headers = headersOf(HttpHeaders.ContentType, "application/json")
+        )
+        request.url.fullPath.startsWith("/driver") && request.method == HttpMethod.Get -> {
+            val driverId = request.url.parameters["id"]?.toIntOrNull() ?: 0
+            respond(
+                content = ByteReadChannel(DRIVERS[driverId]),
+                status = HttpStatusCode.OK,
+                headers = headersOf(HttpHeaders.ContentType, "application/json")
+            )
+        }
+        request.url.fullPath == "/car" && request.method == HttpMethod.Put -> respond(
+            content = ByteReadChannel("Created!"),
+            status = HttpStatusCode.OK,
+            headers = headersOf(HttpHeaders.ContentType, "application/json")
+        )
+        request.url.fullPath == "/driver" && request.method == HttpMethod.Put -> respond(
+            content = ByteReadChannel("Created!"),
+            status = HttpStatusCode.OK,
+            headers = headersOf(HttpHeaders.ContentType, "application/json")
+        )
+        else -> respond(
+            content = ByteReadChannel("Unknown Request!"),
+            status = HttpStatusCode.NotFound
+        )
+    }
+}

kotlin-ktor/src/test/java/com/baeldung/client/RequestsUnitTest.kt

@@ -0,0 +1,180 @@
+package com.baeldung.client
+
+import io.ktor.client.*
+import io.ktor.client.call.*
+import io.ktor.client.plugins.*
+import io.ktor.client.plugins.auth.*
+import io.ktor.client.plugins.auth.providers.*
+import io.ktor.client.plugins.contentnegotiation.*
+import io.ktor.client.plugins.websocket.*
+import io.ktor.client.request.*
+import io.ktor.client.statement.*
+import io.ktor.http.*
+import io.ktor.serialization.jackson.*
+import io.ktor.server.engine.*
+import io.ktor.server.netty.*
+import io.ktor.websocket.*
+import kotlinx.coroutines.runBlocking
+import org.junit.AfterClass
+import kotlin.test.*
+
+class RequestsUnitTest {
+
+    companion object {
+
+        private val client = HttpClient(mockEngine) {
+            expectSuccess = true
+            install(ContentNegotiation) {
+                jackson()
+            }
+            install(Auth) {
+                basic {
+                    credentials {
+                        BasicAuthCredentials(username = "baeldung", password = "baeldung")
+                    }
+                    sendWithoutRequest { _ -> true }
+                }
+            }
+        }
+
+        // Different to the regular client, as that one is using a mock engine
+        private val websocketsClient = HttpClient {
+            install(WebSockets) {
+                contentConverter = JacksonWebsocketContentConverter()
+            }
+        }
+
+        private val noAuthClient = HttpClient(mockEngine) {
+            install(ContentNegotiation) {
+                jackson()
+            }
+        }
+
+        @JvmStatic
+        @AfterClass
+        fun afterTests() {
+            client.close()
+        }
+    }
+
+    @Test
+    fun `when fetching cars then should get two cars`() {
+        runBlocking {
+            with(client.get("/cars")) {
+                assertEquals(HttpStatusCode.OK, status)
+                val cars: List<Car> = body()
+                assertEquals(2, cars.size)
+                assertTrue { cars.any { car -> car.name == "Car 1" } }
+            }
+        }
+    }
+
+    @Test
+    fun `when fetching driver zero then should get driver`() {
+        runBlocking {
+            with(client.get("/driver?id=0")) {
+                assertEquals(HttpStatusCode.OK, status)
+                val driver: Driver = body()
+                assertEquals(0, driver.id)
+            }
+        }
+    }
+
+    @Test
+    fun `when creating car then should succeed`() {
+        runBlocking {
+            with(client.put("/car") {
+                contentType(ContentType.Application.Json)
+                setBody(Car(id = 2, name = "Car 3", driver = 1))
+            }) {
+                assertEquals(HttpStatusCode.OK, status)
+                assertEquals("Created!", bodyAsText())
+            }
+        }
+    }
+
+    @Test
+    fun `when requesting unknown endpoint then should throw exception`() {
+        runBlocking {
+            try {
+                client.get("/this-does-not-exist")
+            } catch (exception: ClientRequestException) {
+                return@runBlocking
+            }
+            fail("Did not throw an exception!")
+        }
+    }
+
+    @Test
+    fun `when creating driver then should succeed`() {
+        runBlocking {
+            with(client.put("/driver") {
+                contentType(ContentType.Application.Json)
+                setBody(Driver(id = 2, name = "Jack"))
+            }) {
+                assertEquals(HttpStatusCode.OK, status)
+                assertEquals("Created!", bodyAsText())
+            }
+        }
+    }
+
+    @Test
+    fun `when sending websocket messages then should receive them`() {
+        val server = startEmbeddedServer()
+        runBlocking {
+            websocketsClient.webSocket(method = HttpMethod.Get, host = "127.0.0.1", port = 8080, path = "/messages") {
+                var message = incoming.receive() as? Frame.Text
+                while (message == null) {
+                    message = incoming.receive() as? Frame.Text
+                }
+                assertEquals("Hi!", String(message.data))
+                send("Bye!")
+            }
+        }
+        server.stop()
+    }
+
+    @Test
+    fun `when requesting websocket driver then should receive and deserialize`() {
+        val server = startEmbeddedServer()
+        runBlocking {
+            websocketsClient.webSocket(method = HttpMethod.Get, host = "127.0.0.1", port = 8080, path = "/driver") {
+                var message = incoming.receive() as? Frame.Text
+                while (message == null) {
+                    message = incoming.receive() as? Frame.Text
+                }
+                assertEquals("Which driver would you like to see?", String(message.data))
+                send("0")
+                val driver = receiveDeserialized<Driver>()
+                assertEquals(0, driver.id)
+                send("Bye!")
+            }
+        }
+        server.stop()
+    }
+
+    @Test
+    fun `when not sending authentication then should not succeed`() {
+        runBlocking {
+            with(noAuthClient.get("/cars")) {
+                assertEquals(HttpStatusCode.Unauthorized, status)
+            }
+        }
+    }
+
+    private fun startEmbeddedServer(): NettyApplicationEngine {
+        val env = applicationEngineEnvironment {
+            module {
+                websocketsModule()
+            }
+            connector {
+                host = "0.0.0.0"
+                port = 8080
+            }
+        }
+        val server = embeddedServer(Netty, env)
+        server.start(false)
+        return server
+    }
+
+}