test: enhance HTTP error handling tests and add streaming error tests

Author: DavidLee528

tests/client/test_errors.py

@@ -27,11 +27,13 @@ def test_instantiation(self):
         assert isinstance(error, A2AClientError)
         assert error.status_code == 404
         assert error.message == 'Not Found'
+        assert error.body is None
+        assert error.headers == {}
 
     def test_message_formatting(self):
         """Test that the error message is formatted correctly."""
         error = A2AClientHTTPError(500, 'Internal Server Error')
-        assert str(error) == 'HTTP Error 500: Internal Server Error'
+        assert str(error) == 'HTTP 500 - Internal Server Error'
 
     def test_inheritance(self):
         """Test that A2AClientHTTPError inherits from A2AClientError."""
@@ -43,7 +45,7 @@ def test_with_empty_message(self):
         error = A2AClientHTTPError(403, '')
         assert error.status_code == 403
         assert error.message == ''
-        assert str(error) == 'HTTP Error 403: '
+        assert str(error) == 'HTTP 403 - '
 
     def test_with_various_status_codes(self):
         """Test with different HTTP status codes."""
@@ -62,7 +64,7 @@ def test_with_various_status_codes(self):
             error = A2AClientHTTPError(status_code, message)
             assert error.status_code == status_code
             assert error.message == message
-            assert str(error) == f'HTTP Error {status_code}: {message}'
+            assert str(error) == f'HTTP {status_code} - {message}'
 
 
 class TestA2AClientJSONError:
@@ -148,7 +150,7 @@ def test_raising_http_error(self):
         error = excinfo.value
         assert error.status_code == 429
         assert error.message == 'Too Many Requests'
-        assert str(error) == 'HTTP Error 429: Too Many Requests'
+        assert str(error) == 'HTTP 429 - Too Many Requests'
 
     def test_raising_json_error(self):
         """Test raising a JSON error and checking its properties."""
@@ -173,9 +175,9 @@ def test_raising_base_error(self):
 @pytest.mark.parametrize(
     'status_code,message,expected',
     [
-        (400, 'Bad Request', 'HTTP Error 400: Bad Request'),
-        (404, 'Not Found', 'HTTP Error 404: Not Found'),
-        (500, 'Server Error', 'HTTP Error 500: Server Error'),
+        (400, 'Bad Request', 'HTTP 400 - Bad Request'),
+        (404, 'Not Found', 'HTTP 404 - Not Found'),
+        (500, 'Server Error', 'HTTP 500 - Server Error'),
     ],
 )
 def test_http_error_parametrized(status_code, message, expected):

tests/client/test_streaming_http_errors.py

@@ -0,0 +1,184 @@
+"""Tests for a2a.client.errors module."""
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import Any
+from unittest.mock import AsyncMock, patch
+
+import httpx
+import pytest
+
+from a2a.client import create_text_message_object
+from a2a.client.errors import A2AClientHTTPError
+from a2a.client.transports.rest import RestTransport
+from a2a.types import MessageSendParams
+
+
+@dataclass
+class DummyServerSentEvent:
+    data: str
+
+
+class MockEventSource:
+    def __init__(
+        self,
+        response: httpx.Response,
+        events: list[Any] | None = None,
+        error: Exception | None = None,
+    ):
+        self.response = response
+        self._events = events or []
+        self._error = error
+
+    async def __aenter__(self) -> 'MockEventSource':
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        return None
+
+    async def aiter_sse(self) -> AsyncIterator[Any]:
+        if self._error:
+            raise self._error
+        for event in self._events:
+            yield event
+
+
+def make_response(
+    status: int,
+    *,
+    json_body: dict[str, Any] | None = None,
+    text_body: str | None = None,
+    headers: dict[str, str] | None = None,
+) -> httpx.Response:
+    request = httpx.Request('POST', 'https://api.example.com/v1/message:stream')
+    if json_body is not None:
+        response = httpx.Response(
+            status,
+            json=json_body,
+            headers=headers,
+            request=request,
+        )
+    else:
+        response = httpx.Response(
+            status,
+            content=text_body.encode() if text_body else b'',
+            headers=headers,
+            request=request,
+        )
+    return response
+
+
+def make_transport() -> RestTransport:
+    httpx_client = AsyncMock(spec=httpx.AsyncClient)
+    transport = RestTransport(
+        httpx_client=httpx_client, url='https://api.example.com'
+    )
+    transport._prepare_send_message = AsyncMock(return_value=({}, {}))
+    return transport
+
+
+async def collect_stream(transport: RestTransport, params: MessageSendParams):
+    return [item async for item in transport.send_message_streaming(params)]
+
+
+def patch_stream_context(event_source: MockEventSource):
+    @asynccontextmanager
+    async def fake_aconnect_sse(*_: Any, **__: Any):
+        yield event_source
+
+    return patch(
+        'a2a.client.transports.rest.aconnect_sse', new=fake_aconnect_sse
+    )
+
+
+@pytest.mark.parametrize(
+    ('status', 'body', 'expected'),
+    [
+        (401, {'error': 'invalid_token'}, 'invalid_token'),
+        (500, {'message': 'DB down'}, 'DB down'),
+        (503, {'detail': 'Service unavailable'}, 'Service unavailable'),
+        (
+            404,
+            {'title': 'Not Found', 'detail': 'No such task'},
+            'Not Found: No such task',
+        ),
+    ],
+)
+@pytest.mark.asyncio
+async def test_streaming_surfaces_http_errors(
+    status: int, body: dict[str, Any], expected: str
+):
+    transport = make_transport()
+    params = MessageSendParams(
+        message=create_text_message_object(content='Hello')
+    )
+    response = make_response(status, json_body=body)
+    event_source = MockEventSource(response)
+
+    with patch_stream_context(event_source), pytest.raises(
+        A2AClientHTTPError
+    ) as exc_info:
+        await collect_stream(transport, params)
+
+    error = exc_info.value
+    assert error.status == status
+    assert expected in error.message
+    assert error.body is not None
+    assert str(status) in str(error)
+
+
+@pytest.mark.asyncio
+async def test_streaming_rejects_wrong_content_type():
+    transport = make_transport()
+    params = MessageSendParams(
+        message=create_text_message_object(content='Hello')
+    )
+    response = make_response(
+        200,
+        json_body={'message': 'not a stream'},
+        headers={'content-type': 'application/json'},
+    )
+    event_source = MockEventSource(response)
+
+    with patch_stream_context(event_source), pytest.raises(
+        A2AClientHTTPError
+    ) as exc_info:
+        await collect_stream(transport, params)
+
+    error = exc_info.value
+    assert error.status == 200
+    assert 'Unexpected Content-Type' in error.message
+    assert 'application/json' in error.message
+
+
+@pytest.mark.asyncio
+async def test_streaming_success_path_unchanged():
+    transport = make_transport()
+    params = MessageSendParams(
+        message=create_text_message_object(content='Hello')
+    )
+    response = make_response(
+        200,
+        text_body='event-stream',
+        headers={'content-type': 'text/event-stream'},
+    )
+    events = [DummyServerSentEvent(data='{"foo":"bar"}')]
+    event_source = MockEventSource(response, events=events)
+
+    with (
+        patch_stream_context(event_source),
+        patch(
+            'a2a.client.transports.rest.Parse',
+            side_effect=lambda data, obj: obj,
+        ) as mock_parse,
+        patch(
+            'a2a.client.transports.rest.proto_utils.FromProto.stream_response',
+            return_value={'result': 'ok'},
+        ) as mock_from_proto,
+    ):
+        results = await collect_stream(transport, params)
+
+    assert results == [{'result': 'ok'}]
+    mock_parse.assert_called()
+    mock_from_proto.assert_called()