added test for appfactory and some refactoring

Author: eadwinCode

ellar/core/factory.py

@@ -13,7 +13,7 @@
 from ellar.core import Config
 from ellar.core.main import App
 from ellar.core.modules import ModuleBase
-from ellar.core.modules.ref import ModuleTemplateRef, create_module_ref_factor
+from ellar.core.modules.ref import create_module_ref_factor
 from ellar.di import EllarInjector, ProviderConfig
 from ellar.reflect import reflect
 
@@ -25,7 +25,7 @@
 class AppFactory:
     @classmethod
     def _read_all_module(
-        cls, module: t.Type[ModuleBase]
+        cls, module: t.Type[t.Union[ModuleBase, t.Any]]
     ) -> t.Dict[t.Type, t.Type[ModuleBase]]:
         modules = reflect.get_metadata(MODULE_METADATA.MODULES, module) or []
         module_dependency = OrderedDict()
@@ -36,11 +36,14 @@ def _read_all_module(
 
     @classmethod
     def _build_modules(
-        cls, app_module: t.Type[ModuleBase], config: Config, injector: EllarInjector
+        cls,
+        app_module: t.Type[t.Union[ModuleBase, t.Any]],
+        config: Config,
+        injector: EllarInjector,
     ) -> None:
         assert reflect.get_metadata(
             MODULE_WATERMARK, app_module
-        ), "Only ApplicationModule is allowed"
+        ), "Only Module is allowed"
 
         module_dependency = [app_module] + list(
             cls._read_all_module(app_module).values()
@@ -56,19 +59,10 @@ def _build_modules(
             )
             injector.add_module(module_ref)
 
-    @classmethod
-    def _run_module_application_ready(
-        cls,
-        modules: t.Dict[t.Type[ModuleBase], ModuleTemplateRef],
-        app: App,
-    ) -> None:
-        for _, module_ref in modules.items():
-            module_ref.run_application_ready(app)
-
     @classmethod
     def _create_app(
         cls,
-        module: t.Type[ModuleBase],
+        module: t.Type[t.Union[ModuleBase, t.Any]],
         global_guards: t.List[
             t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]
         ] = None,
@@ -95,9 +89,6 @@ def _create_app(
             global_guards=global_guards,
         )
 
-        cls._run_module_application_ready(
-            modules=injector.get_templating_modules(), app=app
-        )
         return app
 
     @classmethod
@@ -108,7 +99,7 @@ def create_app(
             t.Union["ModuleRouter", "ModuleMount", Mount, Host]
         ] = tuple(),
         providers: t.Sequence[t.Union[t.Type, "ProviderConfig"]] = tuple(),
-        modules: t.Sequence[t.Type] = (),
+        modules: t.Sequence[t.Type[t.Union[ModuleBase, t.Any]]] = (),
         template_folder: t.Optional[str] = None,
         base_directory: t.Optional[str] = None,
         static_folder: str = "static",
@@ -131,7 +122,7 @@ def create_app(
         app_factory_module = type(f"Module{uuid4().hex[:6]}", (ModuleBase,), {})
         module(app_factory_module)
         return cls._create_app(
-            t.cast(t.Type[ModuleBase], app_factory_module),
+            module=app_factory_module,
             config_module=config_module,
             global_guards=global_guards,
         )

ellar/core/main.py

@@ -219,6 +219,12 @@ def enable_versioning(
             **init_kwargs,
         )
 
+    def _run_module_application_ready(
+        self,
+    ) -> None:
+        for _, module_ref in self.injector.get_templating_modules().items():
+            module_ref.run_application_ready(self)
+
     def _finalize_app_initialization(self) -> None:
         self.injector.container.register_instance(self)
         self.injector.container.register_instance(Reflector())
@@ -228,6 +234,7 @@ def _finalize_app_initialization(self) -> None:
             IExecutionContext,
             ModuleProvider(ExecutionContext, scope={}, receive=None, send=None),
         )
+        self._run_module_application_ready()
 
     def add_exception_handler(
         self,

tests/test_application/test_application_factory.py

@@ -0,0 +1,103 @@
+from starlette.routing import Host, Mount
+
+from ellar.common import Module
+from ellar.core import AppFactory, Config, ModuleBase, TestClient
+from ellar.di import EllarInjector
+
+from .sample import (
+    AppAPIKey,
+    ApplicationModule,
+    ClassBaseController,
+    create_tmp_template_and_static_dir,
+    router,
+    sub_domain,
+    users,
+)
+
+
+@Module(modules=[ApplicationModule])
+class AModule:
+    pass
+
+
+@Module(modules=(AModule,))
+class BModule:
+    pass
+
+
+def test_factory__read_all_module():
+    modules_dict = AppFactory._read_all_module(module=BModule)
+    assert len(modules_dict) == 2
+    assert list(modules_dict.values())[0] is AModule
+    assert list(modules_dict.values())[1] is ApplicationModule
+
+    modules_dict = AppFactory._read_all_module(module=AModule)
+    assert len(modules_dict) == 1
+    assert list(modules_dict.values())[0] is ApplicationModule
+
+    modules_dict = AppFactory._read_all_module(module=ApplicationModule)
+    assert len(modules_dict) == 0
+
+
+def test_factory__build_modules():
+    config = Config()
+    injector = EllarInjector()
+    assert len(injector.get_modules()) == 0
+
+    AppFactory._build_modules(app_module=BModule, config=config, injector=injector)
+    module_refs = injector.get_modules()
+    assert len(module_refs) == 3
+
+    modules = [AModule, ApplicationModule, BModule]
+    for k, v in module_refs.items():
+        assert k in modules
+
+
+def test_factory_create_from_app_module():
+    app = AppFactory.create_from_app_module(
+        module=BModule,
+        global_guards=[AppAPIKey],
+        config_module="tests.test_application.settings",
+    )
+    assert app.get_guards() == [AppAPIKey]
+    assert app.config.config_module == "tests.test_application.settings"
+
+
+def test_factory_create_app_dynamically_creates_module():
+    app = AppFactory.create_app()
+    first_module_ref = next(app.get_module_loaders())
+    module_instance = first_module_ref.get_module_instance()
+    assert isinstance(module_instance, ModuleBase)
+    assert "ellar.core.factory.Module" in str(module_instance.__class__)
+
+
+def test_factory_create_app_works(tmpdir):
+    create_tmp_template_and_static_dir(tmpdir)
+
+    @Module()
+    class CModule:
+        pass
+
+    app = AppFactory.create_app(
+        modules=(CModule,),
+        global_guards=[AppAPIKey],
+        config_module="tests.test_application.settings",
+        controllers=(ClassBaseController,),
+        routers=[
+            Host("{subdomain}.example.org", app=sub_domain),
+            Mount("/users", app=users),
+            router,
+        ],
+        template_folder="templates",
+        static_folder="statics",
+        base_directory=tmpdir,
+    )
+
+    client = TestClient(app)
+    res = client.get("/static/example.txt")
+    assert res.status_code == 200
+    assert res.text == "<file content>"
+
+    template = app.jinja_environment.get_template("example.html")
+    result = template.render()
+    assert result == "<html>Hello World<html/>"