doc: answer a SCIM error to a query parameter FastAPI refuses

The guide has FastAPI validate the query parameters of a collection, which
raises RequestValidationError rather than the ValidationError the error
handlers were registered for, so a malformed count, or an attributes or sortBy
path that does not resolve, answered the FastAPI 422 body and threw away a
scimType that was already computed.

Author: azmeuk

doc/guides/_examples/fastapi_example.py

@@ -9,6 +9,7 @@
 from fastapi import Query
 from fastapi import Request
 from fastapi import Response
+from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse
 from pydantic import ValidationError
 
@@ -104,6 +105,7 @@ def resolve_user(user_id: str):
 
 # -- error-handlers-start --
 @app.exception_handler(ValidationError)
+@app.exception_handler(RequestValidationError)
 async def handle_validation_error(request, error):
     """Turn Pydantic validation errors into SCIM error responses."""
     scim_error = Error.from_validation_error(error.errors()[0])

doc/guides/fastapi.rst

@@ -69,7 +69,9 @@ validation errors, HTTP exceptions, and application errors aligned with SCIM res
 
 ``handle_validation_error`` catches the :class:`~pydantic_core.ValidationError` raised by
 :meth:`~scim2_models.BaseModel.model_validate` and returns a SCIM :class:`~scim2_models.Error`
-response.
+response. It is registered for :class:`~fastapi.exceptions.RequestValidationError` as well, which
+is what FastAPI raises when it validates the query parameters itself: without it a malformed
+``count`` or ``attributes`` answers the FastAPI ``422`` body instead of a SCIM error.
 ``handle_http_exception`` catches HTTP errors such as the 404 raised by the dependency and wraps
 them in a SCIM :class:`~scim2_models.Error`.
 ``handle_scim_error`` catches any :class:`~scim2_models.SCIMException` (uniqueness, mutability, …)

tests/test_doc_examples.py

@@ -409,3 +409,31 @@ def test_fastapi_example_smoke():
     )
     assert put_response.status_code == 200
     assert put_response.json()["displayName"] == "Barbara J."
+
+
+@pytest.mark.parametrize(
+    ("parameters", "scim_type"),
+    [
+        ({"count": "abc"}, "invalidSyntax"),
+        ({"attributes": 'emails[type eq "work"]'}, "invalidPath"),
+    ],
+)
+def test_fastapi_example_answers_a_scim_error_to_a_refused_query_parameter(
+    parameters, scim_type
+):
+    """FastAPI validates the query parameters itself, so a refused one never reaches the endpoint.
+
+    The failure is a RequestValidationError, which the guide handles next to
+    ValidationError: without it the framework answers its own body, and a
+    client reading the scimType of the error finds none.
+    """
+    from starlette.testclient import TestClient
+
+    from doc.guides._examples.fastapi_example import app
+
+    client = TestClient(app)
+
+    response = client.get("/scim/v2/Users", params=parameters)
+    assert response.status_code == 400
+    assert response.headers["Content-Type"] == "application/scim+json"
+    assert response.json()["scimType"] == scim_type