Addressed PR review with TDD

Author: regularkevvv

fastapi_gcp_tasks/requester.py

@@ -1,5 +1,5 @@
 # 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
@@ -86,10 +86,11 @@ def _body(self, *, values: Dict[str, Any]) -> bytes | None:
             got_body = values.get(body_field.name)
             if got_body is None:
                 if body_field.field_info.is_required():
-                    raise MissingParamError(name=body_field.name)
+                    raise MissingParamError(param=body_field.name)
                 got_body = body_field.get_default()
             body_type = body_field.field_info.annotation
-            if body_type is not None and not isinstance(got_body, body_type):
+            check_type = get_origin(body_type) or body_type
+            if body_type is not None and check_type is not None 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

tests/test_requester.py

@@ -0,0 +1,90 @@
+"""Unit tests for Requester._body covering missing-param and generic-type bugs."""
+
+# Standard Library Imports
+from typing import List
+
+# 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."""
+
+
+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"})