JavaScript

apollo-api/src/commonMain/kotlin/com/apollographql/apollo3/api/Operation.kt

@@ -9,6 +9,7 @@ import okio.Buffer
 import okio.BufferedSink
 import okio.BufferedSource
 import okio.ByteString
+import kotlin.js.JsName
 
 /**
  * Represents a GraphQL operation (mutation, query or subscription).
@@ -30,6 +31,7 @@ interface Operation<D : Operation.Data> : Executable<D> {
   /**
    * An unique identifier for the operation. Used for Automatic Persisted Queries. You can customize it with a [OperationIdGenerator]
    */
+  @JsName("operationId")
   fun id(): String
 
   override fun adapter(): Adapter<D>

apollo-api/src/commonMain/kotlin/com/apollographql/apollo3/api/http/Http.kt

@@ -25,7 +25,12 @@ interface HttpBody {
  */
 class HttpHeader(val name: String, val value: String)
 
-fun List<HttpHeader>.valueOf(name: String): String? = firstOrNull { it.name == name }?.value
+/**
+ * Get the value of the "name" header. HTTP header names are case insensitive, see https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
+ *
+ * @param name: the name of the header
+ */
+fun List<HttpHeader>.valueOf(name: String): String? = firstOrNull { it.name.equals(name, true) }?.value
 
 /**
  * a HTTP request to be sent

apollo-api/src/commonMain/kotlin/com/apollographql/apollo3/api/internal/json/Utils.kt

@@ -118,7 +118,6 @@ object Utils {
     try {
       return nextInt()
     } catch (e: Exception) {
-      e.printStackTrace()
     }
     try {
       return nextLong()

apollo-mockserver/build.gradle.kts

@@ -2,7 +2,7 @@ plugins {
   kotlin("multiplatform")
 }
 
-configureMppDefaults(withJs = false)
+configureMppTestsDefaults()
 
 kotlin {
   sourceSets {
@@ -21,10 +21,16 @@ kotlin {
       }
     }
 
+    val jsMain by getting {
+      dependencies {
+        implementation(groovy.util.Eval.x(project, "x.dep.kotlin.nodejs"))
+      }
+    }
+
     val commonTest by getting {
       dependencies {
         implementation(projects.apolloTestingSupport) {
-          because("runWithMainLoop")
+          because("runTest")
         }
         implementation(projects.apolloRuntime) {
           because("We need HttpEngine for SocketTest")

apollo-mockserver/src/appleMain/kotlin/com/apollographql/apollo3/mockserver/MockServer.kt

@@ -30,7 +30,7 @@ import kotlin.native.concurrent.freeze
 actual class MockServer {
   private val pthreadT: pthread_tVar
   private val port: Int
-  private val socket: Socket
+  private var socket: Socket? = null
 
   init {
     val socketFd = socket(AF_INET, SOCK_STREAM, 0)
@@ -64,7 +64,7 @@ actual class MockServer {
 
     socket = Socket(socketFd)
 
-    val stableRef = StableRef.create(socket.freeze())
+    val stableRef = StableRef.create(socket!!.freeze())
 
     pthread_create(pthreadT.ptr, null, staticCFunction { arg ->
       initRuntimeIfNeeded()
@@ -79,27 +79,38 @@ actual class MockServer {
     }, stableRef.asCPointer())
   }
 
-  actual fun url(): String {
+  actual suspend fun url(): String {
     return "http://localhost:$port"
   }
 
   actual fun enqueue(mockResponse: MockResponse) {
-    socket.enqueue(mockResponse)
+    check(socket != null) {
+      "Cannot enqueue a response to a stopped MockServer"
+    }
+    socket!!.enqueue(mockResponse)
   }
 
   /**
    * [MockServer] can only stop in between complete request/responses pairs
    * If stop() is called while we're reading a request, this might wait forever
    * Revisit once okio has native Timeout
    */
-  actual fun stop() {
-    socket.stop()
+  actual suspend fun stop() {
+    if (socket == null) {
+      return
+    }
+    socket!!.stop()
     pthread_join(pthreadT.value, null)
 
     nativeHeap.free(pthreadT.rawPtr)
+    pthreadT.value = null
+    socket = null
   }
 
   actual fun takeRequest(): MockRecordedRequest {
-    return socket.takeRequest()
+    check(socket != null) {
+      "Cannot take a request from a stopped MockServer"
+    }
+    return socket!!.takeRequest()
   }
 }

apollo-mockserver/src/appleMain/kotlin/com/apollographql/apollo3/mockserver/Socket.kt

@@ -4,21 +4,28 @@ import kotlinx.atomicfu.locks.reentrantLock
 import kotlinx.atomicfu.locks.synchronized
 import kotlinx.cinterop.ByteVar
 import kotlinx.cinterop.IntVar
+import kotlinx.cinterop.alloc
 import kotlinx.cinterop.allocArray
 import kotlinx.cinterop.convert
 import kotlinx.cinterop.get
 import kotlinx.cinterop.memScoped
 import kotlinx.cinterop.nativeHeap
+import kotlinx.cinterop.nativeHeap.free
+import kotlinx.cinterop.ptr
+import kotlinx.cinterop.value
 import okio.IOException
 import okio.buffer
 import platform.Foundation.NSMutableArray
 import platform.posix.POLLIN
+import platform.posix.SOL_SOCKET
+import platform.posix.SO_NOSIGPIPE
 import platform.posix.accept
 import platform.posix.close
 import platform.posix.errno
 import platform.posix.pipe
 import platform.posix.poll
 import platform.posix.pollfd
+import platform.posix.setsockopt
 import platform.posix.usleep
 import platform.posix.write
 import kotlin.experimental.and
@@ -70,6 +77,10 @@ class Socket(private val socketFd: Int) {
           "Cannot accept socket (errno = $errno)"
         }
 
+        val one = alloc<IntVar>()
+        one.value = 1
+        setsockopt(connectionFd, SOL_SOCKET, SO_NOSIGPIPE, one.ptr, 4);
+
         handleConnection(connectionFd)
         close(connectionFd)
       }
@@ -103,7 +114,7 @@ class Socket(private val socketFd: Int) {
         val request = try {
           readRequest(source)
         } catch (e: IOException) {
-          debug("'$connectionFd': Connection error")
+          debug("'$connectionFd': readRequest error")
           return
         }
         if (request == null) {
@@ -129,7 +140,13 @@ class Socket(private val socketFd: Int) {
         if (mockResponse.delayMs > 0) {
           usleep((mockResponse.delayMs * 1000).convert())
         }
-        writeResponse(sink, mockResponse, request.version)
+
+        try {
+          writeResponse(sink, mockResponse, request.version)
+        } catch (e: IOException) {
+          debug("'$connectionFd': writeResponse error")
+          return
+        }
 
         debug("Response Written")
       }

apollo-mockserver/src/commonMain/kotlin/com/apollographql/apollo3/mockserver/MockServer.kt

@@ -3,13 +3,26 @@ package com.apollographql.apollo3.mockserver
 import okio.ByteString.Companion.encodeUtf8
 
 expect class MockServer() {
-  fun url(): String
+  /**
+   * Returns the root url for this server
+   *
+   * It will block until a port is found to listen to
+   */
+  suspend fun url(): String
+
+  /**
+   * Stops the server
+   */
+  suspend fun stop()
+
+  /**
+   * Enqueue a response
+   */
   fun enqueue(mockResponse: MockResponse)
 
   /**
    * Returns a request from the recorded requests or throws if no request has been received
    */
   fun takeRequest(): MockRecordedRequest
-  fun stop()
 }
 

apollo-mockserver/src/commonTest/kotlin/com/apollographql/apollo3/mockserver/test/MockServerCommonTest.kt

@@ -47,4 +47,5 @@ class MockServerCommonTest {
     assertEquals("POST", recordedRequest.method)
     assertEquals("Hello world", recordedRequest.body.utf8())
   }
+
 }

apollo-mockserver/src/commonTest/kotlin/com/apollographql/apollo3/mockserver/test/SocketTest.kt

@@ -1,21 +1,21 @@
 package com.apollographql.apollo3.mockserver.test
 
+import com.apollographql.apollo3.api.http.HttpMethod
+import com.apollographql.apollo3.api.http.HttpRequest
 import com.apollographql.apollo3.mockserver.MockResponse
 import com.apollographql.apollo3.mockserver.MockServer
 import com.apollographql.apollo3.network.http.DefaultHttpEngine
-import com.apollographql.apollo3.api.http.HttpMethod
-import com.apollographql.apollo3.api.http.HttpRequest
-import com.apollographql.apollo3.testing.runWithMainLoop
+import com.apollographql.apollo3.testing.runTest
 import okio.ByteString.Companion.encodeUtf8
 import kotlin.random.Random
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
 class SocketTest {
-  val mockServer = MockServer()
-
   @Test
-  fun writeMoreThan8kToTheSocket() = runWithMainLoop {
+  fun writeMoreThan8kToTheSocket() = runTest {
+    val mockServer = MockServer()
+
     val builder = StringBuilder()
     0.until(10000).forEach {
       builder.append(Random.nextInt())
@@ -27,5 +27,7 @@ class SocketTest {
     val response = engine.execute(HttpRequest(HttpMethod.Get, mockServer.url(), emptyList(), null))
 
     assertEquals(response.body!!.readUtf8(), str)
+
+    mockServer.stop()
   }
 }

apollo-mockserver/src/jsMain/kotlin/com/apollographql/apollo3/mockserver/MockServer.kt

@@ -0,0 +1,62 @@
+package com.apollographql.apollo3.mockserver
+
+import Buffer
+import net.AddressInfo
+import okio.ByteString.Companion.toByteString
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+actual class MockServer {
+
+  private val responseQueue = mutableListOf<MockResponse>()
+  private val requests = mutableListOf<MockRecordedRequest>()
+
+  private val server = http.createServer { req, res ->
+    val requestBody = StringBuilder()
+    req.on("data") { chunk ->
+      when (chunk) {
+        is String -> requestBody.append(chunk)
+        is Buffer -> requestBody.append(chunk.toString("utf8"))
+        else -> println("WTF")
+      }
+    }
+    req.on("end") { _ ->
+      requests.add(
+          MockRecordedRequest(
+              req.method,
+              req.url,
+              req.httpVersion,
+              req.rawHeaders.toList().zipWithNext().toMap(),
+              requestBody.toString().encodeToByteArray().toByteString()
+          )
+      )
+    }
+
+    val mockResponse = responseQueue.removeFirst()
+    res.statusCode = mockResponse.statusCode
+    mockResponse.headers.forEach {
+      res.setHeader(it.key, it.value)
+    }
+    res.end(mockResponse.body.utf8())
+  }.listen()
+
+  actual suspend fun url() = suspendCoroutine<String> { cont ->
+    server.on("listening") { _ ->
+      cont.resume("http://localhost:${server.address().unsafeCast<AddressInfo>().port}")
+    }
+  }
+
+  actual fun enqueue(mockResponse: MockResponse) {
+    responseQueue.add(mockResponse)
+  }
+
+  actual fun takeRequest(): MockRecordedRequest {
+    return requests.removeFirst()
+  }
+
+  actual suspend fun stop() = suspendCoroutine<Unit> { cont ->
+    server.close {
+      cont.resume(Unit)
+    }
+  }
+}

apollo-mockserver/src/jvmMain/kotlin/com/apollographql/apollo3/mockserver/MockServer.kt

@@ -37,11 +37,11 @@ actual class MockServer {
     name(it) to get(name(it))!!
   }.toMap()
 
-  actual fun url(): String {
+  actual suspend fun url(): String {
     return mockWebServer.url("/").toString()
   }
 
-  actual fun stop() {
+  actual suspend fun stop() {
     mockWebServer.shutdown()
   }
 }

apollo-mpp-utils/src/appleMain/kotlin/com/apollographql/apollo3/mpp/utils.kt

@@ -29,4 +29,6 @@ actual fun assertMainThreadOnNative() {
   check(NSThread.isMainThread()) {
     "Non-main native call"
   }
-}
+}
+
+actual fun platform() = Platform.Native

apollo-mpp-utils/src/commonMain/kotlin/com/apollographql/apollo3/mpp/utils.kt

@@ -5,4 +5,17 @@ expect fun currentThreadId(): String
 expect fun ensureNeverFrozen(obj: Any)
 expect fun isFrozen(obj: Any): Boolean
 expect fun freeze(obj: Any)
-expect fun assertMainThreadOnNative()
+expect fun assertMainThreadOnNative()
+
+enum class Platform {
+  Jvm,
+  Native,
+  Js
+}
+
+/**
+ * The current platform. This is used from tests because Double.toString() doesn't behave the same on JS and other platforms.
+ * Prefer more specific functions like `assertMainThreadOnNative` when possible instead of checking the platform.
+ */
+expect fun platform(): Platform
+

apollo-mpp-utils/src/jsMain/kotlin/com/apollographql/apollo3/mpp/utils.kt

@@ -18,4 +18,6 @@ actual fun freeze(obj: Any) {
 }
 
 actual fun assertMainThreadOnNative() {
-}
+}
+
+actual fun platform() = Platform.Js

apollo-mpp-utils/src/jvmMain/kotlin/com/apollographql/apollo3/mpp/utils.kt

@@ -16,4 +16,6 @@ actual fun freeze(obj: Any) {
 }
 
 actual fun assertMainThreadOnNative() {
-}
+}
+
+actual fun platform() = Platform.Jvm