bug fixes and test-cov: Fixed some bugs and improved on test-cov

Author: eadwinCode

ellar/app/context.py

@@ -9,15 +9,19 @@
 from ellar.di import EllarInjector
 
 if t.TYPE_CHECKING:
-    from .main import App
+    from ellar.app.main import App
 
 _application_context: ContextVar[
     t.Optional[t.Union["ApplicationContext", t.Any]]
 ] = ContextVar("ellar.app.context")
-_application_context.set(empty)
 
 
 class ApplicationContext:
+    """
+    Provides Necessary Application Properties when running Ellar CLI commands and when serving request.
+
+    """
+
     __slots__ = ("_injector", "_config", "_app")
 
     def __init__(self, config: Config, injector: EllarInjector, app: "App") -> None:
@@ -43,14 +47,13 @@ def config(self) -> Config:
         return self._config
 
     def __enter__(self) -> "ApplicationContext":
-        app_context = _application_context.get()
+        app_context = _application_context.get(empty)
         if app_context is empty:
             # If app_context exist
             _application_context.set(self)
             if current_config._wrapped is not empty:  # pragma: no cover
                 # ensure current_config is in sync with running application context.
                 current_config._wrapped = self.config
-
             app_context = self
         return app_context  # type:ignore[return-value]
 
@@ -72,32 +75,33 @@ def create(cls, app: "App") -> "ApplicationContext":
 
 
 def _get_current_app() -> "App":
-    if _application_context.get() is empty:
-        raise RuntimeError("App is not available at this scope.")
+    app_context = _application_context.get(empty)
+    if app_context is empty:
+        raise RuntimeError("ApplicationContext is not available at this scope.")
 
-    app_context = _application_context.get()
     return app_context.app  # type:ignore[union-attr]
 
 
 def _get_injector() -> EllarInjector:
-    if _application_context.get() is empty:
-        raise RuntimeError("App is not available at this scope.")
+    app_context = _application_context.get(empty)
+    if app_context is empty:
+        raise RuntimeError("ApplicationContext is not available at this scope.")
 
-    app_context = _application_context.get()
     return app_context.injector  # type:ignore[union-attr]
 
 
 def _get_application_config() -> Config:
-    if _application_context.get() is empty:
+    app_context = _application_context.get(empty)
+    if app_context is empty:
         config_module = os.environ.get(ELLAR_CONFIG_MODULE)
         if not config_module:
             raise RuntimeError(
                 "You are trying to access app config outside app context "
                 "and %s is not specified. This may cause differences in config "
                 "values when the app." % (ELLAR_CONFIG_MODULE,)
             )
+        return Config(config_module=config_module)
 
-    app_context = _application_context.get()
     return app_context.config  # type:ignore[union-attr]
 
 

ellar/app/lifespan.py

@@ -1,12 +1,11 @@
 import typing as t
 
 from anyio import create_task_group
-from ellar.common import IApplicationShutdown, IApplicationStartup, logger
+from ellar.common import IApplicationShutdown, IApplicationStartup
+from ellar.common.logger import logger
 from ellar.reflect import asynccontextmanager
 
-from .context import ApplicationContext
-
-if t.TYPE_CHECKING:  # pragma: no cover
+if t.TYPE_CHECKING:
     from ellar.app import App
 
 _T = t.TypeVar("_T")
@@ -53,18 +52,17 @@ async def run_all_shutdown_actions(self, app: "App") -> None:
 
     @asynccontextmanager
     async def lifespan(self, app: "App") -> t.AsyncIterator[t.Any]:
-        logger.logger.debug("Executing Modules Startup Handlers")
+        logger.debug("Executing Modules Startup Handlers")
+        logger.debug("ELLAR LOGGER CONFIGURED")
 
-        with ApplicationContext.create(app):
+        async with create_task_group() as tg:
+            tg.start_soon(self.run_all_startup_actions, app)
+
+        try:
+            async with self._lifespan_context(app) as ctx:  # type:ignore[attr-defined]
+                logger.info("Application is ready.")
+                yield ctx
+        finally:
+            logger.debug("Executing Modules Shutdown Handlers")
             async with create_task_group() as tg:
-                tg.start_soon(self.run_all_startup_actions, app)
-
-            try:
-                async with self._lifespan_context(
-                    app
-                ) as ctx:  # type:ignore[attr-defined]
-                    yield ctx
-            finally:
-                logger.logger.debug("Executing Modules Shutdown Handlers")
-                async with create_task_group() as tg:
-                    tg.start_soon(self.run_all_shutdown_actions, app)
+                tg.start_soon(self.run_all_shutdown_actions, app)

ellar/app/main.py

@@ -2,13 +2,13 @@
 import logging.config
 import typing as t
 
+from ellar.app.context import ApplicationContext
 from ellar.auth.handlers import AuthenticationHandlerType
 from ellar.common import GlobalGuard, IIdentitySchemes
 from ellar.common.compatible import cached_property
 from ellar.common.constants import ELLAR_LOG_FMT_STRING, LOG_LEVELS
 from ellar.common.datastructures import State, URLPath
 from ellar.common.interfaces import IExceptionHandler, IExceptionMiddlewareService
-from ellar.common.logger import logger
 from ellar.common.models import EllarInterceptor, GuardCanActivate
 from ellar.common.templating import Environment
 from ellar.common.types import ASGIApp, T, TReceive, TScope, TSend
@@ -106,9 +106,6 @@ def _config_logging(self) -> None:
             logging.getLogger("ellar").setLevel(log_level)
             logging.getLogger("ellar.request").setLevel(log_level)
 
-        logger.info(f"APP SETTINGS MODULE: {self.config.config_module}")
-        logger.debug("ELLAR LOGGER CONFIGURED")
-
     def _statics_wrapper(self) -> t.Callable:
         async def _statics_func_wrapper(
             scope: TScope, receive: TReceive, send: TSend
@@ -259,9 +256,23 @@ def build_middleware_stack(self) -> ASGIApp:
             app = item(app=app, injector=self.injector)
         return app
 
+    def application_context(self) -> ApplicationContext:
+        """
+        Create an ApplicationContext.
+        Use as a contextmanager block to make `current_app`, `current_injector` and `current_config` point at this application.
+
+        It can be used manually outside ellar cli commands or request,
+        e.g.,
+        with app.application_context():
+            assert current_app is app
+            run_some_actions()
+        """
+        return ApplicationContext.create(app=self)
+
     async def __call__(self, scope: TScope, receive: TReceive, send: TSend) -> None:
-        scope["app"] = self
-        await self.middleware_stack(scope, receive, send)
+        with self.application_context() as ctx:
+            scope["app"] = ctx.app
+            await self.middleware_stack(scope, receive, send)
 
     @property
     def routes(self) -> t.List[BaseRoute]:

ellar/common/datastructures.py

@@ -89,4 +89,4 @@ def __get_validators__(
     def validate(cls: t.Type["UploadFile"], v: t.Any) -> t.Any:
         if not isinstance(v, StarletteUploadFile):
             raise ValueError(f"Expected UploadFile, received: {type(v)}")
-        return v
+        return cls(v.file, size=v.size, filename=v.filename, headers=v.headers)

ellar/socket_io/context.py

@@ -56,9 +56,9 @@ def get_args(self) -> t.Tuple[TScope, TReceive, TSend]:  # pragma: no cover
         return self._context.get_args()
 
     @property
-    def user(self) -> Identity:
+    def user(self) -> Identity:  # pragma: no cover
         return self._context.user
 
     @user.setter
-    def user(self, value: Identity) -> None:
+    def user(self, value: Identity) -> None:  # pragma: no cover
         self._context.user = value

examples/04-auth-with-handlers/auth_project_with_handler/config.py

@@ -3,7 +3,7 @@
 Default Ellar Configurations are exposed here through `ConfigDefaultTypesMixin`
 Make changes and define your own configurations specific to your application
 
-export ELLAR_CONFIG_MODULE=auth_project.config:DevelopmentConfig
+export ELLAR_CONFIG_MODULE=auth_project_with_handler.config:DevelopmentConfig
 """
 
 import typing as t

tests/test_middleware/test_exception_middleware.py

@@ -0,0 +1,21 @@
+import pytest
+from ellar.app import AppFactory
+from ellar.common import IExecutionContext, get
+from starlette.exceptions import HTTPException
+from starlette.responses import Response
+
+
+def test_exception_after_response_sent(test_client_factory):
+    @get()
+    async def home(ctx: IExecutionContext):
+        response = Response(b"", status_code=204)
+        await response(*ctx.get_args())
+        raise HTTPException(status_code=406)
+        # raise RuntimeError("Something went wrong")
+
+    app = AppFactory.create_app()
+    app.router.append(home)
+
+    client = test_client_factory(app)
+    with pytest.raises(RuntimeError):
+        client.get("/")