test(streamable-http): make pagination tests deterministic and simplify assertions; use LoggingLevel.entries

Author: jskjw157

integration-test/src/jvmTest/kotlin/io/modelcontextprotocol/kotlin/sdk/integration/kotlin/AbstractPromptIntegrationTest.kt

@@ -723,16 +723,16 @@ abstract class AbstractPromptIntegrationTest : KotlinTestBase() {
             }
         }
 
-        val first = client.listPrompts()
-        assertTrue(first.prompts.isNotEmpty())
-        val nextCursor = first.nextCursor
-        assertNotNull(nextCursor)
-
-        val second = client.listPrompts(ListPromptsRequest(PaginatedRequestParams(cursor = nextCursor)))
-        assertTrue(second.prompts.isNotEmpty())
-
-        val combined = first.prompts + second.prompts
-        assertTrue(combined.any { it.name.startsWith(pagePrefix) })
+        val allPrompts = mutableListOf<io.modelcontextprotocol.kotlin.sdk.types.Prompt>()
+        var currentCursor: String? = null
+        do {
+            val request = if (currentCursor == null) ListPromptsRequest() else ListPromptsRequest(PaginatedRequestParams(cursor = currentCursor))
+            val response = client.listPrompts(request)
+            allPrompts.addAll(response.prompts)
+            currentCursor = response.nextCursor
+        } while (currentCursor != null)
+
+        assertTrue(allPrompts.any { it.name.startsWith(pagePrefix) })
     }
 
     @Test
@@ -746,10 +746,8 @@ abstract class AbstractPromptIntegrationTest : KotlinTestBase() {
             }
         }
 
-        val exception = org.junit.jupiter.api.assertThrows<McpException> {
-            runBlocking {
-                client.listPrompts(ListPromptsRequest(PaginatedRequestParams(cursor = "not-a-number")))
-            }
+        val exception = kotlin.test.assertFailsWith<McpException> {
+            client.listPrompts(ListPromptsRequest(PaginatedRequestParams(cursor = "not-a-number")))
         }
 
         kotlin.test.assertEquals(RPCError.ErrorCode.INTERNAL_ERROR, exception.code)

integration-test/src/jvmTest/kotlin/io/modelcontextprotocol/kotlin/sdk/integration/kotlin/AbstractResourceIntegrationTest.kt

@@ -335,15 +335,21 @@ abstract class AbstractResourceIntegrationTest : KotlinTestBase() {
             }
         }
 
-        val first = client.listResources()
-        assertTrue(first.resources.isNotEmpty())
-        val next = first.nextCursor
-        assertNotNull(next)
+        val combinedUris = mutableListOf<String>()
+        var currentCursor: String? = null
+
+        do {
+            val request = if (currentCursor == null) {
+                ListResourcesRequest()
+            } else {
+                ListResourcesRequest(PaginatedRequestParams(cursor = currentCursor))
+            }
 
-        val second = client.listResources(ListResourcesRequest(PaginatedRequestParams(cursor = next)))
-        assertTrue(second.resources.isNotEmpty())
+            val response = client.listResources(request)
+            combinedUris += response.resources.map { it.uri }
+            currentCursor = response.nextCursor
+        } while (currentCursor != null)
 
-        val combinedUris = (first.resources + second.resources).map { it.uri }
         assertTrue(combinedUris.any { it.contains(prefix) })
     }
 
@@ -358,10 +364,8 @@ abstract class AbstractResourceIntegrationTest : KotlinTestBase() {
             }
         }
 
-        val exception = org.junit.jupiter.api.assertThrows<McpException> {
-            runBlocking {
-                client.listResources(ListResourcesRequest(PaginatedRequestParams(cursor = "bad")))
-            }
+        val exception = kotlin.test.assertFailsWith<McpException> {
+            client.listResources(ListResourcesRequest(PaginatedRequestParams(cursor = "bad")))
         }
 
         kotlin.test.assertEquals(RPCError.ErrorCode.INTERNAL_ERROR, exception.code)

integration-test/src/jvmTest/kotlin/io/modelcontextprotocol/kotlin/sdk/integration/kotlin/AbstractToolIntegrationTest.kt

@@ -817,15 +817,21 @@ abstract class AbstractToolIntegrationTest : KotlinTestBase() {
             }
         }
 
-        val first = client.listTools()
-        assertTrue(first.tools.isNotEmpty())
-        val next = first.nextCursor
-        assertNotNull(next)
+        val combinedNames = mutableListOf<String>()
+        var currentCursor: String? = null
 
-        val second = client.listTools(ListToolsRequest(PaginatedRequestParams(cursor = next)))
-        assertTrue(second.tools.isNotEmpty())
+        do {
+            val request = if (currentCursor == null) {
+                ListToolsRequest()
+            } else {
+                ListToolsRequest(PaginatedRequestParams(cursor = currentCursor))
+            }
+
+            val response = client.listTools(request)
+            combinedNames += response.tools.map { it.name }
+            currentCursor = response.nextCursor
+        } while (currentCursor != null)
 
-        val combinedNames = (first.tools + second.tools).map { it.name }
         assertTrue(combinedNames.any { it.startsWith(prefix) })
     }
 
@@ -840,10 +846,8 @@ abstract class AbstractToolIntegrationTest : KotlinTestBase() {
             }
         }
 
-        val exception = org.junit.jupiter.api.assertThrows<io.modelcontextprotocol.kotlin.sdk.types.McpException> {
-            runBlocking {
-                client.listTools(ListToolsRequest(PaginatedRequestParams(cursor = "bad")))
-            }
+        val exception = kotlin.test.assertFailsWith<io.modelcontextprotocol.kotlin.sdk.types.McpException> {
+            client.listTools(ListToolsRequest(PaginatedRequestParams(cursor = "bad")))
         }
 
         kotlin.test.assertEquals(io.modelcontextprotocol.kotlin.sdk.types.RPCError.ErrorCode.INTERNAL_ERROR, exception.code)

integration-test/src/jvmTest/kotlin/io/modelcontextprotocol/kotlin/sdk/integration/kotlin/streamablehttp/LoggingIntegrationTestStreamableHttp.kt

@@ -51,7 +51,7 @@ class LoggingIntegrationTestStreamableHttp : KotlinTestBase() {
         }
 
         server.addTool(name = "test-logging-level", description = "test") { request ->
-            LoggingLevel.values().forEach { level ->
+            LoggingLevel.entries.forEach { level ->
                 sendLoggingMessage(
                     LoggingMessageNotification(
                         LoggingMessageNotificationParams(
@@ -105,7 +105,7 @@ class LoggingIntegrationTestStreamableHttp : KotlinTestBase() {
 
         client.callTool(CallToolRequest(CallToolRequestParams("test-logging-level")))
 
-        val expectedLevels = LoggingLevel.values().filter { it >= LoggingLevel.Warning }
+        val expectedLevels = LoggingLevel.entries.filter { it >= LoggingLevel.Warning }
         // wait for expected notifications to arrive (transport may deliver asynchronously)
         withTimeout(2000) {
             while (receivedMessages.size < expectedLevels.size) {