MockServer improvements and TestNetworkTransport

apollo-mockserver/gradle.properties

@@ -1,3 +1,3 @@
 POM_ARTIFACT_ID=apollo-mockserver
 POM_NAME=Apollo Mockserver
-POM_DESCRIPTION=Apollo Mockserver
+POM_DESCRIPTION=Apollo Mockserver

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

@@ -31,10 +31,11 @@ import kotlin.native.concurrent.freeze
  * call. Can be used to simulate slow connections.
  */
 actual class MockServer(
-    private val acceptDelayMillis: Long
-): MockServerInterface {
+    private val acceptDelayMillis: Long,
+    override val mockServerHandler: MockServerHandler = QueueMockServerHandler(),
+) : MockServerInterface {
 
-  actual constructor(): this(0)
+  actual constructor(mockServerHandler: MockServerHandler) : this(0, mockServerHandler)
 
   private val pthreadT: pthread_tVar
   private val port: Int
@@ -70,7 +71,7 @@ actual class MockServer(
 
     pthreadT = nativeHeap.alloc()
 
-    socket = Socket(socketFd, acceptDelayMillis)
+    socket = Socket(socketFd, acceptDelayMillis, mockServerHandler)
 
     val stableRef = StableRef.create(socket!!.freeze())
 
@@ -79,23 +80,30 @@ actual class MockServer(
 
       val ref = arg!!.asStableRef<Socket>()
 
-      ref.get().also {
-        ref.dispose()
-      }.run()
+      try {
+        ref.get().also {
+          ref.dispose()
+        }.run()
+      } catch (e: Throwable) {
+        println("MockServer socket thread crashed: $e")
+        e.printStackTrace()
+      }
 
       null
     }, stableRef.asCPointer())
   }
 
   override suspend fun url(): String {
-    return "http://localhost:$port"
+    return "http://localhost:$port/"
   }
 
   override fun enqueue(mockResponse: MockResponse) {
     check(socket != null) {
       "Cannot enqueue a response to a stopped MockServer"
     }
-    socket!!.enqueue(mockResponse)
+    val queueMockServerHandler = mockServerHandler as? QueueMockServerHandler
+        ?: error("Apollo: cannot call MockServer.enqueue() with a custom handler")
+    queueMockServerHandler.enqueue(mockResponse)
   }
 
   /**
@@ -116,7 +124,7 @@ actual class MockServer(
     socket = null
   }
 
-  override fun takeRequest(): MockRecordedRequest {
+  override fun takeRequest(): MockRequest {
     check(socket != null) {
       "Cannot take a request from a stopped MockServer"
     }

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

@@ -0,0 +1,21 @@
+package com.apollographql.apollo3.mockserver
+
+import platform.Foundation.NSMutableArray
+import kotlin.native.concurrent.freeze
+
+internal actual class QueueMockServerHandler : MockServerHandler {
+  private val queue = NSMutableArray()
+
+  actual fun enqueue(response: MockResponse) {
+    queue.addObject(response.freeze())
+  }
+
+  actual override fun handle(request: MockRequest): MockResponse {
+    check(queue.count.toInt() > 0) {
+      "No more responses in queue"
+    }
+    val response = queue.objectAtIndex(0) as MockResponse
+    queue.removeObjectAtIndex(0)
+    return response
+  }
+}

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

@@ -31,11 +31,14 @@ import kotlin.experimental.and
 import kotlin.native.concurrent.AtomicInt
 import kotlin.native.concurrent.freeze
 
-class Socket(private val socketFd: Int, private val acceptDelayMillis: Long) {
+class Socket(
+    private val socketFd: Int,
+    private val acceptDelayMillis: Long,
+    private val mockServerHandler: MockServerHandler,
+) {
   private val pipeFd = nativeHeap.allocArray<IntVar>(2)
   private val running = AtomicInt(1)
   private val lock = reentrantLock()
-  private val queuedResponses = NSMutableArray()
   private val recordedRequests = NSMutableArray()
 
   init {
@@ -81,7 +84,7 @@ class Socket(private val socketFd: Int, private val acceptDelayMillis: Long) {
 
         val one = alloc<IntVar>()
         one.value = 1
-        setsockopt(connectionFd, SOL_SOCKET, SO_NOSIGPIPE, one.ptr, 4);
+        setsockopt(connectionFd, SOL_SOCKET, SO_NOSIGPIPE, one.ptr, 4)
 
         handleConnection(connectionFd)
         close(connectionFd)
@@ -128,13 +131,11 @@ class Socket(private val socketFd: Int, private val acceptDelayMillis: Long) {
 
         val mockResponse = synchronized(lock) {
           recordedRequests.addObject(request.freeze())
-
-          check(queuedResponses.count.toInt() > 0) {
-            "no queued responses"
+          try {
+            mockServerHandler.handle(request)
+          } catch (e: Exception) {
+            MockResponse("MockServerHandler.handle() threw an exception: ${e.message}", 500)
           }
-          queuedResponses.objectAtIndex(0).also {
-            queuedResponses.removeObjectAtIndex(0)
-          } as MockResponse
         }
 
         debug("Write response: ${mockResponse.statusCode}")
@@ -166,20 +167,14 @@ class Socket(private val socketFd: Int, private val acceptDelayMillis: Long) {
     nativeHeap.free(pipeFd.rawValue)
   }
 
-  fun enqueue(mockResponse: MockResponse) {
-    synchronized(lock) {
-      queuedResponses.addObject(mockResponse.freeze())
-    }
-  }
-
-  fun takeRequest(): MockRecordedRequest {
+  fun takeRequest(): MockRequest {
     return synchronized(lock) {
       check(recordedRequests.count.toInt() > 0) {
         "no recorded request"
       }
       recordedRequests.objectAtIndex(0).also {
         recordedRequests.removeObjectAtIndex(0)
-      } as MockRecordedRequest
+      } as MockRequest
     }
   }
-}
+}

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

@@ -15,6 +15,13 @@ interface MockServerInterface {
    */
   suspend fun stop()
 
+  /**
+   * The mock server handler used to respond to requests.
+   *
+   * The default handler is a [QueueMockServerHandler], which serves a fixed sequence of responses from a queue (see [enqueue]).
+   */
+  val mockServerHandler: MockServerHandler
+
   /**
    * Enqueue a response
    */
@@ -23,10 +30,8 @@ interface MockServerInterface {
   /**
    * Returns a request from the recorded requests or throws if no request has been received
    */
-  fun takeRequest(): MockRecordedRequest
+  fun takeRequest(): MockRequest
 }
 
-
 @ApolloExperimental
-expect class MockServer() : MockServerInterface {
-}
+expect class MockServer(mockServerHandler: MockServerHandler = QueueMockServerHandler()) : MockServerInterface

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

@@ -6,7 +6,6 @@ import okio.BufferedSource
 import okio.ByteString
 import okio.ByteString.Companion.encodeUtf8
 import kotlin.jvm.JvmOverloads
-import kotlin.jvm.JvmStatic
 
 fun parseHeader(line: String): Pair<String, String> {
   val index = line.indexOfFirst { it == ':' }
@@ -17,12 +16,12 @@ fun parseHeader(line: String): Pair<String, String> {
   return line.substring(0, index).trim() to line.substring(index + 1, line.length).trim()
 }
 
-class MockRecordedRequest(
+class MockRequest(
     val method: String,
     val path: String,
     val version: String,
     val headers: Map<String, String> = emptyMap(),
-    val body: ByteString = ByteString.EMPTY
+    val body: ByteString = ByteString.EMPTY,
 )
 
 fun writeResponse(sink: BufferedSink, mockResponse: MockResponse, version: String) {
@@ -51,11 +50,20 @@ class MockResponse(
   constructor(
       body: String,
       statusCode: Int = 200,
-      headers: Map<String, String> = emptyMap()
+      headers: Map<String, String> = emptyMap(),
   ) : this(statusCode, body.encodeUtf8(), headers)
 }
 
-internal fun readRequest(source: BufferedSource): MockRecordedRequest? {
+interface MockServerHandler {
+  /**
+   * Handles the given [MockRequest].
+   *
+   * This method is called from one or several background threads and must be thread-safe.
+   */
+  fun handle(request: MockRequest): MockResponse
+}
+
+internal fun readRequest(source: BufferedSource): MockRequest? {
   var line = source.readUtf8Line()
   if (line == null) {
     // the connection was closed
@@ -90,7 +98,7 @@ internal fun readRequest(source: BufferedSource): MockRecordedRequest? {
     source.read(buffer, contentLength)
   }
 
-  return MockRecordedRequest(
+  return MockRequest(
       method = method,
       path = path,
       version = version,
@@ -112,4 +120,4 @@ fun parseRequestLine(line: String): Triple<String, String, String> {
   }
 
   return Triple(method, match.groupValues[2], match.groupValues[3])
-}
+}

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

@@ -0,0 +1,19 @@
+package com.apollographql.apollo3.mockserver
+
+internal expect class QueueMockServerHandler() : MockServerHandler {
+  fun enqueue(response: MockResponse)
+
+  override fun handle(request: MockRequest): MockResponse
+}
+
+internal class CommonQueueMockServerHandler : MockServerHandler {
+  private val queue = ArrayDeque<MockResponse>()
+
+  fun enqueue(response: MockResponse) {
+    queue.add(response)
+  }
+
+  override fun handle(request: MockRequest): MockResponse {
+    return queue.removeFirstOrNull() ?: error("No more responses in queue")
+  }
+}

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

@@ -0,0 +1,59 @@
+package com.apollographql.apollo3.mockserver.test
+
+import com.apollographql.apollo3.annotations.ApolloExperimental
+import com.apollographql.apollo3.api.http.HttpMethod
+import com.apollographql.apollo3.api.http.HttpRequest
+import com.apollographql.apollo3.mockserver.MockRequest
+import com.apollographql.apollo3.mockserver.MockResponse
+import com.apollographql.apollo3.mockserver.MockServer
+import com.apollographql.apollo3.mockserver.MockServerHandler
+import com.apollographql.apollo3.network.http.DefaultHttpEngine
+import com.apollographql.apollo3.testing.runTest
+import kotlin.test.Test
+
+@OptIn(ApolloExperimental::class)
+class CustomHandlerTest {
+  private lateinit var mockServer: MockServer
+
+  private suspend fun tearDown() {
+    mockServer.stop()
+  }
+
+  @Test
+  fun customHandler() = runTest(after = { tearDown() }) {
+    val mockResponse0 = MockResponse(
+        body = "Hello, World! 000",
+        statusCode = 404,
+        headers = mapOf("Content-Type" to "text/plain"),
+    )
+    val mockResponse1 = MockResponse(
+        body = "Hello, World! 001",
+        statusCode = 200,
+        headers = mapOf("X-Test" to "true"),
+    )
+
+    val mockServerHandler = object : MockServerHandler {
+      override fun handle(request: MockRequest): MockResponse {
+        return when (request.path) {
+          "/0" -> mockResponse0
+          "/1" -> mockResponse1
+          else -> error("Unexpected path: ${request.path}")
+        }
+      }
+    }
+
+    mockServer = MockServer(mockServerHandler)
+
+    val engine = DefaultHttpEngine()
+
+    var httpResponse = engine.execute(HttpRequest.Builder(HttpMethod.Get, mockServer.url() + "1").build())
+    assertMockResponse(mockResponse1, httpResponse)
+
+    httpResponse = engine.execute(HttpRequest.Builder(HttpMethod.Get, mockServer.url() + "0").build())
+    assertMockResponse(mockResponse0, httpResponse)
+
+    httpResponse = engine.execute(HttpRequest.Builder(HttpMethod.Get, mockServer.url() + "1").build())
+    assertMockResponse(mockResponse1, httpResponse)
+  }
+
+}

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

@@ -0,0 +1,58 @@
+package com.apollographql.apollo3.mockserver.test
+
+import com.apollographql.apollo3.annotations.ApolloExperimental
+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.testing.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+@OptIn(ApolloExperimental::class)
+class EnqueueTest {
+  private lateinit var mockServer: MockServer
+
+  private fun setUp() {
+    mockServer = MockServer()
+  }
+
+  private suspend fun tearDown() {
+    mockServer.stop()
+  }
+
+  @Test
+  fun enqueue() = runTest(before = { setUp() }, after = { tearDown() }) {
+    val mockResponses = listOf(
+        MockResponse(
+            body = "Hello, World! 000",
+            statusCode = 404,
+            headers = mapOf("Content-Type" to "text/plain"),
+        ),
+        MockResponse(
+            body = "Hello, World! 001",
+            statusCode = 200,
+            headers = mapOf("X-Test" to "true"),
+        ),
+    )
+    for (mockResponse in mockResponses) {
+      mockServer.enqueue(mockResponse)
+    }
+
+    val engine = DefaultHttpEngine()
+    for (mockResponse in mockResponses) {
+      val httpResponse = engine.execute(HttpRequest.Builder(HttpMethod.Get, mockServer.url()).build())
+      assertMockResponse(mockResponse, httpResponse)
+    }
+  }
+
+  @Test
+  fun status500WhenNothingWasEnqueued() = runTest(before = { setUp() }, after = { tearDown() }) {
+    val engine = DefaultHttpEngine()
+    val httpResponse = engine.execute(HttpRequest.Builder(HttpMethod.Get, mockServer.url()).build())
+    assertEquals(500, httpResponse.statusCode)
+    assertTrue(httpResponse.body!!.readUtf8().contains("No more responses in queue"))
+  }
+}