Add dedicated tests for SSE mount_path functionality

Add tests that verify the integration between FastMCP mount paths and SSE endpoints:
- Test SseServerTransport initialization with different endpoints
- Test FastMCP and SseServerTransport integration with various mount paths
- Test session URI construction with different mount paths and URL encoding

These tests verify that the normalized message endpoint is correctly passed
to SseServerTransport and used to generate proper session URIs.

Author: tim-watcha

tests/server/sse/test_sse_mount_path.py

@@ -0,0 +1,111 @@
+import pytest
+from starlette.applications import Starlette
+from starlette.routing import Mount, Route
+from urllib.parse import quote
+from uuid import UUID, uuid4
+from unittest.mock import patch
+
+from mcp.server.fastmcp import FastMCP
+from mcp.server.sse import SseServerTransport
+
+
+class TestSSEWithMountPath:
+    def test_sse_transport_endpoint_formation(self):
+        """Test that SseServerTransport correctly initializes with different endpoints.
+
+        This test verifies that the SSE transport correctly stores the endpoint
+        passed to its constructor, which will be used to build the session URI.
+        """
+        # Test with root endpoint
+        transport1 = SseServerTransport("/messages/")
+        assert transport1._endpoint == "/messages/"
+
+        # Test with custom endpoint
+        transport2 = SseServerTransport("/api/messages/")
+        assert transport2._endpoint == "/api/messages/"
+
+        # Test with normalized path from FastMCP
+        mcp = FastMCP()
+        normalized_endpoint = mcp._normalize_path("/github", "/messages/")
+        transport3 = SseServerTransport(normalized_endpoint)
+        assert transport3._endpoint == "/github/messages/"
+
+    def test_fastmcp_sse_transport_integration(self):
+        """Test the integration between FastMCP and SseServerTransport with mount paths.
+
+        Verifies that FastMCP correctly generates normalized endpoints based on mount_path
+        settings and passes them to the SseServerTransport.
+        """
+        # Test cases with different mount path configurations
+        test_cases = [
+            # (mount_path, expected_normalized_endpoint)
+            ("/", "/messages/"),
+            ("/api", "/api/messages/"),
+            ("/github", "/github/messages/"),
+            ("/custom/path", "/custom/path/messages/"),
+        ]
+
+        for mount_path, expected_endpoint in test_cases:
+            # Create FastMCP with the specified mount path
+            mcp = FastMCP()
+            mcp.settings.mount_path = mount_path
+
+            # Generate the normalized endpoint
+            normalized_endpoint = mcp._normalize_path(mount_path, "/messages/")
+
+            # Verify the normalized endpoint matches expectations
+            assert normalized_endpoint == expected_endpoint
+
+            # Create app and verify mount_path setting is preserved or updated
+            app = mcp.sse_app()
+            assert mcp.settings.mount_path == mount_path
+
+            # Test with direct mount_path parameter
+            mcp2 = FastMCP()
+            app2 = mcp2.sse_app(mount_path=mount_path)
+
+            # Verify the mount_path was correctly set in settings
+            assert mcp2.settings.mount_path == mount_path
+
+    def test_sse_session_uri_construction(self):
+        """Test that session_uri is correctly constructed for different mount paths.
+
+        This test verifies that the session URI is properly constructed and URL-encoded
+        when using different mount paths. The session URI is used by clients to
+        connect to the correct SSE endpoint.
+        """
+        # Use a fixed UUID for consistent testing
+        test_uuid = uuid4()
+
+        # Test cases with different endpoints and expected URL-encoded prefixes
+        test_cases = [
+            # (endpoint, expected_session_uri_prefix)
+            ("/messages/", quote("/messages/")),
+            ("/api/messages/", quote("/api/messages/")),
+            ("/github/messages/", quote("/github/messages/")),
+            # Verify with normalized paths from FastMCP
+            (
+                FastMCP()._normalize_path("/github", "/messages/"),
+                quote("/github/messages/"),
+            ),
+            (
+                FastMCP()._normalize_path("/custom/path", "/messages/"),
+                quote("/custom/path/messages/"),
+            ),
+        ]
+
+        with patch("uuid.uuid4", return_value=test_uuid):
+            for endpoint, expected_encoded_prefix in test_cases:
+                # Create SSE transport with the endpoint
+                transport = SseServerTransport(endpoint)
+
+                # Manually construct the session_uri as done in connect_sse
+                session_uri = f"{quote(endpoint)}?session_id={test_uuid.hex}"
+
+                # Verify session_uri format
+                assert session_uri.startswith(expected_encoded_prefix)
+                assert session_uri.endswith(f"?session_id={test_uuid.hex}")
+
+                # Complete URI validation
+                expected_uri = f"{quote(endpoint)}?session_id={test_uuid.hex}"
+                assert session_uri == expected_uri