orionis 0.372.0__py3-none-any.whl → 0.374.0__py3-none-any.whl

orionis/__init__.py

@@ -1,5 +1,7 @@
-from orionis.foundation.application import Application as Orionis
-from orionis.foundation.contracts.application import IApplication as IOrionis
+from orionis.foundation.application import (
+    Application as Orionis,
+    IApplication as IOrionis
+)
 
 __all__ = [
     "Orionis",

orionis/container/facades/facade.py

@@ -1,10 +1,13 @@
 from typing import Any
-from orionis.container.container import Container
 from orionis.container.exceptions import OrionisContainerAttributeError, OrionisContainerException
+from orionis.foundation.application import Application
+from typing import TypeVar, Any
+
+T = TypeVar('T')
 
 class FacadeMeta(type):
 
-    def __getattr__(cls, name: str) -> Any:
+    def __getattr__(cls, name: str) -> T:
         """
         When an undefined attribute is accessed, this method resolves the service and delegates the call.
 
@@ -30,8 +33,8 @@ class FacadeMeta(type):
 
 class Facade(metaclass=FacadeMeta):
 
-    # Container instance to resolve services
-    _container = Container()
+    # Application instance to resolve services
+    _app = Application()
 
     @classmethod
     def getFacadeAccessor(cls) -> str:
@@ -79,13 +82,12 @@ class Facade(metaclass=FacadeMeta):
         service_name = cls.getFacadeAccessor()
 
         # Check if the service is bound in the container
-        if not cls._container.bound(service_name):
+        if not cls._app.bound(service_name):
             raise OrionisContainerException(
                 f"Service '{service_name}' not bound in the container. "
-                f"Please ensure '{service_name}' is registered in the container before using the {cls.__name__} facade. "
-                "You can register services in a service provider using the 'register' method."
+                f"Please ensure '{service_name}' is registered in the container before using the {cls.__name__} facade."
             )
 
         # Resolve the service instance from the container
-        service_instance = cls._container.make(service_name, *args, **kwargs)
+        service_instance = cls._app.make(service_name, *args, **kwargs)
         return service_instance

orionis/container/resolver/resolver.py

@@ -7,7 +7,7 @@ from orionis.container.enums.lifetimes import Lifetime
 from orionis.container.exceptions import OrionisContainerException
 from orionis.services.introspection.callables.reflection import ReflectionCallable
 from orionis.services.introspection.concretes.reflection import ReflectionConcrete
-from orionis.services.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
+from orionis.services.introspection.dependencies.entities.known_dependencies import KnownDependency
 
 class Resolver(IResolver):
     """
@@ -367,8 +367,8 @@ class Resolver(IResolver):
             params = {}
             for param_name, dep in dependencies.resolved.items():
 
-                # If the dependency is a ResolvedDependency, resolve it
-                if isinstance(dep, ResolvedDependency):
+                # If the dependency is a KnownDependency, resolve it
+                if isinstance(dep, KnownDependency):
 
                     # If the dependency is a built-in type, raise an exception
                     if dep.module_name == 'builtins':

orionis/foundation/application.py

@@ -64,6 +64,7 @@ class Application(Container, IApplication):
         """
         if not self.__booted:
             self.__loadFrameworkProviders()
+            self.__loadFrameworksKernel()
 
     def __loadFrameworkProviders(self) -> None:
         """
@@ -72,12 +73,15 @@ class Application(Container, IApplication):
         This method should register core services required by the framework
         before user-defined providers are loaded.
         """
+
+        # Import core provider classes
         from orionis.foundation.providers.console_provider import ConsoleProvider
         from orionis.foundation.providers.dumper_provider import DumperProvider
         from orionis.foundation.providers.path_resolver_provider import PathResolverProvider
         from orionis.foundation.providers.progress_bar_provider import ProgressBarProvider
         from orionis.foundation.providers.workers_provider import WorkersProvider
 
+        # List of core providers to register
         core_providers = [
             ConsoleProvider,
             DumperProvider,
@@ -86,9 +90,30 @@ class Application(Container, IApplication):
             WorkersProvider
         ]
 
+        # Register each core provider with the application
         for provider_cls in core_providers:
             self.__registerProvider(provider_cls)
 
+    def __loadFrameworksKernel(self) -> None:
+        """
+        Load the core framework kernel.
+
+        This method is responsible for loading the core kernel of the framework,
+        which is essential for the application to function correctly.
+        """
+
+        # Import Kernel classes
+        from orionis.test.kernel import TestKernel, ITestKernel
+
+        # List of core kernels to register
+        core_kernels = {
+            ITestKernel: TestKernel
+        }
+
+        # Register each core kernel with the application
+        for kernel_name, kernel_cls in core_kernels.items():
+            self.instance(kernel_name, kernel_cls(self))
+
     def __registerProvider(
         self,
         provider_cls: Type[IServiceProvider]

orionis/metadata/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.372.0"
+VERSION = "0.374.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"

orionis/services/introspection/dependencies/entities/callable_dependencies.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from typing import Any, Dict, List
-from orionis.services.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
+from orionis.services.introspection.dependencies.entities.known_dependencies import KnownDependency
 from orionis.services.introspection.exceptions import ReflectionTypeError
 
 @dataclass(frozen=True, kw_only=True)
@@ -10,9 +10,9 @@ class CallableDependency:
 
     Parameters
     ----------
-    resolved : Dict[ResolvedDependency, Any]
+    resolved : Dict[KnownDependency, Any]
         A dictionary mapping resolved dependency descriptors to their corresponding
-        resolved instances or values for the method. All keys must be ResolvedDependency instances.
+        resolved instances or values for the method. All keys must be KnownDependency instances.
     unresolved : List[str]
         A list of method parameter names or dependency identifiers that could not be resolved.
         Must contain only non-empty strings.
@@ -21,12 +21,12 @@ class CallableDependency:
     ------
     ReflectionTypeError
         If types don't match the expected:
-            - resolved: Dict[ResolvedDependency, Any]
+            - resolved: Dict[KnownDependency, Any]
             - unresolved: List[str]
     ValueError
         If resolved contains None keys or unresolved contains empty strings
     """
-    resolved: Dict[ResolvedDependency, Any]
+    resolved: Dict[KnownDependency, Any]
     unresolved: List[str]
 
     def __post_init__(self):
@@ -37,7 +37,7 @@ class CallableDependency:
         ------
         ReflectionTypeError
             If types don't match the expected:
-                - resolved: Dict[ResolvedDependency, Any]
+                - resolved: Dict[KnownDependency, Any]
                 - unresolved: List[str]
         ValueError
             If resolved contains None keys or unresolved contains empty strings

orionis/services/introspection/dependencies/entities/class_dependencies.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from typing import Any, Dict, List
-from orionis.services.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
+from orionis.services.introspection.dependencies.entities.known_dependencies import KnownDependency
 from orionis.services.introspection.exceptions import ReflectionTypeError
 
 @dataclass(frozen=True, kw_only=True)
@@ -10,21 +10,21 @@ class ClassDependency:
 
     Parameters
     ----------
-    resolved : Dict[ResolvedDependency, Any]
+    resolved : Dict[KnownDependency, Any]
         A dictionary mapping resolved dependency descriptors to their corresponding resolved instances or values.
-        All keys must be ResolvedDependency instances.
+        All keys must be KnownDependency instances.
     unresolved : List[str]
         A list of dependency names or identifiers that could not be resolved.
         Must contain only strings.
 
     Attributes
     ----------
-    resolved : Dict[ResolvedDependency, Any]
+    resolved : Dict[KnownDependency, Any]
         Dictionary of resolved dependencies.
     unresolved : List[str]
         List of unresolved dependency names.
     """
-    resolved: Dict[ResolvedDependency, Any]
+    resolved: Dict[KnownDependency, Any]
     unresolved: List[str]
 
     def __post_init__(self):
@@ -35,12 +35,12 @@ class ClassDependency:
         ------
         ReflectionTypeError
             If types don't match the expected:
-                - resolved: Dict[ResolvedDependency, Any]
+                - resolved: Dict[KnownDependency, Any]
                 - unresolved: List[str]
         ValueError
             If resolved contains None keys or unresolved contains empty strings.
         """
-        # Validate 'resolved' is a dict with ResolvedDependency keys
+        # Validate 'resolved' is a dict with KnownDependency keys
         if not isinstance(self.resolved, dict):
             raise ReflectionTypeError(
                 f"'resolved' must be a dict, got {type(self.resolved).__name__}"

orionis/services/introspection/dependencies/entities/{resolved_dependencies.py → known_dependencies.py}

@@ -3,7 +3,7 @@ from typing import Type, Any
 from orionis.services.introspection.exceptions import ReflectionTypeError
 
 @dataclass(frozen=True, kw_only=True)
-class ResolvedDependency:
+class KnownDependency:
     """
     Represents a fully resolved dependency with complete type information.
 

orionis/services/introspection/dependencies/entities/method_dependencies.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from typing import Any, Dict, List
-from orionis.services.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
+from orionis.services.introspection.dependencies.entities.known_dependencies import KnownDependency
 from orionis.services.introspection.exceptions import ReflectionTypeError
 
 @dataclass(frozen=True, kw_only=True)
@@ -10,9 +10,9 @@ class MethodDependency:
 
     Parameters
     ----------
-    resolved : Dict[ResolvedDependency, Any]
+    resolved : Dict[KnownDependency, Any]
         A dictionary mapping resolved dependency descriptors to their corresponding
-        resolved instances or values for the method. All keys must be ResolvedDependency instances.
+        resolved instances or values for the method. All keys must be KnownDependency instances.
     unresolved : List[str]
         A list of method parameter names or dependency identifiers that could not be resolved.
         Must contain only non-empty strings.
@@ -21,12 +21,12 @@ class MethodDependency:
     ------
     ReflectionTypeError
         If types don't match the expected:
-            - resolved: Dict[ResolvedDependency, Any]
+            - resolved: Dict[KnownDependency, Any]
             - unresolved: List[str]
     ValueError
         If resolved contains None keys or unresolved contains empty strings
     """
-    resolved: Dict[ResolvedDependency, Any]
+    resolved: Dict[KnownDependency, Any]
     unresolved: List[str]
 
     def __post_init__(self):
@@ -37,7 +37,7 @@ class MethodDependency:
         ------
         ReflectionTypeError
             If types don't match the expected:
-                - resolved: Dict[ResolvedDependency, Any]
+                - resolved: Dict[KnownDependency, Any]
                 - unresolved: List[str]
         ValueError
             If resolved contains None keys or unresolved contains empty strings

orionis/services/introspection/dependencies/reflection.py

@@ -4,7 +4,7 @@ from orionis.services.introspection.dependencies.contracts.reflection import IRe
 from orionis.services.introspection.dependencies.entities.callable_dependencies import CallableDependency
 from orionis.services.introspection.dependencies.entities.class_dependencies import ClassDependency
 from orionis.services.introspection.dependencies.entities.method_dependencies import MethodDependency
-from orionis.services.introspection.dependencies.entities.resolved_dependencies import ResolvedDependency
+from orionis.services.introspection.dependencies.entities.known_dependencies import KnownDependency
 from orionis.services.introspection.exceptions import ReflectionValueError
 
 class ReflectDependencies(IReflectDependencies):
@@ -114,7 +114,7 @@ class ReflectDependencies(IReflectDependencies):
             # If the parameter has an annotation, it is added to the list of resolved dependencies
             if param.annotation is not param.empty:
                 module_path = param.annotation.__module__
-                resolved_dependencies[param_name] = ResolvedDependency(
+                resolved_dependencies[param_name] = KnownDependency(
                     module_name=module_path,
                     class_name=param.annotation.__name__,
                     type=param.annotation,
@@ -165,7 +165,7 @@ class ReflectDependencies(IReflectDependencies):
             # If the parameter has an annotation, it is added to the list of resolved dependencies
             if param.annotation is not param.empty:
                 module_path = param.annotation.__module__
-                resolved_dependencies[param_name] = ResolvedDependency(
+                resolved_dependencies[param_name] = KnownDependency(
                     module_name=module_path,
                     class_name=param.annotation.__name__,
                     type=param.annotation,
@@ -216,7 +216,7 @@ class ReflectDependencies(IReflectDependencies):
             # If the parameter has an annotation, it is added to the list of resolved dependencies
             if param.annotation is not param.empty:
                 module_path = param.annotation.__module__
-                resolved_dependencies[param_name] = ResolvedDependency(
+                resolved_dependencies[param_name] = KnownDependency(
                     module_name=module_path,
                     class_name=param.annotation.__name__,
                     type=param.annotation,

orionis/test/arguments/parser.py

@@ -0,0 +1,187 @@
+import argparse
+from orionis.test.contracts.parser import ITestArgumentParser
+from orionis.test.entities.arguments import TestArguments
+
+class TestArgumentParser(ITestArgumentParser):
+    """
+    A parser class for handling test command-line arguments.
+
+    This class encapsulates the logic for creating and configuring the argument parser
+    for the Orionis test runner, providing a clean interface for parsing test arguments.
+    """
+
+    def __init__(
+        self
+    ) -> None:
+        """Initialize the argument parser with all required arguments."""
+        self.parser = self.__create()
+
+    def __create(
+        self
+    ) -> argparse.ArgumentParser:
+        """
+        Create and configure the argument parser with all test-related arguments.
+
+        Returns
+        -------
+        argparse.ArgumentParser
+            The configured argument parser instance.
+        """
+        parser = argparse.ArgumentParser(description="Run Orionis tests.")
+
+        # Basic test configuration
+        parser.add_argument(
+            '--verbosity',
+            type=int,
+            default=2,
+            help='Verbosity level (default: 2)'
+        )
+
+        parser.add_argument(
+            '--mode',
+            choices=['parallel', 'sequential'],
+            default='parallel',
+            help='Execution mode for tests (default: parallel)'
+        )
+
+        # Fail fast configuration
+        parser.add_argument(
+            '--fail_fast',
+            dest='fail_fast',
+            action='store_true',
+            help='Stop on first failure'
+        )
+        parser.add_argument(
+            '--no_fail_fast',
+            dest='fail_fast',
+            action='store_false',
+            help='Do not stop on first failure (default)'
+        )
+        parser.set_defaults(fail_fast=False)
+
+        # Print result configuration
+        parser.add_argument(
+            '--print_result',
+            dest='print_result',
+            action='store_true',
+            help='Print test results to console (default)'
+        )
+        parser.add_argument(
+            '--no_print_result',
+            dest='print_result',
+            action='store_false',
+            help='Do not print test results to console'
+        )
+        parser.set_defaults(print_result=True)
+
+        # Exception handling configuration
+        parser.add_argument(
+            '--throw_exception',
+            dest='throw_exception',
+            action='store_true',
+            help='Throw exception on test failure'
+        )
+        parser.add_argument(
+            '--no_throw_exception',
+            dest='throw_exception',
+            action='store_false',
+            help='Do not throw exception on test failure (default)'
+        )
+        parser.set_defaults(throw_exception=False)
+
+        # Persistent mode configuration
+        parser.add_argument(
+            '--persistent',
+            dest='persistent',
+            action='store_true',
+            help='Run tests in persistent mode'
+        )
+        parser.add_argument(
+            '--no_persistent',
+            dest='persistent',
+            action='store_false',
+            help='Do not run tests in persistent mode (default)'
+        )
+        parser.set_defaults(persistent=False)
+
+        parser.add_argument(
+            '--persistent_driver',
+            type=str,
+            default=None,
+            help='Persistent driver to use (default: None)'
+        )
+
+        # Web report configuration
+        parser.add_argument(
+            '--web_report',
+            dest='web_report',
+            action='store_true',
+            help='Generate web report'
+        )
+        parser.add_argument(
+            '--no_web_report',
+            dest='web_report',
+            action='store_false',
+            help='Do not generate web report (default)'
+        )
+        parser.set_defaults(web_report=False)
+
+        # Output buffer configuration
+        parser.add_argument(
+            '--print_output_buffer',
+            dest='print_output_buffer',
+            action='store_true',
+            help='Print output buffer (for CI integrations)'
+        )
+        parser.add_argument(
+            '--no_print_output_buffer',
+            dest='print_output_buffer',
+            action='store_false',
+            help='Do not print output buffer (default)'
+        )
+        parser.set_defaults(print_output_buffer=False)
+
+        return parser
+
+    def parse(
+        self,
+        sys_argv: list[str]
+    ) -> TestArguments:
+        """
+        Parse command line arguments from sys.argv and return TestArguments object.
+
+        Parameters
+        ----------
+        sys_argv : list[str]
+            Command line arguments including script name. The script name (first element)
+            will be automatically removed before parsing.
+
+        Returns
+        -------
+        TestArguments
+            Parsed test arguments object.
+        """
+        # Remove script name from sys.argv (first element)
+        args_only = sys_argv[1:] if len(sys_argv) > 0 else []
+
+        # Parse arguments and convert to TestArguments object
+        parsed_args = self.parser.parse_args(args_only)
+
+        # Create TestArguments instance from parsed arguments
+        return TestArguments(
+            verbosity=parsed_args.verbosity,
+            mode=parsed_args.mode,
+            fail_fast=parsed_args.fail_fast,
+            print_result=parsed_args.print_result,
+            throw_exception=parsed_args.throw_exception,
+            persistent=parsed_args.persistent,
+            persistent_driver=parsed_args.persistent_driver,
+            web_report=parsed_args.web_report,
+            print_output_buffer=parsed_args.print_output_buffer
+        )
+
+    def help(
+        self
+    ) -> None:
+        """Print help message for the test runner."""
+        self.parser.print_help()

orionis/test/cases/asynchronous.py

@@ -0,0 +1,145 @@
+import unittest
+from orionis.test.output.dumper import TestDumper
+
+class AsyncTestCase(unittest.IsolatedAsyncioTestCase, TestDumper):
+    """
+    Base test case class for asynchronous unit testing.
+
+    This class provides a foundation for writing asynchronous unit tests within
+    the Orionis framework. It extends unittest.IsolatedAsyncioTestCase and includes
+    TestDumper functionality for enhanced test output and debugging capabilities.
+
+    The class provides hooks for custom async setup and teardown logic through the
+    onAsyncSetup() and onAsyncTeardown() methods, which can be overridden by subclasses
+    to implement test-specific asynchronous initialization and cleanup procedures.
+
+    Each test method runs in its own isolated asyncio event loop, ensuring proper
+    isolation and preventing side effects between tests.
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    asyncSetUp()
+        Initialize test environment before each async test method execution.
+    asyncTearDown()
+        Clean up test environment after each async test method execution.
+    onAsyncSetup()
+        Hook method for subclass-specific async setup logic.
+    onAsyncTeardown()
+        Hook method for subclass-specific async teardown logic.
+
+    Examples
+    --------
+    >>> class MyAsyncTest(AsyncTestCase):
+    ...     async def onAsyncSetup(self):
+    ...         self.client = AsyncHttpClient()
+    ...         await self.client.connect()
+    ...
+    ...     async def testAsyncOperation(self):
+    ...         result = await self.client.get('/api/data')
+    ...         self.assertEqual(result.status, 200)
+    """
+
+    async def asyncSetUp(self):
+        """
+        Initialize the test environment before each async test method.
+
+        This method is automatically called by the unittest framework before
+        each async test method execution. It performs the standard unittest
+        async setup and then calls the onAsyncSetup() hook for custom
+        asynchronous initialization.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        This method should not be overridden directly. Use onAsyncSetup() instead
+        for custom async setup logic. The method runs in the isolated event loop
+        created for each test.
+        """
+        await super().asyncSetUp()
+        await self.onAsyncSetup()
+
+    async def asyncTearDown(self):
+        """
+        Clean up the test environment after each async test method.
+
+        This method is automatically called by the unittest framework after
+        each async test method execution. It calls the onAsyncTeardown() hook
+        for custom cleanup and then performs the standard unittest async teardown.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        This method should not be overridden directly. Use onAsyncTeardown() instead
+        for custom async teardown logic. The method runs in the same isolated event
+        loop as the test.
+        """
+        await self.onAsyncTeardown()
+        await super().asyncTearDown()
+
+    async def onAsyncSetup(self):
+        """
+        Hook method for subclass-specific async setup logic.
+
+        This method is called during the asyncSetUp() phase and is intended to be
+        overridden by subclasses that need to perform custom asynchronous
+        initialization before each test method execution.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+
+        Examples
+        --------
+        >>> async def onAsyncSetup(self):
+        ...     self.db_connection = await create_async_connection()
+        ...     self.mock_service = AsyncMockService()
+        ...     await self.mock_service.initialize()
+        """
+        pass
+
+    async def onAsyncTeardown(self):
+        """
+        Hook method for subclass-specific async teardown logic.
+
+        This method is called during the asyncTearDown() phase and is intended to be
+        overridden by subclasses that need to perform custom asynchronous cleanup
+        after each test method execution.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+
+        Examples
+        --------
+        >>> async def onAsyncTeardown(self):
+        ...     await self.db_connection.close()
+        ...     await self.mock_service.cleanup()
+        ...     del self.test_data
+        """
+        pass