fixed failing tests

Author: eadwinCode

ellar/app/core_module.py

@@ -44,11 +44,6 @@ def get_core_module(app_module: t.Union[t.Type, t.Any], config: Config) -> t.Typ
     @Module(
         modules=[app_module],
         providers=[
-            ProviderConfig(
-                IExceptionMiddlewareService,
-                use_class=ExceptionMiddlewareService,
-                export=True,
-            ),
             ProviderConfig(
                 Config,
                 use_value=config,
@@ -61,6 +56,11 @@ def get_core_module(app_module: t.Union[t.Type, t.Any], config: Config) -> t.Typ
                 ),
                 export=True,
             ),
+            ProviderConfig(
+                IExceptionMiddlewareService,
+                use_class=ExceptionMiddlewareService,
+                export=True,
+            ),
             ProviderConfig(
                 IExecutionContextFactory, use_class=ExecutionContextFactory, export=True
             ),
@@ -91,7 +91,6 @@ def get_core_module(app_module: t.Union[t.Type, t.Any], config: Config) -> t.Typ
             ProviderConfig(
                 IInterceptorsConsumer, use_value=EllarInterceptorConsumer, export=True
             ),
-            ProviderConfig(Reflector, use_value=reflector, export=True),
             ProviderConfig(IGuardsConsumer, use_class=GuardConsumer, export=True),
             ProviderConfig(IIdentitySchemes, use_class=AppIdentitySchemes, export=True),
             ProviderConfig(
@@ -105,8 +104,8 @@ def get_core_module(app_module: t.Union[t.Type, t.Any], config: Config) -> t.Typ
         ],
     )
     class EllarCoreModule(IApplicationReady, IApplicationStartup, IApplicationShutdown):
-        def __init__(self, config: Config, injector: EllarInjector) -> None:
-            self.config = config
+        def __init__(self, _config: Config, injector: EllarInjector) -> None:
+            self.config = _config
             self.injector = injector
 
         def on_ready(self, app: "App") -> None:

ellar/app/factory.py

@@ -5,8 +5,16 @@
 from ellar.app.core_module import get_core_module
 from ellar.common import IApplicationReady, Module
 from ellar.common.constants import MODULE_METADATA
+from ellar.common.exceptions import ImproperConfiguration
 from ellar.common.models import GuardCanActivate
-from ellar.core import Config, DynamicModule, LazyModuleImport, ModuleBase, ModuleSetup
+from ellar.core import (
+    Config,
+    DynamicModule,
+    ForwardRefModule,
+    LazyModuleImport,
+    ModuleBase,
+    ModuleSetup,
+)
 from ellar.core.modules import ModuleRefBase, ModuleTemplateRef
 from ellar.di import EllarInjector, ProviderConfig
 from ellar.di.injector.tree_manager import ModuleTreeManager
@@ -49,6 +57,10 @@ def read_all_module(
             reflect.get_metadata(MODULE_METADATA.MODULES, module_config.module) or []
         )
         for module in modules:
+            if isinstance(module, ForwardRefModule):
+                # will be initialized using module_config moduleRef setup
+                continue
+
             if isinstance(module, LazyModuleImport):
                 module = module.get_module(global_module_config.module.__name__)
 
@@ -131,6 +143,15 @@ def _get_config_kwargs() -> t.Dict:
             routes = core_module_ref.get_routes()
             app.router.extend(routes)
 
+            for item in config.OVERRIDE_CORE_SERVICE:
+                provider_type = item.get_type()
+                if provider_type not in core_module_ref.providers:
+                    raise ImproperConfiguration(
+                        f"There is not core service identify as {provider_type}"
+                    )
+
+                core_module_ref.add_provider(item, export=True)
+
             # app.setup_jinja_environment
             app.setup_jinja_environment()
 

ellar/app/main.py

@@ -132,6 +132,7 @@ def use_global_interceptors(
         self, *interceptors: t.Union[EllarInterceptor, t.Type[EllarInterceptor]]
     ) -> None:
         self._global_interceptors.extend(interceptors)
+        self._ensure_available_in_providers(*interceptors)
 
     @property
     def injector(self) -> EllarInjector:
@@ -303,6 +304,9 @@ def _finalize_app_initialization(self) -> None:
                 if isinstance(item, EllarMiddleware)
             ]
         )
+        self.injector.owner.add_provider(
+            ProviderConfig(App, use_value=self, tag=self.__class__.__name__)
+        )
 
     def add_exception_handler(
         self,

ellar/auth/policy/base.py

@@ -139,6 +139,10 @@ def __init__(self, policy_1: PolicyType, requirement: t.Any) -> None:
         self._policy_1 = policy_1
         self.requirement = requirement
 
+    @property
+    def policy_type(self) -> PolicyType:
+        return self._policy_1
+
     @t.no_type_check
     def __call__(
         self, *args: t.Any, **kwargs: t.Any

ellar/cache/module.py

@@ -1,7 +1,8 @@
 import typing as t
 
 from ellar.common import IModuleSetup, Module
-from ellar.core import Config, DynamicModule, ModuleBase, ModuleSetup
+from ellar.core.conf import Config
+from ellar.core.modules import DynamicModule, ModuleBase, ModuleRefBase, ModuleSetup
 from ellar.di import ProviderConfig
 
 from .interface import ICacheService
@@ -38,20 +39,21 @@ def setup(
 
     @classmethod
     def register_setup(cls) -> ModuleSetup:
-        return ModuleSetup(cls, inject=[Config], factory=cls.register_setup_factory)
+        return ModuleSetup(cls, inject=[Config], factory=cls.__register_setup_factory)
 
     @staticmethod
-    def register_setup_factory(
-        module: t.Type["CacheModule"], config: Config
+    def __register_setup_factory(
+        module_ref: "ModuleRefBase", config: Config
     ) -> DynamicModule:
         if config.CACHES:
             schema = CacheModuleSchemaSetup(**{"CACHES": config.CACHES})
+            module = t.cast(t.Type[CacheModule], module_ref.module)
             return module._create_dynamic_module(schema)
 
         cache_service = CacheService()
 
         return DynamicModule(
-            module,
+            module_ref.module,
             providers=[
                 ProviderConfig(CacheService, use_value=cache_service),
                 ProviderConfig(ICacheService, use_value=cache_service),

ellar/common/interfaces/interceptor_consumer.py

@@ -4,7 +4,7 @@
 from .context import IExecutionContext
 
 if t.TYPE_CHECKING:  # pragma: no cover
-    from ellar.common.routing import RouteOperationBase
+    from ellar.core.routing import RouteOperationBase
 
 
 class IInterceptorsConsumer(ABC):

ellar/common/models/controller.py

@@ -11,7 +11,7 @@
 
 @dataclasses.dataclass
 class NestedRouterInfo:
-    router: t.Union["ModuleRouter", "ControllerBase"]
+    router: t.Union["ModuleRouter", t.Type["ControllerBase"]]
     prefix: t.Optional[str] = None
 
 
@@ -30,7 +30,7 @@ def full_view_name(cls, name: str) -> str:
 
     def add_router(
         cls,
-        router: t.Union["ControllerBase", "ModuleRouter"],
+        router: t.Union[t.Type["ControllerBase"], "ModuleRouter"],
         prefix: t.Optional[str] = None,
     ) -> None:
         if prefix:

ellar/common/operations/router.py

@@ -52,7 +52,7 @@ def control_type(self) -> t.Type[t.Any]:
 
     def add_router(
         self,
-        router: t.Union["ModuleRouter", "ControllerBase"],
+        router: t.Union["ModuleRouter", t.Type["ControllerBase"]],
         prefix: t.Optional[str] = None,
     ) -> None:
         if prefix:

ellar/core/__init__.py

@@ -6,7 +6,13 @@
 from .execution_context import ExecutionContext, HostContext
 from .guards import GuardConsumer
 from .interceptors import EllarInterceptorConsumer
-from .modules import DynamicModule, LazyModuleImport, ModuleBase, ModuleSetup
+from .modules import (
+    DynamicModule,
+    ForwardRefModule,
+    LazyModuleImport,
+    ModuleBase,
+    ModuleSetup,
+)
 from .services import Reflector, reflector
 from .shortcuts import host, mount
 from .versioning import VersioningSchemes
@@ -33,6 +39,7 @@
     "current_injector",
     "config",
     "ApplicationContext",
+    "ForwardRefModule",
 ]
 
 

ellar/core/conf/app_settings_models.py

@@ -12,11 +12,13 @@
 from ellar.common.templating import JinjaLoaderType
 from ellar.common.types import ASGIApp, TReceive, TScope, TSend
 from ellar.core.conf.mixins import ConfigDefaultTypesMixin
+from ellar.di import ProviderConfig
 from ellar.di.injector.tree_manager import ModuleTreeManager
 from ellar.pydantic import ENCODERS_BY_TYPE as encoders_by_type
-from ellar.pydantic import field_validator
+from ellar.pydantic import AllowTypeOfSource, field_validator
 from starlette.exceptions import HTTPException as StarletteHTTPException
 from starlette.websockets import WebSocketClose
+from typing_extensions import Annotated
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.app.main import App
@@ -52,6 +54,8 @@ class ConfigValidationSchema(Serializer, ConfigDefaultTypesMixin):
 
     model_config = {"validate_assignment": True, "from_attributes": True}
 
+    OVERRIDE_CORE_SERVICE: t.List[Annotated[ProviderConfig, AllowTypeOfSource()]] = []
+
     DEBUG: bool = False
 
     DEFAULT_JSON_CLASS: t.Type[JSONResponse] = JSONResponse