Add/fix StdioClientTransport tests

Author: kpavlov

kotlin-sdk-client/src/commonTest/kotlin/io/modelcontextprotocol/kotlin/sdk/client/stdio/StdioClientTransportLifecycleTest.kt

@@ -0,0 +1,94 @@
+package io.modelcontextprotocol.kotlin.sdk.client.stdio
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import io.modelcontextprotocol.kotlin.sdk.client.StdioClientTransport
+import io.modelcontextprotocol.kotlin.sdk.types.PingRequest
+import io.modelcontextprotocol.kotlin.sdk.types.toJSON
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.runTest
+import kotlinx.io.Buffer
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.time.Duration.Companion.milliseconds
+
+class StdioClientTransportLifecycleTest {
+
+    private lateinit var transport: StdioClientTransport
+
+    @BeforeTest
+    fun beforeEach() {
+        transport = createTransport()
+    }
+
+    @Test
+    fun `should throw when started twice`() = runTest {
+        transport.start()
+
+        val exception = shouldThrow<IllegalStateException> {
+            transport.start()
+        }
+        exception.message shouldContain "already started"
+    }
+
+    @Test
+    fun `should be idempotent when closed twice`() = runTest {
+        val transport = createTransport()
+
+        transport.start()
+        transport.close()
+
+        // Second close should not throw
+        transport.close()
+    }
+
+    @Test
+    fun `should throw when sending before start`() = runTest {
+        val transport = createTransport()
+
+        val exception = shouldThrow<IllegalStateException> {
+            transport.send(PingRequest().toJSON())
+        }
+        exception.message shouldContain "not started"
+    }
+
+    @Test
+    fun `should throw when sending after close`() = runTest {
+        val transport = createTransport()
+
+        transport.start()
+        delay(50.milliseconds)
+        transport.close()
+
+        shouldThrow<Exception> {
+            transport.send(PingRequest().toJSON())
+        }
+    }
+
+    @Test
+    fun `should call onClose exactly once`() = runTest {
+        val transport = createTransport()
+
+        var closeCallCount = 0
+        transport.onClose { closeCallCount++ }
+
+        transport.start()
+        delay(50.milliseconds)
+
+        // Multiple close attempts
+        transport.close()
+        transport.close()
+
+        closeCallCount shouldBe 1
+    }
+
+    private fun createTransport(): StdioClientTransport {
+        val inputBuffer = Buffer()
+        val outputBuffer = Buffer()
+        return StdioClientTransport(
+            input = inputBuffer,
+            output = outputBuffer,
+        )
+    }
+}

kotlin-sdk-client/src/jvmTest/kotlin/io/modelcontextprotocol/kotlin/sdk/client/stdio/StdioClientTransportErrorHandlingTest.kt

@@ -0,0 +1,98 @@
+package io.modelcontextprotocol.kotlin.sdk.client.stdio
+
+import io.kotest.matchers.booleans.shouldBeFalse
+import io.kotest.matchers.shouldBe
+import io.modelcontextprotocol.kotlin.sdk.client.StdioClientTransport
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.runTest
+import kotlinx.io.Buffer
+import kotlinx.io.writeString
+import kotlin.concurrent.atomics.AtomicBoolean
+import kotlin.concurrent.atomics.ExperimentalAtomicApi
+import kotlin.test.Test
+import kotlin.time.Duration.Companion.milliseconds
+
+/**
+ * Tests for StdioClientTransport error handling: EOF, IO errors, and edge cases.
+ */
+class StdioClientTransportErrorHandlingTest {
+
+    private lateinit var transport: StdioClientTransport
+
+    @OptIn(ExperimentalAtomicApi::class)
+    @Test
+    fun `should continue on stderr EOF`() = runTest {
+        val stderrBuffer = Buffer()
+        // Empty stderr = immediate EOF
+
+        val inputBuffer = Buffer()
+        inputBuffer.writeString("""data: {"jsonrpc":"2.0","method":"ping","id":1}\n\n""")
+        val outputBuffer = Buffer()
+
+        transport = StdioClientTransport(
+            input = inputBuffer,
+            output = outputBuffer,
+            error = stderrBuffer,
+        )
+
+        val closeCalled = AtomicBoolean(false)
+        transport.onClose { closeCalled.store(true) }
+
+        transport.start()
+        delay(200.milliseconds)
+
+        // Stderr EOF should not close transport
+        closeCalled.load() shouldBe false
+
+        transport.close()
+        closeCalled.load() shouldBe true
+    }
+
+    @Test
+    fun `should call onClose exactly once on error scenarios`() = runTest {
+        val stderrBuffer = Buffer()
+        stderrBuffer.write("FATAL: critical error\n".encodeToByteArray())
+
+        val inputBuffer = Buffer()
+        val outputBuffer = Buffer()
+
+        var closeCallCount = 0
+
+        transport = StdioClientTransport(
+            input = inputBuffer,
+            output = outputBuffer,
+            error = stderrBuffer,
+            classifyStderr = { StdioClientTransport.StderrSeverity.FATAL },
+        )
+
+        transport.onClose { closeCallCount++ }
+
+        transport.start()
+        delay(100.milliseconds)
+
+        // Explicit close after error already closed it
+        transport.close()
+
+        closeCallCount shouldBe 1
+    }
+
+    @Test
+    fun `should handle empty input gracefully`() = runTest {
+        val inputBuffer = Buffer()
+        val outputBuffer = Buffer()
+
+        transport = StdioClientTransport(
+            input = inputBuffer,
+            output = outputBuffer,
+        )
+
+        var errorCalled = false
+        transport.onError { errorCalled = true }
+
+        transport.start()
+        delay(100.milliseconds)
+
+        // Empty input should close cleanly without error
+        errorCalled.shouldBeFalse()
+    }
+}

kotlin-sdk-test/src/jvmTest/kotlin/io/modelcontextprotocol/kotlin/sdk/client/StdioClientTransportTest.kt

@@ -37,7 +37,7 @@ class StdioClientTransportTest : BaseTransportTest() {
             error = stderr,
         ) {
             println("💥Ah-oh!, error: \"$it\"")
-            true
+            StdioClientTransport.StderrSeverity.FATAL
         }
 
         val client = Client(