test: add infra-independent unit tests for core agent protocols

tests/unit/auth/test_hydra_registration.py

@@ -76,8 +76,10 @@ def test_save_credentials_sets_restrictive_permissions(self):
             save_agent_credentials(credentials, creds_dir)
 
             creds_file = creds_dir / "oauth_credentials.json"
-            # Check permissions (owner read/write only)
-            assert oct(creds_file.stat().st_mode)[-3:] == "600"
+            # Check permissions (owner read/write only) on non-Windows platforms
+            import sys
+            if sys.platform != "win32":
+                assert oct(creds_file.stat().st_mode)[-3:] == "600"
 
     def test_save_credentials_preserves_existing_entries(self):
         """Test that saving new credentials preserves existing ones."""

tests/unit/server/endpoints/test_a2a_protocol.py

@@ -0,0 +1,180 @@
+"""Unit tests for A2A protocol endpoint."""
+
+import json
+import uuid
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from starlette.requests import Request
+from starlette.responses import Response
+
+from bindu.common.protocol.types import (
+    InternalError,
+    JSONParseError,
+    MethodNotFoundError,
+)
+from bindu.server.applications import BinduApplication
+from bindu.server.endpoints.a2a_protocol import agent_run_endpoint
+
+
+@pytest.fixture
+def mock_app():
+    """Create a mock BinduApplication."""
+    app = MagicMock(spec=BinduApplication)
+    app.task_manager = MagicMock()
+    # Mock the handler method on task_manager
+    app.task_manager.mock_handler = AsyncMock(return_value={"result": "success"})
+    return app
+
+
+@pytest.fixture
+def mock_settings():
+    """Mock app settings."""
+    with patch("bindu.server.endpoints.a2a_protocol.app_settings") as mock:
+        mock.agent.method_handlers = {
+            "tasks/list": "mock_handler",
+            "message/send": "mock_handler",
+        }
+        mock.auth.enabled = False
+        mock.auth.require_permissions = False
+        yield mock
+
+
+@pytest.mark.asyncio
+async def test_valid_request(mock_app, mock_settings):
+    """Test successful processing of a valid A2A request."""
+    # Setup request with valid JSON body
+    body = {
+        "jsonrpc": "2.0",
+        "method": "tasks/list",
+        "params": {},
+        "id": str(uuid.uuid4()),
+    }
+
+    mock_request = MagicMock(spec=Request)
+    mock_request.body = AsyncMock(return_value=json.dumps(body).encode())
+
+    class MockState:
+        pass
+    mock_request.state = MockState()
+
+    # Call endpoint
+    response = await agent_run_endpoint(mock_app, mock_request)
+
+    # Verify task manager handler was called
+    mock_app.task_manager.mock_handler.assert_called_once()
+
+    # Verify response
+    assert isinstance(response, Response)
+    assert response.status_code == 200
+    content = json.loads(response.body)
+    assert content["result"] == "success"
+
+
+@pytest.mark.asyncio
+async def test_invalid_json(mock_app):
+    """Test handling of invalid JSON body."""
+    mock_request = MagicMock(spec=Request)
+    mock_request.body = AsyncMock(return_value=b"invalid json")
+
+    response = await agent_run_endpoint(mock_app, mock_request)
+
+    assert response.status_code == 400
+
+
+@pytest.mark.asyncio
+async def test_unsupported_method(mock_app, mock_settings):
+    """Test handling of unsupported method."""
+    body = {
+        "jsonrpc": "2.0",
+        "method": "unknown/method",
+        "id": str(uuid.uuid4()),
+    }
+
+    mock_request = MagicMock(spec=Request)
+    mock_request.body = AsyncMock(return_value=json.dumps(body).encode())
+
+    response = await agent_run_endpoint(mock_app, mock_request)
+
+    assert response.status_code == 400
+    # Validation fails for unknown method tag in discriminated union
+
+
+@pytest.mark.asyncio
+async def test_internal_error(mock_app, mock_settings):
+    """Test handling of internal errors."""
+    body = {
+        "jsonrpc": "2.0",
+        "method": "tasks/list",
+        "params": {},
+        "id": str(uuid.uuid4()),
+    }
+
+    mock_request = MagicMock(spec=Request)
+    mock_request.body = AsyncMock(return_value=json.dumps(body).encode())
+
+    class MockState:
+        pass
+    mock_request.state = MockState()
+
+    # Simulate handler raising exception
+    mock_app.task_manager.mock_handler.side_effect = Exception("Crash")
+
+    response = await agent_run_endpoint(mock_app, mock_request)
+
+    assert response.status_code == 500
+    content = json.loads(response.body)
+    assert "error" in content
+    assert content["error"]["code"] == -32603  # Internal error
+
+
+@pytest.mark.asyncio
+async def test_payment_context_injection(mock_app):
+    """Test injection of payment context into message metadata."""
+    # Mock settings specifically for this test to ensure handler is found
+    with patch("bindu.server.endpoints.a2a_protocol.app_settings") as mock_settings:
+        mock_settings.agent.method_handlers = {"message/send": "mock_handler"}
+        mock_settings.auth.enabled = False
+        mock_settings.auth.require_permissions = False
+
+        body = {
+            "jsonrpc": "2.0",
+            "method": "message/send",
+            "params": {
+                "configuration": {
+                    "acceptedOutputModes": ["text"]
+                },
+                "message": {
+                    "messageId": "123e4567-e89b-12d3-a456-426614174000",
+                    "contextId": "123e4567-e89b-12d3-a456-426614174001",
+                    "taskId": "123e4567-e89b-12d3-a456-426614174002",
+                    "kind": "message",
+                    "role": "user",
+                    "parts": [{"kind": "text", "text": "hello"}]
+                }
+            },
+            "id": str(uuid.uuid4()),
+        }
+
+        mock_request = MagicMock(spec=Request)
+        mock_request.body = AsyncMock(return_value=json.dumps(body).encode())
+
+        # Setup payment context in request state
+        class MockState:
+            payment_payload = {"amount": 100}
+            payment_requirements = {"token": "USDC"}
+            verify_response = {"status": "verified"}
+        mock_request.state = MockState()
+
+        # Call endpoint
+        await agent_run_endpoint(mock_app, mock_request)
+
+        # Verify handler called with modified request
+        call_args = mock_app.task_manager.mock_handler.call_args[0][0]
+        metadata = call_args["params"]["message"]["metadata"]
+
+        assert "_payment_context" in metadata
+        context = metadata["_payment_context"]
+        assert context["payment_payload"] == {"amount": 100}
+        assert context["payment_requirements"] == {"token": "USDC"}
+        assert context["verify_response"] == {"status": "verified"}

tests/unit/server/middleware/test_metrics.py

@@ -96,3 +96,33 @@ async def test_dispatch_decrements_on_error(self):
 
         mock_metrics.increment_requests_in_flight.assert_called_once()
         mock_metrics.decrement_requests_in_flight.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_dispatch_ignores_recording_error(self):
+        """Test that errors during metric recording don't crash request."""
+        mock_request = Mock()
+        mock_request.url.path = "/api/test"
+        mock_request.headers = {}
+
+        mock_response = Mock()
+        mock_response.status_code = 200
+
+        mock_call_next = AsyncMock(return_value=mock_response)
+
+        mock_metrics = Mock()
+        mock_metrics.increment_requests_in_flight = Mock()
+        mock_metrics.decrement_requests_in_flight = Mock()
+        # Simulate error in recording
+        mock_metrics.record_http_request = Mock(side_effect=Exception("Metrics DB down"))
+
+        middleware = MetricsMiddleware(app=Mock())
+
+        with patch(
+            "bindu.server.middleware.metrics.get_metrics", return_value=mock_metrics
+        ):
+            # Should not raise exception
+            response = await middleware.dispatch(mock_request, mock_call_next)
+
+        assert response == mock_response
+        mock_metrics.decrement_requests_in_flight.assert_called_once()  # cleanup always runs
+