fix file and form schema route function: fixed file and form schema route function parameter openapi docs when they go together

eadwinCode · eadwinCode · commit 6d0bd8254156 · 2023-11-12T12:31:30.000+01:00
diff --git a/ellar/common/params/args/request_model.py b/ellar/common/params/args/request_model.py
@@ -5,10 +5,15 @@
 from ellar.common.interfaces import IExecutionContext
 from ellar.common.logger import logger
 from pydantic import BaseModel, create_model
+from pydantic.fields import ModelField
 from starlette.convertors import Convertor
 
 from .. import params
-from ..resolvers import BaseRouteParameterResolver
+from ..resolvers import (
+    BulkFormParameterResolver,
+    IRouteParameterResolver,
+    RouteParameterModelField,
+)
 from .base import EndpointArgsModel
 from .extra_args import ExtraEndpointArg
 
@@ -78,6 +83,16 @@ def __init__(
         )
         self.operation_unique_id = operation_unique_id
 
+    def _get_body_resolver_model_fields(
+        self, body_resolvers: t.List[IRouteParameterResolver]
+    ) -> t.Generator[t.Union["RouteParameterModelField", ModelField], t.Any, None]:
+        for resolver in body_resolvers:
+            if isinstance(resolver, BulkFormParameterResolver):
+                for form_resolver in resolver.resolvers:
+                    yield form_resolver.model_field
+            else:
+                yield resolver.model_field
+
     def build_body_field(self) -> None:
         """
         Group common body / form fields to one field
@@ -92,22 +107,19 @@ def build_body_field(self) -> None:
             and not (
                 body_resolvers[0].model_field.field_info.embed  # type: ignore[attr-defined]
                 and isinstance(
-                    body_resolvers[0].model_field.field_info, params.BodyFieldInfo  # type: ignore[attr-defined]
+                    body_resolvers[0].model_field.field_info, params.BodyFieldInfo
                 )
             )
         ):
-            check_file_field(body_resolvers[0].model_field)  # type: ignore[attr-defined]
+            check_file_field(body_resolvers[0].model_field)
             self.body_resolver = body_resolvers[0]
         elif body_resolvers:
             # if body_resolvers is more than one, we create a bulk_body_resolver instead
-            _body_resolvers_model_fields = (
-                t.cast(BaseRouteParameterResolver, item).model_field
-                for item in body_resolvers
-            )
             model_name = "body_" + self.operation_unique_id
             body_model_field: t.Type[BaseModel] = create_model(model_name)
             _fields_required, _body_param_class = [], {}
-            for f in _body_resolvers_model_fields:
+
+            for f in self._get_body_resolver_model_fields(body_resolvers):
                 f.field_info.embed = True  # type:ignore[attr-defined]
                 body_model_field.__fields__[f.name] = f
                 _fields_required.append(f.required)
@@ -122,12 +134,12 @@ def build_body_field(self) -> None:
             media_type = "application/json"
             if len(_body_param_class) == 1:
                 _, (klass, field_info) = _body_param_class.popitem()
-                body_field_info = klass
+                body_field_info = klass  # type:ignore[assignment]
                 media_type = getattr(field_info, "media_type", media_type)
             elif len(_body_param_class) > 1:
                 key = sorted(_body_param_class.keys(), reverse=True)[0]
                 klass, field_info = _body_param_class[key]
-                body_field_info = klass
+                body_field_info = klass  # type:ignore[assignment]
                 media_type = getattr(field_info, "media_type", media_type)
 
             final_field = create_model_field(
diff --git a/ellar/common/params/resolvers/base.py b/ellar/common/params/resolvers/base.py
@@ -14,6 +14,8 @@ class RouteParameterModelField(ModelField):
 
 
 class IRouteParameterResolver(ABC, metaclass=ABCMeta):
+    model_field: t.Union[RouteParameterModelField, ModelField]
+
     @abstractmethod
     @t.no_type_check
     async def resolve(self, *args: t.Any, **kwargs: t.Any) -> t.Tuple:
diff --git a/tests/test_routing/document_results.py b/tests/test_routing/document_results.py
@@ -41,6 +41,48 @@
                 },
             }
         },
+        "/form-with-schema-spreading": {
+            "post": {
+                "tags": ["default"],
+                "operationId": "form_params_schema_spreading_form_with_schema_spreading_post",
+                "requestBody": {
+                    "content": {
+                        "multipart/form-data": {
+                            "schema": {
+                                "title": "Body",
+                                "allOf": [
+                                    {
+                                        "$ref": "#/components/schemas/body_form_params_schema_spreading_form_with_schema_spreading_post"
+                                    }
+                                ],
+                                "include_in_schema": True,
+                            }
+                        }
+                    },
+                    "required": True,
+                },
+                "responses": {
+                    "200": {
+                        "description": "Successful Response",
+                        "content": {
+                            "application/json": {
+                                "schema": {"title": "Response Model", "type": "object"}
+                            }
+                        },
+                    },
+                    "422": {
+                        "description": "Validation Error",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/HTTPValidationError"
+                                }
+                            }
+                        },
+                    },
+                },
+            }
+        },
         "/mixed": {
             "post": {
                 "tags": ["default"],
@@ -183,6 +225,12 @@
                     }
                 },
             },
+            "Range": {
+                "title": "Range",
+                "enum": [20, 50, 200],
+                "type": "integer",
+                "description": "An enumeration.",
+            },
             "ValidationError": {
                 "title": "ValidationError",
                 "required": ["loc", "msg", "type"],
@@ -197,6 +245,37 @@
                     "type": {"title": "Error Type", "type": "string"},
                 },
             },
+            "body_form_params_schema_spreading_form_with_schema_spreading_post": {
+                # form inputs are combined into one just like json body fields
+                "title": "body_form_params_schema_spreading_form_with_schema_spreading_post",
+                "required": ["momentOfTruth"],
+                "type": "object",
+                "properties": {
+                    "momentOfTruth": {
+                        "title": "Momentoftruth",
+                        "type": "string",
+                        "format": "binary",
+                        "include_in_schema": True,
+                    },
+                    "to": {
+                        "title": "To",
+                        "type": "string",
+                        "format": "date-time",
+                        "include_in_schema": True,
+                    },
+                    "from": {
+                        "title": "From",
+                        "type": "string",
+                        "format": "date-time",
+                        "include_in_schema": True,
+                    },
+                    "range": {
+                        "allOf": [{"$ref": "#/components/schemas/Range"}],
+                        "default": 20,
+                        "include_in_schema": True,
+                    },
+                },
+            },
             "body_form_upload_multiple_case_2_mixed_optional_post": {
                 "title": "body_form_upload_multiple_case_2_mixed_optional_post",
                 "type": "object",
diff --git a/tests/test_routing/test_formparsers.py b/tests/test_routing/test_formparsers.py
@@ -9,6 +9,7 @@
 from starlette.formparsers import UploadFile as StarletteUploadFile
 
 from .document_results import FORM_OPENAPI_DOC
+from .sample import Filter
 
 router = ModuleRouter("")
 
@@ -95,6 +96,14 @@ async def form_upload_multiple_case_2(
     }
 
 
+@router.post("/form-with-schema-spreading")
+def form_params_schema_spreading(
+    file: File[UploadFile, File.P(alias="momentOfTruth")],
+    filters: Filter = Form(..., alias="will_not_work_for_schema_with_many_field"),
+):
+    return dict(filters.dict(), file_name=file.filename)
+
+
 tm = Test.create_test_module(routers=(router,))
 
 
@@ -123,6 +132,26 @@ def test_multipart_request_files(tmpdir):
         }
 
 
+def test_file_with_form_schema_combines_all_to_one_schema(tmpdir):
+    path = os.path.join(tmpdir, "test.txt")
+    with open(path, "wb") as file:
+        file.write(b"<file content>")
+
+    client = tm.get_test_client()
+    with open(path, "rb") as f:
+        response = client.post(
+            "/form-with-schema-spreading",
+            data={"from": "1", "to": "2", "range": "50"},
+            files={"momentOfTruth": ("test.txt", f, "text/plain")},
+        )
+        assert response.json() == {
+            "file_name": "test.txt",
+            "from_datetime": "1970-01-01T00:00:01+00:00",
+            "range": 50,
+            "to_datetime": "1970-01-01T00:00:02+00:00",
+        }
+
+
 def test_multipart_request_files_with_content_type(tmpdir):
     path = os.path.join(tmpdir, "test.txt")
     with open(path, "wb") as file:
