Update Ktor to 3.0.3 (#2066)

timemanx · TheDome0 · web-flow · commit 835d68099c5d · 2025-01-09T09:58:09.000-08:00
### 📝 Description Updated Ktor and updated failing tests and fixed compile issues resulting from the update. Also updated some libraries. ### 🔗 Related Issues #2037 --------- Co-authored-by: TheDome0 <dostoeby@edu.aau.at>
diff --git a/examples/server/ktor-server/src/main/kotlin/com/expediagroup/graphql/examples/server/ktor/GraphQLModule.kt b/examples/server/ktor-server/src/main/kotlin/com/expediagroup/graphql/examples/server/ktor/GraphQLModule.kt
@@ -37,14 +37,14 @@ import io.ktor.server.application.Application
 import io.ktor.server.application.install
 import io.ktor.server.plugins.cors.routing.CORS
 import io.ktor.server.plugins.statuspages.StatusPages
-import io.ktor.server.routing.Routing
+import io.ktor.server.routing.routing
 import io.ktor.server.websocket.WebSockets
 import io.ktor.server.websocket.pingPeriod
-import java.time.Duration
+import kotlin.time.Duration.Companion.seconds
 
 fun Application.graphQLModule() {
     install(WebSockets) {
-        pingPeriod = Duration.ofSeconds(1)
+        pingPeriod = 1.seconds
         contentConverter = JacksonWebsocketContentConverter()
     }
     install(StatusPages) {
@@ -78,7 +78,7 @@ fun Application.graphQLModule() {
             contextFactory = CustomGraphQLContextFactory()
         }
     }
-    install(Routing) {
+    routing {
         graphQLGetRoute()
         graphQLPostRoute()
         graphQLSubscriptionsRoute()
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -1,18 +1,18 @@
 [versions]
 android-plugin = "8.5.0"
 classgraph = "4.8.174"
-dataloader = "3.3.0"
-federation = "5.1.0"
-graphql-java = "22.1"
+dataloader = "3.4.0"
+federation = "5.2.0"
+graphql-java = "22.3"
 graalvm = "0.10.2"
 jackson = "2.17.1"
 # kotlin version has to match the compile-testing compiler version
 kotlin = "2.0.0"
-kotlinx-benchmark = "0.4.11"
-kotlinx-coroutines = "1.8.1"
+kotlinx-benchmark = "0.4.13"
+kotlinx-coroutines = "1.9.0"
 # TODO kotlin 1.9 upgrade: fix GraphQLTestUtils and GenerateKotlinxClientIT
 kotlinx-serialization = "1.6.3"
-ktor = "2.3.12"
+ktor = "3.0.3"
 fastjson2 = "2.0.53"
 maven-plugin-annotation = "3.13.1"
 maven-plugin-api = "3.9.8"
@@ -33,16 +33,16 @@ compile-testing = "0.5.1"
 icu = "75.1"
 junit = "5.10.2"
 logback = "1.5.6"
-mockk = "1.13.11"
+mockk = "1.13.13"
 rxjava = "3.1.8"
 wiremock = "3.7.0"
 
 # plugins
-detekt = "1.23.6"
-dokka = "1.9.20"
+detekt = "1.23.7"
+dokka = "2.0.0"
 jacoco = "0.8.12"
-ktlint-core = "1.3.0"
-ktlint-plugin = "12.1.1"
+ktlint-core = "1.5.0"
+ktlint-plugin = "12.1.2"
 maven-plugin-development = "0.4.3"
 nexus-publish-plugin = "2.0.0"
 plugin-publish = "1.2.1"
diff --git a/integration/graalvm/ktor-graalvm-server/build.gradle.kts b/integration/graalvm/ktor-graalvm-server/build.gradle.kts
@@ -32,7 +32,7 @@ graalvmNative {
     binaries {
         named("main") {
             verbose.set(true)
-            buildArgs.add("--initialize-at-build-time=io.ktor,kotlin,ch.qos.logback,org.slf4j")
+            buildArgs.add("--initialize-at-build-time=io.ktor,kotlin,kotlinx.io,ch.qos.logback,org.slf4j")
             buildArgs.add("-H:+ReportExceptionStackTraces")
             jvmArgs("-Xmx6g")
         }
diff --git a/integration/graalvm/maven-graalvm-server/pom.xml b/integration/graalvm/maven-graalvm-server/pom.xml
@@ -170,7 +170,7 @@
                         <configuration>
                             <verbose>true</verbose>
                             <buildArgs>
-                                <arg>--initialize-at-build-time=io.ktor,kotlin,ch.qos.logback,org.slf4j</arg>
+                                <arg>--initialize-at-build-time=io.ktor,kotlin,kotlinx.io,ch.qos.logback,org.slf4j</arg>
                                 <arg>-H:+ReportExceptionStackTraces</arg>
                             </buildArgs>
                             <jvmArgs>
diff --git a/integration/gradle-plugin-integration-tests/client-generator/custom-scalars-kotlinx/src/main/kotlin/com/expediagroup/scalars/Application.kt b/integration/gradle-plugin-integration-tests/client-generator/custom-scalars-kotlinx/src/main/kotlin/com/expediagroup/scalars/Application.kt
@@ -5,11 +5,8 @@ import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import io.ktor.http.ContentType
 import io.ktor.http.HttpStatusCode
 import io.ktor.server.application.Application
-import io.ktor.server.application.call
-import io.ktor.server.application.install
 import io.ktor.server.response.respond
 import io.ktor.server.response.respondText
-import io.ktor.server.routing.Routing
 import io.ktor.server.routing.get
 import io.ktor.server.routing.post
 import io.ktor.server.routing.routing
@@ -20,7 +17,6 @@ fun Application.graphQLModule() {
     val jacksonObjectMapper: ObjectMapper = jacksonObjectMapper()
     val ktorGraphQLServer: KtorGraphQLServer = KtorGraphQLServer(jacksonObjectMapper)
 
-    install(Routing)
     routing {
         post("graphql") {
             val result = ktorGraphQLServer.execute(call.request)
diff --git a/integration/gradle-plugin-integration-tests/client-generator/custom-scalars-kotlinx/src/test/kotlin/com/expediagroup/scalars/CustomScalarKotlinxTests.kt b/integration/gradle-plugin-integration-tests/client-generator/custom-scalars-kotlinx/src/test/kotlin/com/expediagroup/scalars/CustomScalarKotlinxTests.kt
@@ -31,11 +31,11 @@ class CustomScalarKotlinxTests {
 
     @Test
     fun `verify custom scalars are correctly serialized and deserialized`() {
-        val engine = embeddedServer(CIO, port = 0, module = Application::graphQLModule)
+        val embeddedServer = embeddedServer(CIO, port = 0, module = Application::graphQLModule)
         try {
-            engine.start()
+            embeddedServer.start()
             runBlocking {
-                val port = engine.resolvedConnectors().first().port
+                val port = embeddedServer.engine.resolvedConnectors().first().port
                 val client = GraphQLKtorClient(url = URL("http://localhost:$port/graphql"))
 
                 val undefinedLocaleQuery = LocaleQuery(variables = LocaleQuery.Variables())
@@ -52,17 +52,17 @@ class CustomScalarKotlinxTests {
                 assertEquals(ULocale.CANADA, localeResult.data?.localeQuery)
             }
         } finally {
-            engine.stop(1000, 1000)
+            embeddedServer.stop(1000, 1000)
         }
     }
 
     @Test
     fun `verify undefined optionals are correctly serialized and deserialized`() {
-        val engine = embeddedServer(CIO, port = 0, module = Application::graphQLModule)
+        val embeddedServer = embeddedServer(CIO, port = 0, module = Application::graphQLModule)
         try {
-            engine.start()
+            embeddedServer.start()
             runBlocking {
-                val port = engine.resolvedConnectors().first().port
+                val port = embeddedServer.engine.resolvedConnectors().first().port
                 val client = GraphQLKtorClient(url = URL("http://localhost:$port/graphql"))
 
                 val undefinedWrapperQuery = OptionalScalarQuery(variables = OptionalScalarQuery.Variables())
@@ -97,15 +97,15 @@ class CustomScalarKotlinxTests {
                 assertEquals(0, defaultResult.optionalUUIDList?.size)
             }
         } finally {
-            engine.stop(1000, 1000)
+            embeddedServer.stop(1000, 1000)
         }
     }
 
     @Test
     fun `verify null optionals are correctly serialized and deserialized`() {
-        val engine = embeddedServer(CIO, port = 8080, module = Application::graphQLModule)
+        val embeddedServer = embeddedServer(CIO, port = 8080, module = Application::graphQLModule)
         try {
-            engine.start()
+            embeddedServer.start()
             runBlocking {
                 val client = GraphQLKtorClient(url = URL("http://localhost:8080/graphql"))
 
@@ -142,15 +142,15 @@ class CustomScalarKotlinxTests {
                 assertNull(nullResult.optionalUUIDList)
             }
         } finally {
-            engine.stop(1000, 1000)
+            embeddedServer.stop(1000, 1000)
         }
     }
 
     @Test
     fun `verify defined optionals are correctly serialized and deserialized`() {
-        val engine = embeddedServer(CIO, port = 8080, module = Application::graphQLModule)
+        val embeddedServer = embeddedServer(CIO, port = 8080, module = Application::graphQLModule)
         try {
-            engine.start()
+            embeddedServer.start()
             runBlocking {
                 val client = GraphQLKtorClient(url = URL("http://localhost:8080/graphql"))
 
@@ -187,15 +187,15 @@ class CustomScalarKotlinxTests {
                 assertEquals(randomUUID, result.optionalUUIDList?.get(0))
             }
         } finally {
-            engine.stop(1000, 1000)
+            embeddedServer.stop(1000, 1000)
         }
     }
 
     @Test
     fun `verify serialization and deserialization of required type`() {
-        val engine = embeddedServer(CIO, port = 8080, module = Application::graphQLModule)
+        val embeddedServer = embeddedServer(CIO, port = 8080, module = Application::graphQLModule)
         try {
-            engine.start()
+            embeddedServer.start()
             runBlocking {
                 val client = GraphQLKtorClient(url = URL("http://localhost:8080/graphql"))
 
@@ -232,7 +232,7 @@ class CustomScalarKotlinxTests {
                 assertEquals(wrapper.requiredUUIDList[0], result.requiredUUIDList[0])
             }
         } finally {
-            engine.stop(1000, 1000)
+            embeddedServer.stop(1000, 1000)
         }
     }
 }
diff --git a/integration/gradle-plugin-integration-tests/client-generator/ktor-jackson/src/main/kotlin/com/expediagroup/ktor/jackson/Application.kt b/integration/gradle-plugin-integration-tests/client-generator/ktor-jackson/src/main/kotlin/com/expediagroup/ktor/jackson/Application.kt
@@ -5,11 +5,8 @@ import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import io.ktor.http.ContentType
 import io.ktor.http.HttpStatusCode
 import io.ktor.server.application.Application
-import io.ktor.server.application.call
-import io.ktor.server.application.install
 import io.ktor.server.response.respond
 import io.ktor.server.response.respondText
-import io.ktor.server.routing.Routing
 import io.ktor.server.routing.get
 import io.ktor.server.routing.post
 import io.ktor.server.routing.routing
@@ -20,7 +17,6 @@ fun Application.graphQLModule() {
     val jacksonObjectMapper: ObjectMapper = jacksonObjectMapper()
     val ktorGraphQLServer: KtorGraphQLServer = KtorGraphQLServer(jacksonObjectMapper)
 
-    install(Routing)
     routing {
         post("graphql") {
             val result = ktorGraphQLServer.execute(call.request)
diff --git a/integration/gradle-plugin-integration-tests/client-generator/ktor-jackson/src/test/kotlin/com/expediagroup/ktor/jackson/ApplicationTest.kt b/integration/gradle-plugin-integration-tests/client-generator/ktor-jackson/src/test/kotlin/com/expediagroup/ktor/jackson/ApplicationTest.kt
@@ -18,11 +18,11 @@ import kotlin.test.assertNull
 class ApplicationTest {
     @Test
     fun `verify ktor client can execute queries`() {
-        val engine = embeddedServer(CIO, port = 0, module = Application::graphQLModule)
+        val embeddedServer = embeddedServer(CIO, port = 0, module = Application::graphQLModule)
         try {
-            engine.start()
+            embeddedServer.start()
             runBlocking {
-                val port = engine.resolvedConnectors().first().port
+                val port = embeddedServer.engine.resolvedConnectors().first().port
                 val client = GraphQLKtorClient(url = URL("http://localhost:$port/graphql"))
 
                 val result = client.execute(TestQuery(variables = TestQuery.Variables(name = OptionalInput.Defined("junit"))))
@@ -40,7 +40,7 @@ class ApplicationTest {
                 assertEquals(ExampleEnum.ONE.name, testObject.choice.name)
             }
         } finally {
-            engine.stop(1000, 1000)
+            embeddedServer.stop(1000, 1000)
         }
     }
 }
diff --git a/integration/gradle-plugin-integration-tests/client-generator/ktor-kotlinx/src/main/kotlin/com/expediagroup/ktor/kotlinx/Application.kt b/integration/gradle-plugin-integration-tests/client-generator/ktor-kotlinx/src/main/kotlin/com/expediagroup/ktor/kotlinx/Application.kt
@@ -5,11 +5,8 @@ import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import io.ktor.http.ContentType
 import io.ktor.http.HttpStatusCode
 import io.ktor.server.application.Application
-import io.ktor.server.application.call
-import io.ktor.server.application.install
 import io.ktor.server.response.respond
 import io.ktor.server.response.respondText
-import io.ktor.server.routing.Routing
 import io.ktor.server.routing.get
 import io.ktor.server.routing.post
 import io.ktor.server.routing.routing
@@ -20,7 +17,6 @@ fun Application.graphQLModule() {
     val jacksonObjectMapper: ObjectMapper = jacksonObjectMapper()
     val ktorGraphQLServer: KtorGraphQLServer = KtorGraphQLServer(jacksonObjectMapper)
 
-    install(Routing)
     routing {
         post("graphql") {
             val result = ktorGraphQLServer.execute(call.request)
diff --git a/integration/gradle-plugin-integration-tests/client-generator/ktor-kotlinx/src/test/kotlin/com/expediagroup/ktor/kotlinx/ApplicationTest.kt b/integration/gradle-plugin-integration-tests/client-generator/ktor-kotlinx/src/test/kotlin/com/expediagroup/ktor/kotlinx/ApplicationTest.kt
@@ -18,11 +18,11 @@ import kotlin.test.assertNull
 class ApplicationTest {
     @Test
     fun `verify ktor client can execute queries`() {
-        val engine = embeddedServer(CIO, port = 0, module = Application::graphQLModule)
+        val embeddedServer = embeddedServer(CIO, port = 0, module = Application::graphQLModule)
         try {
-            engine.start()
+            embeddedServer.start()
             runBlocking {
-                val port = engine.resolvedConnectors().first().port
+                val port = embeddedServer.engine.resolvedConnectors().first().port
                 val client = GraphQLKtorClient(url = URL("http://localhost:$port/graphql"))
 
                 val result = client.execute(TestQuery(variables = TestQuery.Variables(name = OptionalInput.Defined("junit"))))
@@ -40,7 +40,7 @@ class ApplicationTest {
                 assertEquals(ExampleEnum.ONE.name, testObject.choice.name)
             }
         } finally {
-            engine.stop(1000, 1000)
+            embeddedServer.stop(1000, 1000)
         }
     }
 }
diff --git a/integration/gradle-plugin-integration-tests/client-generator/polymorphic-types-kotlinx/src/main/kotlin/com/expediagroup/polymorphic/Application.kt b/integration/gradle-plugin-integration-tests/client-generator/polymorphic-types-kotlinx/src/main/kotlin/com/expediagroup/polymorphic/Application.kt
@@ -5,11 +5,8 @@ import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import io.ktor.http.ContentType
 import io.ktor.http.HttpStatusCode
 import io.ktor.server.application.Application
-import io.ktor.server.application.call
-import io.ktor.server.application.install
 import io.ktor.server.response.respond
 import io.ktor.server.response.respondText
-import io.ktor.server.routing.Routing
 import io.ktor.server.routing.get
 import io.ktor.server.routing.post
 import io.ktor.server.routing.routing
@@ -20,7 +17,6 @@ fun Application.graphQLModule() {
     val jacksonObjectMapper: ObjectMapper = jacksonObjectMapper()
     val ktorGraphQLServer: KtorGraphQLServer = KtorGraphQLServer(jacksonObjectMapper)
 
-    install(Routing)
     routing {
         post("graphql") {
             val result = ktorGraphQLServer.execute(call.request)
diff --git a/integration/gradle-plugin-integration-tests/client-generator/polymorphic-types-kotlinx/src/test/kotlin/com/expediagroup/polymorphic/PolymorphicKotlinxTests.kt b/integration/gradle-plugin-integration-tests/client-generator/polymorphic-types-kotlinx/src/test/kotlin/com/expediagroup/polymorphic/PolymorphicKotlinxTests.kt
@@ -26,11 +26,11 @@ class PolymorphicKotlinxTests {
 
     @Test
     fun `verify polymorphic queries are correctly serialized and deserialized`() {
-        val engine = embeddedServer(CIO, port = 0, module = Application::graphQLModule)
+        val embeddedServer = embeddedServer(CIO, port = 0, module = Application::graphQLModule)
         try {
-            engine.start()
+            embeddedServer.start()
             runBlocking {
-                val port = engine.resolvedConnectors().first().port
+                val port = embeddedServer.engine.resolvedConnectors().first().port
                 val client = GraphQLKtorClient(url = URL("http://localhost:$port/graphql"))
 
                 val query = CompletePolymorphicQuery(variables = CompletePolymorphicQuery.Variables(input = "foo"))
@@ -46,16 +46,16 @@ class PolymorphicKotlinxTests {
                 assertNull(nullResponse.data?.unionQuery)
             }
         } finally {
-            engine.stop(1000, 1000)
+            embeddedServer.stop(1000, 1000)
         }
     }
 
     @OptIn(ExperimentalSerializationApi::class)
     @Test
     fun `verify polymorphic queries fallbacks are correctly serialized and deserialized`() {
-        val engine = embeddedServer(CIO, port = 0, module = Application::graphQLModule)
+        val embeddedServer = embeddedServer(CIO, port = 0, module = Application::graphQLModule)
         try {
-            engine.start()
+            embeddedServer.start()
             runBlocking {
                 // need to register fallback logic
                 val serializerWithFallback = GraphQLClientKotlinxSerializer(jsonBuilder = {
@@ -68,7 +68,7 @@ class PolymorphicKotlinxTests {
                         }
                     }
                 })
-                val port = engine.resolvedConnectors().first().port
+                val port = embeddedServer.engine.resolvedConnectors().first().port
                 val client = GraphQLKtorClient(url = URL("http://localhost:$port/graphql"), serializer = serializerWithFallback)
 
                 val fallbackQuery = PartialPolymorphicQuery(variables = PartialPolymorphicQuery.Variables(input = "bar"))
@@ -79,7 +79,7 @@ class PolymorphicKotlinxTests {
                 assertTrue(unionResult is DefaultBasicUnionImplementation)
             }
         } finally {
-            engine.stop(1000, 1000)
+            embeddedServer.stop(1000, 1000)
         }
     }
 }
diff --git a/integration/graphql-http-spec/ktor-server/src/main/kotlin/com/expediagroup/http/spec/ktor/GraphQLModule.kt b/integration/graphql-http-spec/ktor-server/src/main/kotlin/com/expediagroup/http/spec/ktor/GraphQLModule.kt
@@ -20,7 +20,7 @@ import com.expediagroup.graphql.server.ktor.graphQLGetRoute
 import com.expediagroup.graphql.server.ktor.graphQLPostRoute
 import io.ktor.server.application.Application
 import io.ktor.server.application.install
-import io.ktor.server.routing.Routing
+import io.ktor.server.routing.routing
 
 fun Application.graphQLModule() {
     install(GraphQL) {
@@ -31,7 +31,7 @@ fun Application.graphQLModule() {
             )
         }
     }
-    install(Routing) {
+    routing {
         graphQLGetRoute()
         graphQLPostRoute()
     }
diff --git a/servers/graphql-kotlin-ktor-server/src/main/kotlin/com/expediagroup/graphql/server/ktor/GraphQLRoutes.kt b/servers/graphql-kotlin-ktor-server/src/main/kotlin/com/expediagroup/graphql/server/ktor/GraphQLRoutes.kt
diff --git a/servers/graphql-kotlin-ktor-server/src/main/kotlin/com/expediagroup/graphql/server/ktor/KtorGraphQLRequestParser.kt b/servers/graphql-kotlin-ktor-server/src/main/kotlin/com/expediagroup/graphql/server/ktor/KtorGraphQLRequestParser.kt
diff --git a/servers/graphql-kotlin-ktor-server/src/test/kotlin/com/expediagroup/graphql/server/ktor/GraphQLPluginTest.kt b/servers/graphql-kotlin-ktor-server/src/test/kotlin/com/expediagroup/graphql/server/ktor/GraphQLPluginTest.kt
diff --git a/servers/graphql-kotlin-ktor-server/src/test/kotlin/com/expediagroup/graphql/server/ktor/KtorGraphQLRequestParserTest.kt b/servers/graphql-kotlin-ktor-server/src/test/kotlin/com/expediagroup/graphql/server/ktor/KtorGraphQLRequestParserTest.kt

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ graalvmNative {`
`32`	`32`	`binaries {`
`33`	`33`	`named("main") {`
`34`	`34`	`verbose.set(true)`
`35`		`- buildArgs.add("--initialize-at-build-time=io.ktor,kotlin,ch.qos.logback,org.slf4j")`
	`35`	`+ buildArgs.add("--initialize-at-build-time=io.ktor,kotlin,kotlinx.io,ch.qos.logback,org.slf4j")`
`36`	`36`	`buildArgs.add("-H:+ReportExceptionStackTraces")`
`37`	`37`	`jvmArgs("-Xmx6g")`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,11 +18,11 @@ import kotlin.test.assertNull`
`18`	`18`	`class ApplicationTest {`
`19`	`19`	`@Test`
`20`	`20`	fun `verify ktor client can execute queries`() {
`21`		`- val engine = embeddedServer(CIO, port = 0, module = Application::graphQLModule)`
	`21`	`+ val embeddedServer = embeddedServer(CIO, port = 0, module = Application::graphQLModule)`
`22`	`22`	`try {`
`23`		`- engine.start()`
	`23`	`+ embeddedServer.start()`
`24`	`24`	`runBlocking {`
`25`		`- val port = engine.resolvedConnectors().first().port`
	`25`	`+ val port = embeddedServer.engine.resolvedConnectors().first().port`
`26`	`26`	`val client = GraphQLKtorClient(url = URL("http://localhost:$port/graphql"))`
`27`	`27`
`28`	`28`	`val result = client.execute(TestQuery(variables = TestQuery.Variables(name = OptionalInput.Defined("junit"))))`
`@@ -40,7 +40,7 @@ class ApplicationTest {`
`40`	`40`	`assertEquals(ExampleEnum.ONE.name, testObject.choice.name)`
`41`	`41`	`}`
`42`	`42`	`} finally {`
`43`		`- engine.stop(1000, 1000)`
	`43`	`+ embeddedServer.stop(1000, 1000)`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,11 +26,11 @@ class PolymorphicKotlinxTests {`
`26`	`26`
`27`	`27`	`@Test`
`28`	`28`	fun `verify polymorphic queries are correctly serialized and deserialized`() {
`29`		`- val engine = embeddedServer(CIO, port = 0, module = Application::graphQLModule)`
	`29`	`+ val embeddedServer = embeddedServer(CIO, port = 0, module = Application::graphQLModule)`
`30`	`30`	`try {`
`31`		`- engine.start()`
	`31`	`+ embeddedServer.start()`
`32`	`32`	`runBlocking {`
`33`		`- val port = engine.resolvedConnectors().first().port`
	`33`	`+ val port = embeddedServer.engine.resolvedConnectors().first().port`
`34`	`34`	`val client = GraphQLKtorClient(url = URL("http://localhost:$port/graphql"))`
`35`	`35`
`36`	`36`	`val query = CompletePolymorphicQuery(variables = CompletePolymorphicQuery.Variables(input = "foo"))`
`@@ -46,16 +46,16 @@ class PolymorphicKotlinxTests {`
`46`	`46`	`assertNull(nullResponse.data?.unionQuery)`
`47`	`47`	`}`
`48`	`48`	`} finally {`
`49`		`- engine.stop(1000, 1000)`
	`49`	`+ embeddedServer.stop(1000, 1000)`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`@OptIn(ExperimentalSerializationApi::class)`
`54`	`54`	`@Test`
`55`	`55`	fun `verify polymorphic queries fallbacks are correctly serialized and deserialized`() {
`56`		`- val engine = embeddedServer(CIO, port = 0, module = Application::graphQLModule)`
	`56`	`+ val embeddedServer = embeddedServer(CIO, port = 0, module = Application::graphQLModule)`
`57`	`57`	`try {`
`58`		`- engine.start()`
	`58`	`+ embeddedServer.start()`
`59`	`59`	`runBlocking {`
`60`	`60`	`// need to register fallback logic`
`61`	`61`	`val serializerWithFallback = GraphQLClientKotlinxSerializer(jsonBuilder = {`
`@@ -68,7 +68,7 @@ class PolymorphicKotlinxTests {`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`	`})`
`71`		`- val port = engine.resolvedConnectors().first().port`
	`71`	`+ val port = embeddedServer.engine.resolvedConnectors().first().port`
`72`	`72`	`val client = GraphQLKtorClient(url = URL("http://localhost:$port/graphql"), serializer = serializerWithFallback)`
`73`	`73`
`74`	`74`	`val fallbackQuery = PartialPolymorphicQuery(variables = PartialPolymorphicQuery.Variables(input = "bar"))`
`@@ -79,7 +79,7 @@ class PolymorphicKotlinxTests {`
`79`	`79`	`assertTrue(unionResult is DefaultBasicUnionImplementation)`
`80`	`80`	`}`
`81`	`81`	`} finally {`
`82`		`- engine.stop(1000, 1000)`
	`82`	`+ embeddedServer.stop(1000, 1000)`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ import com.expediagroup.graphql.server.ktor.graphQLGetRoute`
`20`	`20`	`import com.expediagroup.graphql.server.ktor.graphQLPostRoute`
`21`	`21`	`import io.ktor.server.application.Application`
`22`	`22`	`import io.ktor.server.application.install`
`23`		`-import io.ktor.server.routing.Routing`
	`23`	`+import io.ktor.server.routing.routing`
`24`	`24`
`25`	`25`	`fun Application.graphQLModule() {`
`26`	`26`	`install(GraphQL) {`
`@@ -31,7 +31,7 @@ fun Application.graphQLModule() {`
`31`	`31`	`)`
`32`	`32`	`}`
`33`	`33`	`}`
`34`		`- install(Routing) {`
	`34`	`+ routing {`
`35`	`35`	`graphQLGetRoute()`
`36`	`36`	`graphQLPostRoute()`
`37`	`37`	`}`