fix(ci, test): Resolve CI failures and hanging SSE transport test

This commit addresses two issues:

1.  Fixes GitHub Actions CI workflow failures (exit code 127) by switching dependency installation from `uv` to standard `pip`, ensuring `pytest` is found.
2.  Resolves a hanging test (`test_sse_route_connection` in `tests/test_sse_transport.py`) by refactoring it to call the `handle_sse` coroutine directly with a mocked Request object, bypassing the problematic `TestClient.stream()` or `TestClient.get()` interaction.

With these changes, the CI pipeline and the test suite now complete successfully. The CHANGELOG.md has been updated.

Author: jbeno

.github/workflows/ci.yml

@@ -21,15 +21,12 @@ jobs:
       with:
         python-version: ${{ matrix.python-version }}
 
-    - name: Install uv
-      run: curl -LsSf https://astral.sh/uv/install.sh | sh
-
-    - name: Install dependencies
-      run: ~/.cargo/bin/uv pip install -e ".[dev]"
-      # Use pip if you prefer: 
-      # run: |
-      #   python -m pip install --upgrade pip
-      #   pip install -e ".[dev]"
+    - name: Install dependencies using pip
+      # run: ~/.cargo/bin/uv pip install -e ".[dev]" # Use pip instead
+      # Use pip (standard method)
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e ".[dev]"
 
     - name: Test with pytest
       run: python -m pytest

CHANGELOG.md

@@ -5,7 +5,7 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.2.3] - 2025-04-19
+## [0.2.3] - 2025-04-20
 
 ### Added
 - CI workflow using GitHub Actions (`.github/workflows/ci.yml`) to run tests on Python 3.9 and 3.12.
@@ -31,6 +31,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Multiple test failures related to incorrect mocking, error expectations, path handling, test setup, and imports (`StringIO`, `FastMCP`).
 - Invalid escape sequence in `pyproject.toml` coverage exclusion pattern.
 - Several issues in SSE transport (`sse_transport.py`) related to refactoring, including incorrect `SseServerTransport` initialization, missing `/messages` route handling, and incorrect parameters passed to the underlying `mcp.server.Server.run` method, causing connection failures.
+- GitHub Actions CI workflow failure (exit code 127) by switching dependency installation from `uv` to standard `pip` to ensure `pytest` is found.
+- Hanging test (`test_sse_route_connection` in `tests/test_sse_transport.py`) by refactoring to call the handler directly with a mock request instead of using `TestClient`.
 
 ## [0.2.2] - 2025-04-19
 

tests/test_sse_transport.py

@@ -49,56 +49,69 @@ def test_root_route(dummy_server_config):
 
 @pytest.mark.asyncio
 async def test_sse_route_connection(dummy_server_config):
-    """Test that connecting to /sse triggers MCP connection logic."""
-    # Mock the FastMCP instance and its underlying server's run method
-    mock_mcp_internal_server = mock.AsyncMock()
-    mock_mcp = mock.Mock(spec=FastMCP)
-    mock_mcp._mcp_server = mock.Mock()
-    mock_mcp._mcp_server.run = mock_mcp_internal_server # Mock the run method
+    """Test that handle_sse calls dependencies correctly."""
+    # --- Mocks Setup ---
+    # Mock the underlying Server.run method
+    mock_internal_run = mock.AsyncMock()
+    # Mock the underlying Server.create_initialization_options method
+    mock_init_options = mock.Mock(name="InitializationOptionsMock")
+    mock_create_options = mock.Mock(return_value=mock_init_options)
+    # Mock the underlying Server instance
+    mock_underlying_server = mock.Mock()
+    mock_underlying_server.run = mock_internal_run
+    mock_underlying_server.create_initialization_options = mock_create_options
+    # Mock the FastMCP wrapper instance
+    mock_mcp_wrapper = mock.Mock(spec=FastMCP)
+    mock_mcp_wrapper._mcp_server = mock_underlying_server # Link wrapper to underlying mock
 
-    # Mock the SseServerTransport.connect_sse context manager
-    # It needs to yield mock stream objects
+    # Mock the streams that connect_sse yields
     mock_read_stream = mock.AsyncMock()
     mock_write_stream = mock.AsyncMock()
+    
+    # Mock the connect_sse async context manager
     mock_connect_sse_cm = mock.AsyncMock()
     mock_connect_sse_cm.__aenter__.return_value = (mock_read_stream, mock_write_stream)
+    
+    # Mock the SseServerTransport instance 
+    mock_transport_instance = mock.Mock(spec=SseServerTransport)
+    mock_transport_instance.connect_sse.return_value = mock_connect_sse_cm
+    
+    # --- Create Mock Request and Call Handler Directly ---
+    # Mock the Starlette Request object
+    mock_request = mock.AsyncMock()
+    # Mock app state attached to the request
+    mock_request.app = mock.Mock()
+    mock_request.app.state = mock.Mock()
+    mock_request.app.state.mcp_server = mock_mcp_wrapper
+    mock_request.app.state.sse_transport = mock_transport_instance
+    mock_request.app.state.config = dummy_server_config # Include config if needed by handler
+    # Mock client info if needed for logging within handler
+    mock_request.client = mock.Mock()
+    mock_request.client.host = "127.0.0.1"
+    mock_request.client.port = 12345
+    # Mock ASGI scope/receive/send if connect_sse needs them (it does)
+    mock_request.scope = {}
+    mock_request.receive = mock.AsyncMock()
+    mock_request._send = mock.AsyncMock() # Note: _send is often used internally
 
-    app = sse_transport.create_starlette_app(mock_mcp, dummy_server_config)
-    client = TestClient(app)
-
-    # Patch the SseServerTransport directly where it's used in handle_sse
-    with mock.patch('cursor_notebook_mcp.sse_transport.SseServerTransport') as MockTransportClass:
-        # Configure the instance's connect_sse method
-        mock_transport_instance = MockTransportClass.return_value
-        mock_transport_instance.connect_sse.return_value = mock_connect_sse_cm
-        
-        # Simulate connecting to the SSE endpoint
-        # TestClient doesn't fully support SSE streaming tests easily,
-        # but we can verify the setup calls happen.
-        # We expect the connection setup to proceed, calling connect_sse and then run.
-        # Making a simple GET might not be enough, POST is often used for MCP init.
-        # Let's try GET and see if connect_sse is called.
-        try:
-            # Use stream=True to mimic connection attempt, though full SSE isn't tested
-            # We expect Starlette to handle the request and call our handler
-             with client.stream("GET", "/sse") as response:
-                 # We don't need to consume the stream, just check mocks
-                 pass 
-        except Exception as e:
-             # Ignore potential exceptions during stream handling in TestClient
-             # as we are only checking mock calls
-             print(f"Ignoring TestClient stream exception: {e}")
-             pass
+    # Call the handler directly
+    await sse_transport.handle_sse(mock_request)
 
-        # Assertions
-        MockTransportClass.assert_called_once() # Was SseServerTransport instantiated?
-        mock_transport_instance.connect_sse.assert_called_once() # Was connect_sse called?
-        # Assert that the MCP server's run method was called via the transport
-        mock_mcp_internal_server.assert_awaited_once_with(
-            transport='stream', 
-            read_stream=mock_read_stream, 
-            write_stream=mock_write_stream
-        )
+    # --- Assertions ---
+    # Check connect_sse was called on the transport instance with ASGI args
+    mock_transport_instance.connect_sse.assert_called_once_with(
+        mock_request.scope, mock_request.receive, mock_request._send
+    )
+    
+    # Check create_initialization_options was called on the underlying server
+    mock_create_options.assert_called_once()
+    
+    # Check run was called on the underlying server with correct arguments
+    mock_internal_run.assert_awaited_once_with(
+        read_stream=mock_read_stream, 
+        write_stream=mock_write_stream,
+        initialization_options=mock_init_options
+    )
 
 # TODO: Add tests for error handling in run_sse_server