fixed all tests

Author: eadwinCode

docs/overview/exception_handling.md

@@ -200,7 +200,7 @@ class ExceptionHandlerAction405(IExceptionHandler):
         self, ctx: IHostContext, exc: HTTPException
     ) -> t.Union[Response, t.Any]:
         context_kwargs = {}
-        return render_template('405.html', request=ctx.switch_to_http_connection().get_request(), **context_kwargs)
+        return render_template('405.html', **context_kwargs)
 ```
 In this code snippet, we've registered a handler for any `HTTP` exception with a `405` status code, and we return a template, `405.html`, as a response. 
 Similarly, you can create an exception handler for the `500` status code that returns an HTML template.

docs/security/rate-limit.md

@@ -103,7 +103,7 @@ from ellar.common import Controller, get
 
 
 @Controller("/limit")
-@Throttle(apply_interceptor=True)
+@Throttle(intercept=True)
 class LimitController:
     def __init__(self, app_service: AppService):
         self.app_service = app_service
@@ -113,15 +113,15 @@ class LimitController:
         return self.app_service.success(use_auth)
 ```
 
-In the above example, by setting `apply_interceptor=True` within **@Throttle**, 
+In the above example, by setting `intercept=True` within **@Throttle**, 
 the `ThrottlerInterceptor` is applied to all routes within the `LimitController`. 
 This feature is particularly useful when `ThrottlerInterceptor` is not globally applied.
 
 Additionally, the **@Throttle** decorator can be used on a route level:
 
 ```python
 @get()
-@Throttle(apply_interceptor=True)
+@Throttle(intercept=True)
 def get_throttled(self, use_auth: bool):
     return self.app_service.success(use_auth)
 ```
@@ -130,7 +130,7 @@ Another application of the **@Throttle** decorator is to override `ttl` and `lim
 
 ```python
 @Controller("/limit")
-@Throttle(apply_interceptor=True, anon={'ttl': 100, 'limit': 30})
+@Throttle(intercept=True, anon={'ttl': 100, 'limit': 30})
 class LimitController:
     def __init__(self, app_service: AppService):
         self.app_service = app_service

pyproject.toml

@@ -107,12 +107,15 @@ warn_unused_ignores = true
 disallow_untyped_defs = true
 check_untyped_defs = true
 implicit_reexport = false
-disable_error_code = ['union-attr']
+disable_error_code = ['union-attr', 'type-abstract', 'arg-type']
 
 [[tool.mypy.overrides]]
 module = "ellar.common.compatible.*"
 ignore_errors = true
 [[tool.mypy.overrides]]
+module = "ellar.core.conf.*"
+ignore_errors = true
+[[tool.mypy.overrides]]
 module = "ellar.core.services.*"
 ignore_errors = true
 [[tool.mypy.overrides]]

tests/test_application/sample.py

@@ -103,14 +103,14 @@ def runtime_error(self, request: Inject[Request]):
     controllers=[ClassBaseController],
 )
 class ApplicationModule(ModuleBase):
-    @exception_handler(405)
+    @exception_handler(405, app=True)
     async def method_not_allow_exception(self, ctx, exec):
         return JSONResponse({"detail": "Custom message"}, status_code=405)
 
-    @exception_handler(500)
+    @exception_handler(500, app=True)
     async def error_500(self, ctx, exec):
         return JSONResponse({"detail": "Server Error"}, status_code=500)
 
-    @exception_handler(HTTPException)
+    @exception_handler(HTTPException, app=True)
     async def http_exception(self, ctx, exc):
         return JSONResponse({"detail": exc.detail}, status_code=exc.status_code)

tests/test_application/test_app_context.py

@@ -1,10 +1,9 @@
 import logging
 
 import pytest
-from ellar.app import App, config, current_injector
+from ellar.app import App
 from ellar.common import Body, post
-from ellar.core import Config
-from ellar.core.context import ApplicationContext
+from ellar.core import Config, config, current_injector, with_injector_context
 from ellar.testing import Test
 
 
@@ -24,7 +23,7 @@ async def test_current_config_fails_when_there_is_no_ellar_config_module(
     with caplog.at_level(logging.WARNING):
         tm = Test.create_test_module()
 
-        async with ApplicationContext.create(tm.create_application()):
+        async with with_injector_context(tm.create_application().injector):
             assert current_injector.get(App) is not None
             assert config.DEBUG is False
 
@@ -43,7 +42,7 @@ async def test_current_config_fails_when_there_is_no_ellar_config_module(
 async def test_current_injector_works(anyio_backend):
     tm = Test.create_test_module()
 
-    async with ApplicationContext.create(tm.create_application()):
+    async with with_injector_context(tm.create_application().injector):
         assert current_injector.get(App) is not None
 
     with pytest.raises(RuntimeError):
@@ -53,7 +52,7 @@ async def test_current_injector_works(anyio_backend):
 async def test_current_app_works(anyio_backend):
     tm = Test.create_test_module()
 
-    async with ApplicationContext.create(tm.create_application()):
+    async with with_injector_context(tm.create_application().injector):
         assert isinstance(current_injector.get(Config), Config)
 
     with pytest.raises(RuntimeError):
@@ -63,7 +62,7 @@ async def test_current_app_works(anyio_backend):
 async def test_current_config_works(anyio_backend):
     tm = Test.create_test_module(config_module={"FRAMEWORK_NAME": "Ellar"})
 
-    async with tm.create_application().application_context():
+    async with with_injector_context(tm.create_application().injector):
         app = current_injector.get(App)
         assert app.config.FRAMEWORK_NAME == config.FRAMEWORK_NAME
 
@@ -72,20 +71,19 @@ async def test_current_config_works(anyio_backend):
 
 
 async def test_current_config_works_(anyio_backend):
-    tm = Test.create_test_module(config_module={"FRAMEWORK_NAME": "Ellar"})
-
     @post
     def add(a: Body[int], b: Body[int]):
-        from ellar.app import current_injector
+        from ellar.core import current_injector
 
         config_ = current_injector.get(Config)
         assert config_.FRAMEWORK_NAME == config.FRAMEWORK_NAME
         return a + b
 
-    app = tm.create_application()
-    app.router.add_route(add)
+    tm = Test.create_test_module(
+        config_module={"FRAMEWORK_NAME": "Ellar"}, routers=[add]
+    )
 
-    async with app.application_context():
+    async with with_injector_context(tm.create_application().injector):
         res = tm.get_test_client().post("/", json={"a": 1, "b": 4})
         assert res.json() == 5
         config_ = current_injector.get(Config)

tests/test_application/test_app_methods.py

@@ -31,8 +31,7 @@ async def homepage(request: Inject[Request], ctx: Inject[IExecutionContext]):
             res = PlainTextResponse("Ellar Route Handler as an ASGI app")
             await res(*ctx.get_args())
 
-        app = AppFactory.create_app()
-        app.router.add_route(homepage)
+        app = AppFactory.create_app(routers=[homepage])
         client = TestClient(app)
         response = client.get("/")
         assert response.status_code == 200
@@ -44,8 +43,7 @@ async def homepage(request: Inject[Request], ctx: Inject[IExecutionContext]):
             res = PlainTextResponse("Ellar Route Handler as an ASGI app")
             return res
 
-        app = AppFactory.create_app()
-        app.router.add_route(homepage)
+        app = AppFactory.create_app(routers=[homepage])
         result = app.url_path_for("homepage")
         assert result == "/homepage-url"
 
@@ -129,14 +127,13 @@ async def catch(
             ) -> t.Union[Response, t.Any]:
                 return JSONResponse({"detail": str(exc)}, status_code=404)
 
-        app = AppFactory.create_app()
-        app.add_exception_handler(CustomExceptionHandler())
-
         @get("/404")
         def raise_custom_exception():
             raise CustomException("Raised an Exception")
 
-        app.router.add_route(raise_custom_exception)
+        app = AppFactory.create_app(routers=[raise_custom_exception])
+        app.add_exception_handler(CustomExceptionHandler())
+
         client = TestClient(app)
         res = client.get("/404")
         assert res.status_code == 404

tests/test_application/test_app_templating.py

@@ -5,13 +5,13 @@
     template_global,
 )
 from ellar.common.templating import Environment
-from ellar.core import ModuleBase
+from ellar.core import ModuleBase, with_injector_context
 from ellar.core.modules import ModuleTemplateRef
 from ellar.threading.sync_worker import execute_async_context_manager
 
 
 class TestAppTemplating:
-    @Module(template_folder="some_template")
+    @Module(template_folder="some_template", name="app_template")
     class AppTemplateModuleTest(ModuleBase):
         @template_filter(name="app_filter")
         def template_filter_test(self, value):
@@ -31,7 +31,7 @@ def test_app_get_module_loaders(self):
 
     def test_app_jinja_environment(self):
         app = AppFactory.create_from_app_module(module=self.AppTemplateModuleTest)
-        with execute_async_context_manager(app.application_context()):
+        with execute_async_context_manager(with_injector_context(app.injector)):
             environment = app.injector.get(Environment)
             assert isinstance(environment, Environment)
 

tests/test_application/test_application_factory.py

@@ -4,7 +4,7 @@
 from ellar.common.constants import MODULE_WATERMARK
 from ellar.common.exceptions import ImproperConfiguration
 from ellar.core import LazyModuleImport as lazyLoad
-from ellar.core import ModuleBase, ModuleSetup
+from ellar.core import ModuleBase, ModuleSetup, with_injector_context
 from ellar.di import ProviderConfig
 from ellar.reflect import reflect
 from ellar.testing import TestClient
@@ -62,7 +62,7 @@ def test_factory_create_from_app_module():
 
 def test_factory_create_app_dynamically_creates_module():
     app = AppFactory.create_app()
-    first_module_ref = app.injector.tree_manager.get_root_module()
+    first_module_ref = app.injector.tree_manager.get_app_module()
     module_instance = first_module_ref.get_module_instance()
     assert not isinstance(module_instance, ModuleBase)
     assert reflect.get_metadata(MODULE_WATERMARK, type(module_instance))
@@ -95,7 +95,7 @@ class CModule:
     res = client.get("/static/example.txt")
     assert res.status_code == 200
     assert res.text == "<file content>"
-    async with app.application_context():
+    async with with_injector_context(app.injector):
         template = app.injector.get(Environment).get_template("example.html")
         result = template.render()
         assert result == "<html>Hello World<html/>"