Added more test

eadwinCode · eadwinCode · commit fa4d207fbe9e · 2023-05-29T14:35:29.000+01:00
diff --git a/ellar/common/commands/base.py b/ellar/common/commands/base.py
@@ -51,7 +51,7 @@ def __init__(
         hidden: bool = Default(False),
         deprecated: bool = Default(False),
         add_completion: bool = True,
-    ) -> None:
+    ) -> None:  # pragma: no cover
         assert name is not None and name != "", "Typer name is required"
         super().__init__(
             name=name,
diff --git a/ellar/common/commands/decorator.py b/ellar/common/commands/decorator.py
@@ -20,7 +20,7 @@ def command(
     no_args_is_help: bool = False,
     hidden: bool = False,
     deprecated: bool = False,
-) -> t.Callable[[CommandFunctionType], CommandFunctionType]:
+) -> t.Callable[[CommandFunctionType], CommandFunctionType]:  # pragma: no cover
     """
     ========= FUNCTION DECORATOR ==============
 
diff --git a/ellar/common/routing/base.py b/ellar/common/routing/base.py
@@ -71,10 +71,10 @@ def get_controller_type(self) -> t.Type:
         :return: a type that wraps the operation
         """
         if not self._controller_type:
-            _control_type = reflect.get_metadata(CONTROLLER_CLASS_KEY, self.endpoint)
-            if _control_type is None:
+            _controller_type = reflect.get_metadata(CONTROLLER_CLASS_KEY, self.endpoint)
+            if _controller_type is None or not isinstance(_controller_type, type):
                 raise Exception("Operation must have a single control type.")
-            self._controller_type = t.cast(t.Type, _control_type)
+            self._controller_type = t.cast(t.Type, _controller_type)
 
         return self._controller_type
 
diff --git a/ellar/common/routing/controller/route.py b/ellar/common/routing/controller/route.py
@@ -2,7 +2,6 @@
 
 from starlette.concurrency import run_in_threadpool
 
-from ellar.common.exceptions import RequestValidationError
 from ellar.common.interfaces import IExecutionContext
 from ellar.common.routing.route import RouteOperation
 
@@ -12,18 +11,9 @@
 class ControllerRouteOperation(ControllerRouteOperationBase, RouteOperation):
     methods: t.Set[str]
 
-    async def handle_request(self, context: IExecutionContext) -> t.Any:
+    async def run(self, context: IExecutionContext, **kwargs: t.Any) -> t.Any:
         controller_instance = self._get_controller_instance(ctx=context)
-
-        func_kwargs, errors = await self.endpoint_parameter_model.resolve_dependencies(
-            ctx=context
-        )
-        if errors:
-            raise RequestValidationError(errors)
-
         if self._is_coroutine:
-            return await self.endpoint(controller_instance, **func_kwargs)
+            return await self.endpoint(controller_instance, **kwargs)
         else:
-            return await run_in_threadpool(
-                self.endpoint, controller_instance, **func_kwargs
-            )
+            return await run_in_threadpool(self.endpoint, controller_instance, **kwargs)
diff --git a/ellar/common/routing/controller/websocket/route.py b/ellar/common/routing/controller/websocket/route.py
@@ -1,9 +1,5 @@
 import typing as t
 
-from starlette.status import WS_1008_POLICY_VIOLATION
-from starlette.websockets import WebSocketState
-
-from ellar.common.exceptions import WebSocketRequestValidationError
 from ellar.common.interfaces import IExecutionContext
 
 from ...websocket import WebsocketRouteOperation
@@ -20,22 +16,8 @@ class ControllerWebsocketRouteOperation(
     def get_websocket_handler(cls) -> t.Type[ControllerWebSocketExtraHandler]:
         return ControllerWebSocketExtraHandler
 
-    async def handle_request(self, context: IExecutionContext) -> t.Any:
+    async def run(self, context: IExecutionContext, **kwargs: t.Any) -> t.Any:
         controller_instance = self._get_controller_instance(ctx=context)
-        func_kwargs, errors = await self.endpoint_parameter_model.resolve_dependencies(
-            ctx=context
-        )
-        if errors:
-            websocket = context.switch_to_websocket().get_client()
-            exc = WebSocketRequestValidationError(errors)
-            if websocket.client_state == WebSocketState.CONNECTING:
-                await websocket.accept()
-            await websocket.send_json(
-                dict(code=WS_1008_POLICY_VIOLATION, errors=exc.errors())
-            )
-            await websocket.close(code=WS_1008_POLICY_VIOLATION)
-            raise exc
-
         if self._use_extra_handler:
             ws_extra_handler_type = (
                 self._extra_handler_type or self.get_websocket_handler()
@@ -45,6 +27,6 @@ async def handle_request(self, context: IExecutionContext) -> t.Any:
                 controller_instance=controller_instance,
                 **self._handlers_kwargs,
             )
-            return await ws_extra_handler.dispatch(context=context, **func_kwargs)
+            return await ws_extra_handler.dispatch(context=context, **kwargs)
         else:
-            return await self.endpoint(controller_instance, **func_kwargs)
+            return await self.endpoint(controller_instance, **kwargs)
diff --git a/ellar/common/routing/route.py b/ellar/common/routing/route.py
@@ -69,7 +69,7 @@ def _load_model(self) -> None:
         extra_route_args: t.Union[t.List["ExtraEndpointArg"], "ExtraEndpointArg"] = (
             reflect.get_metadata(EXTRA_ROUTE_ARGS_KEY, self.endpoint) or []
         )
-        if not isinstance(extra_route_args, list):
+        if not isinstance(extra_route_args, list):  # pragma: no cover
             extra_route_args = [extra_route_args]
 
         if self.endpoint_parameter_model is NOT_SET:
@@ -106,16 +106,20 @@ def get_operation_unique_id(
             name=self.name, path=self.path_format, methods=_methods
         )
 
+    async def run(self, context: IExecutionContext, **kwargs: t.Any) -> t.Any:
+        if self._is_coroutine:
+            return await self.endpoint(**kwargs)
+        else:
+            return await run_in_threadpool(self.endpoint, **kwargs)
+
     async def handle_request(self, context: IExecutionContext) -> t.Any:
         func_kwargs, errors = await self.endpoint_parameter_model.resolve_dependencies(
             ctx=context
         )
         if errors:
             raise RequestValidationError(errors)
-        if self._is_coroutine:
-            return await self.endpoint(**func_kwargs)
-        else:
-            return await run_in_threadpool(self.endpoint, **func_kwargs)
+
+        return await self.run(context, **func_kwargs)
 
     async def handle_response(
         self, context: IExecutionContext, response_obj: t.Any
diff --git a/ellar/common/routing/schema.py b/ellar/common/routing/schema.py
@@ -56,13 +56,13 @@ def validate_methods(cls, value: t.Any) -> t.List[str]:
 
     @validator("endpoint")
     def validate_endpoint(cls, value: t.Any) -> t.Any:
-        if not callable(value):
+        if not callable(value):  # pragma: no cover
             raise ValueError("An endpoint must be a callable")
         return value
 
     @root_validator
     def validate_root(cls, values: t.Any) -> t.Any:
-        if "response" not in values:
+        if "response" not in values:  # pragma: no cover
             raise ValueError(
                 "Expected "
                 "IResponseModel | Dict[int, Any | Type[BaseModel] | "
diff --git a/ellar/common/routing/websocket/route.py b/ellar/common/routing/websocket/route.py
@@ -84,6 +84,19 @@ def add_websocket_handler(self, handler_name: str, handler: t.Callable) -> None:
             )
         self._handlers_kwargs.update({handler_name: handler})
 
+    async def run(self, context: IExecutionContext, **kwargs: t.Any) -> t.Any:
+        if self._use_extra_handler:
+            ws_extra_handler_type = (
+                self._extra_handler_type or self.get_websocket_handler()
+            )
+            ws_extra_handler = ws_extra_handler_type(
+                route_parameter_model=self.endpoint_parameter_model,
+                **self._handlers_kwargs,
+            )
+            return await ws_extra_handler.dispatch(context=context, **kwargs)
+        else:
+            return await self.endpoint(**kwargs)
+
     async def handle_request(self, context: IExecutionContext) -> t.Any:
         func_kwargs, errors = await self.endpoint_parameter_model.resolve_dependencies(
             ctx=context
@@ -99,17 +112,7 @@ async def handle_request(self, context: IExecutionContext) -> t.Any:
             await websocket.close(code=WS_1008_POLICY_VIOLATION)
             raise exc
 
-        if self._use_extra_handler:
-            ws_extra_handler_type = (
-                self._extra_handler_type or self.get_websocket_handler()
-            )
-            ws_extra_handler = ws_extra_handler_type(
-                route_parameter_model=self.endpoint_parameter_model,
-                **self._handlers_kwargs,
-            )
-            return await ws_extra_handler.dispatch(context=context, **func_kwargs)
-        else:
-            return await self.endpoint(**func_kwargs)
+        return await self.run(context, **func_kwargs)
 
     async def handle_response(
         self, context: IExecutionContext, response_obj: t.Any
diff --git a/ellar/common/serializer/base.py b/ellar/common/serializer/base.py
@@ -12,13 +12,13 @@
 __pydantic_root__ = "__root__"
 
 
+@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.__dict__[__pydantic_model__])
-    return None
 
 
 class SerializerConfig(BaseConfig):
diff --git a/ellar/core/modules/ref.py b/ellar/core/modules/ref.py
@@ -230,8 +230,6 @@ def routes(self) -> t.List[BaseRoute]:
     #             self._flatten_routes.append(router)
 
     def _register_module(self) -> None:
-        if not is_decorated_with_injectable(self.module):
-            self._module_type = injectable()(self.module)
         self.container.register(
             self.module, ModuleProvider(self.module, **self._init_kwargs)
         )
diff --git a/ellar/core/services/reflector.py b/ellar/core/services/reflector.py
@@ -32,7 +32,7 @@ def get_all_and_merge(
             return []
 
         if len(metadata_collection) == 1:
-            return metadata_collection[0]
+            return [metadata_collection[0]]
 
         @t.no_type_check
         def inline_function(previous_item: t.Any, next_item: t.Any) -> t.Any:
diff --git a/ellar/core/versioning/resolver.py b/ellar/core/versioning/resolver.py
@@ -53,21 +53,18 @@ def can_activate(self, route_versions: t.Set[t.Union[int, float, str]]) -> bool:
 
 
 class DefaultAPIVersionResolver(BaseAPIVersioningResolver):
-    def raise_exception(self) -> None:
-        raise NotFound()
-
     invalid_version_message = "Invalid API version"
 
+    def raise_exception(self) -> None:
+        raise NotFound(self.invalid_version_message)
+
     def resolve_version(self) -> str:
         return str(NOT_SET)
 
 
 class UrlPathVersionResolver(DefaultAPIVersionResolver):
     invalid_version_message = "Invalid version in URL path."
 
-    def raise_exception(self) -> None:
-        raise NotFound(self.invalid_version_message)
-
     def __init__(self, *args: t.Any, **kwargs: t.Any) -> None:
         super(UrlPathVersionResolver, self).__init__(*args, **kwargs)
 
@@ -137,9 +134,6 @@ def resolve_version(self) -> str:
 class QueryParameterAPIVersionResolver(DefaultAPIVersionResolver):
     invalid_version_message = "Invalid version in query parameter."
 
-    def raise_exception(self) -> None:
-        raise NotFound(self.invalid_version_message)
-
     def resolve_version(self) -> str:
         version = (
             self.connection.query_params.get(self.version_parameter)
diff --git a/ellar/socket_io/gateway.py b/ellar/socket_io/gateway.py
@@ -15,6 +15,7 @@
 )
 from ellar.common.constants import (
     CONTROLLER_CLASS_KEY,
+    CONTROLLER_OPERATION_HANDLER_KEY,
     EXTRA_ROUTE_ARGS_KEY,
     NOT_SET,
     SCOPE_SERVICE_PROVIDER,
@@ -62,6 +63,7 @@ def __init__(
         )
         self._load_model()
         self._register_handler()
+        reflect.define_metadata(CONTROLLER_OPERATION_HANDLER_KEY, self, self.endpoint)
 
     def _load_model(self) -> None:
         path_regex, path_format, param_convertors = compile_path("/")
@@ -84,7 +86,7 @@ def _load_model(self) -> None:
     async def _run_with_exception_handling(
         self, gateway_instance: GatewayBase, sid: str
     ) -> None:
-        config = gateway_instance.context.get_service_provider().get(Config)
+
         try:
             await self.run_route_guards(context=gateway_instance.context)
             await self._run_handler(
@@ -104,6 +106,7 @@ async def _run_with_exception_handling(
                 reason=serialize_object(wex.errors()),
             )
         except Exception as ex:
+            config = gateway_instance.context.get_service_provider().get(Config)
             await self._handle_error(
                 sid=sid,
                 code=status.WS_1011_INTERNAL_ERROR,
@@ -193,7 +196,7 @@ def get_controller_type(self) -> t.Type[GatewayBase]:
         """
         if not self._controller_type:
             _controller_type = reflect.get_metadata(CONTROLLER_CLASS_KEY, self.endpoint)
-            if _controller_type is None:  # pragma: no cover
+            if _controller_type is None or not isinstance(_controller_type, type):
                 raise Exception("Operation must have a single control type.")
             self._controller_type = t.cast(t.Type[GatewayBase], _controller_type)
 
diff --git a/tests/test_events.py b/tests/test_events.py
@@ -67,3 +67,16 @@ def valid_function_1():
     config = Config(ON_REQUEST_STARTUP=[EventHandler(valid_function_1)])
     await config.ON_REQUEST_STARTUP[0].run()
     assert called == 1
+
+
+async def test_events_reload(anyio_backend):
+    called = 0
+
+    def valid_function_1():
+        nonlocal called
+        called += 1
+
+    manager = RouterEventManager()
+    manager.reload([EventHandler(valid_function_1)])
+    await manager.async_run()
+    assert called == 1
diff --git a/tests/test_guard.py b/tests/test_guard.py
@@ -240,3 +240,20 @@ def test_auth_schema():
         },
         "DigestAuth": {"type": "http", "scheme": "digest", "name": "DigestAuth"},
     }
+
+
+def test_global_guard_works():
+    _app = AppFactory.create_app(global_guards=[DigestAuth])
+
+    @get("/global")
+    def _auth_demo_endpoint(request=Req()):
+        return {"authentication": request.user}
+
+    _app.router.append(_auth_demo_endpoint)
+    _client = TestClient(_app)
+    res = _client.get("/global")
+
+    assert res.status_code == 401
+    data = res.json()
+
+    assert data == {"detail": "Forbidden"}
diff --git a/tests/test_middleware/test_functional_middleware.py b/tests/test_middleware/test_functional_middleware.py
@@ -2,7 +2,10 @@
 from starlette.responses import PlainTextResponse
 
 from ellar.common import IHostContext, Module, ModuleRouter, middleware
-from ellar.core import ModuleBase
+from ellar.core import App, Config, ModuleBase
+from ellar.core.middleware import FunctionBasedMiddleware
+from ellar.di import EllarInjector
+from ellar.reflect import asynccontextmanager
 from ellar.testing import Test
 
 mr = ModuleRouter()
@@ -67,3 +70,27 @@ def test_middleware_returns_response():
     response = client.get("/", headers={"ellar": "set"})
     assert response.status_code == 200
     assert response.text == "middleware_return_response returned a response"
+
+
+def test_functional_middleware_skips_lifespan(test_client_factory):
+    async def middleware_function(context: IHostContext, call_next):
+        pass
+
+    startup_complete = False
+    cleanup_complete = False
+
+    @asynccontextmanager
+    async def lifespan(app):
+        nonlocal startup_complete, cleanup_complete
+        startup_complete = True
+        yield
+        cleanup_complete = True
+
+    app = FunctionBasedMiddleware(
+        App(config=Config(), injector=EllarInjector(), lifespan=lifespan),
+        middleware_function,
+    )
+
+    with test_client_factory(app):
+        assert startup_complete
+        assert not cleanup_complete
diff --git a/tests/test_reflector.py b/tests/test_reflector.py
@@ -36,6 +36,9 @@ def test_should_reflect_metadata_of_all_targets_and_concat_arrays():
         value,
     ]
 
+    reflect.define_metadata("key1", value, SampleTarget)
+    assert reflector.get_all_and_merge("key1", *[SampleTarget]) == [value]
+
 
 def test_should_reflect_metadata_of_all_targets_in_an_arrays():
     key = "key"
diff --git a/tests/test_socket_io/test_gateway.py b/tests/test_socket_io/test_gateway.py

Original file line number	Diff line number	Diff line change
`@@ -230,8 +230,6 @@ def routes(self) -> t.List[BaseRoute]:`
`230`	`230`	`# self._flatten_routes.append(router)`
`231`	`231`
`232`	`232`	`def _register_module(self) -> None:`
`233`		`- if not is_decorated_with_injectable(self.module):`
`234`		`- self._module_type = injectable()(self.module)`
`235`	`233`	`self.container.register(`
`236`	`234`	`self.module, ModuleProvider(self.module, **self._init_kwargs)`
`237`	`235`	`)`