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

orionis/test/cases/synchronous.py

@@ -0,0 +1,135 @@
+import unittest
+from orionis.test.output.dumper import TestDumper
+
+class SyncTestCase(unittest.TestCase, TestDumper):
+    """
+    Base test case class for synchronous unit testing.
+
+    This class provides a foundation for writing synchronous unit tests within
+    the Orionis framework. It extends unittest.TestCase and includes TestDumper
+    functionality for enhanced test output and debugging capabilities.
+
+    The class provides hooks for custom setup and teardown logic through the
+    onSetup() and onTeardown() methods, which can be overridden by subclasses
+    to implement test-specific initialization and cleanup procedures.
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    setUp()
+        Initialize test environment before each test method execution.
+    tearDown()
+        Clean up test environment after each test method execution.
+    onSetup()
+        Hook method for subclass-specific setup logic.
+    onTeardown()
+        Hook method for subclass-specific teardown logic.
+
+    Examples
+    --------
+    >>> class MyTest(SyncTestCase):
+    ...     def onSetup(self):
+    ...         self.data = [1, 2, 3]
+    ...
+    ...     def testExample(self):
+    ...         self.assertEqual(len(self.data), 3)
+    """
+
+    def setUp(self):
+        """
+        Initialize the test environment before each test method.
+
+        This method is automatically called by the unittest framework before
+        each test method execution. It performs the standard unittest setup
+        and then calls the onSetup() hook for custom initialization.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        This method should not be overridden directly. Use onSetup() instead
+        for custom setup logic.
+        """
+        super().setUp()
+        self.onSetup()
+
+    def tearDown(self):
+        """
+        Clean up the test environment after each test method.
+
+        This method is automatically called by the unittest framework after
+        each test method execution. It calls the onTeardown() hook for custom
+        cleanup and then performs the standard unittest teardown.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        This method should not be overridden directly. Use onTeardown() instead
+        for custom teardown logic.
+        """
+        self.onTeardown()
+        super().tearDown()
+
+    def onSetup(self):
+        """
+        Hook method for subclass-specific setup logic.
+
+        This method is called during the setUp() phase and is intended to be
+        overridden by subclasses that need to perform custom initialization
+        before each test method execution.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+
+        Examples
+        --------
+        >>> def onSetup(self):
+        ...     self.mock_service = MockService()
+        ...     self.test_data = {"key": "value"}
+        """
+        pass
+
+    def onTeardown(self):
+        """
+        Hook method for subclass-specific teardown logic.
+
+        This method is called during the tearDown() phase and is intended to be
+        overridden by subclasses that need to perform custom cleanup after
+        each test method execution.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+
+        Examples
+        --------
+        >>> def onTeardown(self):
+        ...     self.mock_service.cleanup()
+        ...     del self.test_data
+        """
+        pass

orionis/test/contracts/kernel.py

@@ -0,0 +1,134 @@
+from abc import ABC, abstractmethod
+from typing import Any
+from orionis.foundation.config.testing.entities.testing import Testing as Configuration
+from orionis.test.core.unit_test import UnitTest
+
+class ITestKernel(ABC):
+    """
+    Abstract interface for test kernel implementations.
+
+    This contract defines the required methods that any test kernel implementation
+    must provide for the Orionis testing framework. It ensures consistent behavior
+    across different test kernel implementations.
+
+    The test kernel is responsible for:
+    - Managing application context for testing
+    - Validating and handling test configuration
+    - Orchestrating test discovery and execution
+    - Providing a unified interface for test operations
+    """
+
+    @abstractmethod
+    def handle(
+        self,
+        config: Configuration = None,
+        **kwargs: Any
+    ) -> UnitTest:
+        """
+        Execute the complete test discovery and execution pipeline.
+
+        This is the main entry point for running tests. Implementations must:
+        1. Validate the provided configuration
+        2. Discover test files based on configuration
+        3. Configure and execute the test suite
+        4. Return the test results
+
+        Parameters
+        ----------
+        config : Configuration, optional
+            A pre-configured Testing configuration instance. If None,
+            implementations should create one from kwargs.
+        **kwargs : Any
+            Keyword arguments to create a Configuration instance if config is None.
+            Common parameters include:
+            - base_path : str, base directory for test discovery
+            - folder_path : str or list, specific folders to search
+            - pattern : str, file pattern for test discovery
+            - verbosity : int, output verbosity level
+            - execution_mode : str, test execution mode
+            - max_workers : int, maximum number of worker threads
+            - fail_fast : bool, stop on first failure
+
+        Returns
+        -------
+        UnitTest
+            The configured and executed test suite instance containing all results.
+
+        Raises
+        ------
+        OrionisTestConfigException
+            If the configuration validation fails.
+        """
+        pass
+
+    @abstractmethod
+    def handleCLI(
+        self,
+        sys_argv: list[str]
+    ) -> UnitTest:
+        """
+        Process command line arguments for test execution.
+
+        This method configures and runs tests based on command line arguments. It parses
+        the provided sys_argv list into a TestArguments object, extracts configuration
+        values, executes the tests, and handles output generation.
+
+        Parameters
+        ----------
+        sys_argv : list[str]
+            Command line arguments list including script name. The script name
+            (first element) will be automatically removed before parsing.
+
+        Returns
+        -------
+        UnitTest
+            The test suite instance containing all test results.
+
+        Raises
+        ------
+        OrionisTestConfigException
+            If the provided sys_argv is not a valid list or if argument parsing fails.
+
+        Notes
+        -----
+        The method supports various test execution options including parallel/sequential
+        execution mode, fail fast behavior, result output configuration, and web reporting.
+        """
+        pass
+
+    @abstractmethod
+    def exit(
+        self,
+        code: int = 0
+    ) -> None:
+        """
+        Terminate the test execution process and free associated resources.
+
+        This method performs a clean shutdown of the test kernel by explicitly
+        triggering garbage collection to release memory resources and then
+        terminating the process with the provided exit code. It ensures that any
+        remaining file handles, threads, or other resources are properly released.
+
+        Parameters
+        ----------
+        code : int
+            The exit code to return to the operating system. Should be 0 for
+            successful execution or a non-zero value to indicate an error.
+
+        Returns
+        -------
+        None
+            This method does not return as it terminates the process.
+
+        Raises
+        ------
+        ValueError
+            If the provided code is not a valid integer or outside the allowed range.
+
+        Notes
+        -----
+        Using os._exit() bypasses normal Python cleanup mechanisms and
+        immediately terminates the process. This can be necessary when
+        normal sys.exit() would be caught by exception handlers.
+        """
+        pass

orionis/test/contracts/logs.py

@@ -0,0 +1,125 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Tuple
+
+class ITestLogs(ABC):
+    """
+    Abstract base class for test logging and report persistence.
+
+    This interface defines the contract for managing test reports in a persistent
+    storage system. Implementations should provide functionality to create, retrieve,
+    and reset test report data while maintaining proper data validation and error
+    handling.
+
+    The interface supports chronological retrieval of reports and provides methods
+    for database management operations.
+
+    Methods
+    -------
+    create(report)
+        Create and store a new test report in the persistence layer.
+    reset()
+        Reset the storage by clearing all existing test reports.
+    get(first, last)
+        Retrieve test reports with optional chronological filtering.
+    """
+
+    @abstractmethod
+    def create(self, report: Dict) -> bool:
+        """
+        Create a new test report in the history database.
+
+        This method persists a test report containing execution results and
+        metadata to the underlying storage system. The report should include
+        all necessary fields for proper tracking and analysis.
+
+        Parameters
+        ----------
+        report : Dict
+            A dictionary containing the test report data. Must include fields
+            such as total_tests, passed, failed, errors, skipped, total_time,
+            success_rate, and timestamp.
+
+        Returns
+        -------
+        bool
+            True if the report was successfully created and stored, False otherwise.
+
+        Raises
+        ------
+        OrionisTestValueError
+            If the report structure is invalid or missing required fields.
+        OrionisTestPersistenceError
+            If there is an error during the storage operation.
+        """
+        pass
+
+    @abstractmethod
+    def reset(self) -> bool:
+        """
+        Reset the history database by dropping the existing table.
+
+        This method clears all stored test reports and resets the storage
+        system to its initial state. Use with caution as this operation
+        is irreversible and will result in permanent data loss.
+
+        Returns
+        -------
+        bool
+            True if the database was successfully reset, False otherwise.
+
+        Raises
+        ------
+        OrionisTestPersistenceError
+            If there is an error during the reset operation.
+
+        Notes
+        -----
+        This operation is destructive and cannot be undone. Ensure that
+        any important historical data is backed up before calling this method.
+        """
+        pass
+
+    @abstractmethod
+    def get(
+        self,
+        first: Optional[int] = None,
+        last: Optional[int] = None
+    ) -> List[Tuple]:
+        """
+        Retrieve test reports from the history database.
+
+        This method allows for chronological retrieval of test reports with
+        optional filtering. You can retrieve either the earliest or most recent
+        reports, but not both in a single call.
+
+        Parameters
+        ----------
+        first : Optional[int], default=None
+            The number of earliest reports to retrieve, ordered ascending by ID.
+            Must be a positive integer if specified.
+        last : Optional[int], default=None
+            The number of latest reports to retrieve, ordered descending by ID.
+            Must be a positive integer if specified.
+
+        Returns
+        -------
+        List[Tuple]
+            A list of tuples representing the retrieved reports. Each tuple
+            contains the report data in the order: (id, json, total_tests,
+            passed, failed, errors, skipped, total_time, success_rate, timestamp).
+
+        Raises
+        ------
+        OrionisTestValueError
+            If both 'first' and 'last' are specified, or if either parameter
+            is not a positive integer when provided.
+        OrionisTestPersistenceError
+            If there is an error retrieving reports from the storage system.
+
+        Notes
+        -----
+        Only one of 'first' or 'last' parameters can be specified in a single
+        call. The returned results are ordered chronologically based on the
+        selected parameter.
+        """
+        pass

orionis/test/contracts/parser.py

@@ -0,0 +1,43 @@
+from abc import ABC, abstractmethod
+from orionis.test.entities.arguments import TestArguments
+
+class ITestArgumentParser(ABC):
+    """
+    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.
+    """
+
+    @abstractmethod
+    def parse(
+        self,
+        sys_argv: list[str]
+    ) -> TestArguments:
+        """
+        Parse command line arguments 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 containing all configuration options for test execution.
+
+        Raises
+        ------
+        SystemExit
+            If argument parsing fails or help is requested.
+        """
+        pass
+
+    @abstractmethod
+    def help(
+        self
+    ) -> None:
+        """Print help message for the test runner."""
+        pass

orionis/test/contracts/render.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+
+class ITestingResultRender(ABC):
+
+    @abstractmethod
+    def render(
+        self
+    ) -> str:
+        """
+        Otherwise, uses the current test result stored in memory. The method replaces placeholders in a
+        template file with the test results and the persistence mode, then writes the rendered content
+        to a report file.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        str
+            The full path to the generated report file.
+
+        Notes
+        -----
+        - If persistence is enabled, the last 10 reports are fetched from the SQLite database.
+        - If persistence is not enabled, only the current test result in memory is used.
+        - The method reads a template file, replaces placeholders with the test results and persistence mode,
+          and writes the final content to the report file.
+        """
+        pass

orionis/test/contracts/unit_test.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional
+from orionis.foundation.contracts.application import IApplication
 from orionis.services.system.workers import Workers
 from orionis.test.enums.execution_mode import ExecutionMode
 
@@ -48,6 +49,26 @@ class IUnitTest(ABC):
         """
         pass
 
+    @abstractmethod
+    def setApplication(
+        self,
+        app: 'IApplication'
+    ):
+        """
+        Set the application instance for the UnitTest.
+        This method allows the UnitTest to access the application instance, which is necessary for resolving dependencies and executing tests.
+
+        Parameters
+        ----------
+        app : IApplication
+            The application instance to be set for the UnitTest.
+
+        Returns
+        -------
+        UnitTest
+        """
+        pass
+
     @abstractmethod
     def discoverTestsInFolder(
         self,

orionis/test/core/unit_test.py

@@ -10,9 +10,10 @@ from contextlib import redirect_stdout, redirect_stderr
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
+from orionis.foundation.contracts.application import IApplication
 from orionis.services.introspection.instances.reflection import ReflectionInstance
 from orionis.services.system.workers import Workers
-from orionis.test.entities.test_result import TestResult
+from orionis.test.entities.result import TestResult
 from orionis.test.enums import (
     ExecutionMode,
     TestStatus
@@ -22,7 +23,7 @@ from orionis.test.exceptions import (
     OrionisTestPersistenceError,
     OrionisTestValueError
 )
-from orionis.test.logs.history import TestHistory
+from orionis.test.records.logs import TestLogs
 from orionis.test.contracts.unit_test import IUnitTest
 from orionis.test.output.printer import TestPrinter
 from orionis.test.view.render import TestingResultRender
@@ -42,7 +43,9 @@ class UnitTest(IUnitTest):
     This is an especially suitable choice for those seeking greater robustness, traceability, and visibility in their automated testing processes, offering advantages often missing from other alternatives.
     """
 
-    def __init__(self) -> None:
+    def __init__(
+        self
+    ) -> None:
         """
         Initializes the test suite configuration and supporting components.
 
@@ -100,28 +103,30 @@ class UnitTest(IUnitTest):
             Result of the test execution.
         """
 
+        # Value for application instance
+        self.app: Optional[IApplication] = None
+
         # Values for configuration
-        self.verbosity: int
-        self.execution_mode: str
-        self.max_workers: int
-        self.fail_fast: bool
-        self.print_result: bool
-        self.throw_exception: bool
-        self.persistent: bool
-        self.persistent_driver: str
-        self.web_report: bool
+        self.verbosity: Optional[int] = None
+        self.execution_mode: Optional[str] = None
+        self.max_workers: Optional[int] = None
+        self.fail_fast: Optional[bool] = None
+        self.print_result: Optional[bool] = None
+        self.throw_exception: Optional[bool] = None
+        self.persistent: Optional[bool] = None
+        self.persistent_driver: Optional[str] = None
+        self.web_report: Optional[bool] = None
 
         # Values for discovering tests in folders
-        self.full_path: Optional[str]
-        self.folder_path: str
-        self.base_path: str
-        self.pattern: str
-        self.test_name_pattern: Optional[str]
-        self.tags: Optional[List[str]]
+        self.full_path: Optional[str] = None
+        self.folder_path: Optional[str] = None
+        self.base_path: Optional[str] = None
+        self.pattern: Optional[str] = None
+        self.test_name_pattern: Optional[str] = None
+        self.tags: Optional[List[str]] = None
 
         # Values for discovering tests in modules
-        self.module_name: str
-        self.test_name_pattern: Optional[str]
+        self.module_name: Optional[str] = None
 
         # Initialize the test loader and suite
         self.loader = unittest.TestLoader()
@@ -138,6 +143,33 @@ class UnitTest(IUnitTest):
         # Result of the test execution
         self.__result = None
 
+    def setApplication(
+        self,
+        app: 'IApplication'
+    ) -> 'UnitTest':
+        """
+        Set the application instance for the UnitTest.
+        This method allows the UnitTest to access the application instance, which is necessary for resolving dependencies and executing tests.
+
+        Parameters
+        ----------
+        app : IApplication
+            The application instance to be set for the UnitTest.
+
+        Returns
+        -------
+        UnitTest
+        """
+
+        # Validate the provided application instance
+        if not isinstance(app, IApplication):
+            raise OrionisTestValueError(
+                f"The provided application is not a valid instance of IApplication: {type(app).__name__}."
+            )
+
+        # Set the application instance
+        self.app = app
+
     def configure(
             self,
             *,
@@ -657,6 +689,55 @@ class UnitTest(IUnitTest):
         # Flatten the suite to avoid duplicate tests
         flattened_suite = unittest.TestSuite(self.__flattenTestSuite(self.suite))
 
+        # Create a new test suite with tests that have their dependencies resolved
+        flattened_suite = unittest.TestSuite()
+        app = self.app
+        
+        # Iterate through all test cases
+        for test_case in self.__flattenTestSuite(self.suite):
+            # Get the test method name
+            method_name = getattr(test_case, '_testMethodName', None)
+            
+            # Skip if we can't identify the test method
+            if not method_name:
+                flattened_suite.addTest(test_case)
+                continue
+            
+            # Extract dependencies for the test method
+            rsv = ReflectionInstance(test_case).getMethodDependencies(method_name)
+            
+            # If no dependencies to resolve, just add the original test
+            if not rsv.resolved and not rsv.unresolved:
+                flattened_suite.addTest(test_case)
+                continue
+            
+            # Create a specialized test case with resolved dependencies
+            test_class = test_case.__class__
+            original_method = getattr(test_class, method_name)
+            
+            # Create a dict of resolved dependencies
+            args_ = {}
+            for k, v in rsv.resolved.items():
+                from orionis.services.introspection.dependencies.entities.known_dependencies import KnownDependency
+                if isinstance(v, KnownDependency):
+                    args_[k] = app.make(v.type)
+            
+            # Create a wrapper method that injects dependencies
+            def create_test_wrapper(original_test, resolved_args, unresolved_args):
+                def wrapper(self_instance):
+                    args_list = list(resolved_args.values())
+                    args_list.extend(unresolved_args)
+                    return original_test(self_instance, *args_list)
+                return wrapper
+            
+            # Create a new test case with the wrapped method
+            setattr(test_class, f"_wrapped_{method_name}", create_test_wrapper(original_method, args_, rsv.unresolved))
+            setattr(test_case, '_testMethodName', f"_wrapped_{method_name}")
+            
+            # Add the modified test case to the suite
+            flattened_suite.addTest(test_case)
+        # sys.exit(0)
+
         # Create a custom result class to capture detailed test results
         with redirect_stdout(output_buffer), redirect_stderr(error_buffer):
             runner = unittest.TextTestRunner(
@@ -1108,7 +1189,7 @@ class UnitTest(IUnitTest):
         Notes
         -----
         Depending on the value of `self.persistent_driver`, the summary is either:
-            - Stored in an SQLite database (using the TestHistory class), or
+            - Stored in an SQLite database (using the TestLogs class), or
             - Written to a timestamped JSON file in the specified base path.
 
         Raises
@@ -1129,8 +1210,8 @@ class UnitTest(IUnitTest):
 
             if self.persistent_driver == 'sqlite':
 
-                # Initialize the TestHistory class for database operations
-                history = TestHistory(
+                # Initialize the TestLogs class for database operations
+                history = TestLogs(
                     storage_path=storage_path,
                     db_name='tests.sqlite',
                     table_name='reports'