Formatting/fixes

Author: holtskinner

tests/client/test_auth_middleware.py

@@ -108,10 +108,8 @@ def store():
 @pytest.mark.asyncio
 async def test_auth_interceptor_skips_when_no_agent_card(
     store: InMemoryContextCredentialStore,
-):
-    """
-    Tests that the AuthInterceptor does not modify the request when no AgentCard is provided.
-    """
+) -> None:
+    """Tests that the AuthInterceptor does not modify the request when no AgentCard is provided."""
     request_payload = {'foo': 'bar'}
     http_kwargs = {'fizz': 'buzz'}
     auth_interceptor = AuthInterceptor(credential_service=store)
@@ -130,9 +128,8 @@ async def test_auth_interceptor_skips_when_no_agent_card(
 @pytest.mark.asyncio
 async def test_in_memory_context_credential_store(
     store: InMemoryContextCredentialStore,
-):
-    """
-    Verifies that InMemoryContextCredentialStore correctly stores and retrieves
+) -> None:
+    """Verifies that InMemoryContextCredentialStore correctly stores and retrieves
     credentials based on the session ID in the client context.
     """
     session_id = 'session-id'
@@ -167,11 +164,8 @@ async def test_in_memory_context_credential_store(
 
 @pytest.mark.asyncio
 @respx.mock
-async def test_client_with_simple_interceptor():
-    """
-    Ensures that a custom HeaderInterceptor correctly injects a static header
-    into outbound HTTP requests from the A2AClient.
-    """
+async def test_client_with_simple_interceptor() -> None:
+    """Ensures that a custom HeaderInterceptor correctly injects a static header into outbound HTTP requests from the A2AClient."""
     url = 'http://agent.com/rpc'
     interceptor = HeaderInterceptor('X-Test-Header', 'Test-Value-123')
     card = AgentCard(
@@ -200,9 +194,7 @@ async def test_client_with_simple_interceptor():
 
 @dataclass
 class AuthTestCase:
-    """
-    Represents a test scenario for verifying authentication behavior in AuthInterceptor.
-    """
+    """Represents a test scenario for verifying authentication behavior in AuthInterceptor."""
 
     url: str
     """The endpoint URL of the agent to which the request is sent."""
@@ -290,11 +282,8 @@ class AuthTestCase:
 @respx.mock
 async def test_auth_interceptor_variants(
     test_case: AuthTestCase, store: InMemoryContextCredentialStore
-):
-    """
-    Parametrized test verifying that AuthInterceptor correctly attaches credentials
-    based on the defined security scheme in the AgentCard.
-    """
+) -> None:
+    """Parametrized test verifying that AuthInterceptor correctly attaches credentials based on the defined security scheme in the AgentCard."""
     await store.set_credentials(
         test_case.session_id, test_case.scheme_name, test_case.credential
     )
@@ -336,11 +325,8 @@ async def test_auth_interceptor_variants(
 @pytest.mark.asyncio
 async def test_auth_interceptor_skips_when_scheme_not_in_security_schemes(
     store: InMemoryContextCredentialStore,
-):
-    """
-    Tests that AuthInterceptor skips a scheme if it's listed in security requirements
-    but not defined in security_schemes.
-    """
+) -> None:
+    """Tests that AuthInterceptor skips a scheme if it's listed in security requirements but not defined in security_schemes."""
     scheme_name = 'missing'
     session_id = 'session-id'
     credential = 'dummy-token'

tests/client/test_base_client.py

@@ -63,7 +63,7 @@ def base_client(
 @pytest.mark.asyncio
 async def test_send_message_streaming(
     base_client: BaseClient, mock_transport: MagicMock, sample_message: Message
-):
+) -> None:
     async def create_stream(*args, **kwargs):
         yield Task(
             id='task-123',
@@ -84,7 +84,7 @@ async def create_stream(*args, **kwargs):
 @pytest.mark.asyncio
 async def test_send_message_non_streaming(
     base_client: BaseClient, mock_transport: MagicMock, sample_message: Message
-):
+) -> None:
     base_client._config.streaming = False
     mock_transport.send_message.return_value = Task(
         id='task-456',
@@ -103,7 +103,7 @@ async def test_send_message_non_streaming(
 @pytest.mark.asyncio
 async def test_send_message_non_streaming_agent_capability_false(
     base_client: BaseClient, mock_transport: MagicMock, sample_message: Message
-):
+) -> None:
     base_client._card.capabilities.streaming = False
     mock_transport.send_message.return_value = Task(
         id='task-789',

tests/client/test_client_task_manager.py

@@ -46,21 +46,23 @@ def sample_message() -> Message:
     )
 
 
-def test_get_task_no_task_id_returns_none(task_manager: ClientTaskManager):
+def test_get_task_no_task_id_returns_none(
+    task_manager: ClientTaskManager,
+) -> None:
     assert task_manager.get_task() is None
 
 
 def test_get_task_or_raise_no_task_raises_error(
     task_manager: ClientTaskManager,
-):
+) -> None:
     with pytest.raises(A2AClientInvalidStateError, match='no current Task'):
         task_manager.get_task_or_raise()
 
 
 @pytest.mark.asyncio
 async def test_save_task_event_with_task(
     task_manager: ClientTaskManager, sample_task: Task
-):
+) -> None:
     await task_manager.save_task_event(sample_task)
     assert task_manager.get_task() == sample_task
     assert task_manager._task_id == sample_task.id
@@ -70,7 +72,7 @@ async def test_save_task_event_with_task(
 @pytest.mark.asyncio
 async def test_save_task_event_with_task_already_set_raises_error(
     task_manager: ClientTaskManager, sample_task: Task
-):
+) -> None:
     await task_manager.save_task_event(sample_task)
     with pytest.raises(
         A2AClientInvalidArgsError,
@@ -82,7 +84,7 @@ async def test_save_task_event_with_task_already_set_raises_error(
 @pytest.mark.asyncio
 async def test_save_task_event_with_status_update(
     task_manager: ClientTaskManager, sample_task: Task, sample_message: Message
-):
+) -> None:
     await task_manager.save_task_event(sample_task)
     status_update = TaskStatusUpdateEvent(
         task_id=sample_task.id,
@@ -98,7 +100,7 @@ async def test_save_task_event_with_status_update(
 @pytest.mark.asyncio
 async def test_save_task_event_with_artifact_update(
     task_manager: ClientTaskManager, sample_task: Task
-):
+) -> None:
     await task_manager.save_task_event(sample_task)
     artifact = Artifact(
         artifact_id='art1', parts=[Part(root=TextPart(text='artifact content'))]
@@ -119,7 +121,7 @@ async def test_save_task_event_with_artifact_update(
 @pytest.mark.asyncio
 async def test_save_task_event_creates_task_if_not_exists(
     task_manager: ClientTaskManager,
-):
+) -> None:
     status_update = TaskStatusUpdateEvent(
         task_id='new_task',
         context_id='new_context',
@@ -135,7 +137,7 @@ async def test_save_task_event_creates_task_if_not_exists(
 @pytest.mark.asyncio
 async def test_process_with_task_event(
     task_manager: ClientTaskManager, sample_task: Task
-):
+) -> None:
     with patch.object(
         task_manager, 'save_task_event', new_callable=AsyncMock
     ) as mock_save:
@@ -144,7 +146,9 @@ async def test_process_with_task_event(
 
 
 @pytest.mark.asyncio
-async def test_process_with_non_task_event(task_manager: ClientTaskManager):
+async def test_process_with_non_task_event(
+    task_manager: ClientTaskManager,
+) -> None:
     with patch.object(
         task_manager, 'save_task_event', new_callable=Mock
     ) as mock_save:
@@ -155,14 +159,14 @@ async def test_process_with_non_task_event(task_manager: ClientTaskManager):
 
 def test_update_with_message(
     task_manager: ClientTaskManager, sample_task: Task, sample_message: Message
-):
+) -> None:
     updated_task = task_manager.update_with_message(sample_message, sample_task)
     assert updated_task.history == [sample_message]
 
 
 def test_update_with_message_moves_status_message(
     task_manager: ClientTaskManager, sample_task: Task, sample_message: Message
-):
+) -> None:
     status_message = Message(
         message_id='status_msg',
         role=Role.agent,

tests/client/test_errors.py

@@ -1,3 +1,5 @@
+from typing import NoReturn
+
 import pytest
 
 from a2a.client import A2AClientError, A2AClientHTTPError, A2AClientJSONError
@@ -6,13 +8,13 @@
 class TestA2AClientError:
     """Test cases for the base A2AClientError class."""
 
-    def test_instantiation(self):
+    def test_instantiation(self) -> None:
         """Test that A2AClientError can be instantiated."""
         error = A2AClientError('Test error message')
         assert isinstance(error, Exception)
         assert str(error) == 'Test error message'
 
-    def test_inheritance(self):
+    def test_inheritance(self) -> None:
         """Test that A2AClientError inherits from Exception."""
         error = A2AClientError()
         assert isinstance(error, Exception)
@@ -21,31 +23,31 @@ def test_inheritance(self):
 class TestA2AClientHTTPError:
     """Test cases for A2AClientHTTPError class."""
 
-    def test_instantiation(self):
+    def test_instantiation(self) -> None:
         """Test that A2AClientHTTPError can be instantiated with status_code and message."""
         error = A2AClientHTTPError(404, 'Not Found')
         assert isinstance(error, A2AClientError)
         assert error.status_code == 404
         assert error.message == 'Not Found'
 
-    def test_message_formatting(self):
+    def test_message_formatting(self) -> None:
         """Test that the error message is formatted correctly."""
         error = A2AClientHTTPError(500, 'Internal Server Error')
         assert str(error) == 'HTTP Error 500: Internal Server Error'
 
-    def test_inheritance(self):
+    def test_inheritance(self) -> None:
         """Test that A2AClientHTTPError inherits from A2AClientError."""
         error = A2AClientHTTPError(400, 'Bad Request')
         assert isinstance(error, A2AClientError)
 
-    def test_with_empty_message(self):
+    def test_with_empty_message(self) -> None:
         """Test behavior with an empty message."""
         error = A2AClientHTTPError(403, '')
         assert error.status_code == 403
         assert error.message == ''
         assert str(error) == 'HTTP Error 403: '
 
-    def test_with_various_status_codes(self):
+    def test_with_various_status_codes(self) -> None:
         """Test with different HTTP status codes."""
         test_cases = [
             (200, 'OK'),
@@ -68,29 +70,29 @@ def test_with_various_status_codes(self):
 class TestA2AClientJSONError:
     """Test cases for A2AClientJSONError class."""
 
-    def test_instantiation(self):
+    def test_instantiation(self) -> None:
         """Test that A2AClientJSONError can be instantiated with a message."""
         error = A2AClientJSONError('Invalid JSON format')
         assert isinstance(error, A2AClientError)
         assert error.message == 'Invalid JSON format'
 
-    def test_message_formatting(self):
+    def test_message_formatting(self) -> None:
         """Test that the error message is formatted correctly."""
         error = A2AClientJSONError('Missing required field')
         assert str(error) == 'JSON Error: Missing required field'
 
-    def test_inheritance(self):
+    def test_inheritance(self) -> None:
         """Test that A2AClientJSONError inherits from A2AClientError."""
         error = A2AClientJSONError('Parsing error')
         assert isinstance(error, A2AClientError)
 
-    def test_with_empty_message(self):
+    def test_with_empty_message(self) -> None:
         """Test behavior with an empty message."""
         error = A2AClientJSONError('')
         assert error.message == ''
         assert str(error) == 'JSON Error: '
 
-    def test_with_various_messages(self):
+    def test_with_various_messages(self) -> None:
         """Test with different error messages."""
         test_messages = [
             'Malformed JSON',
@@ -109,21 +111,21 @@ def test_with_various_messages(self):
 class TestExceptionHierarchy:
     """Test the exception hierarchy and relationships."""
 
-    def test_exception_hierarchy(self):
+    def test_exception_hierarchy(self) -> None:
         """Test that the exception hierarchy is correct."""
         assert issubclass(A2AClientError, Exception)
         assert issubclass(A2AClientHTTPError, A2AClientError)
         assert issubclass(A2AClientJSONError, A2AClientError)
 
-    def test_catch_specific_exception(self):
+    def test_catch_specific_exception(self) -> None:
         """Test that specific exceptions can be caught."""
         try:
             raise A2AClientHTTPError(404, 'Not Found')
         except A2AClientHTTPError as e:
             assert e.status_code == 404
             assert e.message == 'Not Found'
 
-    def test_catch_base_exception(self):
+    def test_catch_base_exception(self) -> None:
         """Test that derived exceptions can be caught as base exception."""
         exceptions = [
             A2AClientHTTPError(404, 'Not Found'),
@@ -140,7 +142,7 @@ def test_catch_base_exception(self):
 class TestExceptionRaising:
     """Test cases for raising and handling the exceptions."""
 
-    def test_raising_http_error(self):
+    def test_raising_http_error(self) -> NoReturn:
         """Test raising an HTTP error and checking its properties."""
         with pytest.raises(A2AClientHTTPError) as excinfo:
             raise A2AClientHTTPError(429, 'Too Many Requests')
@@ -150,7 +152,7 @@ def test_raising_http_error(self):
         assert error.message == 'Too Many Requests'
         assert str(error) == 'HTTP Error 429: Too Many Requests'
 
-    def test_raising_json_error(self):
+    def test_raising_json_error(self) -> NoReturn:
         """Test raising a JSON error and checking its properties."""
         with pytest.raises(A2AClientJSONError) as excinfo:
             raise A2AClientJSONError('Invalid format')
@@ -159,7 +161,7 @@ def test_raising_json_error(self):
         assert error.message == 'Invalid format'
         assert str(error) == 'JSON Error: Invalid format'
 
-    def test_raising_base_error(self):
+    def test_raising_base_error(self) -> NoReturn:
         """Test raising the base error."""
         with pytest.raises(A2AClientError) as excinfo:
             raise A2AClientError('Generic client error')
@@ -178,7 +180,9 @@ def test_raising_base_error(self):
         (500, 'Server Error', 'HTTP Error 500: Server Error'),
     ],
 )
-def test_http_error_parametrized(status_code: int, message: str, expected: str):
+def test_http_error_parametrized(
+    status_code: int, message: str, expected: str
+) -> None:
     """Parametrized test for HTTP errors with different status codes."""
     error = A2AClientHTTPError(status_code, message)
     assert error.status_code == status_code
@@ -194,7 +198,7 @@ def test_http_error_parametrized(status_code: int, message: str, expected: str):
         ('Parsing failed', 'JSON Error: Parsing failed'),
     ],
 )
-def test_json_error_parametrized(message: str, expected: str):
+def test_json_error_parametrized(message: str, expected: str) -> None:
     """Parametrized test for JSON errors with different messages."""
     error = A2AClientJSONError(message)
     assert error.message == message