orionis 0.383.0__py3-none-any.whl → 0.385.0__py3-none-any.whl

orionis/metadata/framework.py

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

{orionis-0.383.0.dist-info → orionis-0.385.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.383.0
+Version: 0.385.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

{orionis-0.383.0.dist-info → orionis-0.385.0.dist-info}/RECORD

@@ -247,7 +247,7 @@ orionis/foundation/providers/path_resolver_provider.py,sha256=rXvaVc5sSqmDgRzWJo
 orionis/foundation/providers/progress_bar_provider.py,sha256=75Jr4iEgUOUGl8Di1DioeP5_HRQlR-1lVzPmS96sWjA,737
 orionis/foundation/providers/workers_provider.py,sha256=WWlji3C69_-Y0c42aZDbR_bmcE_qZEh2SaA_cNkCivI,702
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=BqO4gDTSWamxPbPJV_8Vzu2LN3mlPQPQ_sZ8CFxPQ0E,4960
+orionis/metadata/framework.py,sha256=yPevn6fPgNAn7N2vN-FlVyYTvJZ-_piFlZ8RB_V5pDo,4960
 orionis/metadata/package.py,sha256=tqLfBRo-w1j_GN4xvzUNFyweWYFS-qhSgAEc-AmCH1M,5452
 orionis/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -380,15 +380,14 @@ orionis/test/exceptions/value.py,sha256=r3tVWTE3gNp7of2gXk71NN-VYoAlOpB0kulw0LOJ
 orionis/test/output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/output/dumper.py,sha256=5_SrMWTlmdqDbPA6ggnhTrI2gaUMr6aA0xTNYpOLFMk,4202
 orionis/test/output/printer.py,sha256=gHDa2Q_q2ZnWM7j_JpCnrjzfKQrT-lMCcnVp7-2fUyU,17625
-orionis/test/record/history.py,sha256=EOQcloMVdhlNl2lU9igQz8H4b-OtKtiwh2pgr_QZWOI,13186
 orionis/test/records/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/records/logs.py,sha256=EOQcloMVdhlNl2lU9igQz8H4b-OtKtiwh2pgr_QZWOI,13186
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=zd7xDvVfmQ2HxZamDTzL2-z2PpyL99EaolbbM7wTah4,5014
-orionis-0.383.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.385.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/example/test_example.py,sha256=-NNP8odGdR5XrXK7w5vEvdVVGgPcoLFLJWf-ALf4GwU,1057
+tests/example/test_example.py,sha256=8G7kp74PZZ0Tdnw8WkheZ7lvZVFpdx_9ShOZBN9GEF0,25582
 tests/foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/foundation/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/foundation/config/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -486,8 +485,8 @@ tests/support/wrapper/test_services_wrapper_docdict.py,sha256=nTNrvJkMSPx_aopEQ9
 tests/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/test_testing_result.py,sha256=fnH7hjumNSErAFGITJgq2LHxSzvPF2tdtmHL9kyAv-Y,4409
 tests/testing/test_testing_unit.py,sha256=d3CRGo6608fMzYcZKIKapjx_af2aigqWiKSiuK9euIY,7600
-orionis-0.383.0.dist-info/METADATA,sha256=I8CUQ2SmTosK3-sM_gkcoC5aFzXeBpuVGkrb89ZiGZY,4772
-orionis-0.383.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orionis-0.383.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.383.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.383.0.dist-info/RECORD,,
+orionis-0.385.0.dist-info/METADATA,sha256=nphEHmIaOM7ba4ts0gUfRjzTQZr4B0Id_TV_2oN2FH8,4772
+orionis-0.385.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.385.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.385.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.385.0.dist-info/RECORD,,

tests/example/test_example.py

@@ -1,33 +1,735 @@
+"""
+Orionis Framework Test Examples
+===============================
+
+This module contains comprehensive test examples demonstrating the capabilities
+of the Orionis testing framework, including both synchronous and asynchronous
+testing patterns with dependency injection.
+
+Examples
+--------
+    Run synchronous tests:
+        >>> from tests.example.test_example import TestSynchronousExample
+        >>> test = TestSynchronousExample()
+        >>> test.setUp()
+        >>> test.testBasicAssertions()
+
+    Run asynchronous tests:
+        >>> from tests.example.test_example import TestAsynchronousExample
+        >>> test = TestAsynchronousExample()
+        >>> await test.asyncSetUp()
+        >>> await test.testAsyncBasicOperations()
+
+Notes
+-----
+    These examples showcase:
+    - Dependency injection patterns
+    - Path resolution services
+    - Container integration
+    - Error handling strategies
+    - Data validation techniques
+    - Concurrent operations
+    - Async/await patterns
+"""
+
+import asyncio
+import time
+from typing import Dict, List, Any
+from orionis.foundation.application import Application
 from orionis.services.paths.contracts.resolver import IResolver
+from orionis.test.cases.asynchronous import AsyncTestCase
 from orionis.test.cases.synchronous import SyncTestCase
 
-class TestExample(SyncTestCase):
+class TestSynchronousExample(SyncTestCase):
+    """
+    Synchronous test example demonstrating Orionis framework capabilities.
+
+    This class showcases various testing patterns including dependency injection,
+    path resolution, container usage, and error handling in a synchronous context.
+    The tests demonstrate best practices for writing maintainable and reliable
+    test cases within the Orionis framework.
+
+    Attributes
+    ----------
+    test_data : Dict[str, Any]
+        Test data dictionary containing sample files and expected values
+        for use across multiple test methods.
+
+    Methods
+    -------
+    setUp()
+        Initialize test environment before each test method execution.
+    tearDown()
+        Clean up resources after each test method completion.
+    testBasicAssertions()
+        Validate basic assertion functionality and patterns.
+    testPathResolution(paths)
+        Test path resolution service functionality with dependency injection.
+    testContainerIntegration(container)
+        Validate container dependency injection capabilities.
+    testErrorHandling()
+        Test error handling and exception management patterns.
+    testDataValidation()
+        Validate data validation and complex assertion patterns.
+
+    Examples
+    --------
+    Basic usage:
+        >>> test = TestSynchronousExample()
+        >>> test.setUp()
+        >>> test.testBasicAssertions()
+        >>> test.tearDown()
+
+    With dependency injection:
+        >>> test = TestSynchronousExample()
+        >>> test.setUp()
+        >>> # Path resolver will be injected automatically
+        >>> test.testPathResolution(resolver_instance)
+        >>> test.tearDown()
+    """
+
+    def setUp(self) -> None:
+        """
+        Set up test environment before each test method.
+
+        Initializes test data dictionary with sample files and expected values
+        that will be used across multiple test methods. This method is called
+        automatically before each test method execution.
+
+        Notes
+        -----
+        The test_data dictionary contains:
+        - sample_file: Path to the current test file for path resolution tests
+        - expected_values: List of integers used in assertion validation tests
+        """
+        self.test_data: Dict[str, Any] = {
+            "sample_file": "tests/example/test_example.py",
+            "expected_values": [1, 2, 3, 4, 5]
+        }
+
+    def tearDown(self) -> None:
+        """
+        Clean up resources after each test method completion.
+
+        Resets the test_data attribute to None to ensure clean state
+        between test method executions and prevent memory leaks.
+        """
+        self.test_data = None
+
+    def testBasicAssertions(self) -> None:
+        """
+        Test basic assertion functionality and patterns.
+
+        Validates the fundamental assertion methods provided by the testing
+        framework, including equality checks, boolean assertions, and
+        container membership validation.
+
+        Tests
+        -----
+        - Equality assertions (assertEqual)
+        - Boolean assertions (assertTrue, assertFalse)
+        - Container membership (assertIn, assertNotIn)
+
+        Raises
+        ------
+        AssertionError
+            If any of the basic assertions fail, indicating a problem
+            with the testing framework's assertion mechanisms.
+        """
+        # Test equality assertions
+        self.assertEqual(2, 2, "Basic equality check failed")
+        self.assertEqual(3, 3, "Second equality check failed")
+
+        # Test boolean assertions
+        self.assertTrue(True, "Boolean true assertion failed")
+        self.assertFalse(False, "Boolean false assertion failed")
+
+        # Test container assertions
+        self.assertIn(
+            3,
+            self.test_data["expected_values"],
+            "Value not found in container"
+        )
+        self.assertNotIn(
+            10,
+            self.test_data["expected_values"],
+            "Unexpected value found in container"
+        )
+
+    def testPathResolution(self, paths: IResolver) -> None:
+        """
+        Test path resolution service functionality with dependency injection.
+
+        Validates the path resolution service by testing relative path creation
+        and string conversion operations. This method demonstrates how dependency
+        injection works within the Orionis testing framework.
+
+        Parameters
+        ----------
+        paths : IResolver
+            Injected path resolver service instance for testing path operations.
+            This parameter is automatically injected by the testing framework
+            based on the type annotation.
+
+        Tests
+        -----
+        - Relative path creation from string path
+        - Path string conversion and format validation
+        - Path ending validation
+        - Path content validation
+
+        Raises
+        ------
+        AssertionError
+            If path resolution fails or returns unexpected results.
+        """
+        # Test relative path resolution
+        relative_path = paths.relativePath(self.test_data["sample_file"])
+        path_string = relative_path.toString()
+
+        # Verify path resolution results
+        self.assertTrue(
+            path_string.endswith("test_example.py"),
+            "Path should end with test_example.py"
+        )
+        self.assertIn(
+            "tests\\example\\test_example.py",
+            path_string,
+            "Path should contain expected directory structure"
+        )
+
+    def testContainerIntegration(self, container: Application) -> None:
+        """
+        Test container dependency injection functionality.
+
+        Validates the container's ability to resolve services and manage
+        dependencies. This method demonstrates the dependency injection
+        capabilities of the Orionis application container.
+
+        Parameters
+        ----------
+        container : Application
+            Injected application container instance for testing dependency
+            injection capabilities. The container manages service resolution
+            and dependency lifecycle.
+
+        Tests
+        -----
+        - Container instance validation
+        - Service resolution from container
+        - Service functionality validation through container
+        - Dependency lifecycle management
+
+        Raises
+        ------
+        AssertionError
+            If container operations fail or services cannot be resolved.
+        """
+        # Test container instance validation
+        self.assertIsNotNone(container, "Container instance should not be None")
+
+        # Test service resolution from container
+        path_resolver: IResolver = container.make(IResolver)
+        self.assertIsNotNone(
+            path_resolver,
+            "Service resolution should return valid instance"
+        )
+
+        # Test service functionality through container
+        test_path = path_resolver.relativePath("README.md")
+        self.assertIsNotNone(
+            test_path,
+            "Service method execution should return valid result"
+        )
+
+    def testErrorHandling(self) -> None:
+        """
+        Test error handling and exception management patterns.
+
+        Validates the framework's ability to handle expected exceptions
+        and provides examples of proper exception testing patterns.
+        This method demonstrates both basic exception catching and
+        regex-based exception message validation.
+
+        Tests
+        -----
+        - Basic exception assertion with assertRaises
+        - Exception message pattern matching with assertRaisesRegex
+        - Proper exception type validation
+        - Exception context management
+
+        Raises
+        ------
+        AssertionError
+            If expected exceptions are not raised or have incorrect types.
+        """
+        # Test basic exception assertion
+        with self.assertRaises(ValueError):
+            raise ValueError("Expected test exception")
+
+        # Test exception message pattern matching
+        with self.assertRaisesRegex(RuntimeError, r"test.*pattern"):
+            raise RuntimeError("test error pattern match")
+
+    def testDataValidation(self) -> None:
+        """
+        Test data validation and complex assertion patterns.
+
+        Validates complex data structures and demonstrates advanced assertion
+        techniques including list comparisons, dictionary operations, and
+        length validation. This method showcases best practices for testing
+        data integrity and structure validation.
+
+        Tests
+        -----
+        - List length validation
+        - List content comparison with assertListEqual
+        - Dictionary key existence validation
+        - Dictionary value validation
+        - Complex data structure assertions
+
+        Raises
+        ------
+        AssertionError
+            If data validation fails or structures don't match expectations.
+        """
+        # Test list operations and validation
+        test_list = [1, 2, 3, 4, 5]
+        self.assertEqual(
+            len(test_list),
+            5,
+            "List length should match expected value"
+        )
+        self.assertListEqual(
+            test_list,
+            self.test_data["expected_values"],
+            "List content should match expected values"
+        )
+
+        # Test dictionary operations and validation
+        test_dict = {"key1": "value1", "key2": "value2"}
+        self.assertIn(
+            "key1",
+            test_dict,
+            "Dictionary should contain expected key"
+        )
+        self.assertEqual(
+            test_dict["key1"],
+            "value1",
+            "Dictionary value should match expected value"
+        )
+
+class TestAsynchronousExample(AsyncTestCase):
+    """
+    Asynchronous test example demonstrating async capabilities in Orionis framework.
+
+    This class showcases asynchronous testing patterns including async dependency
+    injection, concurrent operations, timing validation, and async error handling.
+    The tests demonstrate best practices for writing async test cases that are
+    both performant and reliable.
+
+    Attributes
+    ----------
+    async_data : Dict[str, Any]
+        Asynchronous test data dictionary containing timing parameters,
+        task configuration, and expected results for async operations.
+
+    Methods
+    -------
+    asyncSetUp()
+        Initialize async test environment before each test method.
+    asyncTearDown()
+        Clean up async resources after each test method completion.
+    testAsyncBasicOperations()
+        Test basic async operations including timing and sleep validation.
+    testAsyncPathResolution(paths)
+        Test async path resolution with dependency injection.
+    testConcurrentOperations()
+        Test concurrent async operations and task management.
+    testAsyncErrorHandling()
+        Test async error handling and timeout management.
+    testAsyncContainerIntegration(container)
+        Test async container dependency injection functionality.
+    testAsyncDataProcessing()
+        Test async data processing and validation patterns.
+
+    Examples
+    --------
+    Basic async usage:
+        >>> test = TestAsynchronousExample()
+        >>> await test.asyncSetUp()
+        >>> await test.testAsyncBasicOperations()
+        >>> await test.asyncTearDown()
 
-    def testUnitExample(self, paths:IResolver) -> None:
+    Concurrent operations:
+        >>> test = TestAsynchronousExample()
+        >>> await test.asyncSetUp()
+        >>> await test.testConcurrentOperations()
+        >>> await test.asyncTearDown()
+    """
+
+    async def asyncSetUp(self) -> None:
+        """
+        Set up async test environment before each test method.
+
+        Initializes async test data dictionary with timing parameters,
+        concurrent task configuration, and expected results for async
+        operations. This method is called automatically before each
+        async test method execution.
+
+        Notes
+        -----
+        The async_data dictionary contains:
+        - delay_time: Standard delay time for async operations testing
+        - concurrent_tasks: Number of concurrent tasks for testing
+        - expected_results: Expected results from concurrent operations
+        """
+        self.async_data: Dict[str, Any] = {
+            "delay_time": 0.1,
+            "concurrent_tasks": 3,
+            "expected_results": ["result1", "result2", "result3"]
+        }
+
+    async def asyncTearDown(self) -> None:
+        """
+        Clean up async resources after each test method completion.
+
+        Resets the async_data attribute to None to ensure clean state
+        between async test method executions and prevent memory leaks.
+        """
+        self.async_data = None
+
+    async def testAsyncBasicOperations(self) -> None:
+        """
+        Test basic async operations including timing and sleep validation.
+
+        Validates the framework's ability to handle async operations
+        correctly, including timing precision and sleep duration validation.
+        This method demonstrates proper async timing testing patterns.
+
+        Tests
+        -----
+        - Async sleep duration validation
+        - Timing precision testing
+        - Async operation timing boundaries
+        - Time measurement accuracy
+
+        Raises
+        ------
+        AssertionError
+            If async timing operations don't meet expected constraints.
+        """
+        # Test async sleep and timing precision
+        start_time = time.time()
+        await asyncio.sleep(self.async_data["delay_time"])
+        end_time = time.time()
+
+        elapsed = end_time - start_time
+        self.assertGreaterEqual(
+            elapsed,
+            self.async_data["delay_time"],
+            "Async sleep duration should meet minimum time requirement"
+        )
+        self.assertLess(
+            elapsed,
+            self.async_data["delay_time"] + 0.05,
+            "Async sleep duration should not exceed maximum time tolerance"
+        )
+
+    async def testAsyncPathResolution(self, paths: IResolver) -> None:
         """
-        Unit test example function.
+        Test async path resolution service functionality with dependency injection.
 
-        This method demonstrates basic unit testing functionality using assertions.
-        It checks simple equality conditions and verifies path resolution through
-        the injected paths service.
+        Validates async path resolution operations by simulating async I/O
+        operations and testing path resolution in an asynchronous context.
+        This method demonstrates async dependency injection patterns.
 
         Parameters
         ----------
         paths : IResolver
-            Service for resolving paths within the application.
+            Injected path resolver service instance for async path operations.
+            This parameter is automatically injected by the async testing framework.
+
+        Tests
+        -----
+        - Async path resolution with simulated I/O delay
+        - Path string conversion in async context
+        - Path validation in async operations
+        - Async service method execution
+
+        Raises
+        ------
+        AssertionError
+            If async path resolution fails or returns unexpected results.
+        """
+        async def resolve_path_async(path_name: str) -> str:
+            """
+            Simulate async path resolution with I/O delay.
+
+            Parameters
+            ----------
+            path_name : str
+                Path name to resolve asynchronously.
+
+            Returns
+            -------
+            str
+                Resolved path as string.
+            """
+            await asyncio.sleep(0.01)  # Simulate async I/O operation
+            return paths.relativePath(path_name).toString()
+
+        # Test async path resolution
+        resolved_path = await resolve_path_async("tests/example/test_example.py")
+        self.assertTrue(
+            resolved_path.endswith("test_example.py"),
+            "Async path resolution should return correct file ending"
+        )
+
+    async def testConcurrentOperations(self) -> None:
+        """
+        Test concurrent async operations and task management.
+
+        Validates the framework's ability to handle multiple concurrent
+        async operations correctly, including task creation, execution,
+        and result aggregation. This method demonstrates proper concurrent
+        async testing patterns.
+
+        Tests
+        -----
+        - Concurrent task creation and execution
+        - Task result aggregation with asyncio.gather
+        - Concurrent operation result validation
+        - Task count and result verification
+
+        Raises
+        ------
+        AssertionError
+            If concurrent operations fail or results don't match expectations.
+        """
+        async def async_task(task_id: int) -> str:
+            """
+            Simulate async task with unique result.
+
+            Parameters
+            ----------
+            task_id : int
+                Unique identifier for the async task.
+
+            Returns
+            -------
+            str
+                Task result string with task ID.
+            """
+            await asyncio.sleep(0.05)
+            return f"result{task_id}"
+
+        # Create concurrent tasks
+        tasks = [
+            async_task(i)
+            for i in range(1, self.async_data["concurrent_tasks"] + 1)
+        ]
+
+        # Execute tasks concurrently
+        results = await asyncio.gather(*tasks)
+
+        # Verify concurrent operation results
+        self.assertEqual(
+            len(results),
+            self.async_data["concurrent_tasks"],
+            "Concurrent task count should match expected value"
+        )
+        self.assertListEqual(
+            results,
+            self.async_data["expected_results"],
+            "Concurrent task results should match expected values"
+        )
 
-        Returns
-        -------
-        None
-            This test method doesn't return anything.
+    async def testAsyncErrorHandling(self) -> None:
         """
+        Test async error handling and timeout management.
+
+        Validates the framework's ability to handle async exceptions
+        and timeout scenarios correctly. This method demonstrates proper
+        async error handling patterns including exception catching and
+        timeout management.
+
+        Tests
+        -----
+        - Async exception assertion with assertRaises
+        - Async timeout handling with asyncio.wait_for
+        - Async exception type validation
+        - Async context manager exception handling
+
+        Raises
+        ------
+        AssertionError
+            If async error handling doesn't work as expected.
+        """
+        async def failing_async_function() -> None:
+            """
+            Simulate async function that raises an exception.
+
+            Raises
+            ------
+            ValueError
+                Always raises ValueError for testing purposes.
+            """
+            await asyncio.sleep(0.01)
+            raise ValueError("Async test exception")
+
+        # Test async exception assertion
+        with self.assertRaises(ValueError):
+            await failing_async_function()
+
+        async def slow_async_function() -> str:
+            """
+            Simulate slow async function for timeout testing.
+
+            Returns
+            -------
+            str
+                Result string after long delay.
+            """
+            await asyncio.sleep(1.0)
+            return "slow result"
+
+        # Test async timeout handling
+        with self.assertRaises(asyncio.TimeoutError):
+            await asyncio.wait_for(slow_async_function(), timeout=0.1)
+
+    async def testAsyncContainerIntegration(self, container: Application) -> None:
+        """
+        Test async container dependency injection functionality.
+
+        Validates the container's ability to resolve services in async
+        contexts and manage async dependencies. This method demonstrates
+        async dependency injection patterns and service resolution.
+
+        Parameters
+        ----------
+        container : Application
+            Injected application container instance for testing async
+            dependency injection capabilities.
+
+        Tests
+        -----
+        - Async service resolution from container
+        - Async service method execution
+        - Async dependency lifecycle management
+        - Async service functionality validation
+
+        Raises
+        ------
+        AssertionError
+            If async container operations fail or services cannot be resolved.
+        """
+        async def resolve_service_async() -> IResolver:
+            """
+            Simulate async service resolution.
+
+            Returns
+            -------
+            IResolver
+                Resolved path resolver service instance.
+            """
+            await asyncio.sleep(0.01)
+            return container.make(IResolver)
+
+        # Test async service resolution
+        path_resolver = await resolve_service_async()
+        self.assertIsNotNone(
+            path_resolver,
+            "Async service resolution should return valid instance"
+        )
+
+        async def use_service_async() -> str:
+            """
+            Simulate async service method execution.
+
+            Returns
+            -------
+            str
+                Result from async service method call.
+            """
+            await asyncio.sleep(0.01)
+            return path_resolver.relativePath("README.md").toString()
+
+        # Test async service method execution
+        result = await use_service_async()
+        self.assertTrue(
+            result.endswith("README.md"),
+            "Async service method execution should return correct result"
+        )
+
+    async def testAsyncDataProcessing(self) -> None:
+        """
+        Test async data processing and validation patterns.
+
+        Validates async data transformation, processing, and validation
+        operations. This method demonstrates proper async data handling
+        patterns and validation techniques.
+
+        Tests
+        -----
+        - Async data transformation operations
+        - Async data validation with type checking
+        - Async list processing and comparison
+        - Async data integrity validation
+
+        Raises
+        ------
+        AssertionError
+            If async data processing fails or results don't match expectations.
+        """
+        async def process_data_async(data: List[int]) -> List[int]:
+            """
+            Simulate async data processing with transformation.
+
+            Parameters
+            ----------
+            data : List[int]
+                Input data list for processing.
+
+            Returns
+            -------
+            List[int]
+                Processed data list with transformed values.
+            """
+            await asyncio.sleep(0.01)
+            return [item * 2 for item in data]
+
+        # Test async data transformation
+        input_data = [1, 2, 3, 4, 5]
+        processed_data = await process_data_async(input_data)
+        expected_data = [2, 4, 6, 8, 10]
+
+        self.assertListEqual(
+            processed_data,
+            expected_data,
+            "Async data processing should transform values correctly"
+        )
+
+        async def validate_data_async(data: List[int]) -> bool:
+            """
+            Simulate async data validation.
 
-        # Check if 1 equals 1
-        self.assertEqual(2, 2)
+            Parameters
+            ----------
+            data : List[int]
+                Data list to validate.
 
-        # Check if 2 equals 2
-        self.assertEqual(3, 3)
+            Returns
+            -------
+            bool
+                True if all items are integers, False otherwise.
+            """
+            await asyncio.sleep(0.01)
+            return all(isinstance(item, int) for item in data)
 
-        # Inyect the paths service to resolve a relative path
-        path = paths.relativePath("tests/example/test_example.py").toString()
-        self.assertTrue(path.endswith("test_example.py"))
+        # Test async data validation
+        is_valid = await validate_data_async(processed_data)
+        self.assertTrue(
+            is_valid,
+            "Async data validation should confirm data integrity"
+        )

orionis/test/record/history.py

@@ -1,385 +0,0 @@
-import json
-import re
-import sqlite3
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple
-from orionis.services.environment.env import Env
-from orionis.test.exceptions import OrionisTestPersistenceError, OrionisTestValueError
-from orionis.test.contracts.logs import ITestLogs
-
-class TestLogs(ITestLogs):
-
-    def __init__(
-        self,
-        storage_path: Optional[str] = None,
-        db_name: Optional[str] = 'tests.sqlite',
-        table_name: Optional[str] = 'reports',
-    ) -> None:
-        """
-        Initialize the history storage for test logs.
-
-        Parameters
-        ----------
-        storage_path : Optional[str], default=None
-            Directory path where the database file will be stored. If not provided,
-            the path is determined from the TEST_DB_PATH environment variable or
-            defaults to 'orionis/test/logs/storage' in the current working directory.
-        db_name : Optional[str], default='tests.sqlite'
-            Name of the SQLite database file. Must be alphanumeric or underscore and
-            end with '.sqlite'.
-        table_name : Optional[str], default='reports'
-            Name of the table to use in the database. Must be alphanumeric or underscore.
-
-        Raises
-        ------
-        OrionisTestValueError
-            If db_name or table_name do not meet the required format.
-        """
-
-        # Validate db_name: only alphanumeric and underscores, must end with .sqlite
-        if not isinstance(db_name, str) or not re.fullmatch(r'[a-zA-Z0-9_]+\.sqlite', db_name):
-            raise OrionisTestValueError("Database name must be alphanumeric/underscore and end with '.sqlite'.")
-        self.__db_name = db_name
-
-        # Validate table_name: only alphanumeric and underscores
-        if not isinstance(table_name, str) or not re.fullmatch(r'[a-zA-Z0-9_]+', table_name):
-            raise OrionisTestValueError("Table name must be alphanumeric/underscore only.")
-        self.__table_name = table_name
-
-        # Determine database path
-        db_path = None
-        if storage_path:
-            db_path = Path(storage_path).expanduser().resolve()
-            if db_path.is_dir():
-                db_path = db_path / self.__db_name
-        else:
-            env_path = Env.get("TEST_DB_PATH", None)
-            if env_path:
-                db_path = Path(env_path).expanduser().resolve()
-                if db_path.is_dir():
-                    db_path = db_path / self.__db_name
-            else:
-                db_path = Path.cwd() / 'storage/framework/testing' / self.__db_name
-
-        # Ensure parent directory exists
-        db_path.parent.mkdir(parents=True, exist_ok=True)
-
-        # Store path in environment
-        Env.set("TEST_DB_PATH", str(db_path), 'path')
-        self.__db_path = db_path
-
-        # Create a connection to the database, initially set to None
-        self._conn: Optional[sqlite3.Connection] = None
-
-    def __connect(
-        self
-    ) -> None:
-        """
-        Establishes a connection to the SQLite database if not already connected.
-
-        Attempts to create a new SQLite connection using the provided database path.
-        If the connection fails, raises an OrionisTestPersistenceError with the error details.
-
-        Raises
-        ------
-        OrionisTestPersistenceError
-            If a database connection error occurs.
-        """
-        if self._conn is None:
-            try:
-                self._conn = sqlite3.connect(str(self.__db_path))
-            except (sqlite3.Error, Exception) as e:
-                raise OrionisTestPersistenceError(f"Database connection error: {e}")
-
-    def __createTableIfNotExists(
-        self
-    ) -> bool:
-        """
-        Ensures that the test history table exists in the database.
-
-        Connects to the database and creates the table with the required schema if it does not already exist.
-        Handles any SQLite errors by rolling back the transaction and raising a custom exception.
-
-        Raises
-        ------
-        OrionisTestPersistenceError
-            If the table creation fails due to a database error.
-
-        Returns
-        -------
-        bool
-            True if the table was created successfully or already exists, False otherwise.
-        """
-
-        self.__connect()
-        try:
-            cursor = self._conn.cursor()
-            cursor.execute(f'''
-                CREATE TABLE IF NOT EXISTS {self.__table_name} (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    json TEXT NOT NULL,
-                    total_tests INTEGER,
-                    passed INTEGER,
-                    failed INTEGER,
-                    errors INTEGER,
-                    skipped INTEGER,
-                    total_time REAL,
-                    success_rate REAL,
-                    timestamp TEXT
-                )
-            ''')
-            self._conn.commit()
-            return True
-        except sqlite3.Error as e:
-            if self._conn:
-                self._conn.rollback()
-            raise OrionisTestPersistenceError(f"Failed to create table: {e}")
-        finally:
-            if self._conn:
-                self.__close()
-                self._conn = None
-
-    def __insertReport(
-        self,
-        report: Dict
-    ) -> bool:
-        """
-        Inserts a test report into the history database table.
-
-        Parameters
-        ----------
-        report : Dict
-            A dictionary containing the report data. Must include the following keys:
-            - total_tests
-            - passed
-            - failed
-            - errors
-            - skipped
-            - total_time
-            - success_rate
-            - timestamp
-
-        Raises
-        ------
-        OrionisTestPersistenceError
-            If there is an error inserting the report into the database.
-        OrionisTestValueError
-            If required fields are missing from the report.
-
-        Returns
-        -------
-        bool
-            True if the report was successfully inserted, False otherwise.
-        """
-
-        # Required fields in the report
-        fields = [
-            "json", "total_tests", "passed", "failed", "errors",
-            "skipped", "total_time", "success_rate", "timestamp"
-        ]
-
-        # Validate report structure
-        missing = []
-        for key in fields:
-            if key not in report and key != "json":
-                missing.append(key)
-        if missing:
-            raise OrionisTestValueError(f"Missing report fields: {missing}")
-
-        # Insert the report into the database
-        self.__connect()
-        try:
-
-            # Query to insert the report into the table
-            query = f'''
-                INSERT INTO {self.__table_name} (
-                    json, total_tests, passed, failed, errors,
-                    skipped, total_time, success_rate, timestamp
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-            '''
-
-            # Execute the insert query with the report data
-            cursor = self._conn.cursor()
-            cursor.execute(query, (
-                json.dumps(report),
-                report["total_tests"],
-                report["passed"],
-                report["failed"],
-                report["errors"],
-                report["skipped"],
-                report["total_time"],
-                report["success_rate"],
-                report["timestamp"]
-            ))
-            self._conn.commit()
-            return True
-        except sqlite3.Error as e:
-            if self._conn:
-                self._conn.rollback()
-            raise OrionisTestPersistenceError(f"Failed to insert report: {e}")
-        finally:
-            if self._conn:
-                self.__close()
-                self._conn = None
-
-    def __getReports(
-        self,
-        first: Optional[int] = None,
-        last: Optional[int] = None
-    ) -> List[Tuple]:
-        """
-        Retrieves a specified number of report records from the database, ordered by their ID.
-
-        Parameters
-        ----------
-        first : Optional[int], default=None
-            The number of earliest reports to retrieve, ordered ascending by ID.
-        last : Optional[int], default=None
-            The number of latest reports to retrieve, ordered descending by ID.
-
-        Returns
-        -------
-        List[Tuple]
-            A list of tuples representing the report records.
-
-        Raises
-        ------
-        OrionisTestValueError
-            If both 'first' and 'last' are specified, or if either is not a positive integer.
-        OrionisTestPersistenceError
-            If there is an error retrieving reports from the database.
-        """
-
-        # Validate parameters
-        if first is not None and last is not None:
-            raise OrionisTestValueError(
-                "Cannot specify both 'first' and 'last' parameters. Use one or the other."
-            )
-        if first is not None:
-            if not isinstance(first, int) or first <= 0:
-                raise OrionisTestValueError("'first' must be an integer greater than 0.")
-        if last is not None:
-            if not isinstance(last, int) or last <= 0:
-                raise OrionisTestValueError("'last' must be an integer greater than 0.")
-
-        order = 'DESC' if last is not None else 'ASC'
-        quantity = first if first is not None else last
-
-        self.__connect()
-        try:
-            cursor = self._conn.cursor()
-            query = f"SELECT * FROM {self.__table_name} ORDER BY id {order} LIMIT ?"
-            cursor.execute(query, (quantity,))
-            results = cursor.fetchall()
-            return results
-        except sqlite3.Error as e:
-            raise OrionisTestPersistenceError(f"Failed to retrieve reports from '{self.__db_name}': {e}")
-        finally:
-            if self._conn:
-                self.__close()
-                self._conn = None
-
-    def __resetDatabase(
-        self
-    ) -> bool:
-        """
-        Resets the database by dropping the existing table.
-        This method connects to the database, drops the table specified by
-        `self.__table_name` if it exists, commits the changes, and then closes
-        the connection. If an error occurs during the process, an
-        OrionisTestPersistenceError is raised.
-
-        Raises
-        ------
-        OrionisTestPersistenceError
-            If the database reset operation fails due to an SQLite error.
-
-        Returns
-        -------
-        bool
-            True if the database was successfully reset, False otherwise.
-        """
-
-        self.__connect()
-        try:
-            cursor = self._conn.cursor()
-            cursor.execute(f'DROP TABLE IF EXISTS {self.__table_name}')
-            self._conn.commit()
-            return True
-        except sqlite3.Error as e:
-            raise OrionisTestPersistenceError(f"Failed to reset database: {e}")
-        finally:
-            if self._conn:
-                self.__close()
-                self._conn = None
-
-    def __close(
-        self
-    ) -> None:
-        """
-        Closes the current database connection.
-        This method checks if a database connection exists. If so, it closes the connection and sets the connection attribute to None.
-
-        Returns
-        -------
-        None
-        """
-
-        if self._conn:
-            self._conn.close()
-            self._conn = None
-
-    def create(
-        self,
-        report: Dict
-    ) -> bool:
-        """
-        Create a new test report in the history database.
-
-        Parameters
-        ----------
-        report : Dict
-            A dictionary containing the test report data.
-
-        Returns
-        -------
-        bool
-            True if the report was successfully created, False otherwise.
-        """
-        self.__createTableIfNotExists()
-        return self.__insertReport(report)
-
-    def reset(
-        self
-    ) -> bool:
-        """
-        Reset the history database by dropping the existing table.
-
-        Returns
-        -------
-        bool
-            True if the database was successfully reset, False otherwise.
-        """
-        return self.__resetDatabase()
-
-    def get(
-        self,
-        first: Optional[int] = None,
-        last: Optional[int] = None
-    ) -> List[Tuple]:
-        """
-        Retrieve test reports from the history database.
-
-        Parameters
-        ----------
-        first : Optional[int], default=None
-            The number of earliest reports to retrieve, ordered ascending by ID.
-        last : Optional[int], default=None
-            The number of latest reports to retrieve, ordered descending by ID.
-
-        Returns
-        -------
-        List[Tuple]
-            A list of tuples representing the retrieved reports.
-        """
-        return self.__getReports(first, last)