test-coverage: added more test

Author: eadwinCode

ellar/common/responses/models/json.py

@@ -91,4 +91,4 @@ def serialize(
                 )
             except Exception:  # pragma:no cover
                 """Could not serialize response obj"""
-        return response_obj
+                return response_obj

ellar/common/routing/base.py

@@ -34,10 +34,11 @@ class RouteOperationBase:
 
     def __init__(self, endpoint: t.Callable) -> None:
         self.endpoint = endpoint
-        _controller_type: t.Type = reflect.get_metadata(  # type: ignore[assignment]
-            CONTROLLER_CLASS_KEY, self.endpoint
-        )
-        self._controller_type: t.Union[t.Type, t.Type["ControllerBase"]] = t.cast(
+
+        self._controller_type = None
+        _controller_type: t.Type = self.get_controller_type()
+
+        self._controller_type: t.Union[t.Type, t.Type["ControllerBase"]] = t.cast(  # type:ignore[no-redef]
             t.Union[t.Type, t.Type["ControllerBase"]], _controller_type
         )
 

ellar/common/routing/schema.py

@@ -71,7 +71,7 @@ class WsRouteParameters(Serializer):
     endpoint: t.Callable
     encoding: t.Optional[str] = Field("json")
     use_extra_handler: bool = Field(False)
-    extra_handler_type: t.Optional[t.Type["WebSocketExtraHandler"]] = None
+    extra_handler_type: t.Optional[t.Type[WebSocketExtraHandler]] = None
     _kwargs: t.Dict = PrivateAttr()
 
     def __init__(self, **data: t.Any) -> None:

ellar/common/routing/websocket/handler.py

@@ -5,7 +5,6 @@
 from ellar.common.interfaces import IExecutionContext
 from ellar.common.logger import request_logger
 from ellar.common.params import WebsocketEndpointArgsModel
-from ellar.pydantic import as_pydantic_validator
 from starlette import status
 from starlette.exceptions import WebSocketException
 from starlette.status import WS_1008_POLICY_VIOLATION
@@ -15,7 +14,7 @@
     from ellar.core.connection import WebSocket
 
 
-@as_pydantic_validator("__validate_input__")
+# @as_pydantic_validator("__validate_input__")
 class WebSocketExtraHandler:
     def __init__(
         self,
@@ -157,16 +156,17 @@ async def decode(self, websocket: "WebSocket", message: Message) -> t.Any:
         ), f"Unsupported 'encoding' attribute {self.encoding}"
         return message["text"] if message.get("text") else message["bytes"]
 
-    @classmethod
-    def __validate_input__(cls, __input_value: t.Any, _: t.Any) -> t.Any:
-        if not isinstance(__input_value, type):
-            raise ValueError(
-                f"Expected Type[WebSocketExtraHandler], received: {type(__input_value)}"
-            )
-        if WebSocketExtraHandler != __input_value or not issubclass(
-            __input_value, WebSocketExtraHandler
-        ):
-            raise ValueError(
-                f"Expected Type[WebSocketExtraHandler], received: {type(__input_value)}"
-            )
-        return __input_value
+    # THIS HAS BEEN TAKEN CARE OF BY PYDANTIC v2
+    # @classmethod
+    # def __validate_input__(cls, __input_value: t.Any, _: t.Any) -> t.Any:
+    #     if not isinstance(__input_value, type):
+    #         raise ValueError(
+    #             f"Expected Type[WebSocketExtraHandler], received: {type(__input_value)}"
+    #         )
+    #     if WebSocketExtraHandler != __input_value or not issubclass(
+    #         __input_value, WebSocketExtraHandler
+    #     ):
+    #         raise ValueError(
+    #             f"Expected Type[WebSocketExtraHandler], received: {type(__input_value)}"
+    #         )
+    #     return __input_value

ellar/common/serializer/base.py

@@ -84,16 +84,13 @@ def serialize(
         self, serializer_filter: t.Optional[SerializerFilter] = None
     ) -> t.Dict:
         _filter = serializer_filter or self._filter
-        return t.cast(
-            dict,
-            super().model_dump(**_filter.dict()),  # type:ignore[misc]
-        )
+        return self.model_dump(**_filter.dict())
 
     def serialize_json(
         self, serializer_filter: t.Optional[SerializerFilter] = None
     ) -> str:
         _filter = serializer_filter or self._filter
-        return super().model_dump_json(**_filter.dict())  # type:ignore[no-any-return,misc]
+        return self.model_dump_json(**_filter.dict())
 
     def dict(self, **kwargs: t.Any) -> t.Dict:
         return self.model_dump(**kwargs)

tests/test_response/test_pydantic_response_model.py

@@ -1,10 +1,10 @@
 from typing import Dict, List, Optional, Union
 
+import ellar.common as common
 from ellar.app import AppFactory
-from ellar.common import ModuleRouter, Serializer, serializer_filter
 from pydantic import BaseModel, Field
 
-mr = ModuleRouter("")
+mr = common.ModuleRouter("")
 
 
 class Item(BaseModel):
@@ -13,7 +13,7 @@ class Item(BaseModel):
     owner_ids: Optional[List[int]] = None
 
 
-class ItemSerializer(Serializer):
+class ItemSerializer(common.Serializer):
     name: str = Field(..., alias="aliased_name")
     price: Optional[float] = None
     owner_ids: Optional[List[int]] = None
@@ -48,19 +48,19 @@ def get_validdict():
 
 
 @mr.get("/items/valid-exclude-unset")
-@serializer_filter(exclude_unset=True)
+@common.serializer_filter(exclude_unset=True)
 def get_valid_exclude_unset():
     return Item(aliased_name="valid", price=1.0)
 
 
 @mr.get("/items/coerce-exclude-unset")
-@serializer_filter(exclude_unset=True)
+@common.serializer_filter(exclude_unset=True)
 def get_coerce_exclude_unset():
     return ItemSerializer(aliased_name="coerce", price="1.0")
 
 
 @mr.get("/items/validlist-exclude-unset")
-@serializer_filter(exclude_unset=True)
+@common.serializer_filter(exclude_unset=True)
 def get_validlist_exclude_unset():
     return [
         Item(aliased_name="foo"),
@@ -70,7 +70,7 @@ def get_validlist_exclude_unset():
 
 
 @mr.get("/items/validdict-exclude-unset")
-@serializer_filter(exclude_unset=True)
+@common.serializer_filter(exclude_unset=True)
 def get_validdict_exclude_unset():
     return {
         "k1": ItemSerializer(aliased_name="foo"),
@@ -79,6 +79,22 @@ def get_validdict_exclude_unset():
     }
 
 
+@mr.get(
+    "/items/valid-ellipsis-response-model",
+    response={201: Dict[str, ItemSerializer], ...: List[Item]},
+)
+def get_valid_ellipsis(switch: common.Query[str]):
+    if switch == "ellipsis":
+        return [
+            Item(aliased_name="bar", price=1.0),
+            Item(aliased_name="bar2", price=2.0),
+        ]
+    return 201, {
+        "k1": ItemSerializer(aliased_name="foo"),
+        "k3": ItemSerializer(aliased_name="baz", price=2.0, owner_ids=[1, 2, 3]),
+    }
+
+
 app = AppFactory.create_app(routers=(mr,))
 
 
@@ -156,3 +172,18 @@ def test_validdict_exclude_unset(test_client_factory):
         "k2": {"aliased_name": "bar", "price": 1.0},
         "k3": {"aliased_name": "baz", "price": 2.0, "owner_ids": [1, 2, 3]},
     }
+
+
+def test_valid_ellipsis(test_client_factory):
+    client = test_client_factory(app)
+    response = client.get("/items/valid-ellipsis-response-model?switch=ellipsis")
+    response.raise_for_status()
+    assert response.json() == [
+        {"aliased_name": "bar", "owner_ids": None, "price": 1.0},
+        {"aliased_name": "bar2", "owner_ids": None, "price": 2.0},
+    ]
+    response = client.get("/items/valid-ellipsis-response-model?switch=none")
+    assert response.json() == {
+        "k1": {"aliased_name": "foo", "owner_ids": None, "price": None},
+        "k3": {"aliased_name": "baz", "owner_ids": [1, 2, 3], "price": 2.0},
+    }

tests/test_response/test_route_response_model.py

@@ -1,7 +1,7 @@
 from typing import List, Union
 
 import pytest
-from ellar.common.constants import RESPONSE_OVERRIDE_KEY
+from ellar.common.constants import CONTROLLER_CLASS_KEY, RESPONSE_OVERRIDE_KEY
 from ellar.common.exceptions import ImproperConfiguration
 from ellar.common.responses.models import (
     EmptyAPIResponseModel,
@@ -111,14 +111,18 @@ def test_route_response_model_exception(inputs):
 
 
 def test_invalid_response_override_definition():
-    reflect.define_metadata(
-        RESPONSE_OVERRIDE_KEY, {EmptyAPIResponseModel()}, endpoint_sample
-    )
-    with pytest.raises(ImproperConfiguration) as ex:
-        RouteOperation(
-            path="/",
-            methods=["get"],
-            endpoint=endpoint_sample,
-            response={200: EmptyAPIResponseModel()},
+    with reflect.context():
+        reflect.define_metadata(
+            RESPONSE_OVERRIDE_KEY, {EmptyAPIResponseModel()}, endpoint_sample
         )
+        reflect.define_metadata(
+            CONTROLLER_CLASS_KEY, type("endpoint_sample_class", (), {}), endpoint_sample
+        )
+        with pytest.raises(ImproperConfiguration) as ex:
+            RouteOperation(
+                path="/",
+                methods=["get"],
+                endpoint=endpoint_sample,
+                response={200: EmptyAPIResponseModel()},
+            )
     assert "`RESPONSE_OVERRIDE` is must be of type `Dict`" in str(ex)