Test Coverage: Increased test converage to 100%

Author: eadwinCode

ellar/common/params/args/request_model.py

@@ -13,6 +13,7 @@
 
 from .. import params
 from ..resolvers import (
+    BodyParameterResolver,
     BulkFormParameterResolver,
     IRouteParameterResolver,
     RouteParameterModelField,
@@ -107,8 +108,10 @@ def build_body_field(self) -> None:
         if (
             body_resolvers
             and len(body_resolvers) == 1
-            and not (
-                body_resolvers[0].model_field.field_info.embed  # type: ignore[attr-defined]
+            and not isinstance(body_resolvers[0], BulkFormParameterResolver)
+            and (
+                isinstance(body_resolvers[0], BodyParameterResolver)
+                and not body_resolvers[0].model_field.field_info.embed  # type: ignore[attr-defined]
             )
         ):
             check_file_field(body_resolvers[0].model_field)

ellar/common/params/resolvers/bulk_parameter.py

@@ -35,7 +35,7 @@ async def resolve_handle(
         errors: t.List[ErrorWrapper] = []
 
         for parameter_resolver in self._resolvers:
-            value_, errors_ = await parameter_resolver.resolve(ctx=ctx)
+            value_, errors_ = await parameter_resolver.resolve(*args, ctx=ctx, **kwargs)
             if value_:
                 values.update(
                     {
@@ -46,15 +46,18 @@ async def resolve_handle(
                 )
             if errors_:
                 errors += self.validate_error_sequence(errors_)
+
         if errors:
             return values, errors
 
+        # Combining resolved values into one pydantic model specified by the user in Route function parameter
         v_, errors_ = self.model_field.validate(
             values,
             {},
             loc=(self.model_field.field_info.in_.value, self.model_field.alias),
         )
-        if errors_:
+        if errors_:  # pragma: no cover
+            # Just in case error still happened after combining each field to on class.
             errors += self.validate_error_sequence(errors_)
             return values, errors
         return {self.model_field.name: v_}, []
@@ -82,13 +85,15 @@ async def resolve_grouped_fields(
         value, resolver_errors = await self._get_resolver_data(ctx, body, by_alias=True)
         if resolver_errors:
             return value, resolver_errors
-
+        # Combining resolved values into one pydantic model specified by the user in Route function parameter
         processed_value, processed_errors = self.model_field.validate(
             value,
             {},
             loc=(self.model_field.field_info.in_.value, self.model_field.alias),
         )
-        if processed_errors:
+
+        if processed_errors:  # pragma: no cover
+            # Just in case error still happened after combining each field to on class.
             processed_errors = self.validate_error_sequence(processed_errors)
             return processed_value, processed_errors
         return {self.model_field.name: processed_value}, []
@@ -125,25 +130,22 @@ async def resolve_handle(
     ) -> t.Tuple:
         request_logger.debug(f"Resolving Form Parameters - '{self.__class__.__name__}'")
         _body = await self.get_request_body(ctx)
-        if self._resolvers:
-            return await self._use_resolver(ctx, _body)
-        return await super(BulkFormParameterResolver, self).resolve_handle(
-            ctx, *args, **kwargs
-        )
+        return await self._use_resolver(ctx, _body)
 
 
-class BulkBodyParameterResolver(BodyParameterResolver, BulkParameterResolver):
+class BulkBodyParameterResolver(BulkParameterResolver, BodyParameterResolver):
     async def resolve_handle(
         self, ctx: IExecutionContext, *args: t.Any, **kwargs: t.Any
     ) -> t.Tuple:
         request_logger.debug(
             f"Resolving Request Body Parameters - '{self.__class__.__name__}'"
         )
         _body = await self.get_request_body(ctx)
-        values, errors = await super(BulkBodyParameterResolver, self).resolve_handle(
-            ctx, *args, body=_body, **kwargs
-        )
-        if not errors:
-            _, body_value = values.popitem()
-            return body_value.dict(), []
-        return values, self.validate_error_sequence(errors)
+
+        values, errors = await super().resolve_handle(ctx, *args, body=_body, **kwargs)
+
+        if errors:
+            return values, self.validate_error_sequence(errors)
+
+        _, body_value = values.popitem()
+        return body_value.dict(), []

ellar/common/params/resolvers/parameter.py

@@ -5,8 +5,6 @@
 
 import anyio
 from ellar.common.constants import (
-    # sequence_shape_to_type,
-    # sequence_shapes,
     sequence_types,
 )
 from ellar.common.exceptions import RequestValidationError
@@ -130,6 +128,15 @@ async def resolve_handle(
             loc = ("body", self.model_field.alias)  # type:ignore
         try:
             value = received_body.get(self.model_field.alias)
+
+            if value is None:
+                if self.model_field.required:
+                    return None, [self.create_error(loc=loc)]
+                else:
+                    return {
+                        self.model_field.name: copy.deepcopy(self.model_field.default)
+                    }, []
+
             v_, errors_ = self.model_field.validate(value, {}, loc=loc)
             return {self.model_field.name: v_}, self.validate_error_sequence(errors_)
         except AttributeError:
@@ -227,7 +234,6 @@ async def resolve_handle(
     ) -> t.Tuple:
         _body = body or await self.get_request_body(ctx)
         embed = getattr(self.model_field.field_info, "embed", False)
-        values = {}  # type: ignore
         received_body = {self.model_field.alias: _body}
         loc = ("body",)
 
@@ -239,22 +245,28 @@ async def resolve_handle(
             loc = ("body", self.model_field.alias)  # type: ignore
             value = _body.getlist(self.model_field.alias)
         else:
-            try:
-                value = received_body.get(self.model_field.alias)  # type: ignore
-            except AttributeError:
-                errors = [self.create_error(loc=loc)]
-                return values, errors
+            value = received_body.get(self.model_field.alias)  # type: ignore
 
-        if not value or is_sequence_field(self.model_field) and len(value) == 0:
+        if (
+            value is None
+            or (
+                isinstance(self.model_field.field_info.resolver, FormParameterResolver)
+                and value == ""
+            )
+            or (
+                isinstance(self.model_field.field_info.resolver, FormParameterResolver)
+                and is_sequence_field(self.model_field)
+                and len(value) == 0
+            )
+        ):
             if self.model_field.required:
-                return await self.process_and_validate(
-                    values=values, value=_body, loc=loc
-                )
+                return None, [self.create_error(loc=loc)]
             else:
-                values[self.model_field.name] = copy.deepcopy(self.model_field.default)
-            return values, []
+                return {
+                    self.model_field.name: copy.deepcopy(self.model_field.default)
+                }, []
 
-        return await self.process_and_validate(values=values, value=value, loc=loc)
+        return await self.process_and_validate(values={}, value=value, loc=loc)
 
 
 class FileParameterResolver(FormParameterResolver):

ellar/openapi/decorators/extra_info.py

@@ -2,6 +2,7 @@
 
 from ellar.common.compatible import AttributeDict
 from ellar.common.decorators import set_metadata as set_meta
+from ellar.common.exceptions import ImproperConfiguration
 from ellar.openapi.constants import OPENAPI_OPERATION_KEY
 
 
@@ -23,6 +24,9 @@ def openapi_info(
     :param deprecated:
     :return:
     """
+    if tags and not isinstance(tags, list):
+        raise ImproperConfiguration("tags must be a sequence of str eg, [tagA, tagB]")
+
     return set_meta(
         OPENAPI_OPERATION_KEY,
         AttributeDict(

ellar/openapi/route_doc_models.py

@@ -150,9 +150,6 @@ def __init__(
         )
         self.guards = guards or []
 
-        if self.tags and not isinstance(self.tags, list):
-            self.tags = [self.tags]
-
     @cached_property
     def _openapi_models(self) -> t.List[t.Union[ModelField, RouteParameterModelField]]:
         _models: t.List[ModelField] = self.input_fields + self.output_fields
@@ -169,7 +166,8 @@ def input_fields(self) -> t.List[ModelField]:
         _models: t.List[ModelField] = self.global_route_parameters
 
         for item in self.route.endpoint_parameter_model.get_all_models():
-            if isinstance(item, BodyParameterResolver):
+            if isinstance(item, BodyParameterResolver):  # pragma: no cover
+                # just incase we have a Body Field
                 continue
 
             if isinstance(item, BulkParameterResolver):
@@ -262,7 +260,7 @@ def get_openapi_operation_parameters(
             }
             if field_info.description:
                 parameter["description"] = field_info.description
-            if field_info.examples:  # pragma:no cover
+            if field_info.examples:  # pragma: no cover
                 parameter["examples"] = field_info.examples  # type:ignore[assignment]
             if field_info.deprecated:
                 parameter["deprecated"] = field_info.deprecated

tests/test_openapi/test_openapi.py …est_openapi/test_extra_info_decorator.pytests/test_openapi/test_openapi.py renamed to tests/test_openapi/test_extra_info_decorator.py tests/test_openapi/test_openapi.py renamed to tests/test_openapi/test_extra_info_decorator.py

@@ -1,4 +1,6 @@
+import pytest
 from ellar.common.compatible import AttributeDict
+from ellar.common.exceptions import ImproperConfiguration
 from ellar.core.connection import Request
 from ellar.openapi import openapi_info
 from ellar.openapi.constants import OPENAPI_OPERATION_KEY
@@ -24,3 +26,14 @@ def test_openapi_sets_endpoint_meta():
     assert open_api_data.deprecated is False
     assert open_api_data.operation_id == "4524d-z23zd-453ed-2342e"
     assert open_api_data.tags == ["endpoint", "endpoint-25"]
+
+
+def test_invalid_openapi_info_decorator_setup():
+    with pytest.raises(ImproperConfiguration):
+
+        @openapi_info(
+            operation_id="4524d-z23zd-453ed-2342e",
+            tags="endpoint",
+        )
+        def endpoint(request: Request):
+            pass  # pragma: no cover

tests/test_openapi/test_open_api_route_documentation.py

@@ -1,9 +1,10 @@
 import typing as t
 
 from ellar.auth.guards import GuardAPIKeyCookie
-from ellar.common import Body, ModuleRouter, Query
+from ellar.common import Body, GuardCanActivate, ModuleRouter, Query, UseGuards
 from ellar.common.constants import CONTROLLER_OPERATION_HANDLER_KEY
 from ellar.common.responses.models import ResponseModel, ResponseModelField
+from ellar.core import ExecutionContext
 from ellar.core.connection import HTTPConnection
 from ellar.core.routing import ModuleRouterFactory
 from ellar.openapi import OpenAPIRouteDocumentation, openapi_info
@@ -14,6 +15,11 @@
 from ..schema import BlogObjectDTO, CreateCarSchema, Filter, NoteSchemaDC
 
 
+class JustAGuard(GuardCanActivate):
+    async def can_activate(self, context: ExecutionContext) -> bool:
+        return True
+
+
 class CustomCookieAPIKey(GuardAPIKeyCookie):
     parameter_name = "custom-key"
 
@@ -41,16 +47,21 @@ class CustomResponseModel(ResponseModel):
 @openapi_info(
     summary="Endpoint Summary",
     description="Endpoint Description",
-    deprecated=False,
+    deprecated=True,
     tags=["endpoint", "endpoint-25"],
 )
-def get_car_by_id(car_id: int, filter: Filter = Query()):
+def get_car_by_id(
+    car_id: int,
+    filter: Filter = Query(),
+    schema: int = Query(description="input field description", deprecated=True),
+):
     res = filter.dict()
-    res.update(car_id=car_id)
+    res.update(car_id=car_id, schema=schema)
     return res
 
 
 @router.get("/create", response={201: CreateCarSchema})
+@UseGuards(JustAGuard)
 def create_car(car: CreateCarSchema):
     return car
 
@@ -68,7 +79,7 @@ def test_open_api_route_model_input_fields():
         CONTROLLER_OPERATION_HANDLER_KEY, get_car_by_id
     )
     openapi_route_doc = OpenAPIRouteDocumentation(route=route_operation)
-    assert len(openapi_route_doc.input_fields) == 3
+    assert len(openapi_route_doc.input_fields) == 4
 
     for field in openapi_route_doc.input_fields:
         assert field.field_info.in_.value in ["query", "path"]
@@ -97,14 +108,16 @@ def test_open_api_route_model_get_openapi_operation_metadata():
         "summary": "Endpoint Summary",
         "description": "Endpoint Description",
         "operationId": "get_car_by_id_cars__car_id__post",
+        "deprecated": True,
     }
 
     result = openapi_route_doc.get_openapi_operation_metadata("some_http_method")
     assert result == {
-        "tags": ["endpoint", "endpoint-25"],
-        "summary": "Endpoint Summary",
+        "deprecated": True,
         "description": "Endpoint Description",
         "operationId": "get_car_by_id_cars__car_id__some_http_method",
+        "summary": "Endpoint Summary",
+        "tags": ["endpoint", "endpoint-25"],
     }
 
 
@@ -160,6 +173,18 @@ def test_open_api_route_get_openapi_operation_parameters_works_for_empty_model_n
                 "title": "From",
             },
         },
+        {
+            "name": "schema",
+            "in": "query",
+            "required": True,
+            "schema": {
+                "type": "integer",
+                "description": "input field description",
+                "title": "Schema",
+            },
+            "description": "input field description",
+            "deprecated": True,
+        },
     ]
 
 
@@ -416,7 +441,7 @@ def test_open_api_route__get_openapi_path_object_works_for_routes_with_multiple_
         CONTROLLER_OPERATION_HANDLER_KEY, list_and_create_car
     )
     openapi_route_doc = OpenAPIRouteDocumentation(
-        route=route_operation, guards=[CustomCookieAPIKey()]
+        route=route_operation, guards=[CustomCookieAPIKey(), JustAGuard()]
     )
     field_mapping, _ = get_definitions(
         fields=openapi_route_doc.get_route_models(),