increase test coverage on exception module

Author: eadwinCode

docs/overview/modules.md

@@ -73,6 +73,7 @@ class BookModule(ModuleBase):
 
 
 ## `Additional Module Configurations`
+
 ### `Module Events`
 Every registered Module receives two event calls during its instantiation and when application is ready.
 
@@ -87,11 +88,43 @@ class ModuleEventSample(ModuleBase):
         """Called before creating Module object"""
 
     def application_ready(self, app: App) -> None:
-        """Called when application is ready"""
+        """Called when application is ready - this is similar to @on_startup event"""
 
 ```
 `before_init` receives current app `Config` as a parameter and `application_ready` function receives `App` instance as parameter.
 
+####  `Starlette Application Events`
+We can register multiple event handlers for dealing with code that needs to run before 
+the application starts `up`, or when the application is shutting `down`.
+This is the way we support `Starlette` start up events in `Ellar`
+
+```python
+
+from ellar.common import Module, on_shutdown, on_startup
+from ellar.core import ModuleBase
+
+@Module()
+class ModuleRequestEventsSample(ModuleBase):
+    @on_startup
+    def on_startup_func(cls):
+        pass
+    
+    @on_startup()
+    async def on_startup_func_2(cls):
+        pass
+    
+    @on_shutdown
+    def on_shutdown_func(cls):
+        pass
+    
+    @on_shutdown()
+    async def on_shutdown_func_2(cls):
+        pass
+```
+These will be registered to the application router during `ModuleRequestEventsSample` computation at runtime.
+Also, the events can be `async` as in the case of `on_shutdown_func_2` and `on_startup_func_2`
+
+
 ### `Module Exceptions`
 In Ellar, custom exceptions can be registered through modules. 
 During module meta-data computation, Ellar reads additional properties such as these from registered modules
@@ -132,35 +165,6 @@ class ModuleTemplateFilterSample(ModuleBase):
     def double_filter_dec(cls, n):
         return n * 2
 ```
-### `Module Request Events`
-During application request handling, application router emits two events `start_up` and `shutdown` event.
-We can subscribe to those events in our modules. 
-```python
-
-from ellar.common import Module, on_shutdown, on_startup
-from ellar.core import ModuleBase
-
-@Module()
-class ModuleRequestEventsSample(ModuleBase):
-    @on_startup
-    def on_startup_func(cls):
-        pass
-    
-    @on_startup()
-    async def on_startup_func_2(cls):
-        pass
-    
-    @on_shutdown
-    def on_shutdown_func(cls):
-        pass
-    
-    @on_shutdown()
-    async def on_shutdown_func_2(cls):
-        pass
-```
-These will be registered to the application router during `ModuleRequestEventsSample` computation at runtime.
-Also, the events can be `async` as in the case of `on_shutdown_func_2` and `on_startup_func_2`
-
 
 ## `Dependency Injection`
 A module class can inject providers as well (e.g., for configuration purposes):

ellar/core/exceptions/callable_exceptions.py

@@ -68,3 +68,11 @@ async def catch(
         if self.is_async:
             return await self.callable_exception_handler(*args)  # type:ignore
         return await run_in_threadpool(self.callable_exception_handler, *args)
+
+    def __eq__(self, other: t.Any) -> bool:
+        if isinstance(other, CallableExceptionHandler):
+            return (
+                other.exception_type_or_code == self.exception_type_or_code
+                and other.callable_exception_handler == other.callable_exception_handler
+            )
+        return False

ellar/core/exceptions/interfaces.py

@@ -7,6 +7,11 @@
 
 
 class IExceptionHandler(ABC, t.Iterable):
+    def __eq__(self, other: t.Any) -> bool:
+        if isinstance(other, IExceptionHandler):
+            return other.exception_type_or_code == self.exception_type_or_code
+        return False
+
     def __iter__(self) -> t.Iterator:
         as_tuple = (self.exception_type_or_code, self)
         return iter(as_tuple)

ellar/core/middleware/di.py

@@ -100,7 +100,10 @@ async def __call__(self, scope: TScope, receive: TReceive, send: TSend) -> None:
 
             scope[SCOPE_SERVICE_PROVIDER] = request_provider
             scope[SCOPE_EXECUTION_CONTEXT_PROVIDER] = execute_context
-            await super().__call__(scope, receive, send)
+            if scope["type"] == "http":
+                await super().__call__(scope, receive, send)
+            else:
+                await self.app(scope, receive, send)
 
     async def error_handler(self, request: Request, exc: Exception) -> Response:
         execute_context = request.scope[SCOPE_EXECUTION_CONTEXT_PROVIDER]

ellar/core/modules/builder.py

@@ -13,7 +13,7 @@
 from ellar.reflect import reflect
 
 from ..exceptions.callable_exceptions import CallableExceptionHandler
-from .helper import class_parameter_executor_wrapper
+from .helper import module_callable_factory
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.middleware.schema import MiddlewareSchema
@@ -52,9 +52,7 @@ def exception_config(self, exception_dict: t.Dict) -> None:
 
     @t.no_type_check
     def middleware_config(self, middleware: "MiddlewareSchema") -> None:
-        middleware.dispatch = class_parameter_executor_wrapper(
-            self._cls, middleware.dispatch
-        )
+        middleware.dispatch = module_callable_factory(middleware.dispatch, self._cls)
         reflect.define_metadata(
             MIDDLEWARE_HANDLERS_KEY,
             middleware.create_middleware(),
@@ -63,23 +61,23 @@ def middleware_config(self, middleware: "MiddlewareSchema") -> None:
         )
 
     def on_request_shut_down_config(self, on_shutdown_event: EventHandler) -> None:
-        on_shutdown_event.handler = class_parameter_executor_wrapper(
-            self._cls, on_shutdown_event.handler
+        on_shutdown_event.handler = module_callable_factory(
+            on_shutdown_event.handler, self._cls
         )
         reflect.define_metadata(
             ON_REQUEST_SHUTDOWN_KEY,
-            on_shutdown_event.handler,
+            on_shutdown_event,
             self._cls,
             default_value=[],
         )
 
     def on_request_startup_config(self, on_startup_event: EventHandler) -> None:
-        on_startup_event.handler = class_parameter_executor_wrapper(
-            self._cls, on_startup_event.handler
+        on_startup_event.handler = module_callable_factory(
+            on_startup_event.handler, self._cls
         )
         reflect.define_metadata(
             ON_REQUEST_STARTUP_KEY,
-            on_startup_event.handler,
+            on_startup_event,
             self._cls,
             default_value=[],
         )
@@ -88,8 +86,8 @@ def template_filter_config(self, template_filter: "TemplateFunctionData") -> Non
         reflect.define_metadata(
             TEMPLATE_FILTER_KEY,
             {
-                template_filter.name: class_parameter_executor_wrapper(
-                    self._cls, template_filter.func
+                template_filter.name: module_callable_factory(
+                    template_filter.func, self._cls
                 )
             },
             self._cls,
@@ -100,8 +98,8 @@ def template_global_config(self, template_filter: "TemplateFunctionData") -> Non
         reflect.define_metadata(
             TEMPLATE_GLOBAL_KEY,
             {
-                template_filter.name: class_parameter_executor_wrapper(
-                    self._cls, template_filter.func
+                template_filter.name: module_callable_factory(
+                    template_filter.func, self._cls
                 )
             },
             self._cls,

ellar/core/modules/helper.py

@@ -4,7 +4,8 @@
 
 
 def _executor_wrapper_async(
-    cls: t.Type, func: t.Callable
+    cls: t.Type,
+    func: t.Callable,
 ) -> t.Callable[..., t.Coroutine]:
     @wraps(func)
     async def _decorator(*args: t.Any, **kwargs: t.Any) -> t.Any:
@@ -21,8 +22,8 @@ def _decorator(*args: t.Any, **kwargs: t.Any) -> t.Any:
     return _decorator
 
 
-def class_parameter_executor_wrapper(
-    cls: t.Type, func: t.Callable
+def module_callable_factory(
+    func: t.Callable, cls: t.Type
 ) -> t.Union[t.Callable, t.Callable[..., t.Coroutine]]:
     if inspect.iscoroutinefunction(func):
         return _executor_wrapper_async(cls, func)

ellar/helper/__init__.py

@@ -34,7 +34,7 @@ def get_name(endpoint: t.Union[t.Callable, t.Type, object]) -> str:
 
 
 def is_async_callable(obj: t.Any) -> bool:
-    while isinstance(obj, functools.partial):
+    while isinstance(obj, functools.partial):  # pragma: no cover
         obj = obj.func
 
     return asyncio.iscoroutinefunction(obj) or (

tests/test_exceptions/test_custom_exceptions.py

@@ -1,4 +1,5 @@
 import typing as t
+from unittest.mock import patch
 
 import pytest
 from pydantic.error_wrappers import ValidationError
@@ -39,6 +40,15 @@ async def catch(
         return JSONResponse({"detail": str(exc)}, status_code=404)
 
 
+class OverrideHTTPException(IExceptionHandler):
+    exception_type_or_code = HTTPException
+
+    async def catch(
+        self, ctx: IExecutionContext, exc: t.Union[t.Any, Exception]
+    ) -> t.Union[Response, t.Any]:
+        return JSONResponse({"detail": "HttpException Override"}, status_code=400)
+
+
 class ServerErrorHandler(IExceptionHandler):
     exception_type_or_code = 500
 
@@ -189,3 +199,34 @@ async def app(scope, receive, send):
     client = test_client_factory(app)
     with pytest.raises(RuntimeError):
         client.get("/")
+
+
+def test_application_add_exception_handler():
+    @get()
+    def homepage():
+        raise HTTPException(detail="Bad Request", status_code=400)
+
+    tm = TestClientFactory.create_test_module()
+    tm.app.router.append(homepage)
+    tm.app.add_exception_handler(OverrideHTTPException())
+
+    client = tm.get_client()
+    res = client.get("/")
+
+    assert res.status_code == 400
+    assert res.json() == {"detail": "HttpException Override"}
+
+
+def test_application_adding_same_exception_twice():
+    tm = TestClientFactory.create_test_module()
+    with patch.object(
+        tm.app.__class__, "rebuild_middleware_stack"
+    ) as rebuild_middleware_stack_mock:
+        tm.app.add_exception_handler(OverrideHTTPException())
+    rebuild_middleware_stack_mock.assert_called()
+
+    with patch.object(
+        tm.app.__class__, "rebuild_middleware_stack"
+    ) as rebuild_middleware_stack_mock:
+        tm.app.add_exception_handler(OverrideHTTPException())
+    assert rebuild_middleware_stack_mock.call_count == 0

tests/test_modules/sample.py

@@ -1,21 +1,6 @@
 from typing import Optional
 
-from ellar.common import (
-    Body,
-    Controller,
-    Module,
-    ModuleRouter,
-    Ws,
-    exception_handler,
-    middleware,
-    on_shutdown,
-    on_startup,
-    put,
-    template_filter,
-    template_global,
-    ws_route,
-)
-from ellar.core import App, Config
+from ellar.common import Body, Controller, Module, ModuleRouter, Ws, put, ws_route
 from ellar.core.connection import WebSocket
 from ellar.core.modules import ModuleBase
 from ellar.di import ProviderConfig
@@ -84,50 +69,13 @@ def post_mr():
     return {"post_mr", "OK"}
 
 
-class ModuleBaseExample(ModuleBase):
-    _before_init_called = False
-    _app_ready_called = False
-
-    @exception_handler(404)
-    async def exception_404(cls, request, exc):
-        pass
-
-    @middleware("http")
-    async def middleware(cls, request, call_next):
-        response = await call_next(request)
-        return response
-
-    @template_global()
-    def some_template_global(cls, n):
-        pass
-
-    @template_filter()
-    def some_template_filter(cls, n):
-        pass
-
-    @classmethod
-    def before_init(cls, config: Config) -> None:
-        cls._before_init_called = True
-
-    def application_ready(self, app: "App") -> None:
-        self.__class__._app_ready_called = True
-
-    @on_startup
-    async def on_startup_handler(cls):
-        pass
-
-    @on_shutdown
-    def on_shutdown_handler(cls):
-        pass
-
-
-ModuleBaseExample2 = type("ModuleBaseExample2", (ModuleBaseExample,), {})
-
-SampleModule = Module(
+@Module(
     controllers=(SampleController,),
     routers=(mr,),
     providers=(
         UserService,
         ProviderConfig(AnotherUserService, use_value=AnotherUserService()),
     ),
-)(ModuleBaseExample2)
+)
+class ModuleBaseExample(ModuleBase):
+    pass