orionis 0.415.0__py3-none-any.whl → 0.417.0__py3-none-any.whl

orionis/metadata/framework.py

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

{orionis-0.415.0.dist-info → orionis-0.417.0.dist-info}/METADATA

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

{orionis-0.415.0.dist-info → orionis-0.417.0.dist-info}/RECORD

@@ -313,7 +313,7 @@ orionis/foundation/providers/progress_bar_provider.py,sha256=WW3grNgH-yV2meSSTeO
 orionis/foundation/providers/testing_provider.py,sha256=iJSN2RIChbYIL-1ue6vmPmDMCSrvERDkti4Er9MPiLA,1102
 orionis/foundation/providers/workers_provider.py,sha256=kiQjQRyUEyiBX2zcbF_KmqRgvc7Bvxsvg5oMtIvYniM,1075
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=PBPhkOuTumFXjj2FcS-EUvGdP6UNUR8seyMhX5M4YOw,4960
+orionis/metadata/framework.py,sha256=mgSuf0lS1a_bBnjhqeXaV2Y7ZfnUu4h2gWcRaoYMTmI,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
@@ -483,7 +483,7 @@ orionis/test/validators/web_report.py,sha256=-h3Fe9jY93_kzUhd2NBIqEfCcBpu-8Ei9x3
 orionis/test/validators/workers.py,sha256=LGffDKtK6SKixFKzIYPQpI5aFeQPAGXpv_LUtmEu6g4,1102
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=3ICz68l-WF3BtnYqH5m-ktN9UD00MELMbmMnyJDV74A,4768
-orionis-0.415.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.417.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/test_container.py,sha256=asv8TkkupVoex6SWod74NBl4dSs7wb9mLmu_glNdNy8,14815
@@ -558,7 +558,7 @@ tests/support/standard/test_services_std.py,sha256=U0hNF50YE4aLE3Z9yWB2awl9owFQR
 tests/support/wrapper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/wrapper/test_services_wrapper_docdict.py,sha256=Q_qyqZodLiTQ6Pv9zILfIoZj6l-WPzNWuIoRf1GTGY0,7535
 tests/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/testing/test_testing_unit.py,sha256=ZZM6RKxxg4TjANG3_Dy7aQpV60atQbCcSTlOdJZiDIs,4704
+tests/testing/test_testing_unit.py,sha256=Y7CBIs8n7GO_Grd9XLNz0BDT5ULSEbKK1zOUWkp3Vio,10207
 tests/testing/cases/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/cases/test_testing_asynchronous.py,sha256=gBcUyx1gmhulC-51BLtJOCwQOK6EMBaUws8eG8nxYOs,2218
 tests/testing/cases/test_testing_synchronous.py,sha256=n7btUA-2cXPx-HLRfyI7YtVuJvcSuYVC-z843SktPCk,2427
@@ -569,8 +569,12 @@ tests/testing/enums/test_testing_status.py,sha256=Jld1j4nn1IvK_Cok4k-BIRUg3DiB55
 tests/testing/output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/output/test_testing_dumper.py,sha256=QWuHEN-ImwiqNszqnsYUOJNwgZB1WM8ussw_DqFkfEY,1063
 tests/testing/output/test_testing_printer.py,sha256=ov4u0FLHtdWt3onXDQr4-uaMMKE3QYZ4Z-K9LGOuUiM,1366
-orionis-0.415.0.dist-info/METADATA,sha256=Vo3D_EQQFEbqYWWc-nexGpjncl_9bLjVGsWk_QH4YFE,4772
-orionis-0.415.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orionis-0.415.0.dist-info/top_level.txt,sha256=nkPWzvqkAzAmwPMPo3_iiUgzWMFOGfz6hVwdASslEGE,37
-orionis-0.415.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.415.0.dist-info/RECORD,,
+tests/testing/records/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/testing/records/test_testing_records.py,sha256=1MY5bCzY9yapjlOPB8t2SJz63V2_iGczqTmtnyHpnlE,6446
+tests/testing/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/testing/validators/test_testing_validators.py,sha256=QdcF0Vhnnl_kD-PzceHJbUYOqwPTB1Td7YaTv8LTr30,19612
+orionis-0.417.0.dist-info/METADATA,sha256=XLg_D-73TO_1-kXgtzAsdiwUPMvcOcRLbdK8rl3a1BA,4772
+orionis-0.417.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.417.0.dist-info/top_level.txt,sha256=nkPWzvqkAzAmwPMPo3_iiUgzWMFOGfz6hVwdASslEGE,37
+orionis-0.417.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.417.0.dist-info/RECORD,,

tests/testing/records/test_testing_records.py

@@ -0,0 +1,181 @@
+import json
+import tempfile
+from orionis.test.cases.asynchronous import AsyncTestCase
+from orionis.test.exceptions import OrionisTestValueError
+from orionis.test.records.logs import TestLogs
+
+class TestTestingRecords(AsyncTestCase):
+
+    async def testCreateAndGetReport(self):
+        """
+        Tests the creation of a test report and retrieval of the most recent report.
+
+        This method creates a test report with all required fields, stores it using
+        the `TestLogs` class, and then retrieves the most recent report to verify
+        its contents.
+
+        Returns
+        -------
+        None
+            This is a test method and does not return any value. Assertions are used
+            to validate expected behavior.
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            logs = TestLogs(tmpdir)
+
+            # Prepare a complete test report dictionary
+            report = {
+                "total_tests": 5,
+                "passed": 4,
+                "failed": 1,
+                "errors": 0,
+                "skipped": 0,
+                "total_time": 1.23,
+                "success_rate": 0.8,
+                "timestamp": "2024-06-01T12:00:00"
+            }
+
+            # Serialize the report to JSON and add to the dictionary
+            report["json"] = json.dumps(report)
+
+            # Store the report in the logs
+            result = logs.create(report)
+            self.assertTrue(result)
+
+            # Retrieve the most recent report
+            reports = logs.get(first=1)
+            self.assertEqual(len(reports), 1)
+
+            # Validate the contents of the retrieved report
+            self.assertEqual(json.loads(reports[0][1])["total_tests"], 5)
+
+    async def testCreateMissingFields(self):
+        """
+        Tests error handling when creating a report with missing required fields.
+
+        This method attempts to create a report without the required 'timestamp'
+        field and expects an `OrionisTestValueError` to be raised.
+
+        Returns
+        -------
+        None
+            This is a test method and does not return any value. Assertions are used
+            to validate expected behavior.
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            logs = TestLogs(tmpdir)
+
+            # Prepare a report missing the 'timestamp' field
+            report = {
+                "total_tests": 5,
+                "passed": 4,
+                "failed": 1,
+                "errors": 0,
+                "skipped": 0,
+                "total_time": 1.23,
+                "success_rate": 0.8,
+            }
+            report["json"] = json.dumps(report)
+
+            # Expect an error when creating the report
+            with self.assertRaises(OrionisTestValueError):
+                logs.create(report)
+
+    async def testResetDatabase(self):
+        """
+        Tests the reset functionality of the test logs database.
+
+        This method creates a report, stores it, and then resets the logs database.
+        It verifies that the reset operation returns True.
+
+        Returns
+        -------
+        None
+            This is a test method and does not return any value. Assertions are used
+            to validate expected behavior.
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            logs = TestLogs(tmpdir)
+
+            # Create and store a single report
+            report = {
+                "total_tests": 1,
+                "passed": 1,
+                "failed": 0,
+                "errors": 0,
+                "skipped": 0,
+                "total_time": 0.1,
+                "success_rate": 1.0,
+                "timestamp": "2024-06-01T12:00:00"
+            }
+            report["json"] = json.dumps(report)
+            logs.create(report)
+
+            # Reset the logs database and verify success
+            self.assertTrue(logs.reset())
+
+    async def testGetReportsInvalidParams(self):
+        """
+        Tests error handling for invalid parameters passed to `TestLogs.get()`.
+
+        This method checks that passing mutually exclusive or invalid values to
+        `get()` raises an `OrionisTestValueError`.
+
+        Returns
+        -------
+        None
+            This is a test method and does not return any value. Assertions are used
+            to validate expected behavior.
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            logs = TestLogs(tmpdir)
+
+            # Both 'first' and 'last' should not be provided together
+            with self.assertRaises(OrionisTestValueError):
+                logs.get(first=1, last=1)
+
+            # 'first' must be greater than zero
+            with self.assertRaises(OrionisTestValueError):
+                logs.get(first=0)
+
+            # 'last' must be greater than zero
+            with self.assertRaises(OrionisTestValueError):
+                logs.get(last=-1)
+
+    async def testGetLastReports(self):
+        """
+        Tests retrieval of the last N reports and verifies their order.
+
+        This method creates multiple reports, retrieves the last two, and checks
+        that the reports are returned in descending order by their identifier.
+
+        Returns
+        -------
+        None
+            This is a test method and does not return any value. Assertions are used
+            to validate expected behavior.
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            logs = TestLogs(tmpdir)
+
+            # Create and store three reports with increasing 'total_tests'
+            for i in range(3):
+                report = {
+                    "total_tests": i+1,
+                    "passed": i,
+                    "failed": 1,
+                    "errors": 0,
+                    "skipped": 0,
+                    "total_time": 0.1 * (i+1),
+                    "success_rate": 0.5,
+                    "timestamp": f"2024-06-01T12:00:0{i}"
+                }
+                report["json"] = json.dumps(report)
+                logs.create(report)
+
+            # Retrieve the last two reports
+            reports = logs.get(last=2)
+            self.assertEqual(len(reports), 2)
+
+            # Ensure the reports are ordered by descending identifier
+            self.assertTrue(reports[0][0] > reports[1][0])

tests/testing/test_testing_unit.py

@@ -9,17 +9,51 @@ class TestTestingUnit(AsyncTestCase):
 
     async def testDefaultConfiguration(self) -> None:
         """
-        Test that the `UnitTest` class initializes with correct default configuration values.
+        Tests the initialization of the `UnitTest` class to ensure it sets up
+        the default configuration values and internal attributes correctly.
+
+        Parameters
+        ----------
+        self : TestTestingUnit
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+
+        Notes
+        -----
+        Verifies that the loader and suite attributes are instances of their expected classes.
         """
         unit_test = UnitTest()
+        # Assert that the loader is correctly initialized as a TestLoader
         self.assertIsInstance(unit_test._UnitTest__loader, unittest.TestLoader)
+        # Assert that the suite is correctly initialized as a TestSuite
         self.assertIsInstance(unit_test._UnitTest__suite, unittest.TestSuite)
 
     async def testConfigureMethod(self) -> None:
         """
-        Tests the `configure` method of the `UnitTest` class for correct configuration updates.
+        Tests the `configure` method of the `UnitTest` class to ensure it correctly updates
+        the internal configuration attributes based on the provided arguments.
+
+        Parameters
+        ----------
+        self : TestTestingUnit
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+
+        Notes
+        -----
+        - Verifies that each configuration parameter is set to the expected value.
+        - Ensures the `configure` method returns the same `UnitTest` instance for chaining.
         """
         unit_test = UnitTest()
+        # Configure the UnitTest instance with custom parameters
         configured = unit_test.configure(
             verbosity=1,
             execution_mode=ExecutionMode.PARALLEL,
@@ -31,6 +65,7 @@ class TestTestingUnit(AsyncTestCase):
             persistent_driver=PersistentDrivers.JSON,
             web_report=False
         )
+        # Assert that each internal attribute matches the configured value
         self.assertEqual(unit_test._UnitTest__verbosity, 1)
         self.assertEqual(unit_test._UnitTest__execution_mode, ExecutionMode.PARALLEL.value)
         self.assertEqual(unit_test._UnitTest__max_workers, 8)
@@ -39,31 +74,72 @@ class TestTestingUnit(AsyncTestCase):
         self.assertFalse(unit_test._UnitTest__persistent)
         self.assertEqual(unit_test._UnitTest__persistent_driver, PersistentDrivers.JSON.value)
         self.assertFalse(unit_test._UnitTest__web_report)
+        # Ensure the configure method returns the same instance for chaining
         self.assertIs(configured, unit_test)
 
     async def testFlattenTestSuite(self) -> None:
         """
-        Tests the `_flattenTestSuite` method of the `UnitTest` class for correct flattening of nested test suites.
+        Tests the `_flattenTestSuite` method of the `UnitTest` class to ensure it correctly flattens
+        nested `TestSuite` instances into a single list of test cases.
+
+        Parameters
+        ----------
+        self : TestTestingUnit
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+
+        Notes
+        -----
+        - Verifies that all test cases within nested suites are extracted and returned in a flat list.
+        - Ensures that the flattened list contains all individual test cases from the nested structure.
         """
         unit_test = UnitTest()
+        # Create mock test cases
         test_case1 = MagicMock()
         test_case2 = MagicMock()
+        # Create a nested TestSuite containing the mock test cases
         nested_suite = unittest.TestSuite()
         nested_suite.addTest(test_case1)
         nested_suite.addTest(test_case2)
+        # Create the main TestSuite and add the nested suite to it
         main_suite = unittest.TestSuite()
         main_suite.addTest(nested_suite)
+        # Flatten the main suite using the method under test
         flattened = unit_test._UnitTest__flattenTestSuite(main_suite)
+        # Assert that the flattened list contains both test cases
         self.assertEqual(len(flattened), 2)
         self.assertIn(test_case1, flattened)
         self.assertIn(test_case2, flattened)
 
     async def testMergeTestResults(self) -> None:
         """
-        Tests the `_mergeTestResults` method of the `UnitTest` class for correct aggregation of test results.
+        Tests the `_mergeTestResults` method of the `UnitTest` class to ensure it correctly aggregates
+        the results from an individual `TestResult` into a combined `TestResult`.
+
+        Parameters
+        ----------
+        self : TestTestingUnit
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+
+        Notes
+        -----
+        - Verifies that the number of tests run, failures, and errors are correctly merged.
+        - Ensures that skipped, expected failures, and unexpected successes are also handled.
+        - The method under test does not return a value; it modifies the `combined` result in place.
         """
         unit_test = UnitTest()
+        # Create a combined TestResult to aggregate results into
         combined = unittest.TestResult()
+        # Create an individual TestResult with sample data
         individual = unittest.TestResult()
         individual.testsRun = 2
         individual.failures = [('test1', 'failure')]
@@ -71,40 +147,103 @@ class TestTestingUnit(AsyncTestCase):
         individual.skipped = []
         individual.expectedFailures = []
         individual.unexpectedSuccesses = []
+        # Merge the individual results into the combined result
         unit_test._UnitTest__mergeTestResults(combined, individual)
+        # Assert that the combined result reflects the merged data
         self.assertEqual(combined.testsRun, 2)
         self.assertEqual(len(combined.failures), 1)
         self.assertEqual(len(combined.errors), 1)
 
     async def testClearTests(self) -> None:
         """
-        Tests the `clearTests` method of the `UnitTest` class to ensure it properly resets the test suite.
+        Tests the `clearTests` method of the `UnitTest` class to verify that it correctly resets the test suite,
+        removing all previously added test cases and leaving the suite empty.
+
+        Parameters
+        ----------
+        self : TestTestingUnit
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+
+        Notes
+        -----
+        - Ensures that after calling `clearTests`, the internal test suite contains no test cases.
+        - Validates that the suite is properly cleared regardless of its previous state.
         """
         unit_test = UnitTest()
+        # Add a mock test case to the suite
         mock_test = MagicMock()
         unit_test._UnitTest__suite.addTest(mock_test)
+        # Clear all tests from the suite
         unit_test.clearTests()
+        # Assert that the suite is now empty
         self.assertEqual(len(unit_test._UnitTest__suite._tests), 0)
 
     async def testGetTestNames(self) -> None:
         """
-        Tests the `getTestNames` method of the `UnitTest` class for correct extraction of test identifiers.
+        Tests the `getTestNames` method of the `UnitTest` class to ensure it accurately retrieves
+        the identifiers of all test cases present in the internal test suite.
+
+        Parameters
+        ----------
+        self : TestTestingUnit
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+
+        Notes
+        -----
+        - Verifies that the method returns a list of test identifiers corresponding to each test case in the suite.
+        - Ensures that the returned list contains the expected test IDs as provided by the test case's `id()` method.
+        - The expected return value of `getTestNames` is a list of strings, where each string is the identifier of a test case.
         """
         unit_test = UnitTest()
+        # Create a mock test case and set its id() method to return a specific identifier
         mock_test = MagicMock()
         mock_test.id.return_value = 'test_id'
+        # Add the mock test case to the UnitTest's internal suite
         unit_test._UnitTest__suite.addTest(mock_test)
+        # Retrieve the list of test names using the method under test
         names = unit_test.getTestNames()
+        # Assert that the returned list contains the expected test identifier
         self.assertEqual(names, ['test_id'])
 
     async def testGetTestCount(self) -> None:
         """
-        Tests the `getTestCount` method of the `UnitTest` class for accurate test counting.
+        Tests the `getTestCount` method of the `UnitTest` class to ensure it accurately returns
+        the total number of test cases present in the internal test suite.
+
+        Parameters
+        ----------
+        self : TestTestingUnit
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+
+        Notes
+        -----
+        - Verifies that the method returns the correct count of test cases added to the suite.
+        - Ensures that the count matches the number of test cases present in the suite at the time of invocation.
+        - The expected return value of `getTestCount` is an integer representing the number of test cases in the suite.
         """
         unit_test = UnitTest()
+        # Create two mock test cases
         mock_test1 = MagicMock()
         mock_test2 = MagicMock()
+        # Add the mock test cases to the UnitTest's internal suite
         unit_test._UnitTest__suite.addTest(mock_test1)
         unit_test._UnitTest__suite.addTest(mock_test2)
+        # Retrieve the count of test cases using the method under test
         count = unit_test.getTestCount()
-        self.assertEqual(count, 2)
+        # Assert that the returned count matches the number of test cases added
+        self.assertEqual(count, 2)

tests/testing/validators/test_testing_validators.py

@@ -0,0 +1,449 @@
+from orionis.test.cases.asynchronous import AsyncTestCase
+from orionis.support.facades.workers import Workers
+from orionis.test.exceptions import OrionisTestValueError
+from orionis.test.validators import *
+
+class TestTestingDumper(AsyncTestCase):
+
+    async def testValidWorkers(self) -> None:
+        """
+        Tests the ValidWorkers validator for correct validation of worker counts.
+
+        This method verifies that ValidWorkers accepts valid worker counts within the allowed range,
+        and raises OrionisTestValueError for invalid values such as zero, negative numbers, values
+        exceeding the maximum allowed, and non-integer types.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        # Get the maximum allowed number of workers from the Workers facade
+        max_allowed = Workers.calculate()
+
+        # Valid cases: should return the input value if within allowed range
+        self.assertEqual(ValidWorkers(1), 1)
+        self.assertEqual(ValidWorkers(max_allowed), max_allowed)
+
+        # Invalid cases: should raise OrionisTestValueError for out-of-range or wrong type
+        with self.assertRaises(OrionisTestValueError):
+            ValidWorkers(0)  # Zero is not allowed
+        with self.assertRaises(OrionisTestValueError):
+            ValidWorkers(max_allowed + 1)  # Exceeds maximum allowed
+        with self.assertRaises(OrionisTestValueError):
+            ValidWorkers(-5)  # Negative value is not allowed
+        with self.assertRaises(OrionisTestValueError):
+            ValidWorkers("not_an_int")  # Non-integer type is not allowed
+
+    async def testValidBasePath(self) -> None:
+        """
+        Tests the ValidBasePath validator for correct validation of base path inputs.
+
+        This method checks that ValidBasePath accepts valid path strings and Path objects,
+        returning a pathlib.Path instance. It also verifies that invalid inputs such as empty strings,
+        None, and non-path types raise OrionisTestValueError.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        from orionis.test.validators import ValidBasePath
+        from pathlib import Path
+
+        # Valid cases: should return a Path instance for valid string or Path input
+        self.assertIsInstance(ValidBasePath("/tmp"), Path)
+        self.assertIsInstance(ValidBasePath(Path("/tmp")), Path)
+
+        # Invalid cases: should raise OrionisTestValueError for empty string, None, or non-path type
+        with self.assertRaises(OrionisTestValueError):
+            ValidBasePath("")
+        with self.assertRaises(OrionisTestValueError):
+            ValidBasePath(None)
+        with self.assertRaises(OrionisTestValueError):
+            ValidBasePath(123)
+
+    async def testValidExecutionMode(self) -> None:
+        """
+        Tests the ValidExecutionMode validator for correct validation of execution mode inputs.
+
+        This method verifies that ValidExecutionMode accepts valid execution mode strings and enum values,
+        returning the corresponding string value. It also checks that invalid inputs such as unknown strings
+        and non-enum types raise OrionisTestValueError.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        from orionis.test.validators import ValidExecutionMode
+        from orionis.foundation.config.testing.enums.mode import ExecutionMode
+
+        # Valid cases: should return the string value for valid mode string or enum input
+        self.assertEqual(ValidExecutionMode("parallel"), ExecutionMode.PARALLEL.value)
+        self.assertEqual(ValidExecutionMode(ExecutionMode.SEQUENTIAL), ExecutionMode.SEQUENTIAL.value)
+
+        # Invalid cases: should raise OrionisTestValueError for unknown string or non-enum type
+        with self.assertRaises(OrionisTestValueError):
+            ValidExecutionMode("INVALID")  # Unknown execution mode string
+        with self.assertRaises(OrionisTestValueError):
+            ValidExecutionMode(123)        # Non-enum type
+
+    async def testValidFailFast(self) -> None:
+        """
+        Tests the ValidFailFast validator for correct validation of fail-fast configuration.
+
+        This method verifies that ValidFailFast accepts valid boolean inputs, returning the corresponding
+        boolean value. It also checks that invalid inputs, such as non-boolean types or None, raise
+        OrionisTestValueError.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        from orionis.test.validators import ValidFailFast
+
+        # Valid cases: should return True or False for boolean input
+        self.assertTrue(ValidFailFast(True))
+        self.assertFalse(ValidFailFast(False))
+
+        # Invalid cases: should raise OrionisTestValueError for non-boolean or None input
+        with self.assertRaises(OrionisTestValueError):
+            ValidFailFast("not_bool")
+        with self.assertRaises(OrionisTestValueError):
+            ValidFailFast(None)
+
+    async def testValidFolderPath(self) -> None:
+        """
+        Tests the ValidFolderPath validator for correct validation of folder path inputs.
+
+        This method checks that ValidFolderPath accepts valid folder path strings, including those
+        with leading or trailing whitespace, and returns the normalized string path. It also verifies
+        that invalid inputs such as empty strings, None, or non-string types raise OrionisTestValueError.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        from orionis.test.validators import ValidFolderPath
+
+        # Valid cases: should return the normalized string path for valid input
+        self.assertEqual(ValidFolderPath("/tmp"), "/tmp")
+        self.assertEqual(ValidFolderPath("  /tmp  "), "/tmp")
+
+        # Invalid cases: should raise OrionisTestValueError for empty string, None, or non-string type
+        with self.assertRaises(OrionisTestValueError):
+            ValidFolderPath("")
+        with self.assertRaises(OrionisTestValueError):
+            ValidFolderPath(None)
+        with self.assertRaises(OrionisTestValueError):
+            ValidFolderPath(123)
+
+    async def testValidModuleName(self) -> None:
+        """
+        Tests the ValidModuleName validator for correct validation of module name inputs.
+
+        This method verifies that ValidModuleName accepts valid non-empty string module names,
+        returning the normalized string value. It also checks that invalid inputs such as empty strings,
+        None, or non-string types raise OrionisTestValueError.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        from orionis.test.validators import ValidModuleName
+
+        # Valid case: should return the normalized string for a valid module name
+        self.assertEqual(ValidModuleName("mod"), "mod")
+
+        # Invalid cases: should raise OrionisTestValueError for empty string, None, or non-string type
+        with self.assertRaises(OrionisTestValueError):
+            ValidModuleName("")
+        with self.assertRaises(OrionisTestValueError):
+            ValidModuleName(None)
+        with self.assertRaises(OrionisTestValueError):
+            ValidModuleName(123)
+
+    async def testValidNamePattern(self) -> None:
+        """
+        Tests the ValidNamePattern validator for correct validation of name pattern inputs.
+
+        This method verifies that ValidNamePattern accepts valid non-empty string patterns and None,
+        returning the normalized string pattern or None. It also checks that invalid inputs such as
+        empty strings or non-string types raise OrionisTestValueError.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        from orionis.test.validators import ValidNamePattern
+
+        # Valid case: should return the normalized string for a valid pattern
+        self.assertEqual(ValidNamePattern("test_*"), "test_*")
+
+        # Valid case: should return None when input is None
+        self.assertIsNone(ValidNamePattern(None))
+
+        # Invalid cases: should raise OrionisTestValueError for empty string or non-string type
+        with self.assertRaises(OrionisTestValueError):
+            ValidNamePattern("")
+        with self.assertRaises(OrionisTestValueError):
+            ValidNamePattern(123)
+
+    async def testValidPattern(self) -> None:
+        """
+        Tests the ValidPattern validator for correct validation of pattern string inputs.
+
+        This method verifies that ValidPattern accepts valid non-empty string patterns,
+        returning the normalized string value. It also checks that invalid inputs such as
+        empty strings, None, or non-string types raise OrionisTestValueError.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        from orionis.test.validators import ValidPattern
+
+        # Valid case: should return the normalized string for a valid pattern
+        self.assertEqual(ValidPattern("abc"), "abc")
+
+        # Invalid cases: should raise OrionisTestValueError for empty string, None, or non-string type
+        with self.assertRaises(OrionisTestValueError):
+            ValidPattern("")
+        with self.assertRaises(OrionisTestValueError):
+            ValidPattern(None)
+        with self.assertRaises(OrionisTestValueError):
+            ValidPattern(123)
+
+    async def testValidPersistentDriver(self) -> None:
+        """
+        Tests the ValidPersistentDriver validator for correct validation of persistent driver inputs.
+
+        This method verifies that ValidPersistentDriver accepts valid persistent driver names as strings
+        and enum values, returning the corresponding normalized string value. It also checks that invalid
+        inputs, such as unknown driver names or non-enum types, raise OrionisTestValueError.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        from orionis.test.validators import ValidPersistentDriver
+        from orionis.foundation.config.testing.enums.drivers import PersistentDrivers
+
+        # Valid cases: should return the normalized string for valid driver name or enum input
+        self.assertEqual(ValidPersistentDriver("sqlite"), "sqlite")
+        self.assertEqual(ValidPersistentDriver(PersistentDrivers.SQLITE), "sqlite")
+
+        # Invalid cases: should raise OrionisTestValueError for unknown driver name or non-enum type
+        with self.assertRaises(OrionisTestValueError):
+            ValidPersistentDriver("invalid")
+        with self.assertRaises(OrionisTestValueError):
+            ValidPersistentDriver(123)
+
+    async def testValidPersistent(self) -> None:
+        """
+        Tests the ValidPersistent validator for correct validation of persistent configuration values.
+
+        This method verifies that ValidPersistent accepts valid boolean inputs, returning the corresponding
+        boolean value. It also checks that invalid inputs, such as non-boolean types or None, raise
+        OrionisTestValueError.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        from orionis.test.validators import ValidPersistent
+
+        # Valid cases: should return True or False for boolean input
+        self.assertTrue(ValidPersistent(True))
+        self.assertFalse(ValidPersistent(False))
+
+        # Invalid cases: should raise OrionisTestValueError for non-boolean or None input
+        with self.assertRaises(OrionisTestValueError):
+            ValidPersistent("not_bool")
+        with self.assertRaises(OrionisTestValueError):
+            ValidPersistent(None)
+
+    async def testValidPrintResult(self) -> None:
+        """
+        Tests the ValidPrintResult validator for correct validation of print result configuration.
+
+        This method verifies that ValidPrintResult accepts valid boolean inputs, returning the corresponding
+        boolean value. It also checks that invalid inputs, such as non-boolean types or None, raise
+        OrionisTestValueError.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        from orionis.test.validators import ValidPrintResult
+
+        # Valid cases: should return True or False for boolean input
+        self.assertTrue(ValidPrintResult(True))
+        self.assertFalse(ValidPrintResult(False))
+
+        # Invalid cases: should raise OrionisTestValueError for non-boolean or None input
+        with self.assertRaises(OrionisTestValueError):
+            ValidPrintResult("not_bool")
+        with self.assertRaises(OrionisTestValueError):
+            ValidPrintResult(None)
+
+    async def testValidTags(self) -> None:
+        """
+        Tests the ValidTags validator for correct validation of tag list inputs.
+
+        This method verifies that ValidTags accepts a list of non-empty string tags, normalizes whitespace,
+        and returns a list of cleaned tag strings. It also checks that None is accepted and returns None.
+        Invalid cases, such as empty lists, lists containing empty strings or non-string types, and non-list
+        inputs, should raise OrionisTestValueError.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        from orionis.test.validators import ValidTags
+
+        # Valid case: should return a list of normalized tag strings
+        self.assertEqual(ValidTags(["a", "b ", " c"]), ["a", "b", "c"])
+
+        # Valid case: should return None when input is None
+        self.assertIsNone(ValidTags(None))
+
+        # Invalid case: should raise OrionisTestValueError for empty list
+        with self.assertRaises(OrionisTestValueError):
+            ValidTags([])
+
+        # Invalid case: should raise OrionisTestValueError for list containing empty string
+        with self.assertRaises(OrionisTestValueError):
+            ValidTags([""])
+
+        # Invalid case: should raise OrionisTestValueError for list containing non-string type
+        with self.assertRaises(OrionisTestValueError):
+            ValidTags([123])
+
+        # Invalid case: should raise OrionisTestValueError for non-list input
+        with self.assertRaises(OrionisTestValueError):
+            ValidTags("not_a_list")
+
+    async def testValidThrowException(self) -> None:
+        """
+        Tests the ValidThrowException validator for correct validation of throw exception configuration.
+
+        This method verifies that ValidThrowException accepts valid boolean inputs, returning the corresponding
+        boolean value. It also checks that invalid inputs, such as non-boolean types or None, raise
+        OrionisTestValueError.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        from orionis.test.validators import ValidThrowException
+
+        # Valid cases: should return True or False for boolean input
+        self.assertTrue(ValidThrowException(True))
+        self.assertFalse(ValidThrowException(False))
+
+        # Invalid cases: should raise OrionisTestValueError for non-boolean or None input
+        with self.assertRaises(OrionisTestValueError):
+            ValidThrowException("not_bool")
+        with self.assertRaises(OrionisTestValueError):
+            ValidThrowException(None)
+
+    async def testValidVerbosity(self) -> None:
+        """
+        Tests the ValidVerbosity validator for correct validation of verbosity mode inputs.
+
+        This method verifies that ValidVerbosity accepts valid verbosity mode enum values and their corresponding
+        integer values, returning the normalized integer value. It also checks that invalid inputs such as
+        negative values, unknown integers, or non-integer types raise OrionisTestValueError.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        from orionis.test.validators import ValidVerbosity
+        from orionis.foundation.config.testing.enums.verbosity import VerbosityMode
+
+        # Valid cases: should return the integer value for valid enum or integer input
+        self.assertEqual(ValidVerbosity(VerbosityMode.MINIMAL), VerbosityMode.MINIMAL.value)
+        self.assertEqual(ValidVerbosity(VerbosityMode.DETAILED.value), VerbosityMode.DETAILED.value)
+
+        # Invalid cases: should raise OrionisTestValueError for negative, unknown, or non-integer input
+        with self.assertRaises(OrionisTestValueError):
+            ValidVerbosity(-1)
+        with self.assertRaises(OrionisTestValueError):
+            ValidVerbosity("not_int")
+        with self.assertRaises(OrionisTestValueError):
+            ValidVerbosity(999)
+
+    async def testValidWebReport(self) -> None:
+        """
+        Tests the ValidWebReport validator for correct validation of web report configuration.
+
+        This method verifies that ValidWebReport accepts valid boolean inputs, returning the corresponding
+        boolean value. It also checks that invalid inputs, such as non-boolean types or None, raise
+        OrionisTestValueError.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts expected behavior using test assertions.
+        """
+        from orionis.test.validators import ValidWebReport
+
+        # Valid cases: should return True or False for boolean input
+        self.assertTrue(ValidWebReport(True))
+        self.assertFalse(ValidWebReport(False))
+
+        # Invalid cases: should raise OrionisTestValueError for non-boolean or None input
+        with self.assertRaises(OrionisTestValueError):
+            ValidWebReport("not_bool")
+        with self.assertRaises(OrionisTestValueError):
+            ValidWebReport(None)