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

tests/testing/entities/test_testing_result.py

@@ -0,0 +1,185 @@
+from orionis.test.cases.asynchronous import AsyncTestCase
+from orionis.test.entities.result import TestResult
+from orionis.test.enums import TestStatus
+
+class TestTestingResult(AsyncTestCase):
+
+    async def testDefaultValues(self) -> None:
+        """
+        Ensures that optional fields in a TestResult instance are set to None when not provided during initialization.
+
+        This test checks the default behavior for the following optional fields:
+            - error_message
+            - traceback
+            - class_name
+            - method
+            - module
+            - file_path
+
+        The method asserts that each of these fields is None after instantiating TestResult with only required arguments.
+
+        Parameters
+        ----------
+        self : TestTestingResult
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It performs assertions to validate default field values.
+
+        Notes
+        -----
+        This test verifies that the TestResult dataclass correctly initializes optional fields to None when they are omitted.
+        """
+        # Create a TestResult instance with only required fields
+        result = TestResult(
+            id=1,
+            name="Sample Test",
+            status=TestStatus.PASSED,
+            execution_time=0.5
+        )
+        # Assert that all optional fields are set to None by default
+        self.assertIsNone(result.error_message)
+        self.assertIsNone(result.traceback)
+        self.assertIsNone(result.class_name)
+        self.assertIsNone(result.method)
+        self.assertIsNone(result.module)
+        self.assertIsNone(result.file_path)
+
+    async def testRequiredFields(self) -> None:
+        """
+        Validates that TestResult enforces the presence of all required fields during initialization.
+
+        This test attempts to instantiate TestResult without required fields and expects a TypeError to be raised.
+
+        Parameters
+        ----------
+        self : TestTestingResult
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It performs assertions to validate required field enforcement.
+
+        Notes
+        -----
+        - Attempts to instantiate TestResult with no arguments.
+        - Attempts to instantiate TestResult missing the 'id' field.
+        - Expects a TypeError to be raised in both cases.
+        """
+        # Attempt to create TestResult with no arguments; should raise TypeError
+        with self.assertRaises(TypeError):
+            TestResult()  # Missing all required fields
+
+        # Attempt to create TestResult missing the 'id' field; should raise TypeError
+        with self.assertRaises(TypeError):
+            TestResult(
+                name="Sample Test",
+                status=TestStatus.PASSED,
+                execution_time=0.5
+            )
+
+    async def testImmutable(self) -> None:
+        """
+        Tests the immutability of TestResult instances.
+
+        Ensures that TestResult, implemented as a frozen dataclass, does not allow modification of its attributes after instantiation.
+
+        Parameters
+        ----------
+        self : TestTestingResult
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It performs assertions to validate immutability.
+
+        Raises
+        ------
+        Exception
+            If an attempt is made to modify an attribute of a frozen TestResult instance.
+
+        Notes
+        -----
+        Attempts to modify the 'name' attribute of a TestResult instance and expects an exception to be raised.
+        """
+        # Create a TestResult instance
+        result = TestResult(
+            id=1,
+            name="Sample Test",
+            status=TestStatus.PASSED,
+            execution_time=0.5
+        )
+        # Attempt to modify an attribute; should raise an exception due to immutability
+        with self.assertRaises(Exception):
+            result.name = "Modified Name"
+
+    async def testStatusValues(self) -> None:
+        """
+        Verifies that all possible values of the TestStatus enum can be assigned to the status field of a TestResult instance.
+
+        Iterates over each TestStatus value, assigns it to a TestResult, and asserts that the status is set correctly.
+
+        Parameters
+        ----------
+        self : TestTestingResult
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It performs assertions to validate status assignment.
+
+        Notes
+        -----
+        This test ensures that the status field in TestResult supports all enum values defined in TestStatus.
+        """
+        # Iterate through all possible TestStatus values
+        for status in TestStatus:
+            # Create a TestResult instance with the current status
+            result = TestResult(
+                id=1,
+                name="Status Test",
+                status=status,
+                execution_time=0.1
+            )
+            # Assert that the status field matches the assigned value
+            self.assertEqual(result.status, status)
+
+    async def testErrorFields(self) -> None:
+        """
+        Verifies that the error_message and traceback fields are correctly stored in the TestResult object when provided.
+
+        This test initializes a TestResult with error_message and traceback values and asserts that they are set as expected.
+
+        Parameters
+        ----------
+        self : TestTestingResult
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It performs assertions to validate error field assignment.
+
+        Notes
+        -----
+        This test ensures that error-related fields are properly assigned and retrievable from the TestResult instance.
+        """
+        error_msg = "Test failed"
+        traceback = "Traceback info"
+        # Create a TestResult instance with error fields
+        result = TestResult(
+            id=1,
+            name="Failing Test",
+            status=TestStatus.FAILED,
+            execution_time=0.2,
+            error_message=error_msg,
+            traceback=traceback
+        )
+        # Assert that error_message and traceback fields are set correctly
+        self.assertEqual(result.error_message, error_msg)
+        self.assertEqual(result.traceback, traceback)

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/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)

orionis-0.413.0.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-orionis
-tests