Added test for ForwardRefModule

Author: eadwinCode

ellar/app/core_module.py

@@ -3,6 +3,8 @@
 from ellar.auth import AppIdentitySchemes, IdentityAuthenticationService
 from ellar.auth.session import SessionServiceNullStrategy, SessionStrategy
 from ellar.common import (
+    GlobalGuard,
+    GuardCanActivate,
     IApplicationReady,
     IApplicationShutdown,
     IApplicationStartup,
@@ -29,7 +31,7 @@
 from ellar.core.guards import GuardConsumer
 from ellar.core.interceptors import EllarInterceptorConsumer
 from ellar.core.services import Reflector, reflector
-from ellar.di import EllarInjector, ProviderConfig, request_scope
+from ellar.di import EllarInjector, ProviderConfig, injectable, request_scope
 from ellar.di.injector.tree_manager import ModuleTreeManager
 
 if t.TYPE_CHECKING:  # pragma: no cover
@@ -40,6 +42,14 @@ def _raise_unavailable_exception() -> None:
     raise Exception("Service is only available during request")
 
 
+@injectable
+class GlobalCanActivatePlaceHolder(GuardCanActivate):
+    placeholder: bool = True
+
+    async def can_activate(self, context: IExecutionContext) -> bool:
+        return True
+
+
 def get_core_module(app_module: t.Union[t.Type, t.Any], config: Config) -> t.Type:
     @Module(
         modules=[app_module],
@@ -49,6 +59,11 @@ def get_core_module(app_module: t.Union[t.Type, t.Any], config: Config) -> t.Typ
                 use_value=config,
                 export=True,
             ),
+            ProviderConfig(
+                GlobalGuard,
+                use_class=GlobalCanActivatePlaceHolder,
+                export=True,
+            ),
             ProviderConfig(
                 ModuleTreeManager,
                 use_value=lambda: config.MODULE_TREE_MANAGER_CLASS(

ellar/app/main.py

@@ -127,6 +127,7 @@ def use_global_guards(
         self, *guards: t.Union["GuardCanActivate", t.Type["GuardCanActivate"]]
     ) -> None:
         self._global_guards.extend(guards)
+        self._ensure_available_in_providers(*guards)
 
     def use_global_interceptors(
         self, *interceptors: t.Union[EllarInterceptor, t.Type[EllarInterceptor]]
@@ -332,6 +333,9 @@ def __global_guard(
     ) -> t.List[t.Union[t.Type[GuardCanActivate], GuardCanActivate]]:
         try:
             guard = self.injector.get(GlobalGuard)
+            if guard.__class__.__name__ == "GlobalCanActivatePlaceHolder":
+                return []
+
             return [guard]
         except Exception:
             return []

ellar/core/modules/config.py

@@ -97,8 +97,8 @@ def setup(cls, param1: Any, param2: Any, foo: str) -> DynamicModule:
             return DynamicModule(cls, providers=[], controllers=[], routers=[])
 
 
-    def module_a_configuration_factory(module: Type[MyModule], config: Config, foo: Foo):
-        return module.setup(param1=config.param1, param2=config.param2, foo=foo.foo)
+    def module_a_configuration_factory(module_ref: ModuleRefBase, config: Config, foo: Foo):
+        return module_ref.module.setup(param1=config.param1, param2=config.param2, foo=foo.foo)
 
 
     @Module(modules=[ModuleSetup(MyModule, inject=[Config, Foo], factory=module_a_configuration_factory), ])
@@ -162,39 +162,28 @@ def providers(self) -> t.Dict[t.Type, t.Type]:
     def is_ready(self) -> bool:
         raise Exception(f"{self.module} is not ready")
 
-    # @property
-    # def has_factory_function(self) -> bool:
-    #     if self.factory is not None:
-    #         # if we have a factory function, we need to check if the services to inject is just config
-    #         # if so, then we can go ahead and have the configuration executed since at this level,
-    #         # the config service is available to be injected.
-    #         inject_size = len(self.inject)
-    #         if inject_size == 0:
-    #             return False
-    #
-    #         if inject_size == 1 and self.inject[0] == Config:
-    #             return False
-    #         return True
-
-    def get_module_ref(
-        self, config: "Config", container: Container
-    ) -> t.Union["ModuleRefBase", "ModuleSetup"]:
-        # if self.has_factory_function or self.ref_type == MODULE_REF_TYPES.APP_DEPENDENT:
-        #     return self
-
+    def get_module_ref(self, config: "Config", container: Container) -> ModuleRefBase:
         if self.factory is not None:
-            ref = self.configure_with_factory(config, container)
+            ref = self._configure_with_factory(config, container)
         else:
             ref = create_module_ref_factor(
                 self.module, config, container, **self.init_kwargs
             )
 
+        assert isinstance(
+            ref, ModuleRefBase
+        ), f"{ref.module} is not properly configured."
+
         ref.initiate_module_build()
         return ref
 
-    def configure_with_factory(
+    def _configure_with_factory(
         self, config: "Config", container: Container
     ) -> "ModuleRefBase":
+        if self.ref_type == MODULE_REF_TYPES.APP_DEPENDENT:
+            app = fail_silently(container.injector.get, interface="App")
+            assert app, "Application is not ready"
+
         services = self._get_services(container.injector)
         init_kwargs = dict(self.init_kwargs)
 
@@ -226,32 +215,12 @@ def _get_services(self, injector: EllarInjector) -> t.List:
             res.append(injector.get(service))
         return res
 
-    def build(
-        self,
-        injector: EllarInjector,
-        config: "Config",
-    ) -> "ModuleRefBase":
-        # routes = []
-
-        if self.ref_type == MODULE_REF_TYPES.APP_DEPENDENT:
-            app = fail_silently(injector.get, interface="App")
-            assert app, "Application is not ready"
-
-        ref = self.get_module_ref(container=injector.container, config=config)
-        assert isinstance(
-            ref, ModuleRefBase
-        ), f"{ref.module} is not properly configured."
-
-        # ref.initiate_module_build()
-        # ref.build_modules(ref_type)
-        return ref
-
     def build_and_get_routes(
         self,
         injector: EllarInjector,
         config: "Config",
     ) -> t.List[BaseRoute]:
-        ref = self.build(injector, config)
+        ref = self.get_module_ref(config, injector.container)
         ref.build_dependencies()
 
         return ref.get_routes()
@@ -319,7 +288,7 @@ def get_module_dependency_by_type(
                 )
             except Exception as ex:
                 raise ImproperConfiguration(
-                    f'Unable to import "{self.module}" registered in "{parent_module_ref.module}"'
+                    f"Unable to import '{self.module}' registered in '{parent_module_ref.module}'"
                 ) from ex
         else:
             module_cls = t.cast(t.Type["ModuleBase"], self.module)
@@ -328,8 +297,9 @@ def get_module_dependency_by_type(
 
         if not node:
             raise ImproperConfiguration(
-                f"ForwardRefModule module='{self.module_name}' "
-                f"defined in {parent_module_ref.module} could not be found."
+                f"ForwardRefModule module='{self.module}' "
+                f"defined in {parent_module_ref.module} could not be found.\n"
+                f"Please kindly ensure a {self.module} is decorated with @Module() is registered"
             )
 
         return node.value.module

ellar/core/modules/ref/base.py

@@ -12,7 +12,6 @@
     MODULE_WATERMARK,
     ROUTE_INTERCEPTORS,
 )
-from ellar.common.exceptions import ImproperConfiguration
 from ellar.core.conf import Config
 from ellar.core.context import ApplicationContext
 from ellar.core.modules.base import ModuleBase
@@ -144,12 +143,9 @@ def build_dependencies(self, step: int = -1) -> None:
             if step != -1 and idx + 1 > step:
                 break
 
-            ref = module_config
+            ref = module_config.value
             if not isinstance(module_config.value, ModuleRefBase):
-                ref = module_config.value.build(self.container.injector, self.config)
-
-            if not isinstance(ref, ModuleRefBase):  # pragma: no cover
-                raise ImproperConfiguration(f"Expected 'ModuleRefBase' but got '{ref}'")
+                ref = module_config.value.get_module_ref(self.config, self.container)
 
             ref.build_dependencies(step - 1 if step != -1 else step)
 
@@ -202,8 +198,8 @@ def add_provider(
             self._providers.update({provider_type: provider_type})
             provider.register(self.container)
 
-        if provider.export or export:
-            self.add_exports(provider_type)
+            if provider.export or export:
+                self.add_exports(provider_type)
 
     def _build_module_parameters(self) -> None:
         from ellar.core.modules.config import ForwardRefModule

ellar/testing/module.py

@@ -39,13 +39,19 @@ def override_provider(
         *,
         use_value: t.Optional[T] = None,
         use_class: t.Optional[t.Union[t.Type[T], t.Any]] = None,
+        core: bool = False,
+        export: bool = True,
     ) -> "TestingModule":
         """
         Overrides Service at module level.
         Use this function before creating an application instance.
         """
         provider_config = ProviderConfig(
-            base_type, use_class=use_class, use_value=use_value, export=True
+            base_type,
+            use_class=use_class,
+            use_value=use_value,
+            export=export,
+            core=core,
         )
         reflect.define_metadata(
             constants.MODULE_METADATA.PROVIDERS, [provider_config], self._testing_module

samples/03-auth-with-guards/auth_project/auth/module.py

@@ -18,11 +18,9 @@ def register_providers(self, container: Container) -> None:
 
 """
 
-from datetime import timedelta
-
 from ellar.common import GlobalGuard, Module
+from ellar.core import ForwardRefModule, ModuleBase
 from ellar.core import LazyModuleImport as lazyLoad
-from ellar.core import ModuleBase
 from ellar.di import ProviderConfig
 from ellar_jwt import JWTModule
 
@@ -34,14 +32,12 @@ def register_providers(self, container: Container) -> None:
 @Module(
     modules=[
         lazyLoad("auth_project.users.module:UsersModule"),
-        JWTModule.setup(
-            signing_secret_key="my_poor_secret_key_lol", lifetime=timedelta(minutes=5)
-        ),
+        ForwardRefModule(JWTModule),
     ],
     controllers=[AuthController],
     providers=[
         AuthService,
-        ProviderConfig(GlobalGuard, use_class=AuthGuard, export=True),
+        ProviderConfig(GlobalGuard, use_class=AuthGuard, core=True),
     ],
 )
 class AuthModule(ModuleBase):

samples/03-auth-with-guards/auth_project/auth/tests/test_auth_controllers.py

@@ -1,9 +1,10 @@
+from datetime import timedelta
 from unittest.mock import Mock
 
 from ellar.common import Identity
 from ellar.di import ProviderConfig
 from ellar.testing import Test
-from ellar_jwt import JWTService
+from ellar_jwt import JWTModule, JWTService
 
 from ..controllers import AuthController
 from ..module import AuthModule
@@ -48,7 +49,15 @@ async def test_get_all_action(self, anyio_backend):
 
 class TestAuthControllerE2E:
     def setup_method(self):
-        self.test_module = Test.create_test_module(modules=[AuthModule])
+        self.test_module = Test.create_test_module(
+            modules=[
+                AuthModule,
+                JWTModule.setup(
+                    signing_secret_key="my_poor_secret_key_lol",
+                    lifetime=timedelta(minutes=5),
+                ),
+            ]
+        )
         jwt_service: JWTService = self.test_module.get(JWTService)
         self.token = jwt_service.sign({"username": "john", "id": 23, "sub": "john"})
 

samples/03-auth-with-guards/auth_project/root_module.py

@@ -1,3 +1,5 @@
+from datetime import timedelta
+
 from ellar.common import (
     IExecutionContext,
     JSONResponse,
@@ -8,9 +10,18 @@
 from ellar.core import LazyModuleImport as lazyLoad
 from ellar.core import ModuleBase
 from ellar.samples.modules import HomeModule
+from ellar_jwt import JWTModule
 
 
-@Module(modules=[HomeModule, lazyLoad("auth_project.auth.module:AuthModule")])
+@Module(
+    modules=[
+        HomeModule,
+        lazyLoad("auth_project.auth.module:AuthModule"),
+        JWTModule.setup(
+            signing_secret_key="my_poor_secret_key_lol", lifetime=timedelta(minutes=5)
+        ),
+    ]
+)
 class ApplicationModule(ModuleBase):
     @exception_handler(404)
     def exception_404_handler(self, ctx: IExecutionContext, exc: Exception) -> Response:

tests/test_application/test_execution_context.py

@@ -83,7 +83,7 @@ def lookup_status_code_exception_handler(self, status_code: int):
 
 def test_can_replace_host_context():
     tm = Test.create_test_module(controllers=[ExampleController]).override_provider(
-        IHostContextFactory, use_class=NewHostContextFactory
+        IHostContextFactory, use_class=NewHostContextFactory, core=True
     )
 
     assert hasattr(NewHostContext, "worked") is False
@@ -127,7 +127,7 @@ def exception_400(self, context: IHostContext, exc: Exception):
 
 def test_can_replace_execution_context():
     tm = Test.create_test_module(controllers=[ExampleController]).override_provider(
-        IExecutionContextFactory, use_class=NewExecutionHostFactory
+        IExecutionContextFactory, use_class=NewExecutionHostFactory, core=True
     )
 
     assert hasattr(NewExecutionContext, "worked") is False

tests/test_auth/test_guards/test_auth_guards.py

@@ -287,7 +287,7 @@ def _auth_demo_endpoint(request: Inject[Request]):
 
 def test_global_guard_case_2_works():
     _app = AppFactory.create_app(
-        providers=[ProviderConfig(GlobalGuard, use_class=DigestAuth)]
+        providers=[ProviderConfig(GlobalGuard, use_class=DigestAuth, core=True)]
     )
 
     @get("/global")
@@ -326,7 +326,7 @@ def test_if_an_auth_guard_return_converts_to_identity(
     input_type, is_authenticated, expect_result
 ):
     _app = AppFactory.create_app(
-        providers=[ProviderConfig(GlobalGuard, use_class=DigestAuth)]
+        providers=[ProviderConfig(GlobalGuard, use_class=DigestAuth, core=True)]
     )
 
     @get("/global")