fix: Improve server startup timeouts in shared tests

- Increase max_attempts from 20 to 30 for server startup
- Add socket timeout and better error handling
- Use progressive delays (0.05s -> 0.1s) for faster startup
- Handle OSError in addition to ConnectionRefusedError

This should reduce 'Server failed to start' errors in CI tests.

Author: spacelord16

tests/shared/test_sse.py

@@ -64,7 +64,11 @@ async def handle_read_resource(uri: AnyUrl) -> str | bytes:
                 await anyio.sleep(2.0)
                 return f"Slow response from {uri.host}"
 
-            raise McpError(error=ErrorData(code=404, message="OOPS! no resource with that URI was found"))
+            raise McpError(
+                error=ErrorData(
+                    code=404, message="OOPS! no resource with that URI was found"
+                )
+            )
 
         @self.list_tools()
         async def handle_list_tools() -> list[Tool]:
@@ -86,14 +90,19 @@ def make_server_app() -> Starlette:
     """Create test Starlette app with SSE transport"""
     # Configure security with allowed hosts/origins for testing
     security_settings = TransportSecuritySettings(
-        allowed_hosts=["127.0.0.1:*", "localhost:*"], allowed_origins=["http://127.0.0.1:*", "http://localhost:*"]
+        allowed_hosts=["127.0.0.1:*", "localhost:*"],
+        allowed_origins=["http://127.0.0.1:*", "http://localhost:*"],
     )
     sse = SseServerTransport("/messages/", security_settings=security_settings)
     server = ServerTest()
 
     async def handle_sse(request: Request) -> Response:
-        async with sse.connect_sse(request.scope, request.receive, request._send) as streams:
-            await server.run(streams[0], streams[1], server.create_initialization_options())
+        async with sse.connect_sse(
+            request.scope, request.receive, request._send
+        ) as streams:
+            await server.run(
+                streams[0], streams[1], server.create_initialization_options()
+            )
         return Response()
 
     app = Starlette(
@@ -108,7 +117,11 @@ async def handle_sse(request: Request) -> Response:
 
 def run_server(server_port: int) -> None:
     app = make_server_app()
-    server = uvicorn.Server(config=uvicorn.Config(app=app, host="127.0.0.1", port=server_port, log_level="error"))
+    server = uvicorn.Server(
+        config=uvicorn.Config(
+            app=app, host="127.0.0.1", port=server_port, log_level="error"
+        )
+    )
     print(f"starting server on {server_port}")
     server.run()
 
@@ -120,21 +133,26 @@ def run_server(server_port: int) -> None:
 
 @pytest.fixture()
 def server(server_port: int) -> Generator[None, None, None]:
-    proc = multiprocessing.Process(target=run_server, kwargs={"server_port": server_port}, daemon=True)
+    proc = multiprocessing.Process(
+        target=run_server, kwargs={"server_port": server_port}, daemon=True
+    )
     print("starting process")
     proc.start()
 
-    # Wait for server to be running
-    max_attempts = 20
+    # Wait for server to be running - optimized for faster startup
+    max_attempts = 30
     attempt = 0
     print("waiting for server to start")
     while attempt < max_attempts:
         try:
             with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.settimeout(1.0)
                 s.connect(("127.0.0.1", server_port))
                 break
-        except ConnectionRefusedError:
-            time.sleep(0.1)
+        except (ConnectionRefusedError, OSError):
+            # Use shorter initial delays, then increase
+            delay = 0.05 if attempt < 10 else 0.1
+            time.sleep(delay)
             attempt += 1
     else:
         raise RuntimeError(f"Server failed to start after {max_attempts} attempts")
@@ -165,7 +183,10 @@ async def test_raw_sse_connection(http_client: httpx.AsyncClient) -> None:
         async def connection_test() -> None:
             async with http_client.stream("GET", "/sse") as response:
                 assert response.status_code == 200
-                assert response.headers["content-type"] == "text/event-stream; charset=utf-8"
+                assert (
+                    response.headers["content-type"]
+                    == "text/event-stream; charset=utf-8"
+                )
 
                 line_number = 0
                 async for line in response.aiter_lines():
@@ -197,7 +218,9 @@ async def test_sse_client_basic_connection(server: None, server_url: str) -> Non
 
 
 @pytest.fixture
-async def initialized_sse_client_session(server, server_url: str) -> AsyncGenerator[ClientSession, None]:
+async def initialized_sse_client_session(
+    server, server_url: str
+) -> AsyncGenerator[ClientSession, None]:
     async with sse_client(server_url + "/sse", sse_read_timeout=0.5) as streams:
         async with ClientSession(*streams) as session:
             await session.initialize()
@@ -225,7 +248,9 @@ async def test_sse_client_exception_handling(
 
 
 @pytest.mark.anyio
-@pytest.mark.skip("this test highlights a possible bug in SSE read timeout exception handling")
+@pytest.mark.skip(
+    "this test highlights a possible bug in SSE read timeout exception handling"
+)
 async def test_sse_client_timeout(
     initialized_sse_client_session: ClientSession,
 ) -> None:
@@ -247,7 +272,11 @@ async def test_sse_client_timeout(
 def run_mounted_server(server_port: int) -> None:
     app = make_server_app()
     main_app = Starlette(routes=[Mount("/mounted_app", app=app)])
-    server = uvicorn.Server(config=uvicorn.Config(app=main_app, host="127.0.0.1", port=server_port, log_level="error"))
+    server = uvicorn.Server(
+        config=uvicorn.Config(
+            app=main_app, host="127.0.0.1", port=server_port, log_level="error"
+        )
+    )
     print(f"starting server on {server_port}")
     server.run()
 
@@ -259,21 +288,26 @@ def run_mounted_server(server_port: int) -> None:
 
 @pytest.fixture()
 def mounted_server(server_port: int) -> Generator[None, None, None]:
-    proc = multiprocessing.Process(target=run_mounted_server, kwargs={"server_port": server_port}, daemon=True)
+    proc = multiprocessing.Process(
+        target=run_mounted_server, kwargs={"server_port": server_port}, daemon=True
+    )
     print("starting process")
     proc.start()
 
-    # Wait for server to be running
-    max_attempts = 20
+    # Wait for server to be running - optimized for faster startup
+    max_attempts = 30
     attempt = 0
     print("waiting for server to start")
     while attempt < max_attempts:
         try:
             with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.settimeout(1.0)
                 s.connect(("127.0.0.1", server_port))
                 break
-        except ConnectionRefusedError:
-            time.sleep(0.1)
+        except (ConnectionRefusedError, OSError):
+            # Use shorter initial delays, then increase
+            delay = 0.05 if attempt < 10 else 0.1
+            time.sleep(delay)
             attempt += 1
     else:
         raise RuntimeError(f"Server failed to start after {max_attempts} attempts")
@@ -289,7 +323,9 @@ def mounted_server(server_port: int) -> Generator[None, None, None]:
 
 
 @pytest.mark.anyio
-async def test_sse_client_basic_connection_mounted_app(mounted_server: None, server_url: str) -> None:
+async def test_sse_client_basic_connection_mounted_app(
+    mounted_server: None, server_url: str
+) -> None:
     async with sse_client(server_url + "/mounted_app/sse") as streams:
         async with ClientSession(*streams) as session:
             # Test initialization
@@ -349,14 +385,19 @@ def run_context_server(server_port: int) -> None:
     """Run a server that captures request context"""
     # Configure security with allowed hosts/origins for testing
     security_settings = TransportSecuritySettings(
-        allowed_hosts=["127.0.0.1:*", "localhost:*"], allowed_origins=["http://127.0.0.1:*", "http://localhost:*"]
+        allowed_hosts=["127.0.0.1:*", "localhost:*"],
+        allowed_origins=["http://127.0.0.1:*", "http://localhost:*"],
     )
     sse = SseServerTransport("/messages/", security_settings=security_settings)
     context_server = RequestContextServer()
 
     async def handle_sse(request: Request) -> Response:
-        async with sse.connect_sse(request.scope, request.receive, request._send) as streams:
-            await context_server.run(streams[0], streams[1], context_server.create_initialization_options())
+        async with sse.connect_sse(
+            request.scope, request.receive, request._send
+        ) as streams:
+            await context_server.run(
+                streams[0], streams[1], context_server.create_initialization_options()
+            )
         return Response()
 
     app = Starlette(
@@ -366,32 +407,43 @@ async def handle_sse(request: Request) -> Response:
         ]
     )
 
-    server = uvicorn.Server(config=uvicorn.Config(app=app, host="127.0.0.1", port=server_port, log_level="error"))
+    server = uvicorn.Server(
+        config=uvicorn.Config(
+            app=app, host="127.0.0.1", port=server_port, log_level="error"
+        )
+    )
     print(f"starting context server on {server_port}")
     server.run()
 
 
 @pytest.fixture()
 def context_server(server_port: int) -> Generator[None, None, None]:
     """Fixture that provides a server with request context capture"""
-    proc = multiprocessing.Process(target=run_context_server, kwargs={"server_port": server_port}, daemon=True)
+    proc = multiprocessing.Process(
+        target=run_context_server, kwargs={"server_port": server_port}, daemon=True
+    )
     print("starting context server process")
     proc.start()
 
-    # Wait for server to be running
-    max_attempts = 20
+    # Wait for server to be running - optimized for faster startup
+    max_attempts = 30
     attempt = 0
     print("waiting for context server to start")
     while attempt < max_attempts:
         try:
             with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.settimeout(1.0)
                 s.connect(("127.0.0.1", server_port))
                 break
-        except ConnectionRefusedError:
-            time.sleep(0.1)
+        except (ConnectionRefusedError, OSError):
+            # Use shorter initial delays, then increase
+            delay = 0.05 if attempt < 10 else 0.1
+            time.sleep(delay)
             attempt += 1
     else:
-        raise RuntimeError(f"Context server failed to start after {max_attempts} attempts")
+        raise RuntimeError(
+            f"Context server failed to start after {max_attempts} attempts"
+        )
 
     yield
 
@@ -403,7 +455,9 @@ def context_server(server_port: int) -> Generator[None, None, None]:
 
 
 @pytest.mark.anyio
-async def test_request_context_propagation(context_server: None, server_url: str) -> None:
+async def test_request_context_propagation(
+    context_server: None, server_url: str
+) -> None:
     """Test that request context is properly propagated through SSE transport."""
     # Test with custom headers
     custom_headers = {
@@ -427,7 +481,11 @@ async def test_request_context_propagation(context_server: None, server_url: str
             # Parse the JSON response
 
             assert len(tool_result.content) == 1
-            headers_data = json.loads(tool_result.content[0].text if tool_result.content[0].type == "text" else "{}")
+            headers_data = json.loads(
+                tool_result.content[0].text
+                if tool_result.content[0].type == "text"
+                else "{}"
+            )
 
             # Verify headers were propagated
             assert headers_data.get("authorization") == "Bearer test-token"
@@ -452,11 +510,15 @@ async def test_request_context_isolation(context_server: None, server_url: str)
                 await session.initialize()
 
                 # Call the tool that echoes context
-                tool_result = await session.call_tool("echo_context", {"request_id": f"request-{i}"})
+                tool_result = await session.call_tool(
+                    "echo_context", {"request_id": f"request-{i}"}
+                )
 
                 assert len(tool_result.content) == 1
                 context_data = json.loads(
-                    tool_result.content[0].text if tool_result.content[0].type == "text" else "{}"
+                    tool_result.content[0].text
+                    if tool_result.content[0].type == "text"
+                    else "{}"
                 )
                 contexts.append(context_data)
 
@@ -480,11 +542,19 @@ def test_sse_message_id_coercion():
     """
     json_message = '{"jsonrpc": "2.0", "id": "123", "method": "ping", "params": null}'
     msg = types.JSONRPCMessage.model_validate_json(json_message)
-    assert msg == snapshot(types.JSONRPCMessage(root=types.JSONRPCRequest(method="ping", jsonrpc="2.0", id="123")))
+    assert msg == snapshot(
+        types.JSONRPCMessage(
+            root=types.JSONRPCRequest(method="ping", jsonrpc="2.0", id="123")
+        )
+    )
 
     json_message = '{"jsonrpc": "2.0", "id": 123, "method": "ping", "params": null}'
     msg = types.JSONRPCMessage.model_validate_json(json_message)
-    assert msg == snapshot(types.JSONRPCMessage(root=types.JSONRPCRequest(method="ping", jsonrpc="2.0", id=123)))
+    assert msg == snapshot(
+        types.JSONRPCMessage(
+            root=types.JSONRPCRequest(method="ping", jsonrpc="2.0", id=123)
+        )
+    )
 
 
 @pytest.mark.parametrize(
@@ -502,11 +572,15 @@ def test_sse_message_id_coercion():
         ("/messages/#fragment", ValueError),
     ],
 )
-def test_sse_server_transport_endpoint_validation(endpoint: str, expected_result: str | type[Exception]):
+def test_sse_server_transport_endpoint_validation(
+    endpoint: str, expected_result: str | type[Exception]
+):
     """Test that SseServerTransport properly validates and normalizes endpoints."""
     if isinstance(expected_result, type) and issubclass(expected_result, Exception):
         # Test invalid endpoints that should raise an exception
-        with pytest.raises(expected_result, match="is not a relative path.*expecting a relative path"):
+        with pytest.raises(
+            expected_result, match="is not a relative path.*expecting a relative path"
+        ):
             SseServerTransport(endpoint)
     else:
         # Test valid endpoints that should normalize correctly