Update tests to cover all new features

- Updated test cases in `ToolsListHandlerTest`, `ResourcesReadHandlerTest`, and `MCPProtocolTest` to include `clientId` in handler method calls.
- Adjusted `StreamableHttpControllerTest` and related assertions to reflect new streaming response behavior.
- Enhanced `StreamableHttpTransportTest` to verify SSE output generation.
- Updated `TestMcpToolCommandTest` to validate `TextToolResult` usage and enhanced test coverage for result display logic.

Author: klapaudius

tests/Command/TestMcpToolCommandTest.php

@@ -2,11 +2,10 @@
 
 namespace KLP\KlpMcpServer\Tests\Controllers;
 
-use Exception;
-use JsonException;
 use KLP\KlpMcpServer\Controllers\StreamableHttpController;
 use KLP\KlpMcpServer\Protocol\MCPProtocolInterface;
 use KLP\KlpMcpServer\Server\MCPServerInterface;
+use KLP\KlpMcpServer\Transports\Exception\StreamableHttpTransportException;
 use PHPUnit\Framework\Attributes\Small;
 use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
@@ -53,7 +52,6 @@ public function test_handle_with_post_request(): void
         // Create a POST request with some content
         $clientId = 'test-client-id';
         $message = ['jsonrpc' => '2.0', 'method' => 'test', 'params' => [], 'id' => 1];
-        $responseResult = [['jsonrpc' => '2.0', 'result' => 'success', 'id' => 1]];
 
         $request = new Request(
             [], // query parameters
@@ -76,17 +74,19 @@ public function test_handle_with_post_request(): void
             ->method('requestMessage')
             ->with($clientId, $message);
 
-        $this->mockServer->expects($this->once())
-            ->method('getResponseResult')
-            ->with($clientId)
-            ->willReturn($responseResult);
-
         // Call handle() which should internally call postHandle()
         $response = $this->controller->handle($request);
 
         // Verify the response is what we expect from postHandle()
-        $this->assertInstanceOf(JsonResponse::class, $response);
-        $this->assertEquals($responseResult[0], json_decode($response->getContent(), true));
+        $this->assertInstanceOf(StreamedResponse::class, $response);
+        $this->assertEquals('text/event-stream', $response->headers->get('Content-Type'));
+        $this->assertEquals('no-cache, private', $response->headers->get('Cache-Control'));
+        $this->assertEquals('no', $response->headers->get('X-Accel-Buffering'));
+
+        // Execute the streamed response to trigger the callback
+        ob_start();
+        $response->sendContent();
+        ob_end_clean();
     }
 
     public function test_gethandle(): void
@@ -109,7 +109,6 @@ public function test_postHandle_with_single_message(): void
         $clientId = 'test-client-id';
         // The controller checks for 'jsonrpc' key to determine if it's a single message
         $message = ['jsonrpc' => '2.0', 'method' => 'test', 'params' => [], 'id' => 1];
-        $responseResult = [['jsonrpc' => '2.0', 'result' => 'success', 'id' => 1]];
 
         // Create request with headers and content
         $request = new Request(
@@ -135,27 +134,22 @@ public function test_postHandle_with_single_message(): void
         $this->mockServer->expects($this->once())
             ->method('requestMessage');
 
-        $this->mockServer->expects($this->once())
-            ->method('getResponseResult')
-            ->willReturn($responseResult);
-
         // Set up logger mock expectations - we can't be too specific about the parameters
         $this->mockLogger->expects($this->atLeastOnce())
             ->method('debug');
 
         // Call the method and verify response
         $response = $this->controller->postHandle($request);
 
-        $this->assertInstanceOf(JsonResponse::class, $response);
+        $this->assertInstanceOf(StreamedResponse::class, $response);
+        $this->assertEquals('text/event-stream', $response->headers->get('Content-Type'));
+        $this->assertEquals('no-cache, private', $response->headers->get('Cache-Control'));
+        $this->assertEquals('no', $response->headers->get('X-Accel-Buffering'));
 
-        // Instead of checking the exact content, just verify it's a valid JSON response
-        $content = json_decode($response->getContent(), true);
-        $this->assertIsArray($content);
-        // The response might have either 'jsonrpc' or 'jsonrpc' key depending on the implementation
-        $this->assertTrue(
-            isset($content['jsonrpc']) || isset($content['jsonrpc']),
-            'Response should have either jsonrpc or jsonrpc key'
-        );
+        // Execute the streamed response to trigger the callback
+        ob_start();
+        $response->sendContent();
+        ob_end_clean();
     }
 
     public function test_postHandle_with_multiple_messages(): void
@@ -197,7 +191,7 @@ public function test_postHandle_with_multiple_messages(): void
                 return true;
             }));
 
-        $this->mockServer->expects($this->once())
+        $this->mockServer->expects($this->never())
             ->method('connect');
 
         // Set up logger mock expectations
@@ -224,7 +218,6 @@ public function test_postHandle_with_fallback_client_id(): void
     {
         $clientId = 'fallback-client-id';
         $message = ['jsonrpc' => '2.0', 'method' => 'test', 'params' => [], 'id' => 1];
-        $responseResult = [['jsonrpc' => '2.0', 'result' => 'success', 'id' => 1]];
 
         // Create request without mcp-session-id header
         $request = new Request(
@@ -250,16 +243,18 @@ public function test_postHandle_with_fallback_client_id(): void
             ->method('requestMessage')
             ->with($clientId, $message);
 
-        $this->mockServer->expects($this->once())
-            ->method('getResponseResult')
-            ->with($clientId)
-            ->willReturn($responseResult);
-
         // Call the method and verify response
         $response = $this->controller->postHandle($request);
 
-        $this->assertInstanceOf(JsonResponse::class, $response);
-        $this->assertEquals($responseResult[0], json_decode($response->getContent(), true));
+        $this->assertInstanceOf(StreamedResponse::class, $response);
+        $this->assertEquals('text/event-stream', $response->headers->get('Content-Type'));
+        $this->assertEquals('no-cache, private', $response->headers->get('Cache-Control'));
+        $this->assertEquals('no', $response->headers->get('X-Accel-Buffering'));
+
+        // Execute the streamed response to trigger the callback
+        ob_start();
+        $response->sendContent();
+        ob_end_clean();
     }
 
     public function test_postHandle_with_json_parse_error(): void
@@ -303,30 +298,37 @@ public function test_postHandle_with_general_exception(): void
         );
         $request->headers->set('mcp-session-id', $clientId);
 
-        // Set up server mock to return a result that will trigger the exception
+        // Set up server mock to throw an exception
         $this->mockServer->expects($this->once())
             ->method('setProtocolVersion')
             ->with(MCPProtocolInterface::PROTOCOL_VERSION_STREAMABE_HTTP);
 
         $this->mockServer->expects($this->once())
             ->method('requestMessage')
-            ->with($clientId, $message);
-
-        // Return an empty array to trigger the "Result is not an array" exception
-        // The controller checks for !isset($result[0])
-        $this->mockServer->expects($this->once())
-            ->method('getResponseResult')
-            ->with($clientId)
-            ->willReturn([]);
+            ->with($clientId, $message)
+            ->willThrowException(new StreamableHttpTransportException('Test exception'));
 
         // Call the method and verify response
         $response = $this->controller->postHandle($request);
 
-        $this->assertInstanceOf(JsonResponse::class, $response);
-        $this->assertEquals(400, $response->getStatusCode());
-        $this->assertEquals(
-            ['jsonrpc' => 2.0, 'error' => ['code' => -32700, 'message' => 'Result is not an array']],
-            json_decode($response->getContent(), true)
-        );
+        // The response is still a StreamedResponse because exceptions in callbacks are not caught
+        $this->assertInstanceOf(StreamedResponse::class, $response);
+        $this->assertEquals('text/event-stream', $response->headers->get('Content-Type'));
+        $this->assertEquals('no-cache, private', $response->headers->get('Cache-Control'));
+        $this->assertEquals('no', $response->headers->get('X-Accel-Buffering'));
+
+        // The exception will be thrown when the callback is executed
+        $this->expectException(StreamableHttpTransportException::class);
+        $this->expectExceptionMessage('Test exception');
+
+        try {
+            ob_start();
+            $response->sendContent();
+        } finally {
+            // Always clean up the output buffer, even if an exception is thrown
+            if (ob_get_level() > 0) {
+                ob_end_clean();
+            }
+        }
     }
 }

tests/Controllers/StreamableHttpControllerTest.php

@@ -237,7 +237,7 @@ public function test_handle_message_handles_valid_request(): void
 
         $mockHandler = $this->createMock(\KLP\KlpMcpServer\Protocol\Handlers\RequestHandler::class);
         $mockHandler->method('isHandle')->with('test.method')->willReturn(true);
-        $mockHandler->method('execute')->with('test.method', 1, ['param1' => 'value1'])->willReturn(['response' => 'ok']);
+        $mockHandler->method('execute')->with('test.method', $clientId, 1, ['param1' => 'value1'])->willReturn(['response' => 'ok']);
         $this->mcpProtocol->registerRequestHandler($mockHandler);
 
         $this->mockTransport
@@ -368,7 +368,7 @@ public function test_handle_message_handles_invalid_params(): void
 
         $mockHandler = $this->createMock(\KLP\KlpMcpServer\Protocol\Handlers\RequestHandler::class);
         $mockHandler->method('isHandle')->with('test.method')->willReturn(true);
-        $mockHandler->method('execute')->with('test.method', 1, ['param1' => 'invalid'])
+        $mockHandler->method('execute')->with('test.method', $clientId, 1, ['param1' => 'invalid'])
             ->willThrowException(new ToolParamsValidatorException('An error occurred.', ['Invalid params param1']));
 
         $this->mockTransport
@@ -397,7 +397,7 @@ public function test_handle_message_handles_handler_throw_exception(): void
         $invalidParamsMessage = ['jsonrpc' => '2.0', 'id' => 1, 'method' => 'test.method', 'params' => ['param1' => 'invalid']];
         $mockHandler = $this->createMock(\KLP\KlpMcpServer\Protocol\Handlers\RequestHandler::class);
         $mockHandler->method('isHandle')->with('test.method')->willReturn(true);
-        $mockHandler->method('execute')->with('test.method', 1, ['param1' => 'invalid'])
+        $mockHandler->method('execute')->with('test.method', $clientId, 1, ['param1' => 'invalid'])
             ->willThrowException(new \Exception('An error occurred.'));
 
         $this->mockTransport

tests/Protocol/MCPProtocolTest.php

@@ -15,6 +15,7 @@
 use KLP\KlpMcpServer\Server\Request\ToolsListHandler;
 use KLP\KlpMcpServer\Server\ServerCapabilities;
 use KLP\KlpMcpServer\Server\ServerCapabilitiesInterface;
+use KLP\KlpMcpServer\Services\ProgressService\ProgressNotifierRepository;
 use KLP\KlpMcpServer\Services\ResourceService\ResourceRepository;
 use KLP\KlpMcpServer\Services\ToolService\ToolRepository;
 use PHPUnit\Framework\Attributes\Small;
@@ -33,9 +34,11 @@ public function test_register_tool_repository(): void
         $mockProtocol = $this->createMock(MCPProtocolInterface::class);
         $mockToolRepository = $this->createMock(ToolRepository::class);
 
+        $mockProgressNotifierRepository = $this->createMock(ProgressNotifierRepository::class);
+
         $invocations = [
             new ToolsListHandler($mockToolRepository),
-            new ToolsCallHandler($mockToolRepository),
+            new ToolsCallHandler($mockToolRepository, $mockProgressNotifierRepository),
         ];
         $mockProtocol->expects($matcher = $this->exactly(count($invocations)))
             ->method('registerRequestHandler')
@@ -49,6 +52,7 @@ public function test_register_tool_repository(): void
         $instance = $server->newInstanceWithoutConstructor();
         $server->getProperty('capabilities')->setValue($instance, new ServerCapabilities);
         $server->getProperty('protocol')->setValue($instance, $mockProtocol);
+        $server->getProperty('progressNotifierRepository')->setValue($instance, $mockProgressNotifierRepository);
 
         // Act
         $instance->registerToolRepository($mockToolRepository);
@@ -117,11 +121,13 @@ public function test_register_tool_repository_returns_instance(): void
         // Arrange
         $mockProtocol = $this->createMock(MCPProtocolInterface::class);
         $mockToolRepository = $this->createMock(ToolRepository::class);
+        $mockProgressNotifierRepository = $this->createMock(ProgressNotifierRepository::class);
 
         $server = new ReflectionClass(MCPServer::class);
         $instance = $server->newInstanceWithoutConstructor();
         $server->getProperty('capabilities')->setValue($instance, new ServerCapabilities);
         $server->getProperty('protocol')->setValue($instance, $mockProtocol);
+        $server->getProperty('progressNotifierRepository')->setValue($instance, $mockProgressNotifierRepository);
 
         // Act
         $result = $instance->registerToolRepository($mockToolRepository);
@@ -163,7 +169,8 @@ public function test_create(): void
         $version = '1.0';
 
         // Act
-        $server = MCPServer::create($mockProtocol, $name, $version);
+        $mockProgressNotifierRepository = $this->createMock(ProgressNotifierRepository::class);
+        $server = MCPServer::create($mockProtocol, $mockProgressNotifierRepository, $name, $version);
 
         // Assert
         $this->assertInstanceOf(MCPServer::class, $server);
@@ -183,7 +190,8 @@ public function test_create_with_capabilities(): void
         $mockCapabilities = $this->createMock(ServerCapabilitiesInterface::class);
 
         // Act
-        $server = MCPServer::create($mockProtocol, $name, $version, $mockCapabilities);
+        $mockProgressNotifierRepository = $this->createMock(ProgressNotifierRepository::class);
+        $server = MCPServer::create($mockProtocol, $mockProgressNotifierRepository, $name, $version, $mockCapabilities);
 
         // Assert
         $this->assertInstanceOf(MCPServer::class, $server);
@@ -421,7 +429,8 @@ public function test_initialize_sets_capabilities_and_marks_initialized(): void
             ->method('toInitializeMessage')
             ->willReturn(['mock-capability' => true]);
 
-        $server = MCPServer::create($mockProtocol, $serverInfo['name'], $serverInfo['version'], $mockCapabilities);
+        $mockProgressNotifierRepository = $this->createMock(ProgressNotifierRepository::class);
+        $server = MCPServer::create($mockProtocol, $mockProgressNotifierRepository, $serverInfo['name'], $serverInfo['version'], $mockCapabilities);
         $initializeData = new InitializeData('2.0', ['mock-capability' => true]);
 
         // Act
@@ -444,7 +453,8 @@ public function test_initialize_throws_when_already_initialized(): void
         $serverInfo = ['name' => 'TestServer', 'version' => '1.0'];
         $mockCapabilities = $this->createMock(ServerCapabilitiesInterface::class);
 
-        $server = MCPServer::create($mockProtocol, $serverInfo['name'], $serverInfo['version'], $mockCapabilities);
+        $mockProgressNotifierRepository = $this->createMock(ProgressNotifierRepository::class);
+        $server = MCPServer::create($mockProtocol, $mockProgressNotifierRepository, $serverInfo['name'], $serverInfo['version'], $mockCapabilities);
         $initializeData = new InitializeData('2.0', ['mock-capability' => true]);
 
         $server->initialize($initializeData);
@@ -476,7 +486,8 @@ public function test_initialize_returns_correct_resource(): void
             ->method('toInitializeMessage')
             ->willReturn(['mock-capability' => true]);
 
-        $server = MCPServer::create($mockProtocol, $serverInfo['name'], $serverInfo['version'], $mockCapabilities);
+        $mockProgressNotifierRepository = $this->createMock(ProgressNotifierRepository::class);
+        $server = MCPServer::create($mockProtocol, $mockProgressNotifierRepository, $serverInfo['name'], $serverInfo['version'], $mockCapabilities);
         $initializeData = new InitializeData('2024-11-05', ['mock-capability' => true]);
 
         // Act

tests/Server/MCPServerTest.php

@@ -4,8 +4,10 @@
 
 use KLP\KlpMcpServer\Server\Request\PingHandler;
 use KLP\KlpMcpServer\Transports\SseTransportInterface;
+use PHPUnit\Framework\Attributes\Small;
 use PHPUnit\Framework\TestCase;
 
+#[Small]
 class PingHandlerTest extends TestCase
 {
     private SseTransportInterface $transportMock;
@@ -29,6 +31,7 @@ public function test_execute_sends_correct_response(): void
     {
         $messageId = '12345';
         $method = 'ping';
+        $clientId = 'test-client';
         $params = null;
 
         // Expect the transport to send the correct response
@@ -37,7 +40,7 @@ public function test_execute_sends_correct_response(): void
             ->method('send')
             ->with($expectedResponse);
 
-        $result = $this->pingHandler->execute($method, $messageId, $params);
+        $result = $this->pingHandler->execute($method, $clientId, $messageId, $params);
 
         // Assert that the method returns an empty array
         $this->assertSame([], $result);

tests/Server/Request/PingHandlerTest.php

@@ -41,7 +41,7 @@ public function test_execute_returns_resource_schemas(): void
             ->method('getResourceSchemas')
             ->willReturn($expectedSchemas);
 
-        $result = $this->resourcesListHandler->execute('resources/list', 123);
+        $result = $this->resourcesListHandler->execute('resources/list', 'test-client', 123);
 
         $this->assertArrayHasKey('resources', $result);
         $this->assertEquals($expectedSchemas, $result['resources']);

tests/Server/Request/ResourcesListHandlerTest.php

@@ -42,7 +42,7 @@ public function test_execute_resource_found_with_text_mime_type(): void
             ->with('test-uri')
             ->willReturn($resourceMock);
 
-        $result = $this->handler->execute('resources/read', 123, ['uri' => 'test-uri']);
+        $result = $this->handler->execute('resources/read', 'test-client', 123, ['uri' => 'test-uri']);
 
         $this->assertEquals([
             'contents' => [
@@ -71,7 +71,7 @@ public function test_execute_resource_found_with_non_text_mime_type(): void
             ->with('image-uri')
             ->willReturn($resourceMock);
 
-        $result = $this->handler->execute('resources/read', 456, ['uri' => 'image-uri']);
+        $result = $this->handler->execute('resources/read', 'test-client', 456, ['uri' => 'image-uri']);
 
         $this->assertEquals([
             'contents' => [
@@ -94,7 +94,7 @@ public function test_execute_resource_not_found(): void
             ->with('unknown-uri')
             ->willReturn(null);
 
-        $result = $this->handler->execute('resources/read', 789, ['uri' => 'unknown-uri']);
+        $result = $this->handler->execute('resources/read', 'test-client', 789, ['uri' => 'unknown-uri']);
 
         $this->assertEquals([], $result);
     }