Some tests updates

Mr3zee · Mr3zee · commit 6210ad4e1f46 · 2025-09-05T17:10:49.000+02:00
diff --git a/krpc/krpc-core/src/commonTest/kotlin/kotlinx/rpc/krpc/KrpcConnectorTest.kt b/krpc/krpc-core/src/commonTest/kotlin/kotlinx/rpc/krpc/KrpcConnectorTest.kt
@@ -352,9 +352,11 @@ abstract class KrpcConnectorBaseTest {
             isServer = true,
         )
 
-        body(clientConnector, serverConnector)
-
-        transport.coroutineContext.job.cancelAndJoin()
+        try {
+            body(clientConnector, serverConnector)
+        } finally {
+            transport.coroutineContext.job.cancelAndJoin()
+        }
     }
 }
 
diff --git a/krpc/krpc-core/src/commonTest/kotlin/kotlinx/rpc/krpc/KrpcReceiveBufferTest.kt b/krpc/krpc-core/src/commonTest/kotlin/kotlinx/rpc/krpc/KrpcReceiveBufferTest.kt
@@ -77,8 +77,10 @@ internal abstract class KrpcReceiveBufferBaseTest {
             bufferSize = { bufferSize },
         )
 
-        body(buffer)
-
-        buffer.close(null)
+        try {
+            body(buffer)
+        } finally {
+            buffer.close(null)
+        }
     }
 }
diff --git a/krpc/krpc-core/src/commonTest/kotlin/kotlinx/rpc/krpc/KrpcReceiveHandlerTest.kt b/krpc/krpc-core/src/commonTest/kotlin/kotlinx/rpc/krpc/KrpcReceiveHandlerTest.kt
@@ -257,13 +257,15 @@ internal abstract class KrpcReceiveHandlerBaseTest {
         val handler = KrpcStoringReceiveHandler(buffer, sender)
         val config = TestConfig(handler, buffer, channel, sender, this)
 
-        body(config)
-
-        handler.close(HandlerKey.Generic, null)
-        buffer.close(null)
-        channel.cancel()
-        channel.close()
-        senderJob.cancelAndJoin()
+        try {
+            body(config)
+        } finally {
+            handler.close(HandlerKey.Generic, null)
+            buffer.close(null)
+            channel.cancel()
+            channel.close()
+            senderJob.cancelAndJoin()
+        }
     }
 }
 
diff --git a/krpc/krpc-core/src/commonTest/kotlin/kotlinx/rpc/krpc/KrpcSendHandlerTest.kt b/krpc/krpc-core/src/commonTest/kotlin/kotlinx/rpc/krpc/KrpcSendHandlerTest.kt
@@ -120,10 +120,13 @@ internal abstract class KrpcSendHandlerBaseTest {
         )
 
         val handler = KrpcSendHandler(channel)
-        body(channel, handler)
-        handler.close()
-        channel.cancel()
-        channel.close()
+        try {
+            body(channel, handler)
+        } finally {
+            handler.close()
+            channel.cancel()
+            channel.close()
+        }
     }
 }
 
diff --git a/krpc/krpc-ktor/krpc-ktor-core/src/jvmTest/kotlin/kotlinx/rpc/krpc/ktor/KtorTransportTest.kt b/krpc/krpc-ktor/krpc-ktor-core/src/jvmTest/kotlin/kotlinx/rpc/krpc/ktor/KtorTransportTest.kt
@@ -21,8 +21,9 @@ import kotlinx.coroutines.debug.DebugProbes
 import kotlinx.coroutines.test.runTest
 import kotlinx.rpc.annotations.Rpc
 import kotlinx.rpc.krpc.client.KrpcClient
-import kotlinx.rpc.krpc.internal.logging.RpcInternalDumpLogger
+import kotlinx.rpc.krpc.internal.logging.RpcInternalCommonLogger
 import kotlinx.rpc.krpc.internal.logging.RpcInternalDumpLoggerContainer
+import kotlinx.rpc.krpc.internal.logging.dumpLogger
 import kotlinx.rpc.krpc.ktor.client.installKrpc
 import kotlinx.rpc.krpc.ktor.client.rpc
 import kotlinx.rpc.krpc.ktor.client.rpcConfig
@@ -31,8 +32,6 @@ import kotlinx.rpc.krpc.ktor.server.rpc
 import kotlinx.rpc.krpc.serialization.json.json
 import kotlinx.rpc.withService
 import org.junit.Assert.assertEquals
-import org.junit.platform.commons.logging.Logger
-import org.junit.platform.commons.logging.LoggerFactory
 import java.net.ServerSocket
 import java.util.concurrent.Executors
 import java.util.concurrent.TimeUnit
@@ -245,17 +244,10 @@ class KtorTransportTest {
         return port
     }
 
-    private fun setupLogger(): Logger {
-        val logger = LoggerFactory.getLogger(KtorTransportTest::class.java)
+    private fun setupLogger(): RpcInternalCommonLogger {
+        val logger = RpcInternalCommonLogger.logger(KtorTransportTest::class)
 
-        RpcInternalDumpLoggerContainer.set(object : RpcInternalDumpLogger {
-
-            override val isEnabled: Boolean = true
-
-            override fun dump(vararg tags: String, message: () -> String) {
-                logger.info { "[${tags.joinToString()}] ${message()}" }
-            }
-        })
+        RpcInternalDumpLoggerContainer.set(logger.dumpLogger())
 
         return logger
     }
diff --git a/krpc/krpc-logging/src/commonMain/kotlin/kotlinx/rpc/krpc/internal/logging/RpcInternalDumpLogger.kt b/krpc/krpc-logging/src/commonMain/kotlin/kotlinx/rpc/krpc/internal/logging/RpcInternalDumpLogger.kt
@@ -13,6 +13,17 @@ public interface RpcInternalDumpLogger {
     public fun dump(vararg tags: String, message: () -> String)
 }
 
+@InternalRpcApi
+public fun RpcInternalCommonLogger.dumpLogger(): RpcInternalDumpLogger {
+    return object : RpcInternalDumpLogger {
+        override val isEnabled: Boolean = true
+
+        override fun dump(vararg tags: String, message: () -> String) {
+            this@dumpLogger.info { "${tags.joinToString(" ") { "[$it]" }} ${message()}" }
+        }
+    }
+}
+
 @InternalRpcApi
 public object RpcInternalDumpLoggerContainer {
     private var logger: RpcInternalDumpLogger? = null
diff --git a/krpc/krpc-test/src/commonTest/kotlin/kotlinx/rpc/krpc/test/CoroutineContextPropagationTest.kt b/krpc/krpc-test/src/commonTest/kotlin/kotlinx/rpc/krpc/test/CoroutineContextPropagationTest.kt
@@ -4,7 +4,9 @@
 
 package kotlinx.rpc.krpc.test
 
+import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.job
 import kotlinx.coroutines.test.runTest
 import kotlinx.coroutines.withContext
 import kotlinx.rpc.krpc.rpcClientConfig
@@ -51,9 +53,17 @@ class CoroutineContextPropagationTest {
                 }
             }
         }
-        withContext(CoroutineElement("client")) {
-            client.withService(Echo::class).echo("request")
+        try {
+            withContext(CoroutineElement("client")) {
+                client.withService(Echo::class).echo("request")
+            }
+            assertEquals(CoroutineElement("transport"), actualContext)
+        } finally {
+            server.close()
+            client.close()
+            server.awaitCompletion()
+            client.awaitCompletion()
+            transport.coroutineContext.job.cancelAndJoin()
         }
-        assertEquals(CoroutineElement("transport"), actualContext)
     }
 }
diff --git a/krpc/krpc-test/src/commonTest/kotlin/kotlinx/rpc/krpc/test/ProtocolTestBase.kt b/krpc/krpc-test/src/commonTest/kotlin/kotlinx/rpc/krpc/test/ProtocolTestBase.kt
@@ -39,9 +39,13 @@ abstract class ProtocolTestBase {
         block: suspend TestBody.() -> Unit,
     ): TestResult {
         return kotlinx.coroutines.test.runTest {
-            val finished = TestBody(clientConfig, serverConfig, this).apply { block() }
+            val finished = TestBody(clientConfig, serverConfig, this)
 
-            finished.transport.coroutineContext.job.cancelAndJoin()
+            try {
+                finished.block()
+            } finally {
+                finished.transport.coroutineContext.job.cancelAndJoin()
+            }
         }
     }
 
diff --git a/krpc/krpc-test/src/commonTest/kotlin/kotlinx/rpc/krpc/test/TransportTest.kt b/krpc/krpc-test/src/commonTest/kotlin/kotlinx/rpc/krpc/test/TransportTest.kt
@@ -105,11 +105,13 @@ class TransportTest {
                 }
             })
 
-            block(logs)
-
-            RpcInternalDumpLoggerContainer.set(null)
-            logsJob.cancelAndJoin()
-            logsChannel.close()
+            try {
+                block(logs)
+            } finally {
+                RpcInternalDumpLoggerContainer.set(null)
+                logsJob.cancelAndJoin()
+                logsChannel.close()
+            }
         }
     }
 
diff --git a/krpc/krpc-test/src/commonTest/kotlin/kotlinx/rpc/krpc/test/cancellation/CancellationToolkit.kt b/krpc/krpc-test/src/commonTest/kotlin/kotlinx/rpc/krpc/test/cancellation/CancellationToolkit.kt
@@ -11,6 +11,7 @@ import kotlinx.rpc.krpc.KrpcConfigBuilder
 import kotlinx.rpc.krpc.internal.logging.RpcInternalCommonLogger
 import kotlinx.rpc.krpc.internal.logging.RpcInternalDumpLogger
 import kotlinx.rpc.krpc.internal.logging.RpcInternalDumpLoggerContainer
+import kotlinx.rpc.krpc.internal.logging.dumpLogger
 import kotlinx.rpc.krpc.rpcClientConfig
 import kotlinx.rpc.krpc.rpcServerConfig
 import kotlinx.rpc.krpc.serialization.json.json
@@ -25,8 +26,11 @@ import kotlin.time.Duration.Companion.seconds
 fun runCancellationTest(body: suspend CancellationToolkit.() -> Unit): TestResult {
     return runTest(timeout = 3.seconds) {
         debugCoroutines()
-        CancellationToolkit(this).apply {
-            body()
+        val toolkit = CancellationToolkit(this)
+        try {
+            body(toolkit)
+        } finally {
+            toolkit.close()
         }
     }
 }
@@ -35,13 +39,7 @@ class CancellationToolkit(scope: CoroutineScope) : CoroutineScope by scope {
     private val logger = RpcInternalCommonLogger.logger("CancellationTest")
 
     init {
-        RpcInternalDumpLoggerContainer.set(object : RpcInternalDumpLogger {
-            override val isEnabled: Boolean = true
-
-            override fun dump(vararg tags: String, message: () -> String) {
-                logger.info { "${tags.joinToString(" ") { "[$it]" }} ${message()}" }
-            }
-        })
+        RpcInternalDumpLoggerContainer.set(logger.dumpLogger())
     }
 
     private val configBuilder: KrpcConfigBuilder.() -> Unit = {
@@ -75,4 +73,13 @@ class CancellationToolkit(scope: CoroutineScope) : CoroutineScope by scope {
             }
         }
     }
+
+    suspend fun close() {
+        RpcInternalDumpLoggerContainer.set(null)
+        client.close()
+        server.close()
+        client.awaitCompletion()
+        server.awaitCompletion()
+        transport.coroutineContext.job.cancelAndJoin()
+    }
 }
diff --git a/krpc/krpc-test/src/jvmTest/kotlin/kotlinx/rpc/krpc/test/BaseServiceTest.kt b/krpc/krpc-test/src/jvmTest/kotlin/kotlinx/rpc/krpc/test/BaseServiceTest.kt
@@ -58,12 +58,14 @@ abstract class BaseServiceTest {
         server.registerService<TestService> { impl }
 
         val env = Env(service, impl, client, server, transport, this)
-        body(env)
-
-        client.close()
-        server.close()
-        client.awaitCompletion()
-        server.awaitCompletion()
-        transport.coroutineContext.cancelAndJoin()
+        try {
+            body(env)
+        } finally {
+            client.close()
+            server.close()
+            client.awaitCompletion()
+            server.awaitCompletion()
+            transport.coroutineContext.cancelAndJoin()
+        }
     }
 }
diff --git a/tests/krpc-compatibility-tests/src/test/kotlin/kotlinx/rpc/krpc/compatibility/KrpcCompatibilityTests.kt b/tests/krpc-compatibility-tests/src/test/kotlin/kotlinx/rpc/krpc/compatibility/KrpcCompatibilityTests.kt
@@ -4,6 +4,8 @@
 
 package kotlinx.rpc.krpc.compatibility
 
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.job
 import kotlinx.coroutines.test.runTest
 import kotlinx.rpc.krpc.rpcClientConfig
 import kotlinx.rpc.krpc.rpcServerConfig
@@ -68,7 +70,15 @@ class KrpcCompatibilityTests {
                     val client = KrpcTestClient(rpcClientConfig, localTransport.client)
                     clientServer.server.serveAllInterfaces(server)
 
-                    test(client)
+                    try {
+                        test(client)
+                    } finally {
+                        server.close()
+                        client.close()
+                        server.awaitCompletion()
+                        client.awaitCompletion()
+                        localTransport.coroutineContext.job.cancelAndJoin()
+                    }
                 }
             }
         }.stream()

Original file line number	Diff line number	Diff line change
`@@ -352,9 +352,11 @@ abstract class KrpcConnectorBaseTest {`
`352`	`352`	`isServer = true,`
`353`	`353`	`)`
`354`	`354`
`355`		`- body(clientConnector, serverConnector)`
`356`		`-`
`357`		`- transport.coroutineContext.job.cancelAndJoin()`
	`355`	`+ try {`
	`356`	`+ body(clientConnector, serverConnector)`
	`357`	`+ } finally {`
	`358`	`+ transport.coroutineContext.job.cancelAndJoin()`
	`359`	`+ }`
`358`	`360`	`}`
`359`	`361`	`}`
`360`	`362`
Original file line number	Diff line number	Diff line change
`@@ -77,8 +77,10 @@ internal abstract class KrpcReceiveBufferBaseTest {`
`77`	`77`	`bufferSize = { bufferSize },`
`78`	`78`	`)`
`79`	`79`
`80`		`- body(buffer)`
`81`		`-`
`82`		`- buffer.close(null)`
	`80`	`+ try {`
	`81`	`+ body(buffer)`
	`82`	`+ } finally {`
	`83`	`+ buffer.close(null)`
	`84`	`+ }`
`83`	`85`	`}`
`84`	`86`	`}`
Original file line number	Diff line number	Diff line change
`@@ -120,10 +120,13 @@ internal abstract class KrpcSendHandlerBaseTest {`
`120`	`120`	`)`
`121`	`121`
`122`	`122`	`val handler = KrpcSendHandler(channel)`
`123`		`- body(channel, handler)`
`124`		`- handler.close()`
`125`		`- channel.cancel()`
`126`		`- channel.close()`
	`123`	`+ try {`
	`124`	`+ body(channel, handler)`
	`125`	`+ } finally {`
	`126`	`+ handler.close()`
	`127`	`+ channel.cancel()`
	`128`	`+ channel.close()`
	`129`	`+ }`
`127`	`130`	`}`
`128`	`131`	`}`
`129`	`132`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,9 @@`
`4`	`4`
`5`	`5`	`package kotlinx.rpc.krpc.test`
`6`	`6`
	`7`	`+import kotlinx.coroutines.cancelAndJoin`
`7`	`8`	`import kotlinx.coroutines.currentCoroutineContext`
	`9`	`+import kotlinx.coroutines.job`
`8`	`10`	`import kotlinx.coroutines.test.runTest`
`9`	`11`	`import kotlinx.coroutines.withContext`
`10`	`12`	`import kotlinx.rpc.krpc.rpcClientConfig`
`@@ -51,9 +53,17 @@ class CoroutineContextPropagationTest {`
`51`	`53`	`}`
`52`	`54`	`}`
`53`	`55`	`}`
`54`		`- withContext(CoroutineElement("client")) {`
`55`		`- client.withService(Echo::class).echo("request")`
	`56`	`+ try {`
	`57`	`+ withContext(CoroutineElement("client")) {`
	`58`	`+ client.withService(Echo::class).echo("request")`
	`59`	`+ }`
	`60`	`+ assertEquals(CoroutineElement("transport"), actualContext)`
	`61`	`+ } finally {`
	`62`	`+ server.close()`
	`63`	`+ client.close()`
	`64`	`+ server.awaitCompletion()`
	`65`	`+ client.awaitCompletion()`
	`66`	`+ transport.coroutineContext.job.cancelAndJoin()`
`56`	`67`	`}`
`57`		`- assertEquals(CoroutineElement("transport"), actualContext)`
`58`	`68`	`}`
`59`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,9 +39,13 @@ abstract class ProtocolTestBase {`
`39`	`39`	`block: suspend TestBody.() -> Unit,`
`40`	`40`	`): TestResult {`
`41`	`41`	`return kotlinx.coroutines.test.runTest {`
`42`		`- val finished = TestBody(clientConfig, serverConfig, this).apply { block() }`
	`42`	`+ val finished = TestBody(clientConfig, serverConfig, this)`
`43`	`43`
`44`		`- finished.transport.coroutineContext.job.cancelAndJoin()`
	`44`	`+ try {`
	`45`	`+ finished.block()`
	`46`	`+ } finally {`
	`47`	`+ finished.transport.coroutineContext.job.cancelAndJoin()`
	`48`	`+ }`
`45`	`49`	`}`
`46`	`50`	`}`
`47`	`51`
Original file line number	Diff line number	Diff line change
`@@ -105,11 +105,13 @@ class TransportTest {`
`105`	`105`	`}`
`106`	`106`	`})`
`107`	`107`
`108`		`- block(logs)`
`109`		`-`
`110`		`- RpcInternalDumpLoggerContainer.set(null)`
`111`		`- logsJob.cancelAndJoin()`
`112`		`- logsChannel.close()`
	`108`	`+ try {`
	`109`	`+ block(logs)`
	`110`	`+ } finally {`
	`111`	`+ RpcInternalDumpLoggerContainer.set(null)`
	`112`	`+ logsJob.cancelAndJoin()`
	`113`	`+ logsChannel.close()`
	`114`	`+ }`
`113`	`115`	`}`
`114`	`116`	`}`
`115`	`117`