Merge pull request #87 from SimplifyJobs/renovate/fastapi-0.x

fix(deps): update dependency fastapi to >=0.110.0,<0.136.0

Author: regularkevvv

examples/full/serializer.py

@@ -1,5 +1,5 @@
 # Third Party Imports
-from pydantic.v1 import BaseModel
+from pydantic import BaseModel
 
 
 class Payload(BaseModel):

examples/simple/main.py

@@ -5,7 +5,7 @@
 # Third Party Imports
 from fastapi import FastAPI
 from fastapi.routing import APIRouter
-from pydantic.v1 import BaseModel
+from pydantic import BaseModel
 
 # Imports from this repository
 from fastapi_gcp_tasks import DelayedRouteBuilder

fastapi_gcp_tasks/exception.py

@@ -1,20 +1,20 @@
-# Third Party Imports
-from pydantic.v1.errors import MissingError, PydanticValueError
-
-# TODO: Migrate to Pydantic v2.0 Errors
-
-
-class MissingParamError(MissingError):
+class MissingParamError(ValueError):
     """Error raised when a required parameter is missing."""
 
     msg_template = "field required: {param}"
 
+    def __init__(self, **ctx: object) -> None:
+        super().__init__(self.msg_template.format(**ctx))
 
-class WrongTypeError(PydanticValueError):
+
+class WrongTypeError(ValueError):
     """Error raised when a parameter is of the wrong type."""
 
     msg_template = "Expected {field} to be of type {type}"
 
+    def __init__(self, **ctx: object) -> None:
+        super().__init__(self.msg_template.format(**ctx))
+
 
 class BadMethodError(Exception):
     """Error raised when an invalid method is passed to a task."""

fastapi_gcp_tasks/requester.py

@@ -1,12 +1,11 @@
 # Standard Library Imports
-from typing import Any, Dict, List, Tuple
+from typing import Any, Dict, List, Tuple, get_origin
 from urllib.parse import parse_qsl, urlencode, urlparse, urlunparse
 
 # Third Party Imports
 from fastapi.dependencies.utils import request_params_to_args
 from fastapi.encoders import jsonable_encoder
 from fastapi.routing import APIRoute
-from pydantic.v1.error_wrappers import ErrorWrapper
 
 # Imports from this repository
 from fastapi_gcp_tasks.exception import MissingParamError, WrongTypeError
@@ -86,20 +85,23 @@ def _body(self, *, values: Dict[str, Any]) -> bytes | None:
         if body_field and body_field.name:
             got_body = values.get(body_field.name)
             if got_body is None:
-                if body_field.required:
-                    raise MissingParamError(name=body_field.name)
+                if body_field.field_info.is_required():
+                    raise MissingParamError(param=body_field.name)
                 got_body = body_field.get_default()
-            if not isinstance(got_body, body_field.type_):
-                raise WrongTypeError(field=body_field.name, type=body_field.type_)
+            body_type = body_field.field_info.annotation
+            check_type = get_origin(body_type) or body_type
+            if body_type is not None and isinstance(check_type, type) and not isinstance(got_body, check_type):
+                raise WrongTypeError(field=body_field.name, type=body_type)
             body = json.dumps(jsonable_encoder(got_body)).encode()
         return body
 
 
-def _err_val(resp: Tuple[Dict, List[ErrorWrapper]]) -> Dict:
+def _err_val(resp: Tuple[Dict[str, Any], List[Any]]) -> Dict[str, Any]:
     values, errors = resp
 
     if len(errors) != 0:
         # TODO: Log everything but raise first only
         # TODO: find a better way to raise and display these errors
-        raise errors[0].exc
+        err = errors[0]
+        raise ValueError(str(err))
     return values

pyproject.toml

@@ -9,7 +9,7 @@ requires-python = ">=3.11,<3.14"
 dependencies = [
     "google-cloud-tasks>=2.21.0,<2.22.0",
     "google-cloud-scheduler>=2.13.3,<2.20.0",
-    "fastapi>=0.110.0,<0.130.0",
+    "fastapi>=0.110.0,<0.136.0",
 ]
 
 [dependency-groups]

tests/test_requester.py

@@ -0,0 +1,102 @@
+"""Unit tests for Requester._body covering missing-param and generic-type bugs."""
+
+# Standard Library Imports
+from typing import List, Union
+
+# Third Party Imports
+import pytest
+from fastapi import FastAPI
+from fastapi.routing import APIRoute
+from pydantic import BaseModel
+
+# Imports from this repository
+from fastapi_gcp_tasks.exception import MissingParamError, WrongTypeError
+from fastapi_gcp_tasks.requester import Requester
+
+
+class Item(BaseModel):
+    """Simple model for testing."""
+
+    name: str
+
+
+app = FastAPI()
+
+
+@app.post("/required_body")
+async def required_body_endpoint(item: Item) -> None:
+    """Endpoint with a required body param."""
+
+
+@app.post("/optional_body")
+async def optional_body_endpoint(item: Item = Item(name="default")) -> None:
+    """Endpoint with an optional body param."""
+
+
+@app.post("/list_body")
+async def list_body_endpoint(items: List[Item]) -> None:
+    """Endpoint with a parameterized generic body."""
+
+
+@app.post("/union_body")
+async def union_body_endpoint(item: Union[Item, str] = "fallback") -> None:
+    """Endpoint with a Union-typed body."""
+
+
+def _get_route(path: str) -> APIRoute:
+    for route in app.routes:
+        if isinstance(route, APIRoute) and route.path == path:
+            return route
+    raise ValueError(f"Route {path} not found")
+
+
+class TestMissingRequiredBody:
+    """Bug: MissingParamError called with name= but template expects {param}."""
+
+    def test_missing_required_body_raises_missing_param_error(self) -> None:
+        """Missing required body should raise MissingParamError, not KeyError."""
+        route = _get_route("/required_body")
+        requester = Requester(route=route, base_url="http://localhost")
+        with pytest.raises(MissingParamError, match="field required"):
+            requester._body(values={})
+
+    def test_optional_body_uses_default(self) -> None:
+        """Optional body should fall back to default when not provided."""
+        route = _get_route("/optional_body")
+        requester = Requester(route=route, base_url="http://localhost")
+        body = requester._body(values={})
+        assert body is not None
+        assert b"default" in body
+
+
+class TestGenericBodyType:
+    """Bug: isinstance crashes with parameterized generics like list[Item]."""
+
+    def test_list_body_does_not_crash_with_valid_input(self) -> None:
+        """Parameterized generic body should not raise TypeError on isinstance."""
+        route = _get_route("/list_body")
+        requester = Requester(route=route, base_url="http://localhost")
+        items = [Item(name="a"), Item(name="b")]
+        body = requester._body(values={"items": items})
+        assert body is not None
+
+    def test_list_body_wrong_type_raises(self) -> None:
+        """Wrong type for a generic body should raise WrongTypeError."""
+        route = _get_route("/list_body")
+        requester = Requester(route=route, base_url="http://localhost")
+        with pytest.raises(WrongTypeError):
+            requester._body(values={"items": "not a list"})
+
+    def test_simple_body_wrong_type_raises(self) -> None:
+        """Wrong type for a simple body should raise WrongTypeError."""
+        route = _get_route("/required_body")
+        requester = Requester(route=route, base_url="http://localhost")
+        with pytest.raises(WrongTypeError):
+            requester._body(values={"item": "not an Item"})
+
+    def test_union_body_does_not_crash(self) -> None:
+        """Union-typed body should not raise TypeError on isinstance check."""
+        route = _get_route("/union_body")
+        requester = Requester(route=route, base_url="http://localhost")
+        body = requester._body(values={"item": Item(name="test")})
+        assert body is not None