test-coverage: increased test coverage and some code refactoring

eadwinCode · eadwinCode · commit 8fe61531ffc1 · 2023-12-19T09:10:42.000+01:00
diff --git a/ellar/common/decorators/controller.py b/ellar/common/decorators/controller.py
@@ -48,28 +48,35 @@ def reflect_all_controller_type_routes(cls: t.Type[ControllerBase]) -> None:
                     )
                 reflect.define_metadata(CONTROLLER_CLASS_KEY, cls, item)
 
-                parameter = item.__dict__[ROUTE_OPERATION_PARAMETERS]
+                parameters = item.__dict__[ROUTE_OPERATION_PARAMETERS]
                 operation: t.Union[
                     ControllerRouteOperation, ControllerWebsocketRouteOperation
                 ]
-                if isinstance(parameter, RouteParameters):
-                    operation = ControllerRouteOperation(**parameter.dict())
-                elif isinstance(parameter, WsRouteParameters):
-                    operation = ControllerWebsocketRouteOperation(**parameter.dict())
-                else:  # pragma: no cover
-                    logger.warning(
-                        f"Parameter type is not recognized. {type(parameter) if not isinstance(parameter, type) else parameter}"
+
+                if not isinstance(parameters, list):
+                    parameters = [parameters]
+
+                for parameter in parameters:
+                    if isinstance(parameter, RouteParameters):
+                        operation = ControllerRouteOperation(**parameter.dict())
+                    elif isinstance(parameter, WsRouteParameters):
+                        operation = ControllerWebsocketRouteOperation(
+                            **parameter.dict()
+                        )
+                    else:  # pragma: no cover
+                        logger.warning(
+                            f"Parameter type is not recognized. {type(parameter) if not isinstance(parameter, type) else parameter}"
+                        )
+                        continue
+
+                    reflect.define_metadata(
+                        CONTROLLER_OPERATION_HANDLER_KEY,
+                        [operation],
+                        cls,
                     )
-                    continue
 
                 del item.__dict__[ROUTE_OPERATION_PARAMETERS]
 
-                reflect.define_metadata(
-                    CONTROLLER_OPERATION_HANDLER_KEY,
-                    [operation],
-                    cls,
-                )
-
 
 @t.no_type_check
 def Controller(
diff --git a/ellar/common/responses/models/base.py b/ellar/common/responses/models/base.py
@@ -6,7 +6,7 @@
 from ellar.common.exceptions import RequestValidationError
 from ellar.common.interfaces import IExecutionContext, IResponseModel
 from ellar.common.logging import request_logger
-from ellar.common.serializer import BaseSerializer, SerializerFilter
+from ellar.common.serializer import BaseSerializer, SerializerFilter, serialize_object
 from ellar.pydantic import ModelField, create_model_field
 from ellar.reflect import reflect
 from starlette.responses import Response
@@ -204,7 +204,18 @@ def serialize(
         response_obj: t.Any,
         serializer_filter: t.Optional[SerializerFilter] = None,
     ) -> t.Union[t.List[t.Dict], t.Dict, t.Any]:
-        return response_obj
+        return self._serialize_with_serializer_object(response_obj)
+
+    def _serialize_with_serializer_object(
+        self,
+        response_obj: t.Any,
+        serializer_filter: t.Optional[SerializerFilter] = None,
+    ) -> t.Union[t.List[t.Dict], t.Dict, t.Any]:
+        try:
+            return serialize_object(response_obj, serializer_filter=serializer_filter)
+        except Exception:  # pragma: no cover
+            """Could not serialize response obj"""
+            return response_obj
 
 
 class ResponseResolver(t.NamedTuple):
diff --git a/ellar/common/responses/models/json.py b/ellar/common/responses/models/json.py
@@ -3,7 +3,7 @@
 from ellar.common.constants import SERIALIZER_FILTER_KEY
 from ellar.common.interfaces import IExecutionContext
 from ellar.common.logging import request_logger
-from ellar.common.serializer import SerializerFilter, serialize_object
+from ellar.common.serializer import SerializerFilter
 from ellar.pydantic import as_pydantic_validator, create_model_field
 from ellar.reflect import reflect
 
@@ -85,10 +85,6 @@ def serialize(
         try:
             return super().serialize(response_obj, serializer_filter)
         except Exception:
-            try:
-                return serialize_object(
-                    response_obj, serializer_filter=serializer_filter
-                )
-            except Exception:  # pragma:no cover
-                """Could not serialize response obj"""
-                return response_obj
+            return self._serialize_with_serializer_object(
+                response_obj, serializer_filter
+            )
diff --git a/ellar/common/responses/models/type_converter.py b/ellar/common/responses/models/type_converter.py
@@ -3,12 +3,7 @@
 
 from ellar.common.constants import primitive_types
 from ellar.common.converters import TypeDefinitionConverter
-from ellar.common.serializer.base import (
-    BaseSerializer,
-    Serializer,
-    SerializerBase,
-    convert_dataclass_to_pydantic_model,
-)
+from ellar.common.serializer.base import BaseSerializer, Serializer
 from ellar.pydantic import BaseModel
 
 
@@ -27,14 +22,15 @@ def _get_converted_type(
             return outer_type_
 
         if is_dataclass(outer_type_):
-            pydantic_dataclass = convert_dataclass_to_pydantic_model(outer_type_)
-
-            cls = type(
-                outer_type_.__name__,
-                (pydantic_dataclass, SerializerBase),
-                {},
-            )
-            return t.cast(t.Type[BaseSerializer], cls)
+            # pydantic_dataclass = convert_dataclass_to_pydantic_model(outer_type_)
+            #
+            # cls = type(
+            #     outer_type_.__name__,
+            #     (pydantic_dataclass, SerializerBase),
+            #     {},
+            # )
+            # return t.cast(t.Type[BaseSerializer], cls)
+            return outer_type_
 
         if outer_type_ in primitive_types:
             return outer_type_
diff --git a/ellar/common/responses/response_types.py b/ellar/common/responses/response_types.py
@@ -24,13 +24,13 @@
 
 try:
     import ujson
-except ImportError:  # pragma: nocover
+except ImportError:  # pragma: no cover
     ujson = None  # type: ignore
 
 
 try:
     import orjson
-except ImportError:  # pragma: nocover
+except ImportError:  # pragma: no cover
     orjson = None  # type: ignore
 
 
diff --git a/ellar/common/routing/operation_definitions.py b/ellar/common/routing/operation_definitions.py
@@ -58,7 +58,11 @@ class OperationDefinitions:
 
     def _get_operation(self, route_parameter: RouteParameters) -> t.Callable:
         setattr(route_parameter.endpoint, OPERATION_ENDPOINT_KEY, True)
-        setattr(route_parameter.endpoint, ROUTE_OPERATION_PARAMETERS, route_parameter)
+        route_parameters = getattr(
+            route_parameter.endpoint, ROUTE_OPERATION_PARAMETERS, []
+        )
+        route_parameters.append(route_parameter)
+        setattr(route_parameter.endpoint, ROUTE_OPERATION_PARAMETERS, route_parameters)
         return route_parameter.endpoint
 
     def _get_ws_operation(self, ws_route_parameters: WsRouteParameters) -> t.Callable:
diff --git a/ellar/common/serializer/__init__.py b/ellar/common/serializer/__init__.py
@@ -5,7 +5,6 @@
     SerializerConfig,
     SerializerFilter,
     default_serializer_filter,
-    get_dataclass_pydantic_model,
     serialize_object,
 )
 
@@ -16,6 +15,5 @@
     "SerializerBase",
     "BaseSerializer",
     "serialize_object",
-    "get_dataclass_pydantic_model",
     "default_serializer_filter",
 ]
diff --git a/ellar/common/serializer/base.py b/ellar/common/serializer/base.py
@@ -11,7 +11,6 @@
     BaseModel,
     TypeAdapter,
     model_dump,
-    pydantic_dataclass,
 )
 
 __pydantic_model__ = "__pydantic_core_schema__"
@@ -20,12 +19,26 @@
 __skip_filter__ = "__skip_filter__"
 
 
-@t.no_type_check
-def get_dataclass_pydantic_model(
-    dataclass_type: t.Type,
-) -> t.Optional[t.Type[BaseModel]]:
-    if hasattr(dataclass_type, __pydantic_model__):
-        return t.cast(t.Type[BaseModel], dataclass_type)
+# @t.no_type_check
+# def get_dataclass_pydantic_model(
+#     dataclass_type: t.Type,
+# ) -> t.Optional[t.Type[BaseModel]]:
+#     if hasattr(dataclass_type, __pydantic_model__):
+#         return t.cast(t.Type[BaseModel], dataclass_type)
+#
+# def convert_dataclass_to_pydantic_model(dataclass_type: t.Type) -> t.Type[BaseModel]:
+#     if is_dataclass(dataclass_type):
+#         if get_dataclass_pydantic_model(dataclass_type):
+#             return t.cast(t.Type[BaseModel], dataclass_type)
+#
+#         # convert to dataclass
+#         decorator = pydantic_dataclass(
+#             config=getattr(dataclass_type, __pydantic_config__, SerializerConfig),
+#         )
+#         pydantic_dataclass_cls = decorator(t.cast(t.Any, dataclass_type))
+#         # sa = {item: getattr(pydantic_dataclass, item) for item in dir(pydantic_dataclass)}
+#         return t.cast(t.Type[BaseModel], pydantic_dataclass_cls)
+#     raise Exception(f"{dataclass_type} is not a dataclass")
 
 
 class SerializerConfig(BaseConfig):
@@ -108,21 +121,6 @@ class Serializer(SerializerBase, BaseModel, __skip_filter__=True):
     model_config = {"from_attributes": True}
 
 
-def convert_dataclass_to_pydantic_model(dataclass_type: t.Type) -> t.Type[BaseModel]:
-    if is_dataclass(dataclass_type):
-        if get_dataclass_pydantic_model(dataclass_type):
-            return t.cast(t.Type[BaseModel], dataclass_type)
-
-        # convert to dataclass
-        decorator = pydantic_dataclass(
-            config=getattr(dataclass_type, __pydantic_config__, SerializerConfig),
-        )
-        pydantic_dataclass_cls = decorator(t.cast(t.Any, dataclass_type))
-        # sa = {item: getattr(pydantic_dataclass, item) for item in dir(pydantic_dataclass)}
-        return t.cast(t.Type[BaseModel], pydantic_dataclass_cls)
-    raise Exception(f"{dataclass_type} is not a dataclass")
-
-
 def _lazy_current_config() -> t.Any:
     return LazyStrImport("ellar.app:current_config")
 
diff --git a/ellar/core/routing/app.py b/ellar/core/routing/app.py
@@ -53,8 +53,9 @@ def __init__(
         self.routes: RouteCollection = RouteCollection(routes)
 
     def append(self, item: t.Union[BaseRoute, t.Callable]) -> None:
-        _item: t.Any = build_route_handler(item)
-        self.routes.append(_item)
+        _items: t.Any = build_route_handler(item)
+        if _items:
+            self.routes.extend(_items)
 
     def extend(self, routes: t.Sequence[t.Union[BaseRoute, t.Callable]]) -> None:
         for route in routes:
diff --git a/ellar/core/routing/helper.py b/ellar/core/routing/helper.py
@@ -18,7 +18,7 @@
 
 
 @t.no_type_check
-def build_route_handler(item: t.Callable) -> t.Optional[RouteOperationBase]:
+def build_route_handler(item: t.Callable) -> t.Optional[t.List[RouteOperationBase]]:
     _item: t.Any = item
 
     if callable(item) and type(item) == FunctionType:
@@ -28,11 +28,19 @@ def build_route_handler(item: t.Callable) -> t.Optional[RouteOperationBase]:
         reflect.define_metadata(CONTROLLER_CLASS_KEY, get_unique_control_type(), item)
 
     if not _item and hasattr(item, ROUTE_OPERATION_PARAMETERS):
-        operations = build_route_parameters([item.__dict__[ROUTE_OPERATION_PARAMETERS]])
-        if not operations:
-            return None  # pragma: no cover
-        return operations[0]
-    return _item
+        parameters = item.__dict__[ROUTE_OPERATION_PARAMETERS]
+
+        if not isinstance(parameters, list):
+            parameters = [parameters]
+
+        operations = build_route_parameters(parameters)
+        if isinstance(operations, list):
+            return operations
+
+    if _item:
+        return [_item]
+
+    return _item  # pragma: no cover
 
 
 @t.no_type_check
diff --git a/tests/test_controller/test_route_collection.py b/tests/test_controller/test_route_collection.py
@@ -42,7 +42,7 @@ def endpoint_sample():
         )
         return response
 
-    return build_route_handler(endpoint_sample)
+    return build_route_handler(endpoint_sample)[0]
 
 
 def create_ws_route_operation(
@@ -57,7 +57,7 @@ def endpoint_sample():
         response = JSONResponse(content={"path": path, "versioning": versions})
         return response
 
-    return build_route_handler(endpoint_sample)
+    return build_route_handler(endpoint_sample)[0]
 
 
 class MockHostRouteOperation(Host):
diff --git a/tests/test_response/test_json_response_type_swap.py b/tests/test_response/test_json_response_type_swap.py
@@ -0,0 +1,65 @@
+from ellar.common import ModuleRouter, ORJSONResponse, UJSONResponse
+from ellar.testing import Test
+
+from ..schema import NoteSchemaDC
+
+
+class AssertUJSONResponseSwap(UJSONResponse):
+    def render(self, content) -> bytes:
+        content.update(rendered="AssertUJSONResponseSwap")
+        return super().render(content)
+
+
+router = ModuleRouter()
+
+
+@router.get("/orjson", response=ORJSONResponse)
+def json_with_orjson():
+    return NoteSchemaDC(id=1, completed=False, text="JSON rendered with ORJSON")
+
+
+@router.get("/ujson", response=UJSONResponse)
+def json_with_ujson():
+    return NoteSchemaDC(id=1, completed=False, text="JSON rendered with UJSON")
+
+
+@router.get("/json", response=NoteSchemaDC)
+def json_swapped_with_ujson():
+    return NoteSchemaDC(id=1, completed=False, text="JSON rendered with UJSON")
+
+
+tm = Test.create_test_module(
+    routers=[router], config_module={"DEFAULT_JSON_CLASS": AssertUJSONResponseSwap}
+)
+client = tm.get_test_client()
+
+
+def test_orjson_response():
+    res = client.get("/orjson")
+    assert res.status_code == 200
+    assert res.json() == {
+        "completed": False,
+        "id": 1,
+        "text": "JSON rendered with ORJSON",
+    }
+
+
+def test_ujson_response():
+    res = client.get("/ujson")
+    assert res.status_code == 200
+    assert res.json() == {
+        "completed": False,
+        "id": 1,
+        "text": "JSON rendered with UJSON",
+    }
+
+
+def test_json_swapped_response():
+    res = client.get("/json")
+    assert res.status_code == 200
+    assert res.json() == {
+        "completed": False,
+        "id": 1,
+        "rendered": "AssertUJSONResponseSwap",
+        "text": "JSON rendered with UJSON",
+    }
diff --git a/tests/test_response/test_response_type_definition_converter.py b/tests/test_response/test_response_type_definition_converter.py
diff --git a/tests/test_response/test_route_response_model.py b/tests/test_response/test_route_response_model.py
diff --git a/tests/test_routing/test_body_schema_extra_properties.py b/tests/test_routing/test_body_schema_extra_properties.py
diff --git a/tests/test_routing/test_put_with_no_body_schema.py b/tests/test_routing/test_put_with_no_body_schema.py
diff --git a/tests/test_serializer.py b/tests/test_serializer.py

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,6 @@`
`5`	`5`	`SerializerConfig,`
`6`	`6`	`SerializerFilter,`
`7`	`7`	`default_serializer_filter,`
`8`		`- get_dataclass_pydantic_model,`
`9`	`8`	`serialize_object,`
`10`	`9`	`)`
`11`	`10`
`@@ -16,6 +15,5 @@`
`16`	`15`	`"SerializerBase",`
`17`	`16`	`"BaseSerializer",`
`18`	`17`	`"serialize_object",`
`19`		`- "get_dataclass_pydantic_model",`
`20`	`18`	`"default_serializer_filter",`
`21`	`19`	`]`