Fixed NO BODY methods with Model

Author: mr-fatalyst

fastopenapi/core/router.py

@@ -81,7 +81,13 @@ def __init__(
 
     def add_route(self, path: str, method: str, endpoint: Callable):
         """Add a route to the router"""
-        meta = getattr(endpoint, "__route_meta__", {})
+        try:
+            if not hasattr(endpoint, "__route_meta__"):
+                endpoint.__route_meta__ = {}
+            endpoint.__route_meta__.setdefault("method", method)
+        except AttributeError:
+            pass
+        meta = getattr(endpoint, "__route_meta__", {"method": method})
         route = RouteInfo(path, method, endpoint, meta)
         self._routes.append(route)
         self._openapi_schema = None
@@ -137,6 +143,7 @@ def _create_route_decorator(self, path: str, method: str, meta: dict):
         """Create a decorator for route registration"""
 
         def decorator(func: Callable):
+            meta["method"] = method
             func.__route_meta__ = meta
             self.add_route(path, method, func)
             return func

tests/core/test_base_router.py

@@ -254,6 +254,54 @@ def options_endpoint():
         assert hasattr(get_endpoint, "__route_meta__")
         assert get_endpoint.__route_meta__["tags"] == ["test"]
 
+    def test_decorator_writes_method_to_route_meta(self):
+        """Test that decorators write HTTP method into __route_meta__"""
+
+        @self.router.get("/get-test")
+        def get_ep():
+            pass
+
+        @self.router.post("/post-test")
+        def post_ep():
+            pass
+
+        @self.router.delete("/delete-test")
+        def delete_ep():
+            pass
+
+        @self.router.head("/head-test")
+        def head_ep():
+            pass
+
+        assert get_ep.__route_meta__["method"] == "GET"
+        assert post_ep.__route_meta__["method"] == "POST"
+        assert delete_ep.__route_meta__["method"] == "DELETE"
+        assert head_ep.__route_meta__["method"] == "HEAD"
+
+    def test_add_route_sets_route_meta(self):
+        """Test that add_route sets __route_meta__ on bare functions"""
+
+        def bare_func():
+            pass
+
+        assert not hasattr(bare_func, "__route_meta__")
+        self.router.add_route("/bare", "GET", bare_func)
+
+        assert hasattr(bare_func, "__route_meta__")
+        assert bare_func.__route_meta__["method"] == "GET"
+
+    def test_add_route_preserves_existing_route_meta(self):
+        """Test that add_route doesn't overwrite existing method in __route_meta__"""
+
+        def func_with_meta():
+            pass
+
+        func_with_meta.__route_meta__ = {"method": "POST", "tags": ["custom"]}
+        self.router.add_route("/meta", "POST", func_with_meta)
+
+        assert func_with_meta.__route_meta__["method"] == "POST"
+        assert func_with_meta.__route_meta__["tags"] == ["custom"]
+
     def test_openapi_property_lazy_loading(self):
         # Test the openapi property (lazy loading)
 

tests/resolution/test_parameter_resolver.py

@@ -320,6 +320,53 @@ class Model(BaseModel):
         source = ParameterResolver._determine_source("data", param, {})
         assert source == ParameterSource.BODY
 
+    @pytest.mark.parametrize("method", ["GET", "HEAD", "DELETE"])
+    def test_determine_source_pydantic_model_no_body_methods(self, method) -> None:
+        """Test that Pydantic models resolve as QUERY for NO_BODY methods"""
+
+        class FilterModel(BaseModel):
+            search: str
+            limit: int = 10
+
+        param = inspect.Parameter(
+            "filters",
+            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            annotation=FilterModel,
+        )
+        source = ParameterResolver._determine_source(
+            "filters", param, {}, method=method
+        )
+        assert source == ParameterSource.QUERY
+
+    @pytest.mark.parametrize("method", ["POST", "PUT", "PATCH"])
+    def test_determine_source_pydantic_model_body_methods(self, method) -> None:
+        """Test that Pydantic models resolve as BODY for body-carrying methods"""
+
+        class DataModel(BaseModel):
+            name: str
+
+        param = inspect.Parameter(
+            "data",
+            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            annotation=DataModel,
+        )
+        source = ParameterResolver._determine_source("data", param, {}, method=method)
+        assert source == ParameterSource.BODY
+
+    def test_determine_source_pydantic_model_no_method(self) -> None:
+        """Test that Pydantic models resolve as BODY when method is None"""
+
+        class DataModel(BaseModel):
+            name: str
+
+        param = inspect.Parameter(
+            "data",
+            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            annotation=DataModel,
+        )
+        source = ParameterResolver._determine_source("data", param, {}, method=None)
+        assert source == ParameterSource.BODY
+
     def test_determine_source_query_default(self) -> None:
         """Test source determination defaults to query"""
         param = inspect.Parameter(