orionis 0.414.0__py3-none-any.whl → 0.416.0__py3-none-any.whl

tests/testing/enums/test_testing_status.py

@@ -0,0 +1,68 @@
+from enum import Enum
+from orionis.test.cases.asynchronous import AsyncTestCase
+from orionis.test.enums.status import TestStatus
+
+class TestTestStatus(AsyncTestCase):
+
+    async def testHasEnumMembers(self):
+        """
+        Checks that the TestStatus enum contains the expected members.
+
+        This test verifies the presence of the following enum members:
+        'PASSED', 'FAILED', 'ERRORED', and 'SKIPPED'.
+
+        Returns
+        -------
+        None
+            This method does not return a value. It asserts the existence of enum members.
+        """
+        # Assert that each expected member exists in TestStatus
+        self.assertTrue(hasattr(TestStatus, "PASSED"))
+        self.assertTrue(hasattr(TestStatus, "FAILED"))
+        self.assertTrue(hasattr(TestStatus, "ERRORED"))
+        self.assertTrue(hasattr(TestStatus, "SKIPPED"))
+
+    async def testEnumValuesAreUnique(self):
+        """
+        Ensures that all TestStatus enum member values are unique.
+
+        This test collects all values from the TestStatus enum and checks for uniqueness.
+
+        Returns
+        -------
+        None
+            This method does not return a value. It asserts the uniqueness of enum values.
+        """
+        # Gather all enum values
+        values = [status.value for status in TestStatus]
+        # Assert that the number of values equals the number of unique values
+        self.assertEqual(len(values), len(set(values)))
+
+    async def testEnumIsInstanceOfEnum(self):
+        """
+        Validates that TestStatus is a subclass of Enum.
+
+        This test checks the inheritance of TestStatus from the Enum base class.
+
+        Returns
+        -------
+        None
+            This method does not return a value. It asserts the subclass relationship.
+        """
+        # Assert that TestStatus inherits from Enum
+        self.assertTrue(issubclass(TestStatus, Enum))
+
+    async def testEnumMembersType(self):
+        """
+        Confirms that each member of TestStatus is an instance of TestStatus.
+
+        This test iterates through all members of TestStatus and checks their type.
+
+        Returns
+        -------
+        None
+            This method does not return a value. It asserts the type of each enum member.
+        """
+        # Assert that each enum member is an instance of TestStatus
+        for status in TestStatus:
+            self.assertIsInstance(status, TestStatus)

tests/testing/output/test_testing_dumper.py

@@ -0,0 +1,32 @@
+from orionis.test.cases.asynchronous import AsyncTestCase
+from orionis.test.output.dumper import TestDumper
+
+class TestTestingDumper(AsyncTestCase):
+
+    async def testMethodsExist(self):
+        """
+        Checks if the required methods are present in the TestDumper class.
+
+        This test verifies that the `TestDumper` class contains all methods
+        specified in the `required_methods` list. It asserts the existence of
+        each method using `hasattr`.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It raises an assertion error if any required method is missing.
+        """
+
+        required_methods = [
+            "dd",
+            "dump"
+        ]
+
+        # Iterate over the list of required method names
+        for method_name in required_methods:
+
+            # Assert that each required method exists in TestDumper
+            self.assertTrue(
+                hasattr(TestDumper, method_name),
+                f"{method_name} does not exist"
+            )

tests/testing/output/test_testing_printer.py

@@ -0,0 +1,42 @@
+from orionis.test.cases.asynchronous import AsyncTestCase
+from orionis.test.output.printer import TestPrinter
+
+class TestTestingPrinter(AsyncTestCase):
+
+    async def testMethodsExist(self):
+        """
+        Checks for the existence of required methods in the TestPrinter class.
+
+        This test ensures that all methods listed in `required_methods` are present
+        in the `TestPrinter` class by asserting their existence using `hasattr`.
+
+        Parameters
+        ----------
+        self : TestTestingPrinter
+            The test case instance.
+
+        Returns
+        -------
+        None
+            Raises an AssertionError if any required method is missing.
+        """
+        # List of method names that must exist in TestPrinter
+        required_methods = [
+            "print",
+            "startMessage",
+            "finishMessage",
+            "executePanel",
+            "linkWebReport",
+            "summaryTable",
+            "displayResults",
+            "unittestResult"
+        ]
+
+        # Check each required method for existence in TestPrinter
+        for method_name in required_methods:
+
+            # Assert that the method exists in TestPrinter
+            self.assertTrue(
+                hasattr(TestPrinter, method_name),
+                f"{method_name} does not exist"
+            )

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

@@ -1,209 +1,110 @@
-# from unittest import TestLoader
-# from unittest.mock import MagicMock, patch
-# from orionis.test.cases.asynchronous import AsyncTestCase
-# from orionis.test.core.unit_test import UnitTest
-# from orionis.test.enums import ExecutionMode
-# from unittest import (
-#     TestSuite as StandardTestSuite,
-#     TestResult as StandardTestResult
-# )
-
-# class TestTestingUnit(AsyncTestCase):
-
-#     async def testDefaultConfiguration(self) -> None:
-#         """
-#         Test that UnitTest initializes with correct default configuration values.
-
-#         Notes
-#         -----
-#         Verifies that all default attributes are set as expected upon initialization.
-#         """
-#         unit_test = UnitTest()
-#         self.assertIsInstance(unit_test.loader, TestLoader)
-#         self.assertIsInstance(unit_test.suite, StandardTestSuite)
-
-#     async def testConfigureMethod(self) -> None:
-#         """
-#         Test the `configure` method for correct configuration updates.
-#         This test verifies that all configuration parameters of the `UnitTest` class
-#         can be updated through the `configure` method and that the changes are
-#         reflected in the instance attributes.
-
-#         Parameters
-#         ----------
-#         self : TestCase
-#             The test case instance.
-
-#         Notes
-#         -----
-#         The test checks the following configuration parameters:
-#         - verbosity
-#         - execution_mode
-#         - max_workers
-#         - fail_fast
-#         - print_result
-#         - throw_exception
-#         It also asserts that the `configure` method returns the instance itself.
-#         """
-#         unit_test = UnitTest()
-#         configured = unit_test.configure(
-#             verbosity=1,
-#             execution_mode=ExecutionMode.PARALLEL,
-#             max_workers=8,
-#             fail_fast=True,
-#             print_result=False,
-#             throw_exception=True
-#         )
-
-#         self.assertEqual(unit_test.verbosity, 1)
-#         self.assertEqual(unit_test.execution_mode, ExecutionMode.PARALLEL.value)
-#         self.assertEqual(unit_test.max_workers, 8)
-#         self.assertTrue(unit_test.fail_fast)
-#         self.assertFalse(unit_test.print_result)
-#         self.assertTrue(unit_test.throw_exception)
-#         self.assertEqual(configured, unit_test)
-
-#     async def testDiscoverTestsInModule(self) -> None:
-#         """
-#         Test that `discoverTestsInModule` correctly loads tests from a module.
-
-#         Verifies that tests can be discovered from a module and added to the test suite.
-
-#         Notes
-#         -----
-#         This test mocks the loader's `loadTestsFromName` method to ensure that
-#         `discoverTestsInModule` calls it with the correct arguments and that the
-#         returned suite is handled as expected.
-#         """
-#         unit_test = UnitTest()
-#         with patch.object(unit_test.loader, 'loadTestsFromName') as mock_load:
-#             mock_load.return_value = StandardTestSuite()
-#             result = unit_test.discoverTestsInModule(module_name='test_module')
-
-#             mock_load.assert_called_once_with(name='test_module')
-#             self.assertEqual(result, unit_test)
-#             self.assertEqual(len(unit_test.suite._tests), 0)
-
-#     async def testFlattenTestSuite(self) -> None:
-#         """
-#         Test the _flattenTestSuite method for correct flattening of nested test suites.
-#         This test verifies that the _flattenTestSuite method of the UnitTest class
-#         correctly flattens both simple and nested unittest suites into a single list
-#         of test cases.
-
-#         Parameters
-#         ----------
-#         self : TestCase
-#             The test case instance.
-
-#         Notes
-#         -----
-#         - Ensures that nested suites are recursively flattened.
-#         - Asserts that all test cases from nested suites are present in the flattened result.
-#         """
-#         unit_test = UnitTest()
-#         test_case1 = MagicMock()
-#         test_case2 = MagicMock()
-
-#         nested_suite = StandardTestSuite()
-#         nested_suite.addTest(test_case1)
-#         nested_suite.addTest(test_case2)
-
-#         main_suite = StandardTestSuite()
-#         main_suite.addTest(nested_suite)
-
-#         flattened = unit_test._UnitTest__flattenTestSuite(main_suite)
-#         self.assertEqual(len(flattened), 2)
-#         self.assertIn(test_case1, flattened)
-#         self.assertIn(test_case2, flattened)
-
-#     async def testMergeTestResults(self) -> None:
-#         """
-#         Test the _mergeTestResults method for correct merging of test results.
-#         Ensures that the method accurately combines the number of tests run,
-#         as well as the lists of failures and errors from individual test results.
-
-#         Notes
-#         -----
-#         - Verifies that the total number of tests run is updated correctly.
-#         - Checks that failures and errors are merged without loss of information.
-#         """
-#         unit_test = UnitTest()
-#         combined = StandardTestResult()
-#         individual = StandardTestResult()
-
-#         individual.testsRun = 2
-#         individual.failures = [('test1', 'failure')]
-#         individual.errors = [('test2', 'error')]
-
-#         unit_test._UnitTest__mergeTestResults(combined, individual)
-#         self.assertEqual(combined.testsRun, 2)
-#         self.assertEqual(len(combined.failures), 1)
-#         self.assertEqual(len(combined.errors), 1)
-
-#     async def testClearTests(self) -> None:
-#         """
-#         Test the clearTests method to ensure it resets the test suite.
-#         This test verifies that after adding a mock test to the suite and calling
-#         the clearTests method, the suite is emptied as expected.
-
-#         Steps
-#         -----
-#         1. Create an instance of UnitTest.
-#         2. Add a mock test to the test suite.
-#         3. Call the clearTests method.
-#         4. Assert that the test suite is empty.
-
-#         Assertions
-#         ----------
-#         - The length of the test suite should be zero after calling clearTests.
-#         """
-#         unit_test = UnitTest()
-#         mock_test = MagicMock()
-#         unit_test.suite.addTest(mock_test)
-
-#         unit_test.clearTests()
-#         self.assertEqual(len(unit_test.suite._tests), 0)
-
-#     async def testGetTestNames(self) -> None:
-#         """
-#         This test verifies that the `getTestNames` method of the `UnitTest` class
-#         correctly extracts and returns the identifiers of tests present in the test suite.
-
-#         Notes
-#         -----
-#         - Mocks a test case with a predefined identifier.
-#         - Adds the mock test to the test suite.
-#         - Asserts that the returned list of test names matches the expected value.
-#         """
-#         unit_test = UnitTest()
-#         mock_test = MagicMock()
-#         mock_test.id.return_value = 'test_id'
-#         unit_test.suite.addTest(mock_test)
-
-#         names = unit_test.getTestNames()
-#         self.assertEqual(names, ['test_id'])
-
-#     async def testGetTestCount(self) -> None:
-#         """
-#         Test that `getTestCount` returns the correct number of tests.
-
-#         Verifies that the count matches the number of tests in the suite.
-
-#         Notes
-#         -----
-#         - Adds two mock tests to the suite.
-#         - Asserts that `getTestCount` returns 2.
-
-#         Returns
-#         -------
-#         None
-#         """
-#         unit_test = UnitTest()
-#         mock_test1 = MagicMock()
-#         mock_test2 = MagicMock()
-#         unit_test.suite.addTest(mock_test1)
-#         unit_test.suite.addTest(mock_test2)
-
-#         count = unit_test.getTestCount()
-#         self.assertEqual(count, 2)
+import unittest
+from unittest.mock import MagicMock
+from orionis.foundation.config.testing.enums.drivers import PersistentDrivers
+from orionis.foundation.config.testing.enums.mode import ExecutionMode
+from orionis.test.cases.asynchronous import AsyncTestCase
+from orionis.test.core.unit_test import UnitTest
+
+class TestTestingUnit(AsyncTestCase):
+
+    async def testDefaultConfiguration(self) -> None:
+        """
+        Test that the `UnitTest` class initializes with correct default configuration values.
+        """
+        unit_test = UnitTest()
+        self.assertIsInstance(unit_test._UnitTest__loader, unittest.TestLoader)
+        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.
+        """
+        unit_test = UnitTest()
+        configured = unit_test.configure(
+            verbosity=1,
+            execution_mode=ExecutionMode.PARALLEL,
+            max_workers=8,
+            fail_fast=True,
+            print_result=False,
+            throw_exception=True,
+            persistent=False,
+            persistent_driver=PersistentDrivers.JSON,
+            web_report=False
+        )
+        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)
+        self.assertTrue(unit_test._UnitTest__fail_fast)
+        self.assertTrue(unit_test._UnitTest__throw_exception)
+        self.assertFalse(unit_test._UnitTest__persistent)
+        self.assertEqual(unit_test._UnitTest__persistent_driver, PersistentDrivers.JSON.value)
+        self.assertFalse(unit_test._UnitTest__web_report)
+        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.
+        """
+        unit_test = UnitTest()
+        test_case1 = MagicMock()
+        test_case2 = MagicMock()
+        nested_suite = unittest.TestSuite()
+        nested_suite.addTest(test_case1)
+        nested_suite.addTest(test_case2)
+        main_suite = unittest.TestSuite()
+        main_suite.addTest(nested_suite)
+        flattened = unit_test._UnitTest__flattenTestSuite(main_suite)
+        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.
+        """
+        unit_test = UnitTest()
+        combined = unittest.TestResult()
+        individual = unittest.TestResult()
+        individual.testsRun = 2
+        individual.failures = [('test1', 'failure')]
+        individual.errors = [('test2', 'error')]
+        individual.skipped = []
+        individual.expectedFailures = []
+        individual.unexpectedSuccesses = []
+        unit_test._UnitTest__mergeTestResults(combined, individual)
+        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.
+        """
+        unit_test = UnitTest()
+        mock_test = MagicMock()
+        unit_test._UnitTest__suite.addTest(mock_test)
+        unit_test.clearTests()
+        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.
+        """
+        unit_test = UnitTest()
+        mock_test = MagicMock()
+        mock_test.id.return_value = 'test_id'
+        unit_test._UnitTest__suite.addTest(mock_test)
+        names = unit_test.getTestNames()
+        self.assertEqual(names, ['test_id'])
+
+    async def testGetTestCount(self) -> None:
+        """
+        Tests the `getTestCount` method of the `UnitTest` class for accurate test counting.
+        """
+        unit_test = UnitTest()
+        mock_test1 = MagicMock()
+        mock_test2 = MagicMock()
+        unit_test._UnitTest__suite.addTest(mock_test1)
+        unit_test._UnitTest__suite.addTest(mock_test2)
+        count = unit_test.getTestCount()
+        self.assertEqual(count, 2)