bumped up test coverage

Author: eadwinCode

ellar/core/middleware/__init__.py

@@ -6,6 +6,7 @@
 from starlette.middleware.httpsredirect import (
     HTTPSRedirectMiddleware as HTTPSRedirectMiddleware,
 )
+from starlette.middleware.sessions import SessionMiddleware as SessionMiddleware
 from starlette.middleware.trustedhost import (
     TrustedHostMiddleware as TrustedHostMiddleware,
 )
@@ -29,4 +30,5 @@
     "WSGIMiddleware",
     "RequestVersioningMiddleware",
     "RequestServiceProviderMiddleware",
+    "SessionMiddleware",
 ]

ellar/core/modules/ref.py

@@ -218,11 +218,13 @@ def routers(self) -> t.Sequence[t.Union[BaseRoute, ModuleMount, Mount]]:
     def routes(self) -> t.List[BaseRoute]:
         if not self._flatten_routes:
             for router in self._routers:
-                if isinstance(router, ModuleMount):
-                    # TODO: Allow users to choose whether to run flatten route of group routes together
-                    # router.build_child_routes()
-                    self._flatten_routes.append(router)
-                    continue
+                # if isinstance(router, ModuleMount):
+                #     # TODO: Allow users to choose whether to run flatten route of group routes together
+                #     # router.build_child_routes()
+                #     self._flatten_routes.append(router)
+                #     continue
+                # if isinstance(router, BaseRoute):
+                #     self._flatten_routes.append(router)
                 if isinstance(router, BaseRoute):
                     self._flatten_routes.append(router)
         return self._flatten_routes

ellar/core/routing/controller/base.py

@@ -13,7 +13,9 @@ def _get_controller_instance(self, ctx: IExecutionContext) -> ControllerBase:
         controller_type: t.Optional[t.Type[ControllerBase]] = reflect.get_metadata(
             CONTROLLER_CLASS_KEY, self.endpoint
         )
-        if not controller_type and issubclass(controller_type, ControllerBase):  # type: ignore
+        if not controller_type or (
+            controller_type and not issubclass(controller_type, ControllerBase)
+        ):
             raise RuntimeError("Controller Type was not found")
 
         service_provider = ctx.get_service_provider()

ellar/core/routing/route.py

@@ -44,7 +44,7 @@ def __init__(
         path: str,
         methods: t.List[str],
         endpoint: t.Callable,
-        response: t.Mapping[int, t.Type],
+        response: t.Mapping[int, t.Union[t.Type, t.Any]],
         name: t.Optional[str] = None,
         include_in_schema: bool = True,
     ) -> None:

ellar/core/routing/websocket/route.py

@@ -144,6 +144,3 @@ def _load_model(self) -> None:
                 "`WsBody` should only be used when "
                 "`use_extra_handler` flag is set to True in WsRoute"
             )
-
-    def __hash__(self) -> t.Any:
-        return self.endpoint

tests/test_common/test_decorators/test_controller.py

@@ -1,7 +1,9 @@
-from ellar.core import ControllerBase
+import pytest
 
 from ellar.common import Controller, set_metadata
 from ellar.constants import CONTROLLER_METADATA, GUARDS_KEY, NOT_SET, VERSIONING_KEY
+from ellar.core import ControllerBase
+from ellar.core.exceptions import ImproperConfiguration
 from ellar.reflect import reflect
 
 
@@ -109,3 +111,14 @@ def test_controller_set_metadata_decorator_works():
         )
         == "Something"
     )
+
+
+def test_controller_decorator_fails_as_a_function_decorator():
+    def controller_function():
+        pass  # pragma: no cover
+
+    with pytest.raises(
+        ImproperConfiguration,
+        match=f"Controller is a class decorator - {controller_function}",
+    ):
+        Controller("/some-prefix")(controller_function)

tests/test_controller/test_controller_inheritance.py

@@ -2,6 +2,7 @@
 
 from ellar.common import Controller, get, ws_route
 from ellar.constants import CONTROLLER_CLASS_KEY
+from ellar.core import AppFactory
 from ellar.core.routing.router.module import controller_router_factory
 from ellar.reflect import reflect
 
@@ -49,3 +50,40 @@ def endpoint_once(self):
 
     with pytest.raises(Exception, match=r"Operation must have a single control type."):
         controller_router_factory(AnotherSampleController)
+
+
+def test_controller_raise_exception_for_controller_operation_without_controller_class(
+    test_client_factory,
+):
+    @Controller("/abcd")
+    class Another2SampleController:
+        @get("/test")
+        def endpoint_once(self):
+            pass
+
+    app = AppFactory.create_app(controllers=(Another2SampleController,))
+    reflect.delete_metadata(
+        CONTROLLER_CLASS_KEY, Another2SampleController.endpoint_once
+    )
+    client = test_client_factory(app)
+    with pytest.raises(RuntimeError, match=r"Controller Type was not found"):
+        client.get("/abcd/test")
+
+
+def test_controller_raise_exception_for_controller_operation_for_invalid_type(
+    test_client_factory,
+):
+    @Controller("/abcd")
+    class Another3SampleController:
+        @get("/test")
+        def endpoint_once(self):
+            pass
+
+    reflect.delete_metadata(
+        CONTROLLER_CLASS_KEY, Another3SampleController.endpoint_once
+    )
+    app = AppFactory.create_app(controllers=(Another3SampleController,))
+
+    client = test_client_factory(app)
+    with pytest.raises(RuntimeError, match=r"Controller Type was not found"):
+        client.get("/abcd/test")

tests/test_response/test_route_response_model.py

@@ -3,17 +3,25 @@
 import pytest
 from starlette.responses import JSONResponse
 
+from ellar.constants import RESPONSE_OVERRIDE_KEY
+from ellar.core.exceptions import ImproperConfiguration
 from ellar.core.response.model import (
     EmptyAPIResponseModel,
     JSONResponseModel,
     ResponseModel,
     RouteResponseExecution,
     RouteResponseModel,
 )
+from ellar.core.routing import RouteOperation
+from ellar.reflect import reflect
 
 from ..schema import BlogObjectDTO, NoteSchemaDC
 
 
+def endpoint_sample():
+    pass  # pragma: no cover
+
+
 class JsonApiResponse(JSONResponse):
     media_type = "application/vnd.api+json"
 
@@ -101,3 +109,17 @@ def test_route_response_model(
 def test_route_response_model_exception(inputs):
     with pytest.raises(RouteResponseExecution):
         RouteResponseModel(route_responses=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()},
+        )
+    assert "`RESPONSE_OVERRIDE` is must be of type `Dict`" in str(ex)

tests/test_routing/test_route_endpoint_params.py

@@ -5,26 +5,45 @@
 from starlette.responses import Response as StarletteResponse
 from starlette.websockets import WebSocket as StarletteWebSocket
 
-from ellar.common import Context, Http, Req, Res, Ws
-from ellar.core import ExecutionContext, TestClientFactory
+from ellar.common import Context, Host, Http, Provide, Req, Res, Session, Ws
+from ellar.core import Config, ExecutionContext, TestClientFactory
 from ellar.core.connection import (
     HTTPConnection as EllarHTTPConnection,
     Request as EllarRequest,
     WebSocket as EllarWebSocket,
 )
 from ellar.core.context import IExecutionContext
+from ellar.core.middleware import Middleware, SessionMiddleware
 from ellar.core.routing import ModuleRouter
+from ellar.helper.importer import get_class_import
 
 router = ModuleRouter()
 
 
+class SampleConfig:
+    SECRET_KEY: str = "ellar_cf303596-e51a-441a-ba67-5da42dbffb07"
+
+    MIDDLEWARE = [Middleware(SessionMiddleware, secret_key=SECRET_KEY)]
+
+
+config_path = get_class_import(SampleConfig)
+
+
 @router.get("/starlette-request")
 def get_requests(request: StarletteRequest, req=Req()):
     assert isinstance(request, EllarRequest)  # True
     assert isinstance(req, EllarRequest)
     return req == request
 
 
+@router.get("/others")
+def get_requests(session=Session(), host=Host(), config=Provide(Config)):
+    assert isinstance(config, Config)  # True
+    assert host == "testclient"
+    assert isinstance(session, dict) and len(session) == 0
+    return True
+
+
 @router.get("/ellar-context")
 def get_requests(context_1: IExecutionContext, context_2=Context()):
     assert isinstance(context_1, ExecutionContext)
@@ -54,7 +73,7 @@ async def get_websockets(websocket: StarletteWebSocket, ws=Ws()):
     await ws.close()
 
 
-tm = TestClientFactory.create_test_module(routers=[router])
+tm = TestClientFactory.create_test_module(routers=[router], config_module=config_path)
 client = tm.get_client()
 
 
@@ -82,6 +101,12 @@ def test_get_response():
     assert response.json() is True
 
 
+def test_other_route_function_parameter():
+    response = client.get("/others")
+    assert response.status_code == 200
+    assert response.json() is True
+
+
 def test_get_websocket():
     with client.websocket_connect("/starlette-websocket") as session:
         data = session.receive_json()

tests/test_websocket_handler.py

@@ -3,6 +3,7 @@
 
 from ellar.common import ModuleRouter, WsBody
 from ellar.core import TestClientFactory
+from ellar.core.exceptions import ImproperConfiguration
 
 from .schema import Item
 
@@ -92,3 +93,16 @@ def test_plain_websocket_route():
         websocket.send_text("Ellar")
         message = websocket.receive_json()
         assert message == {"message": "Thanks. Ellar"}
+
+
+def test_websocket_setup_fails_when_using_body_without_handler():
+    with pytest.raises(
+        ImproperConfiguration,
+        match=r"`WsBody` should only be used when `use_extra_handler` flag is set to True in WsRoute",
+    ):
+
+        @router.ws_route("/ws-with-handler", use_extra_handler=False)
+        async def websocket_with_handler(
+            websocket: WebSocket, query: str, data: Item = WsBody()
+        ):
+            pass