WIP

tests/client/test_sse_attempt.py

@@ -1,4 +1,5 @@
 import anyio
+import asyncio
 import pytest
 from starlette.applications import Starlette
 from starlette.routing import Mount, Route
@@ -24,32 +25,42 @@ async def sse_app(sse_transport):
     async def handle_sse(request):
         """Handler for SSE connections."""
         async def event_generator():
+            try:
+                async with sse_transport.connect_sse(
+                    request.scope, request.receive, request._send
+                ) as streams:
+                    client_to_server, server_to_client = streams
                     # Send initial connection event
                     yield {
                         "event": "endpoint",
                         "data": "/messages",
                     }
 
-            # Keep connection alive
+                    # Process messages
-            async with sse_transport.connect_sse(
+                    async with anyio.create_task_group() as tg:
-                request.scope, request.receive, request._send
+                        try:
-            ) as streams:
-                client_to_server, server_to_client = streams
                             async for message in client_to_server:
+                                if isinstance(message, Exception):
+                                    break
                                 yield {
                                     "event": "message",
                                     "data": message.model_dump_json(),
                                 }
+                        except (asyncio.CancelledError, GeneratorExit):
+                            print('cancelled')
+                            return
+                        except Exception as e:
+                            print("unhandled exception:", e)
+                            return
+            except Exception:
+                # Log any unexpected errors but allow connection to close gracefully
+                pass
 
         return EventSourceResponse(event_generator())
 
-    async def handle_post(request):
-        """Handler for POST messages."""
-        return Response(status_code=200)
-
     routes = [
         Route("/sse", endpoint=handle_sse),
-        Route("/messages", endpoint=handle_post, methods=["POST"]),
+        Mount("/messages", app=sse_transport.handle_post_message),
     ]
 
     return Starlette(routes=routes)
@@ -62,7 +73,7 @@ async def test_client(sse_app):
     async with httpx.AsyncClient(
         transport=transport,
         base_url="http://testserver",
-        timeout=5.0,
+        timeout=10.0,
     ) as client:
         yield client
 
@@ -70,13 +81,20 @@ async def test_client(sse_app):
 @pytest.mark.anyio
 async def test_sse_connection(test_client):
     """Test basic SSE connection and message exchange."""
+    async with anyio.create_task_group() as tg:
+        try:
             async with sse_client(
                 "http://testserver/sse",
                 headers={"Host": "testserver"},
-        timeout=2,
+                timeout=5,
-        sse_read_timeout=1,
+                sse_read_timeout=5,
                 client=test_client,
             ) as (read_stream, write_stream):
+                # First get the initial endpoint message
+                async with read_stream:
+                    init_message = await read_stream.__anext__()
+                    assert isinstance(init_message, JSONRPCMessage)
+
                 # Send a test message
                 test_message = JSONRPCMessage.model_validate({"jsonrpc": "2.0", "method": "test"})
                 await write_stream.send(test_message)
@@ -87,63 +105,69 @@ async def test_sse_connection(test_client):
                     assert isinstance(message, JSONRPCMessage)
                     assert message.model_dump() == test_message.model_dump()
 
-
+                # Explicitly close streams
-@pytest.mark.anyio
+                await write_stream.aclose()
-async def test_sse_read_timeout(test_client):
+                await read_stream.aclose()
-    """Test that SSE client properly handles read timeouts."""
+        except Exception as e:
-    with pytest.raises(ReadTimeout):
+            pytest.fail(f"Test failed with error: {str(e)}")
-        async with sse_client(
-            "http://testserver/sse",
-            headers={"Host": "testserver"},
-            timeout=2,
-            sse_read_timeout=1,
-            client=test_client,
-        ) as (read_stream, write_stream):
-            async with read_stream:
-                # This should timeout since no messages are being sent
-                await read_stream.__anext__()
 
 
-@pytest.mark.anyio
+# @pytest.mark.anyio
-async def test_sse_connection_error(test_client):
+# async def test_sse_read_timeout(test_client):
-    """Test SSE client behavior with connection errors."""
+#     """Test that SSE client properly handles read timeouts."""
-    with pytest.raises(httpx.HTTPError):
+#     with pytest.raises(ReadTimeout):
-        async with sse_client(
+#         async with sse_client(
-            "http://testserver/nonexistent",
+#             "http://testserver/sse",
-            headers={"Host": "testserver"},
+#             headers={"Host": "testserver"},
-            timeout=2,
+#             timeout=5,
-            client=test_client,
+#             sse_read_timeout=2,
-        ):
+#             client=test_client,
-            pass  # Should not reach here
+#         ) as (read_stream, write_stream):
+#             async with read_stream:
+#                 # This should timeout since no messages are being sent
+#                 await read_stream.__anext__()
 
 
-@pytest.mark.anyio
+# @pytest.mark.anyio
-async def test_sse_multiple_messages(test_client):
+# async def test_sse_connection_error(test_client):
-    """Test sending and receiving multiple SSE messages."""
+#     """Test SSE client behavior with connection errors."""
-    async with sse_client(
+#     with pytest.raises(httpx.HTTPError):
-        "http://testserver/sse",
+#         async with sse_client(
-        headers={"Host": "testserver"},
+#             "http://testserver/nonexistent",
-        timeout=2,
+#             headers={"Host": "testserver"},
-        sse_read_timeout=1,
+#             timeout=5,
-        client=test_client,
+#             client=test_client,
-    ) as (read_stream, write_stream):
+#         ):
-        # Send multiple test messages
+#             pass  # Should not reach here
-        messages = [
-            JSONRPCMessage.model_validate({"jsonrpc": "2.0", "method": f"test{i}"})
-            for i in range(3)
-        ]
 
-        for msg in messages:
-            await write_stream.send(msg)
 
-        # Receive all echoed messages
+# @pytest.mark.anyio
-        received = []
+# async def test_sse_multiple_messages(test_client):
-        async with read_stream:
+#     """Test sending and receiving multiple SSE messages."""
-            for _ in range(len(messages)):
+#     async with sse_client(
-                message = await read_stream.__anext__()
+#         "http://testserver/sse",
-                assert isinstance(message, JSONRPCMessage)
+#         headers={"Host": "testserver"},
-                received.append(message)
+#         timeout=5,
+#         sse_read_timeout=5,
+#         client=test_client,
+#     ) as (read_stream, write_stream):
+#         # Send multiple test messages
+#         messages = [
+#             JSONRPCMessage.model_validate({"jsonrpc": "2.0", "method": f"test{i}"})
+#             for i in range(3)
+#         ]
 
-        # Verify all messages were received in order
+#         for msg in messages:
-        for sent, received in zip(messages, received):
+#             await write_stream.send(msg)
-            assert sent.model_dump() == received.model_dump()
+
+#         # Receive all echoed messages
+#         received = []
+#         async with read_stream:
+#             for _ in range(len(messages)):
+#                 message = await read_stream.__anext__()
+#                 assert isinstance(message, JSONRPCMessage)
+#                 received.append(message)
+
+#         # Verify all messages were received in order
+#         for sent, received in zip(messages, received):
+#             assert sent.model_dump() == received.model_dump()