Rename adapters :wip

hexagontk · Sep 28, 2024 · 9d470f8 · 9d470f8
1 parent 6063496
commit 9d470f8
Show file tree

Hide file tree

Showing 4 changed files with 33 additions and 32 deletions.
diff --git a/http/http_client/src/test/kotlin/com/hexagontk/http/client/HttpClientTest.kt b/http/http_client/src/test/kotlin/com/hexagontk/http/client/HttpClientTest.kt
@@ -17,49 +17,49 @@ import kotlin.test.*
 internal class HttpClientTest {
 
     @Test fun `Default settings are created as expected`() {
-        assertEquals(HttpClientSettings(), HttpClient(VoidAdapter).settings)
+        assertEquals(HttpClientSettings(), HttpClient(VoidHttpClient).settings)
 
         val noCookiesSettings = HttpClientSettings(useCookies = false)
-        assertFalse(HttpClient(VoidAdapter, noCookiesSettings).settings.useCookies)
+        assertFalse(HttpClient(VoidHttpClient, noCookiesSettings).settings.useCookies)
 
         val base = "http://example.org"
         val baseUrl = urlOf(base)
         assertEquals(
             baseUrl,
-            HttpClient(VoidAdapter, HttpClientSettings(baseUrl)).settings.baseUrl
+            HttpClient(VoidHttpClient, HttpClientSettings(baseUrl)).settings.baseUrl
         )
         assertEquals(
             baseUrl,
-            HttpClient(VoidAdapter, noCookiesSettings.copy(baseUrl = baseUrl)).settings.baseUrl
+            HttpClient(VoidHttpClient, noCookiesSettings.copy(baseUrl = baseUrl)).settings.baseUrl
         )
         assertFalse(
-            HttpClient(VoidAdapter, noCookiesSettings.copy(baseUrl = baseUrl)).settings.useCookies
+            HttpClient(VoidHttpClient, noCookiesSettings.copy(baseUrl = baseUrl)).settings.useCookies
         )
 
         val settingsBaseUrl = urlOf("http://server.com")
         val baseUrlSettings = HttpClientSettings(baseUrl = settingsBaseUrl)
         assertEquals(
             baseUrl,
-            HttpClient(VoidAdapter, baseUrlSettings.copy(baseUrl = baseUrl)).settings.baseUrl
+            HttpClient(VoidHttpClient, baseUrlSettings.copy(baseUrl = baseUrl)).settings.baseUrl
         )
-        assertEquals(settingsBaseUrl, HttpClient(VoidAdapter, baseUrlSettings).settings.baseUrl)
+        assertEquals(settingsBaseUrl, HttpClient(VoidHttpClient, baseUrlSettings).settings.baseUrl)
     }
 
     @Test fun `Cookies map works ok`() {
-        val client = HttpClient(VoidAdapter)
+        val client = HttpClient(VoidHttpClient)
         client.cookies += Cookie("cookie", "value")
         assertNull(client.cookiesMap()["name"])
         assertEquals(Cookie("cookie", "value"), client.cookiesMap()["cookie"])
     }
 
     @Test fun `HTTP Client is closeable`() {
-        val client = HttpClient(VoidAdapter)
+        val client = HttpClient(VoidHttpClient)
         client.use {
-            assertFalse(VoidAdapter.started)
+            assertFalse(VoidHttpClient.started)
             it.start()
-            assertTrue(VoidAdapter.started)
+            assertTrue(VoidHttpClient.started)
         }
-        assertFalse(VoidAdapter.started)
+        assertFalse(VoidHttpClient.started)
     }
 
     @Test fun `Client helper methods work properly`() {
@@ -74,9 +74,9 @@ internal class HttpClientTest {
             assertEquals(contentType, this.contentType)
         }
 
-        val client = HttpClient(VoidAdapter)
+        val client = HttpClient(VoidHttpClient)
         val csv = ContentType(TEXT_CSV)
-        val csvClient = HttpClient(VoidAdapter, HttpClientSettings(contentType = csv))
+        val csvClient = HttpClient(VoidHttpClient, HttpClientSettings(contentType = csv))
         val headers = Headers(Header("h1", "v1"))
         val body = "body"
 
@@ -137,13 +137,13 @@ internal class HttpClientTest {
     }
 
     @Test fun `Shut down not started client fails`() {
-        val client = HttpClient(VoidAdapter)
+        val client = HttpClient(VoidHttpClient)
         val message = assertFailsWith<IllegalStateException> { client.stop() }.message
         assertEquals("HTTP client *MUST BE STARTED* before shut-down", message)
     }
 
     @Test fun `HTTP clients fails to start if already started`() {
-        val client = HttpClient(VoidAdapter)
+        val client = HttpClient(VoidHttpClient)
         client.start()
         assert(client.started())
         val message = assertFailsWith<IllegalStateException> { client.start() }.message
@@ -156,7 +156,7 @@ internal class HttpClientTest {
             val next = receive(body = "p_" + request.bodyString()).next()
             next.send(body = next.request.bodyString() + next.response.bodyString() + "_s")
         }
-        val client = HttpClient(VoidAdapter, handler = handler)
+        val client = HttpClient(VoidHttpClient, handler = handler)
 
         val e = assertFailsWith<IllegalStateException> { client.get("http://localhost") }
         assertEquals("HTTP client *MUST BE STARTED* before sending requests", e.message)
@@ -170,7 +170,7 @@ internal class HttpClientTest {
     @Test fun `Request is sent even if no handler`() {
         val pathPattern = LiteralPathPattern("/test")
         val handler = FilterHandler(HttpPredicate(pathPattern = pathPattern)) { error("Failure") }
-        val client = HttpClient(VoidAdapter, handler = handler)
+        val client = HttpClient(VoidHttpClient, handler = handler)
 
         val e1 = assertFailsWith<IllegalStateException> { client.get("http://localhost") }
         assertEquals("HTTP client *MUST BE STARTED* before sending requests", e1.message)
@@ -190,7 +190,7 @@ internal class HttpClientTest {
             assertEquals("abc", request.authorization?.value)
             next()
         }
-        val client = HttpClient(VoidAdapter, handler = handler)
+        val client = HttpClient(VoidHttpClient, handler = handler)
 
         client.request {
             val accept = listOf(ContentType(TEXT_PLAIN))
@@ -200,7 +200,7 @@ internal class HttpClientTest {
     }
 
     @Test fun `SSE requests work properly`() {
-        val client = HttpClient(VoidAdapter)
+        val client = HttpClient(VoidHttpClient)
 
         val e = assertFailsWith<IllegalStateException> { client.sse("http://localhost") }
         assertEquals("HTTP client *MUST BE STARTED* before sending requests", e.message)
@@ -219,12 +219,12 @@ internal class HttpClientTest {
                     subscription.request(Long.MAX_VALUE)
                 }
             })
-            VoidAdapter.eventPublisher.submit(ServerEvent("event", "data", "id", 1))
+            VoidHttpClient.eventPublisher.submit(ServerEvent("event", "data", "id", 1))
         }
     }
 
     @Test fun `WebSockets requests work properly`() {
-        val client = HttpClient(VoidAdapter)
+        val client = HttpClient(VoidHttpClient)
 
         val e = assertFailsWith<IllegalStateException> { client.ws("http://localhost") }
         assertEquals("HTTP client *MUST BE STARTED* before connecting to WS", e.message)

diff --git a/.../com/hexagontk/http/client/VoidAdapter.kt → ...m/hexagontk/http/client/VoidHttpClient.kt b/.../com/hexagontk/http/client/VoidAdapter.kt → ...m/hexagontk/http/client/VoidHttpClient.kt
@@ -6,7 +6,8 @@ import java.net.URI
 import java.util.concurrent.Flow.Publisher
 import java.util.concurrent.SubmissionPublisher
 
-object VoidAdapter : HttpClientPort {
+// TODO Rename all adapters with patter ${name}Port (Port is port name without 'Port')
+object VoidHttpClient : HttpClientPort {
     internal val eventPublisher = SubmissionPublisher<ServerEvent>()
     var started: Boolean = false
 

diff --git a/http/http_server/src/test/kotlin/com/hexagontk/http/server/HttpServerTest.kt b/http/http_server/src/test/kotlin/com/hexagontk/http/server/HttpServerTest.kt
@@ -18,17 +18,17 @@ internal class HttpServerTest {
 
     @Test fun `Default parameters`() {
         val serverSettings = HttpServerSettings(address("localhost"), 9999, banner = "name")
-        val server = HttpServer(VoidAdapter, PathHandler(), serverSettings)
+        val server = HttpServer(VoidHttpServer, PathHandler(), serverSettings)
 
         assertEquals("name", server.settings.banner)
-        assertEquals(VoidAdapter.javaClass.simpleName, server.portName)
+        assertEquals(VoidHttpServer.javaClass.simpleName, server.portName)
         assertEquals(address("localhost"), server.settings.bindAddress)
         assertEquals(9999, server.settings.bindPort)
     }
 
     @Test fun `Runtime port`() {
         val serverSettings = HttpServerSettings(address("localhost"), 9999, banner = "name")
-        val server = HttpServer(VoidAdapter, PathHandler(), serverSettings)
+        val server = HttpServer(VoidHttpServer, PathHandler(), serverSettings)
 
         assertFailsWith<IllegalStateException>("Server is not running") { server.runtimePort }
         assert(!server.started())
@@ -46,7 +46,7 @@ internal class HttpServerTest {
             banner = null,
         )
 
-        val s = serve(VoidAdapter, serverSettings) {}
+        val s = serve(VoidHttpServer, serverSettings) {}
         s.createBanner(System.currentTimeMillis()).let {
             assert(it.startsWith(" at"))
             assert(it.contains(" ms)"))
@@ -64,7 +64,7 @@ internal class HttpServerTest {
             banner = bannerPrefix,
         )
 
-        val s = serve(VoidAdapter, serverSettings) {}
+        val s = serve(VoidHttpServer, serverSettings) {}
         s.createBanner(System.currentTimeMillis()).let {
             assertEquals(bannerPrefix, it.lines()[1].trimIndent())
             assertContains(it, "✅HTTP" )
@@ -81,7 +81,7 @@ internal class HttpServerTest {
             12345,
         )
 
-        val server = serve(VoidAdapter, serverSettings) {}
+        val server = serve(VoidHttpServer, serverSettings) {}
         val createdBanner = server.createBanner(System.currentTimeMillis())
         server.stop()
 
@@ -95,7 +95,7 @@ internal class HttpServerTest {
 
     @Test fun `Server can not be created with ZIP compression if not supported by its adapter`() {
         assertFailsWith<IllegalStateException> {
-            HttpServer(VoidAdapter, OnHandler { this }, HttpServerSettings(zip = true))
+            HttpServer(VoidHttpServer, OnHandler { this }, HttpServerSettings(zip = true))
         }.let {
             val errorMessage = "Requesting ZIP compression with an adapter without support:"
             assertContains(it.message ?: "", errorMessage)
@@ -104,7 +104,7 @@ internal class HttpServerTest {
 
     @Test fun `Server can not be created with a protocol not supported by its adapter`() {
         assertFailsWith<IllegalStateException> {
-            HttpServer(VoidAdapter, OnHandler { this }, HttpServerSettings(protocol = H2C))
+            HttpServer(VoidHttpServer, OnHandler { this }, HttpServerSettings(protocol = H2C))
         }.let {
             val message = it.message ?: ""
             assertContains(message, "Requesting unsupported protocol. Adapter's protocols:")

diff --git a/.../com/hexagontk/http/server/VoidAdapter.kt → ...m/hexagontk/http/server/VoidHttpServer.kt b/.../com/hexagontk/http/server/VoidAdapter.kt → ...m/hexagontk/http/server/VoidHttpServer.kt
@@ -4,7 +4,7 @@ import com.hexagontk.http.model.HttpProtocol
 import com.hexagontk.http.model.HttpProtocol.H2C
 import com.hexagontk.http.server.HttpServerFeature.SSE
 
-internal object VoidAdapter : HttpServerPort {
+internal object VoidHttpServer : HttpServerPort {
     private var started = false
 
     override fun runtimePort() = 12345