fix: bubble up sparql endpoint errors (#447)

recalcitrantsupplant · web-flow · commit b116d26f9bb9 · 2025-12-15T22:06:38.000+10:00
* bubble up sparql endpoint errors

* black
diff --git a/prez/repositories/remote_sparql.py b/prez/repositories/remote_sparql.py
@@ -42,6 +42,7 @@ async def _send_query(self, query: str, mediatype="text/turtle") -> httpx.Respon
         )
         try:
             response = await self.async_client.send(query_rq, stream=True)
+            response.raise_for_status()
             return response
         except httpx.TimeoutException as e:
             timeout_msg = (
@@ -51,6 +52,10 @@ async def _send_query(self, query: str, mediatype="text/turtle") -> httpx.Respon
                 timeout_msg += f" (sent '{settings.sparql_timeout_param_name}={settings.sparql_timeout}' to remote endpoint)"
             log.error(timeout_msg)
             raise httpx.TimeoutException(timeout_msg) from e
+        except httpx.HTTPStatusError as e:
+            # Read the response body for error details
+            await e.response.aread()
+            raise
 
     async def rdf_query_to_rdflib_graph(
         self, query: str, into_graph: Graph | None = None
diff --git a/prez/services/exception_catchers.py b/prez/services/exception_catchers.py
@@ -107,13 +107,33 @@ async def catch_missing_filter_query_param(
 
 
 async def catch_httpx_error(request: Request, exc: httpx.HTTPError):
+    # Handle HTTP status errors from SPARQL endpoint - pass through the actual error
+    if isinstance(exc, httpx.HTTPStatusError):
+        # Extract the actual status code and response from the SPARQL endpoint
+        status_code = exc.response.status_code
+        try:
+            # Try to get the response text if available
+            error_detail = (
+                exc.response.text if hasattr(exc.response, "text") else str(exc)
+            )
+        except Exception:
+            error_detail = str(exc)
+
+        return JSONResponse(
+            status_code=status_code,
+            content={
+                "error": "SPARQL_ENDPOINT_ERROR",
+                "detail": error_detail,
+            },
+        )
+
     # Determine appropriate status code based on exception type
-    if isinstance(exc, httpx.ConnectError):
-        status_code = 503  # Service Unavailable
-        error_type = "SPARQL_CONNECTION_ERROR"
-    elif isinstance(exc, httpx.TimeoutException):
+    if isinstance(exc, httpx.TimeoutException):
         status_code = 504  # Gateway Timeout
         error_type = "SPARQL_TIMEOUT_ERROR"
+    elif isinstance(exc, httpx.ConnectError):
+        status_code = 503  # Service Unavailable
+        error_type = "SPARQL_CONNECTION_ERROR"
     else:
         status_code = 502  # Bad Gateway
         error_type = "SPARQL_ERROR"
diff --git a/tests/test_remote_sparql_timeout.py b/tests/test_remote_sparql_timeout.py
@@ -26,6 +26,7 @@ async def test_send_query_with_timeout_param(self, remote_repo, mock_async_clien
         """Test that timeout parameter is added to form data when configured."""
         # Setup
         mock_response = Mock(spec=httpx.Response)
+        mock_response.raise_for_status = Mock()  # Mock raise_for_status method
         mock_async_client.build_request.return_value = Mock()
         mock_async_client.send.return_value = mock_response
 
@@ -51,6 +52,7 @@ async def test_send_query_without_timeout_param(
         """Test that no timeout parameter is added when not configured."""
         # Setup
         mock_response = Mock(spec=httpx.Response)
+        mock_response.raise_for_status = Mock()  # Mock raise_for_status method
         mock_async_client.build_request.return_value = Mock()
         mock_async_client.send.return_value = mock_response
 
@@ -119,6 +121,7 @@ async def test_sparql_post_with_timeout_param(self, remote_repo, mock_async_clie
     async def test_different_timeout_param_names(self, remote_repo, mock_async_client):
         """Test various timeout parameter names work correctly."""
         mock_response = Mock(spec=httpx.Response)
+        mock_response.raise_for_status = Mock()  # Mock raise_for_status method
         mock_async_client.build_request.return_value = Mock()
         mock_async_client.send.return_value = mock_response
 
diff --git a/tests/test_sparql_error_passthrough.py b/tests/test_sparql_error_passthrough.py
@@ -0,0 +1,207 @@
+"""Tests for SPARQL endpoint error passthrough functionality."""
+
+import pytest
+from unittest.mock import AsyncMock, Mock, patch
+import httpx
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+from prez.repositories.remote_sparql import RemoteSparqlRepo
+from prez.services.exception_catchers import catch_httpx_error
+from prez.config import settings
+from starlette.requests import Request
+
+
+@pytest.fixture
+def mock_async_client():
+    """Mock httpx AsyncClient for testing."""
+    return Mock(spec=httpx.AsyncClient)
+
+
+@pytest.fixture
+def remote_repo(mock_async_client):
+    """Create RemoteSparqlRepo with mocked client."""
+    with patch.object(settings, "sparql_endpoint", "http://test-sparql-endpoint.com"):
+        return RemoteSparqlRepo(mock_async_client)
+
+
+class TestSparqlErrorPassthrough:
+    """Test that SPARQL endpoint errors are passed through correctly."""
+
+    @pytest.mark.asyncio
+    async def test_send_query_with_400_error(self, remote_repo, mock_async_client):
+        """Test that 400 errors from SPARQL endpoint are raised as HTTPStatusError."""
+        # Setup mock response with 400 status code
+        mock_response = Mock(spec=httpx.Response)
+        mock_response.status_code = 400
+        mock_response.text = "Invalid SPARQL query syntax"
+
+        # Mock aread to make response.text available
+        async def mock_aread():
+            return b"Invalid SPARQL query syntax"
+
+        mock_response.aread = mock_aread
+
+        # Make raise_for_status raise HTTPStatusError
+        def raise_status_error():
+            raise httpx.HTTPStatusError(
+                "Client error '400 Bad Request' for url",
+                request=Mock(),
+                response=mock_response,
+            )
+
+        mock_response.raise_for_status = raise_status_error
+        mock_async_client.build_request.return_value = Mock()
+        mock_async_client.send.return_value = mock_response
+
+        # Execute and verify HTTPStatusError is raised
+        with pytest.raises(httpx.HTTPStatusError) as exc_info:
+            await remote_repo._send_query("INVALID QUERY")
+
+        assert exc_info.value.response.status_code == 400
+        assert exc_info.value.response.text == "Invalid SPARQL query syntax"
+
+    @pytest.mark.asyncio
+    async def test_send_query_with_500_error(self, remote_repo, mock_async_client):
+        """Test that 500 errors from SPARQL endpoint are raised as HTTPStatusError."""
+        # Setup mock response with 500 status code
+        mock_response = Mock(spec=httpx.Response)
+        mock_response.status_code = 500
+        mock_response.text = "Internal SPARQL server error: query execution failed"
+
+        # Mock aread to make response.text available
+        async def mock_aread():
+            return b"Internal SPARQL server error: query execution failed"
+
+        mock_response.aread = mock_aread
+
+        # Make raise_for_status raise HTTPStatusError
+        def raise_status_error():
+            raise httpx.HTTPStatusError(
+                "Server error '500 Internal Server Error' for url",
+                request=Mock(),
+                response=mock_response,
+            )
+
+        mock_response.raise_for_status = raise_status_error
+        mock_async_client.build_request.return_value = Mock()
+        mock_async_client.send.return_value = mock_response
+
+        # Execute and verify HTTPStatusError is raised
+        with pytest.raises(httpx.HTTPStatusError) as exc_info:
+            await remote_repo._send_query("SELECT * WHERE { ?s ?p ?o }")
+
+        assert exc_info.value.response.status_code == 500
+        assert "Internal SPARQL server error" in exc_info.value.response.text
+
+    @pytest.mark.asyncio
+    async def test_exception_handler_passes_through_status_code(self):
+        """Test that catch_httpx_error handler passes through the SPARQL endpoint status code."""
+        # Create mock request
+        mock_request = Mock(spec=Request)
+
+        # Create mock response with error
+        mock_response = Mock(spec=httpx.Response)
+        mock_response.status_code = 400
+        mock_response.text = "Malformed SPARQL query"
+
+        # Create HTTPStatusError
+        exc = httpx.HTTPStatusError(
+            "Client error '400 Bad Request' for url",
+            request=Mock(),
+            response=mock_response,
+        )
+
+        # Call the exception handler
+        response = await catch_httpx_error(mock_request, exc)
+
+        # Verify response has correct status code and error details
+        assert response.status_code == 400
+        assert response.body is not None
+
+        # Parse response body
+        import json
+
+        body = json.loads(response.body)
+        assert body["error"] == "SPARQL_ENDPOINT_ERROR"
+        assert "Malformed SPARQL query" in body["detail"]
+
+    @pytest.mark.asyncio
+    async def test_exception_handler_passes_through_500_status(self):
+        """Test that catch_httpx_error handler passes through 500 status code."""
+        mock_request = Mock(spec=Request)
+
+        mock_response = Mock(spec=httpx.Response)
+        mock_response.status_code = 500
+        mock_response.text = "Database connection failed"
+
+        exc = httpx.HTTPStatusError(
+            "Server error '500 Internal Server Error' for url",
+            request=Mock(),
+            response=mock_response,
+        )
+
+        response = await catch_httpx_error(mock_request, exc)
+
+        assert response.status_code == 500
+
+        import json
+
+        body = json.loads(response.body)
+        assert body["error"] == "SPARQL_ENDPOINT_ERROR"
+        assert "Database connection failed" in body["detail"]
+
+    @pytest.mark.asyncio
+    async def test_exception_handler_still_handles_timeout(self):
+        """Test that catch_httpx_error still properly handles timeout exceptions."""
+        mock_request = Mock(spec=Request)
+
+        exc = httpx.TimeoutException("Request timed out after 30 seconds")
+
+        response = await catch_httpx_error(mock_request, exc)
+
+        assert response.status_code == 504
+
+        import json
+
+        body = json.loads(response.body)
+        assert body["error"] == "SPARQL_TIMEOUT_ERROR"
+        assert "timed out" in body["detail"]
+
+    @pytest.mark.asyncio
+    async def test_exception_handler_still_handles_connect_error(self):
+        """Test that catch_httpx_error still properly handles connection errors."""
+        mock_request = Mock(spec=Request)
+
+        exc = httpx.ConnectError("Connection refused")
+
+        response = await catch_httpx_error(mock_request, exc)
+
+        assert response.status_code == 503
+
+        import json
+
+        body = json.loads(response.body)
+        assert body["error"] == "SPARQL_CONNECTION_ERROR"
+        assert "Connection refused" in body["detail"]
+
+    @pytest.mark.asyncio
+    async def test_send_query_success_does_not_raise(
+        self, remote_repo, mock_async_client
+    ):
+        """Test that successful queries don't raise exceptions."""
+        # Setup successful mock response
+        mock_response = Mock(spec=httpx.Response)
+        mock_response.status_code = 200
+        mock_response.raise_for_status = Mock()  # Does nothing on success
+
+        async def mock_aread():
+            return b"<rdf>...</rdf>"
+
+        mock_response.aread = mock_aread
+
+        mock_async_client.build_request.return_value = Mock()
+        mock_async_client.send.return_value = mock_response
+
+        # Should not raise any exception
+        result = await remote_repo._send_query("SELECT * WHERE { ?s ?p ?o }")
+        assert result == mock_response
