Reusing the same test server for all tests (as JUnit extension)

This improves the performance of the tests (no longer 15s each),
also makes for a better organization.

Author: joffrey-bion

src/jvmTest/kotlin/LocalIntegrationTestBase.kt

@@ -6,168 +6,168 @@ import org.hildan.chrome.devtools.domains.dom.*
 import org.hildan.chrome.devtools.domains.runtime.RemoteObjectSubtype
 import org.hildan.chrome.devtools.protocol.*
 import org.hildan.chrome.devtools.sessions.*
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.RegisterExtension
 import org.testcontainers.*
 import kotlin.test.*
 import kotlin.time.Duration.Companion.seconds
 
 abstract class LocalIntegrationTestBase : IntegrationTestBase() {
 
+    companion object {
+        @RegisterExtension
+        val resourceServer = TestResourcesServerExtension()
+    }
+
+    @BeforeEach
+    fun register() {
+        Testcontainers.exposeHostPorts(resourceServer.port)
+    }
+
+    protected suspend fun PageSession.gotoTestPageResource(resourcePath: String) {
+        goto("http://host.testcontainers.internal:${resourceServer.port}/$resourcePath")
+    }
+
     @OptIn(ExperimentalChromeApi::class)
     @Test
     fun basicFlow_fileScheme() = runTestWithRealTime {
-        withResourceServerForTestcontainers {
-            chromeWebSocket().use { browser ->
-                val pageSession = browser.newPage()
-                val targetId = pageSession.metaData.targetId
-
-                pageSession.use { page ->
-                    page.gotoTestPageResource("basic.html")
-                    assertEquals("Basic tab title", page.target.getTargetInfo().targetInfo.title)
-                    assertTrue(browser.hasTarget(targetId), "the new target should be listed")
-                }
-                assertFalse(browser.hasTarget(targetId), "the new target should be closed (not listed)")
+        chromeWebSocket().use { browser ->
+            val pageSession = browser.newPage()
+            val targetId = pageSession.metaData.targetId
+
+            pageSession.use { page ->
+                page.gotoTestPageResource("basic.html")
+                assertEquals("Basic tab title", page.target.getTargetInfo().targetInfo.title)
+                assertTrue(browser.hasTarget(targetId), "the new target should be listed")
             }
+            assertFalse(browser.hasTarget(targetId), "the new target should be closed (not listed)")
         }
     }
 
     @OptIn(ExperimentalChromeApi::class)
     @Test
     fun basicFlow_httpScheme() = runTestWithRealTime {
-        withResourceServerForTestcontainers {
-            chromeWebSocket().use { browser ->
-                val pageSession = browser.newPage()
-                val targetId = pageSession.metaData.targetId
-
-                pageSession.use { page ->
-                    page.gotoTestPageResource("basic.html")
-                    assertEquals("Basic tab title", page.target.getTargetInfo().targetInfo.title)
-                    assertTrue(browser.hasTarget(targetId), "the new target should be listed")
-                }
-                assertFalse(browser.hasTarget(targetId), "the new target should be closed (not listed)")
+        chromeWebSocket().use { browser ->
+            val pageSession = browser.newPage()
+            val targetId = pageSession.metaData.targetId
+
+            pageSession.use { page ->
+                page.gotoTestPageResource("basic.html")
+                assertEquals("Basic tab title", page.target.getTargetInfo().targetInfo.title)
+                assertTrue(browser.hasTarget(targetId), "the new target should be listed")
             }
+            assertFalse(browser.hasTarget(targetId), "the new target should be closed (not listed)")
         }
     }
 
     @Test
     fun page_getTargets_fileScheme() = runTestWithRealTime {
-        withResourceServerForTestcontainers {
-            chromeWebSocket().use { browser ->
-                browser.newPage().use { page ->
-                    page.gotoTestPageResource("basic.html")
-                    val targets = page.target.getTargets().targetInfos
-                    val targetInfo = targets.first { it.targetId == page.metaData.targetId }
-                    assertEquals("page", targetInfo.type)
-                    assertTrue(targetInfo.attached)
-                    assertTrue(targetInfo.url.contains("basic.html"))
-                }
+        chromeWebSocket().use { browser ->
+            browser.newPage().use { page ->
+                page.gotoTestPageResource("basic.html")
+                val targets = page.target.getTargets().targetInfos
+                val targetInfo = targets.first { it.targetId == page.metaData.targetId }
+                assertEquals("page", targetInfo.type)
+                assertTrue(targetInfo.attached)
+                assertTrue(targetInfo.url.contains("basic.html"))
             }
         }
     }
 
     @Test
     fun page_getTargets_httpScheme() = runTestWithRealTime {
-        withResourceServerForTestcontainers {
-            chromeWebSocket().use { browser ->
-                browser.newPage().use { page ->
-                    page.gotoTestPageResource("basic.html")
-                    val targets = page.target.getTargets().targetInfos
-                    val targetInfo = targets.first { it.targetId == page.metaData.targetId }
-                    assertEquals("page", targetInfo.type)
-                    assertTrue(targetInfo.attached)
-                    assertTrue(targetInfo.url.contains("basic.html"))
-                }
+        chromeWebSocket().use { browser ->
+            browser.newPage().use { page ->
+                page.gotoTestPageResource("basic.html")
+                val targets = page.target.getTargets().targetInfos
+                val targetInfo = targets.first { it.targetId == page.metaData.targetId }
+                assertEquals("page", targetInfo.type)
+                assertTrue(targetInfo.attached)
+                assertTrue(targetInfo.url.contains("basic.html"))
             }
         }
     }
 
     @OptIn(ExperimentalChromeApi::class)
     @Test
     fun page_goto() = runTestWithRealTime {
-        withResourceServerForTestcontainers {
-            chromeWebSocket().use { browser ->
-                browser.newPage().use { page ->
-                    page.gotoTestPageResource("basic.html")
-                    assertEquals("Basic tab title", page.target.getTargetInfo().targetInfo.title)
-
-                    page.gotoTestPageResource("other.html")
-                    assertEquals("Other tab title", page.target.getTargetInfo().targetInfo.title)
-                    val nodeId = withTimeoutOrNull(5.seconds) {
-                        page.dom.awaitNodeBySelector("p[class='some-p-class']")
-                    }
-                    assertNotNull(
-                        nodeId,
-                        "timed out while waiting for DOM node with attribute: p[class='some-p-class']"
-                    )
-
-                    val getOuterHTMLResponse = page.dom.getOuterHTML(GetOuterHTMLRequest(nodeId = nodeId))
-                    assertTrue(getOuterHTMLResponse.outerHTML.contains("<p class=\"some-p-class\">"))
+        chromeWebSocket().use { browser ->
+            browser.newPage().use { page ->
+                page.gotoTestPageResource("basic.html")
+                assertEquals("Basic tab title", page.target.getTargetInfo().targetInfo.title)
+
+                page.gotoTestPageResource("other.html")
+                assertEquals("Other tab title", page.target.getTargetInfo().targetInfo.title)
+                val nodeId = withTimeoutOrNull(5.seconds) {
+                    page.dom.awaitNodeBySelector("p[class='some-p-class']")
                 }
+                assertNotNull(
+                    nodeId,
+                    "timed out while waiting for DOM node with attribute: p[class='some-p-class']"
+                )
+
+                val getOuterHTMLResponse = page.dom.getOuterHTML(GetOuterHTMLRequest(nodeId = nodeId))
+                assertTrue(getOuterHTMLResponse.outerHTML.contains("<p class=\"some-p-class\">"))
             }
         }
     }
 
     @OptIn(ExperimentalChromeApi::class)
     @Test
     fun sessionThrowsIOExceptionIfAlreadyClosed() = runTestWithRealTime {
-        withResourceServerForTestcontainers {
-            val browser = chromeWebSocket()
-            val session = browser.newPage()
-            session.gotoTestPageResource("basic.html")
+        val browser = chromeWebSocket()
+        val session = browser.newPage()
+        session.gotoTestPageResource("basic.html")
 
-            browser.close()
+        browser.close()
 
-            assertFailsWith<RequestNotSentException> {
-                session.target.getTargetInfo().targetInfo
-            }
+        assertFailsWith<RequestNotSentException> {
+            session.target.getTargetInfo().targetInfo
         }
     }
 
     @Test
     fun attributesAccess() = runTestWithRealTime {
-        withResourceServerForTestcontainers {
-            chromeWebSocket().use { browser ->
-                browser.newPage().use { page ->
-                    page.gotoTestPageResource("select.html")
-
-                    val nodeId = page.dom.findNodeBySelector("select[name=pets] option[selected]")
-                    assertNull(nodeId, "No option is selected in this <select>")
-
-                    val attributes1 = page.dom.getTypedAttributes("select[name=pets] option[selected]")
-                    assertNull(attributes1, "No option is selected in this <select>")
-
-                    val attributes2 = page.dom.getTypedAttributes("select[name=pets-selected] option[selected]")
-                    assertNotNull(attributes2, "There should be a selected option")
-                    assertEquals(true, attributes2.selected)
-                    assertEquals("cat", attributes2.value)
-                    val value = page.dom.getAttributeValue("select[name=pets-selected] option[selected]", "value")
-                    assertEquals("cat", value)
-                    // Attributes without value (e.g. "selected" in <option name="x" selected />) are returned as empty
-                    // strings by the protocol.
-                    val selected = page.dom.getAttributeValue("select[name=pets-selected] option[selected]", "selected")
-                    assertEquals("", selected)
-
-                    val absentValue =
-                        page.dom.getAttributeValue("select[name=pets-selected-without-value] option[selected]", "value")
-                    assertNull(absentValue, "There is no 'value' attribute in this select option")
-                }
+        chromeWebSocket().use { browser ->
+            browser.newPage().use { page ->
+                page.gotoTestPageResource("select.html")
+
+                val nodeId = page.dom.findNodeBySelector("select[name=pets] option[selected]")
+                assertNull(nodeId, "No option is selected in this <select>")
+
+                val attributes1 = page.dom.getTypedAttributes("select[name=pets] option[selected]")
+                assertNull(attributes1, "No option is selected in this <select>")
+
+                val attributes2 = page.dom.getTypedAttributes("select[name=pets-selected] option[selected]")
+                assertNotNull(attributes2, "There should be a selected option")
+                assertEquals(true, attributes2.selected)
+                assertEquals("cat", attributes2.value)
+                val value = page.dom.getAttributeValue("select[name=pets-selected] option[selected]", "value")
+                assertEquals("cat", value)
+                // Attributes without value (e.g. "selected" in <option name="x" selected />) are returned as empty
+                // strings by the protocol.
+                val selected = page.dom.getAttributeValue("select[name=pets-selected] option[selected]", "selected")
+                assertEquals("", selected)
+
+                val absentValue =
+                    page.dom.getAttributeValue("select[name=pets-selected-without-value] option[selected]", "value")
+                assertNull(absentValue, "There is no 'value' attribute in this select option")
             }
         }
     }
 
     @OptIn(ExperimentalChromeApi::class)
     @Test
     fun test_deserialization_unknown_enum() = runTestWithRealTime {
-        withResourceServerForTestcontainers {
-            chromeWebSocket().use { browser ->
-                browser.newPage().use { page ->
-                    page.gotoTestPageResource("basic.html")
-                    val tree = page.accessibility.getFullAXTree() // just test that this doesn't fail
-
-                    assertTrue("we are no longer testing that unknown AXPropertyName values are deserialized as NotDefinedInProtocol") {
-                        tree.nodes.any { n ->
-                            n.properties.anyUndefinedName() || n.ignoredReasons.anyUndefinedName()
-                        }
+        chromeWebSocket().use { browser ->
+            browser.newPage().use { page ->
+                page.gotoTestPageResource("basic.html")
+                val tree = page.accessibility.getFullAXTree() // just test that this doesn't fail
+
+                assertTrue("we are no longer testing that unknown AXPropertyName values are deserialized as NotDefinedInProtocol") {
+                    tree.nodes.any { n ->
+                        n.properties.anyUndefinedName() || n.ignoredReasons.anyUndefinedName()
                     }
                 }
             }
@@ -177,36 +177,20 @@ abstract class LocalIntegrationTestBase : IntegrationTestBase() {
     @OptIn(ExperimentalChromeApi::class)
     @Test
     fun test_deserialization_RemoteObject_subtype_enum() = runTestWithRealTime {
-        withResourceServerForTestcontainers {
-            chromeWebSocket().use { browser ->
-                browser.newPage().use { page ->
-                    page.runtime.enable()
-                    val deferredEvent = async(start = CoroutineStart.UNDISPATCHED) {
-                        page.runtime.consoleAPICalledEvents().first()
-                    }
-                    page.gotoTestPageResource("trustedtype.html")
-                    val event = deferredEvent.await()
-                    // proof that we have to provide this subtype as enum value
-                    assertEquals(RemoteObjectSubtype.trustedtype, event.args.first().subtype)
+        chromeWebSocket().use { browser ->
+            browser.newPage().use { page ->
+                page.runtime.enable()
+                val deferredEvent = async(start = CoroutineStart.UNDISPATCHED) {
+                    page.runtime.consoleAPICalledEvents().first()
                 }
+                page.gotoTestPageResource("trustedtype.html")
+                val event = deferredEvent.await()
+                // proof that we have to provide this subtype as enum value
+                assertEquals(RemoteObjectSubtype.trustedtype, event.args.first().subtype)
             }
         }
     }
 
-    class TestServerContext(val baseUrl: String) {
-
-        suspend fun PageSession.gotoTestPageResource(resourcePath: String) {
-            goto("$baseUrl/$resourcePath")
-        }
-    }
-
-    protected suspend fun withResourceServerForTestcontainers(block: suspend TestServerContext.() -> Unit) {
-        withResourceHttpServer { port ->
-            Testcontainers.exposeHostPorts(port)
-            TestServerContext("http://host.testcontainers.internal:$port").block()
-        }
-    }
-
     private fun List<AXProperty>?.anyUndefinedName(): Boolean =
         this != null && this.any { it.name is AXPropertyName.NotDefinedInProtocol }
 }

src/jvmTest/kotlin/TestServer.kt

@@ -1,6 +1,38 @@
 import com.sun.net.httpserver.*
+import org.junit.jupiter.api.extension.AfterAllCallback
+import org.junit.jupiter.api.extension.AfterEachCallback
+import org.junit.jupiter.api.extension.BeforeAllCallback
+import org.junit.jupiter.api.extension.BeforeEachCallback
+import org.junit.jupiter.api.extension.Extension
+import org.junit.jupiter.api.extension.ExtensionContext
+import org.testcontainers.Testcontainers
 import java.io.*
 import java.net.*
+import kotlin.properties.Delegates
+
+class TestResourcesServerExtension : Extension, BeforeAllCallback, AfterAllCallback {
+    private lateinit var httpServer: HttpServer
+
+    val port: Int
+        get() = httpServer.address.port
+
+    override fun beforeAll(context: ExtensionContext?) {
+        httpServer = HttpServer.create(InetSocketAddress(InetAddress.getLoopbackAddress(), 0), 10)
+        httpServer.createContext("/") { exchange ->
+            if (exchange.requestMethod != "GET") {
+                exchange.respondInvalidMethod(listOf("GET"))
+                return@createContext
+            }
+            val resourcePath = exchange.requestURI.path.removePrefix("/")
+            exchange.respondWithResource(resourcePath)
+        }
+        httpServer.start()
+    }
+
+    override fun afterAll(context: ExtensionContext?) {
+        httpServer.stop(0)
+    }
+}
 
 /**
  * Creates an HTTP server that serves Java resources from the current program at '/'.

src/jvmTest/kotlin/ZenikaIntegrationTests.kt

@@ -68,19 +68,17 @@ class ZenikaIntegrationTests : LocalIntegrationTestBase() {
     @OptIn(ExperimentalChromeApi::class)
     @Test
     fun parallelPages() = runTestWithRealTime {
-        withResourceServerForTestcontainers {
-            chromeWebSocket().use { browser ->
-                // we want all coroutines to finish before we close the browser session
-                withContext(Dispatchers.IO) {
-                    repeat(20) {
-                        launch {
-                            browser.newPage().use { page ->
-                                page.gotoTestPageResource("basic.html")
-                                page.runtime.getHeapUsage()
-                                val docRoot = page.dom.getDocumentRootNodeId()
-                                page.dom.describeNode(DescribeNodeRequest(docRoot, depth = 2))
-                                page.storage.getCookies()
-                            }
+        chromeWebSocket().use { browser ->
+            // we want all coroutines to finish before we close the browser session
+            withContext(Dispatchers.IO) {
+                repeat(20) {
+                    launch {
+                        browser.newPage().use { page ->
+                            page.gotoTestPageResource("basic.html")
+                            page.runtime.getHeapUsage()
+                            val docRoot = page.dom.getDocumentRootNodeId()
+                            page.dom.describeNode(DescribeNodeRequest(docRoot, depth = 2))
+                            page.storage.getCookies()
                         }
                     }
                 }