Added test for dynamic module config

Author: eadwinCode

ellar/core/__init__.py

@@ -7,7 +7,7 @@
 from .factory import AppFactory
 from .guard import BaseAPIKey, BaseAuthGuard, BaseHttpAuth, GuardCanActivate
 from .main import App
-from .modules import DynamicModule, IModuleConfigure, ModuleBase, ModuleConfigure
+from .modules import DynamicModule, IModuleSetup, ModuleBase, ModuleSetup
 from .response import (
     FileResponse,
     HTMLResponse,
@@ -36,7 +36,7 @@
     "ModuleBase",
     "BaseAPIKey",
     "BaseAuthGuard",
-    "IModuleConfigure",
+    "IModuleSetup",
     "BaseHttpAuth",
     "GuardCanActivate",
     "Config",
@@ -53,7 +53,7 @@
     "Response",
     "Request",
     "WebSocket",
-    "ModuleConfigure",
+    "ModuleSetup",
     "DynamicModule",
 ]
 

ellar/core/factory.py

@@ -8,7 +8,7 @@
 from ellar.constants import MODULE_METADATA, MODULE_WATERMARK
 from ellar.core import Config
 from ellar.core.main import App
-from ellar.core.modules import DynamicModule, ModuleBase, ModuleConfigure
+from ellar.core.modules import DynamicModule, ModuleBase, ModuleSetup
 from ellar.di import EllarInjector, ProviderConfig
 from ellar.reflect import reflect
 
@@ -26,7 +26,7 @@ class AppFactory:
     """
 
     @classmethod
-    def get_all_modules(cls, module_config: ModuleConfigure) -> t.List[ModuleConfigure]:
+    def get_all_modules(cls, module_config: ModuleSetup) -> t.List[ModuleSetup]:
         """
         Gets all registered modules from a particular module in their order of dependencies
         :param module_config: Module Type
@@ -38,9 +38,7 @@ def get_all_modules(cls, module_config: ModuleConfigure) -> t.List[ModuleConfigu
         return module_dependency
 
     @classmethod
-    def read_all_module(
-        cls, module_config: ModuleConfigure
-    ) -> t.Dict[t.Type, ModuleConfigure]:
+    def read_all_module(cls, module_config: ModuleSetup) -> t.Dict[t.Type, ModuleSetup]:
         """
         Retrieves all modules dependencies registered in another module
         :param module_config: Module Type
@@ -52,9 +50,11 @@ def read_all_module(
         module_dependency = OrderedDict()
         for module in modules:
             if isinstance(module, DynamicModule):
-                module_config = ModuleConfigure(module.module)
+                module_config = ModuleSetup(module.module)
+            elif isinstance(module, ModuleSetup):
+                module_config = module
             else:
-                module_config = ModuleConfigure(module)
+                module_config = ModuleSetup(module)
 
             module_dependency[module_config.module] = module_config
             module_dependency.update(cls.read_all_module(module_config))
@@ -78,7 +78,7 @@ def _build_modules(
             MODULE_WATERMARK, app_module
         ), "Only Module is allowed"
 
-        app_module_config = ModuleConfigure(app_module)
+        app_module_config = ModuleSetup(app_module)
         module_dependency = cls.get_all_modules(app_module_config)
         routes = []
 
@@ -90,14 +90,14 @@ def _build_modules(
                 container=injector.container, config=config
             )
 
-            if not isinstance(module_ref, ModuleConfigure):
+            if not isinstance(module_ref, ModuleSetup):
                 module_ref.run_module_register_services()
                 routes.extend(module_ref.routes)
 
             injector.add_module(module_ref)
 
         for module_config in injector.get_dynamic_modules():
-            if injector.get_module(module_config.module):
+            if injector.get_module(module_config.module):  # pragma: no cover
                 continue
 
             module_ref = module_config.configure_with_factory(
@@ -144,7 +144,7 @@ def _create_app(
         module_changed = False
 
         for module_config in injector.get_app_dependent_modules():
-            if injector.get_module(module_config.module):
+            if injector.get_module(module_config.module):  # pragma: no cover
                 continue
 
             module_ref = module_config.configure_with_factory(

ellar/core/main.py

@@ -20,12 +20,7 @@
     RequestVersioningMiddleware,
     TrustedHostMiddleware,
 )
-from ellar.core.modules import (
-    DynamicModule,
-    ModuleBase,
-    ModuleConfigure,
-    ModuleTemplateRef,
-)
+from ellar.core.modules import DynamicModule, ModuleBase, ModuleSetup, ModuleTemplateRef
 from ellar.core.routing import ApplicationRouter
 from ellar.core.templating import AppTemplating, Environment
 from ellar.core.versioning import VERSIONING, BaseAPIVersioning
@@ -139,9 +134,9 @@ def install_module(
         **init_kwargs: t.Any,
     ) -> t.Union[T, ModuleBase]:
         if isinstance(module, DynamicModule):
-            module_config = ModuleConfigure(module.module, init_kwargs=init_kwargs)
+            module_config = ModuleSetup(module.module, init_kwargs=init_kwargs)
         else:
-            module_config = ModuleConfigure(module, init_kwargs=init_kwargs)
+            module_config = ModuleSetup(module, init_kwargs=init_kwargs)
 
         module_ref = self.injector.get_module(module_config.module)
         if module_ref:

ellar/core/modules/__init__.py

@@ -1,13 +1,13 @@
 from .base import ModuleBase
-from .config import DynamicModule, IModuleConfigure, ModuleConfigure
+from .config import DynamicModule, IModuleSetup, ModuleSetup
 from .ref import ModulePlainRef, ModuleRefBase, ModuleTemplateRef
 
 __all__ = [
     "ModuleBase",
     "ModulePlainRef",
     "ModuleTemplateRef",
     "ModuleRefBase",
-    "ModuleConfigure",
-    "IModuleConfigure",
+    "IModuleSetup",
+    "ModuleSetup",
     "DynamicModule",
 ]

ellar/core/modules/config.py

@@ -7,21 +7,20 @@
 import ellar.core.conf as conf
 import ellar.core.main as main
 import ellar.di as di
-from ellar.constants import MODULE_METADATA, MODULE_REF_TYPES, MODULE_WATERMARK
+from ellar.constants import MODULE_METADATA, MODULE_REF_TYPES
 from ellar.reflect import reflect
 
+from .base import ModuleBase
 from .ref import ModuleRefBase, create_module_ref_factor
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core import ControllerBase
 
-    from .base import ModuleBase
-
 
 @dataclasses.dataclass
 class DynamicModule:
     # Module type to be configured
-    module: t.Type[t.Union["ModuleBase", "IModuleConfigure", t.Any]]
+    module: t.Type[t.Union["ModuleBase", t.Any]]
 
     providers: t.List[t.Union[t.Type, t.Any]] = dataclasses.field(
         default_factory=lambda: []
@@ -35,9 +34,7 @@ class DynamicModule:
     )
 
     def __post_init__(self) -> None:
-        if not reflect.get_metadata(MODULE_WATERMARK, self.module) or not isinstance(
-            self.module, type
-        ):
+        if not isinstance(self.module, type) or not issubclass(self.module, ModuleBase):
             raise Exception(f"{self.module.__name__} is not a valid Module")
 
         kwargs = dict(
@@ -50,12 +47,14 @@ def __post_init__(self) -> None:
             MODULE_METADATA.ROUTERS,
             MODULE_METADATA.PROVIDERS,
         ]:
-            reflect.delete_metadata(key, self.module)
-            reflect.define_metadata(key, kwargs[key], self.module)
+            value = kwargs[key]
+            if value:
+                reflect.delete_metadata(key, self.module)
+                reflect.define_metadata(key, value, self.module)
 
 
 @dataclasses.dataclass
-class ModuleConfigure:
+class ModuleSetup:
     """
     ModuleConfigure is a way to configure a module late after the application has started.
     This is necessary for Module that requires some services available to configure them.
@@ -76,7 +75,7 @@ def module_a_configuration_factory(module: ModuleA, config: Config, foo: Foo):
     """
 
     # Module type to be configured
-    module: t.Type[t.Union["ModuleBase", "IModuleConfigure", t.Any]]
+    module: t.Type[t.Union[ModuleBase, "IModuleSetup", t.Any]]
 
     # `inject` property holds collection types to be injected to `use_factory` method.
     # the order at which the types are defined becomes the order at which they are injected.
@@ -91,9 +90,7 @@ def module_a_configuration_factory(module: ModuleA, config: Config, foo: Foo):
     factory: t.Callable[..., DynamicModule] = None  # type: ignore[assignment]
 
     def __post_init__(self) -> None:
-        if not reflect.get_metadata(MODULE_WATERMARK, self.module) or not isinstance(
-            self.module, type
-        ):
+        if not isinstance(self.module, type) or not issubclass(self.module, ModuleBase):
             raise Exception(f"{self.module.__name__} is not a valid Module")
 
         if main.App in self.inject:
@@ -105,13 +102,17 @@ def has_factory_function(self) -> bool:
             # 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.
-            if len(self.inject) == 1 and self.inject[0] == conf.Config:
+            inject_size = len(self.inject)
+            if inject_size == 0:
+                return False
+
+            if inject_size == 1 and self.inject[0] == conf.Config:
                 return False
             return True
 
     def get_module_ref(
         self, config: conf.Config, container: di.Container
-    ) -> t.Union["ModuleRefBase", "ModuleConfigure"]:
+    ) -> t.Union[ModuleRefBase, "ModuleSetup"]:
         if self.has_factory_function or self.ref_type == MODULE_REF_TYPES.APP_DEPENDENT:
             return self
 
@@ -148,15 +149,15 @@ def _get_services(self, injector: di.EllarInjector) -> t.List:
             res.append(injector.get(service))
         return res
 
-    def __hash__(self) -> int:
+    def __hash__(self) -> int:  # pragma: no cover
         return hash(self.module)
 
 
-class IModuleConfigure:
+class IModuleSetup:
     """Modules that must have a custom setup should inherit from IModuleConfigure"""
 
     @classmethod
     @abstractmethod
     @t.no_type_check
-    def module_configure(cls, *args: t.Any, **kwargs: t.Any) -> DynamicModule:
-        """Module Configure"""
+    def setup(cls, *args: t.Any, **kwargs: t.Any) -> DynamicModule:
+        """Module Dynamic Setup"""

ellar/core/testclient.py

@@ -9,6 +9,9 @@
 from ellar.core.routing import ModuleRouter
 from ellar.di import ProviderConfig
 
+if t.TYPE_CHECKING:  # pragma: no cover
+    from ellar.core import GuardCanActivate
+
 
 class _TestingModule:
     def __init__(self, app: App) -> None:
@@ -36,33 +39,41 @@ class TestClientFactory:
     @classmethod
     def create_test_module(
         cls,
+        modules: t.Sequence[t.Union[t.Type, t.Any]] = tuple(),
         controllers: t.Sequence[t.Union[t.Any]] = tuple(),
         routers: t.Sequence[ModuleRouter] = tuple(),
         providers: t.Sequence[ProviderConfig] = tuple(),
         template_folder: t.Optional[str] = None,
         base_directory: t.Optional[t.Union[str, Path]] = None,
         static_folder: str = "static",
+        global_guards: t.List[
+            t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]
+        ] = None,
         config_module: str = None,
     ) -> _TestingModule:
         """
         Create a TestingModule to test controllers and services in isolation
+        :param modules:
         :param controllers:
         :param routers:
         :param providers:
         :param template_folder:
         :param base_directory:
         :param static_folder:
         :param config_module:
+        :param global_guards:
         :return:
         """
         app = AppFactory.create_app(
+            modules=modules,
             controllers=controllers,
             routers=routers,
             providers=providers,
             template_folder=template_folder,
             base_directory=base_directory,
             static_folder=static_folder,
             config_module=config_module,
+            global_guards=global_guards,
         )
         return _TestingModule(app=app)
 

ellar/di/injector/ellar_injector.py

@@ -16,8 +16,8 @@
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.modules import (
         ModuleBase,
-        ModuleConfigure,
         ModuleRefBase,
+        ModuleSetup,
         ModuleTemplateRef,
     )
 
@@ -72,15 +72,15 @@ def get_modules(
 
     def get_dynamic_modules(
         self,
-    ) -> t.Generator["ModuleConfigure", t.Any, None]:
+    ) -> t.Generator["ModuleSetup", t.Any, None]:
         for _, module_configure in self._modules[MODULE_REF_TYPES.DYNAMIC].items():
             yield module_configure
 
         self._modules[MODULE_REF_TYPES.DYNAMIC].clear()
 
     def get_app_dependent_modules(
         self,
-    ) -> t.Generator["ModuleConfigure", t.Any, None]:
+    ) -> t.Generator["ModuleSetup", t.Any, None]:
         for _, module_configure in self._modules[
             MODULE_REF_TYPES.APP_DEPENDENT
         ].items():
@@ -104,9 +104,7 @@ def get_templating_modules(
     ) -> t.Dict[t.Type["ModuleBase"], "ModuleTemplateRef"]:
         return self._modules.get(MODULE_REF_TYPES.TEMPLATE, {})
 
-    def add_module(
-        self, module_ref: t.Union["ModuleRefBase", "ModuleConfigure"]
-    ) -> None:
+    def add_module(self, module_ref: t.Union["ModuleRefBase", "ModuleSetup"]) -> None:
         self._modules[module_ref.ref_type].update({module_ref.module: module_ref})
 
     @t.no_type_check

ellar/di/service_config.py

@@ -33,7 +33,7 @@ def __init__(
         base_type: t.Union[t.Type[T], t.Type],
         *,
         use_value: T = None,
-        use_class: t.Type[T] = None
+        use_class: t.Union[t.Type[T], t.Any] = None
     ):
         if use_value and use_class:
             raise DIImproperConfiguration(