Use kotlinx-coroutines-test to catch dangling coroutines

joffrey-bion · joffrey-bion · commit c7ba45efba1d · 2025-04-21T03:09:13.000+02:00
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -89,6 +89,7 @@ kotlin {
         commonTest {
             dependencies {
                 implementation(kotlin("test"))
+                implementation(libs.kotlinx.coroutines.test)
             }
         }
         jvmTest {
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -33,6 +33,7 @@ vyarus-github-info-plugin = "2.0.0"
 kotlinpoet = { module = "com.squareup:kotlinpoet", version.ref = "kotlinpoet"}
 kotlinx-atomicfu = { module = "org.jetbrains.kotlinx:atomicfu", version.ref = "kotlinx-atomicfu" }
 kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
 kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
 ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
 ktor-client-contentNegotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
diff --git a/src/commonTest/kotlin/org/hildan/chrome/devtools/RealTimeTestScope.kt b/src/commonTest/kotlin/org/hildan/chrome/devtools/RealTimeTestScope.kt
@@ -0,0 +1,32 @@
+package org.hildan.chrome.devtools
+
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.plus
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.withContext
+import kotlin.coroutines.CoroutineContext
+
+interface RealTimeTestScope : CoroutineScope {
+    val backgroundScope: CoroutineScope
+}
+
+/**
+ * Provides the same facilities as [runTest] but without delay skipping.
+ */
+fun runTestWithRealTime(
+    nestedContext: CoroutineContext = Dispatchers.Default,
+    block: suspend RealTimeTestScope.() -> Unit,
+) = runTest {
+    val testScopeBackground = backgroundScope + CoroutineExceptionHandler { _, e ->
+        println("Error in background scope: $e")
+    }
+    withContext(nestedContext) {
+        val regularScope = this
+        val scopeWithBackground = object : RealTimeTestScope, CoroutineScope by regularScope {
+            override val backgroundScope: CoroutineScope = testScopeBackground
+        }
+        scopeWithBackground.block()
+    }
+}
diff --git a/src/jvmTest/kotlin/IntegrationTestBase.kt b/src/jvmTest/kotlin/IntegrationTestBase.kt
@@ -3,7 +3,6 @@ import kotlinx.coroutines.flow.*
 import kotlinx.serialization.*
 import kotlinx.serialization.json.*
 import org.hildan.chrome.devtools.*
-import org.hildan.chrome.devtools.domains.accessibility.*
 import org.hildan.chrome.devtools.domains.backgroundservice.*
 import org.hildan.chrome.devtools.domains.dom.*
 import org.hildan.chrome.devtools.domains.domdebugger.*
@@ -14,7 +13,6 @@ import org.hildan.chrome.devtools.protocol.json.*
 import org.hildan.chrome.devtools.sessions.*
 import org.hildan.chrome.devtools.targets.*
 import kotlin.test.*
-import kotlin.time.Duration.Companion.minutes
 import kotlin.time.Duration.Companion.seconds
 
 abstract class IntegrationTestBase {
@@ -36,113 +34,115 @@ abstract class IntegrationTestBase {
 
     protected fun chromeHttp(): ChromeDPHttpApi = ChromeDP.httpApi(httpUrl)
 
-    protected suspend fun chromeWebSocket(): BrowserSession = ChromeDP.connect(wsConnectUrl)
+    protected suspend fun RealTimeTestScope.chromeWebSocket(): BrowserSession = ChromeDP.connect(
+        wsOrHttpUrl = wsConnectUrl,
+        sessionContext = backgroundScope.coroutineContext,
+    )
 
     @Test
-    fun httpMetadataEndpoints() {
-        runBlockingWithTimeout {
-            val chrome = chromeHttp()
-
-            val version = chrome.version()
-            assertTrue(version.browser.contains("Chrome"))
-            assertTrue(version.userAgent.contains("HeadlessChrome"))
-            assertTrue(version.webSocketDebuggerUrl.startsWith("ws://"), "the debugger URL should start with ws://, but was: ${version.webSocketDebuggerUrl}")
-            println("Chrome version: $version")
-
-            val protocolJson = chrome.protocolJson()
-            assertTrue(protocolJson.isNotEmpty(), "the JSON definition of the protocol should not be empty")
-            val descriptor = Json.decodeFromString<ChromeProtocolDescriptor>(protocolJson)
-            println("Chrome protocol JSON version: ${descriptor.version}")
-        }
+    fun httpMetadataEndpoints() = runTestWithRealTime {
+        val chrome = chromeHttp()
+
+        val version = chrome.version()
+        assertTrue(version.browser.contains("Chrome"))
+        assertTrue(version.userAgent.contains("HeadlessChrome"))
+        assertTrue(version.webSocketDebuggerUrl.startsWith("ws://"), "the debugger URL should start with ws://, but was: ${version.webSocketDebuggerUrl}")
+        println("Chrome version: $version")
+
+        val protocolJson = chrome.protocolJson()
+        assertTrue(protocolJson.isNotEmpty(), "the JSON definition of the protocol should not be empty")
+        val descriptor = Json.decodeFromString<ChromeProtocolDescriptor>(protocolJson)
+        println("Chrome protocol JSON version: ${descriptor.version}")
     }
 
     @OptIn(ExperimentalChromeApi::class)
     @Test
-    fun basicFlow_remote() {
-        runBlockingWithTimeout {
-            chromeWebSocket().use { browser ->
-                val pageSession = browser.newPage()
-                val targetId = pageSession.metaData.targetId
+    fun basicFlow_remote() = runTestWithRealTime {
+        chromeWebSocket().use { browser ->
+            val pageSession = browser.newPage()
+            val targetId = pageSession.metaData.targetId
 
-                pageSession.use { page ->
-                    page.goto("http://www.google.com")
+            pageSession.use { page ->
+                page.goto("https://www.google.com")
 
-                    assertEquals("Google", page.target.getTargetInfo().targetInfo.title)
+                assertEquals("Google", page.target.getTargetInfo().targetInfo.title)
 
-                    assertTrue(browser.target.getTargets().targetInfos.any { it.targetId == targetId }, "the new target should be listed")
-
-                    val nodeId = withTimeoutOrNull(5.seconds) {
-                        page.dom.awaitNodeBySelector("form[action='/search']")
-                    }
-                    assertNotNull(nodeId, "timed out while waiting for DOM node with attribute: form[action='/search']")
+                assertTrue(browser.hasTarget(targetId), "the new target should be listed")
 
-                    val getOuterHTMLResponse = page.dom.getOuterHTML(GetOuterHTMLRequest(nodeId = nodeId))
-                    assertTrue(getOuterHTMLResponse.outerHTML.contains("<input name=\"source\""))
+                val nodeId = withTimeoutOrNull(5.seconds) {
+                    page.dom.awaitNodeBySelector("form[action='/search']")
                 }
-                assertTrue(browser.target.getTargets().targetInfos.none { it.targetId == targetId }, "the new target should be closed (not listed)")
+                assertNotNull(nodeId, "timed out while waiting for DOM node with attribute: form[action='/search']")
+
+                val getOuterHTMLResponse = page.dom.getOuterHTML(GetOuterHTMLRequest(nodeId = nodeId))
+                assertTrue(getOuterHTMLResponse.outerHTML.contains("<input name=\"source\""))
             }
+            assertFalse(browser.hasTarget(targetId), "the new target should be closed (not listed)")
         }
     }
 
+    protected suspend fun BrowserSession.hasTarget(targetId: String) =
+        target.getTargets().targetInfos.any { it.targetId == targetId }
+
     @OptIn(ExperimentalChromeApi::class)
     @Test
-    fun supportedDomains_all() {
-        runBlockingWithTimeout {
-            val client = chromeHttp()
-            val descriptor = Json.decodeFromString<ChromeProtocolDescriptor>(client.protocolJson())
-
-            val actualSupportedDomains = descriptor.domains
-                .filterNot { it.domain in knownUnsupportedDomains}
-                .map { it.domain }
-                .toSet()
-            val domainsDiff = actualSupportedDomains - knownUnsupportedDomains - AllDomainsTarget.supportedDomains
-            if (domainsDiff.isNotEmpty()) {
-                fail("The library should support all domains that the server actually exposes (apart from " +
-                         "$knownUnsupportedDomains), but it's missing: ${domainsDiff.sorted()}")
-            }
+    fun supportedDomains_all() = runTestWithRealTime {
+        val client = chromeHttp()
+        val descriptor = Json.decodeFromString<ChromeProtocolDescriptor>(client.protocolJson())
+
+        val actualSupportedDomains = descriptor.domains
+            .filterNot { it.domain in knownUnsupportedDomains }
+            .map { it.domain }
+            .toSet()
+        val domainsDiff = actualSupportedDomains - knownUnsupportedDomains - AllDomainsTarget.supportedDomains
+        if (domainsDiff.isNotEmpty()) {
+            fail(
+                "The library should support all domains that the server actually exposes (apart from " +
+                    "$knownUnsupportedDomains), but it's missing: ${domainsDiff.sorted()}"
+            )
         }
     }
 
     @OptIn(ExperimentalChromeApi::class)
     @Test
-    fun supportedDomains_pageTarget() {
-        runBlockingWithTimeout {
-            chromeWebSocket().use { browser ->
-                browser.newPage().use { page ->
-                    page.accessibility.enable()
-                    page.animation.enable()
-                    page.backgroundService.clearEvents(ServiceName.backgroundFetch)
-                    page.browser.getVersion()
-                    // Commenting this one out until the issue is better understood
-                    // https://github.com/joffrey-bion/chrome-devtools-kotlin/issues/233
-                    //page.cacheStorage.requestCacheNames(RequestCacheNamesRequest("google.com"))
-                    page.css.getMediaQueries()
-                    page.debugger.disable()
-                    page.deviceOrientation.clearDeviceOrientationOverride()
-                    page.domDebugger.setDOMBreakpoint(
-                        nodeId = page.dom.getDocumentRootNodeId(),
-                        type = DOMBreakpointType.attributeModified,
+    fun supportedDomains_pageTarget() = runTestWithRealTime {
+        chromeWebSocket().use { browser ->
+            browser.newPage().use { page ->
+                page.accessibility.enable()
+                page.animation.enable()
+                page.backgroundService.clearEvents(ServiceName.backgroundFetch)
+                page.browser.getVersion()
+                // Commenting this one out until the issue is better understood
+                // https://github.com/joffrey-bion/chrome-devtools-kotlin/issues/233
+                //page.cacheStorage.requestCacheNames(RequestCacheNamesRequest("google.com"))
+                page.css.getMediaQueries()
+                page.debugger.disable()
+                page.deviceOrientation.clearDeviceOrientationOverride()
+                page.domDebugger.setDOMBreakpoint(
+                    nodeId = page.dom.getDocumentRootNodeId(),
+                    type = DOMBreakpointType.attributeModified,
+                )
+                page.domSnapshot.enable()
+                page.domStorage.enable()
+                page.fetch.disable()
+                page.heapProfiler.enable()
+                page.indexedDB.enable()
+                page.layerTree.enable()
+                page.performance.disable()
+                page.profiler.disable()
+                page.runtime.enable()
+
+                // We cannot replace this schema Domain call by an HTTP call to /json/protocol, because
+                // the protocol JSON contains the list of all domains, not just for the page target type.
+                @Suppress("DEPRECATION")
+                val actualPageDomains = page.schema.getDomains().domains.map { it.name }.toSet()
+
+                val pageDomainsDiff = actualPageDomains - knownUnsupportedDomains - PageTarget.supportedDomains
+                if (pageDomainsDiff.isNotEmpty()) {
+                    fail(
+                        "PageSession should support all domains that the server actually exposes (apart from " +
+                            "$knownUnsupportedDomains), but it's missing: ${pageDomainsDiff.sorted()}"
                     )
-                    page.domSnapshot.enable()
-                    page.domStorage.enable()
-                    page.fetch.disable()
-                    page.heapProfiler.enable()
-                    page.indexedDB.enable()
-                    page.layerTree.enable()
-                    page.performance.disable()
-                    page.profiler.disable()
-                    page.runtime.enable()
-
-                    // We cannot replace this schema Domain call by an HTTP call to /json/protocol, because
-                    // the protocol JSON contains the list of all domains, not just for the page target type.
-                    @Suppress("DEPRECATION")
-                    val actualPageDomains = page.schema.getDomains().domains.map { it.name }.toSet()
-
-                    val pageDomainsDiff = actualPageDomains - knownUnsupportedDomains - PageTarget.supportedDomains
-                    if (pageDomainsDiff.isNotEmpty()) {
-                        fail("PageSession should support all domains that the server actually exposes (apart from " +
-                                 "$knownUnsupportedDomains), but it's missing: ${pageDomainsDiff.sorted()}")
-                    }
                 }
             }
         }
@@ -152,46 +152,38 @@ abstract class IntegrationTestBase {
     data class Person(val firstName: String, val lastName: String)
 
     @Test
-    fun runtime_evaluateJs() {
-        runBlockingWithTimeout {
-            chromeWebSocket().use { browser ->
-                browser.newPage().use { page ->
-                    assertEquals(42, page.runtime.evaluateJs<Int>("42"))
-                    assertEquals(
-                        42 to "test",
-                        page.runtime.evaluateJs<Pair<Int, String>>("""eval({first: 42, second: "test"})""")
-                    )
-                    assertEquals(
-                        Person("Bob", "Lee Swagger"),
-                        page.runtime.evaluateJs<Person>("""eval({firstName: "Bob", lastName: "Lee Swagger"})""")
-                    )
-                }
+    fun runtime_evaluateJs() = runTestWithRealTime {
+        chromeWebSocket().use { browser ->
+            browser.newPage().use { page ->
+                assertEquals(42, page.runtime.evaluateJs<Int>("42"))
+                assertEquals(
+                    42 to "test",
+                    page.runtime.evaluateJs<Pair<Int, String>>("""eval({first: 42, second: "test"})""")
+                )
+                assertEquals(
+                    Person("Bob", "Lee Swagger"),
+                    page.runtime.evaluateJs<Person>("""eval({firstName: "Bob", lastName: "Lee Swagger"})""")
+                )
             }
         }
     }
 
     @OptIn(ExperimentalChromeApi::class)
     @Test
-    open fun missingExpiresInCookie() {
-        runBlockingWithTimeout {
-            chromeWebSocket().use { browser ->
-                browser.newPage().use { page ->
-                    page.goto("https://x.com")
-                    page.network.enable()
-                    coroutineScope {
-                        launch {
-                            // ensures we don't crash on deserialization
-                            page.network.responseReceivedExtraInfoEvents().first()
-                        }
-                        page.dom.awaitNodeBySelector("a[href=\"/login\"]")
-                        page.clickOnElement("a[href=\"/login\"]")
+    open fun missingExpiresInCookie() = runTestWithRealTime {
+        chromeWebSocket().use { browser ->
+            browser.newPage().use { page ->
+                page.goto("https://x.com")
+                page.network.enable()
+                coroutineScope {
+                    launch {
+                        // ensures we don't crash on deserialization
+                        page.network.responseReceivedExtraInfoEvents().first()
                     }
+                    page.dom.awaitNodeBySelector("a[href=\"/login\"]")
+                    page.clickOnElement("a[href=\"/login\"]")
                 }
             }
         }
     }
-
-    protected fun runBlockingWithTimeout(block: suspend CoroutineScope.() -> Unit) = runBlocking {
-        withTimeout(1.minutes, block)
-    }
 }
diff --git a/src/jvmTest/kotlin/LocalIntegrationTestBase.kt b/src/jvmTest/kotlin/LocalIntegrationTestBase.kt
diff --git a/src/jvmTest/kotlin/ZenikaIntegrationTests.kt b/src/jvmTest/kotlin/ZenikaIntegrationTests.kt

Original file line number	Diff line number	Diff line change
`@@ -89,6 +89,7 @@ kotlin {`
`89`	`89`	`commonTest {`
`90`	`90`	`dependencies {`
`91`	`91`	`implementation(kotlin("test"))`
	`92`	`+ implementation(libs.kotlinx.coroutines.test)`
`92`	`93`	`}`
`93`	`94`	`}`
`94`	`95`	`jvmTest {`