orionis 0.546.0__py3-none-any.whl → 0.548.0__py3-none-any.whl

tests/testing/enums/test_testing_status.py

@@ -1,63 +0,0 @@
-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):
-        """
-        Test that the TestStatus enum contains the expected members.
-
-        Checks for the presence of the 'PASSED', 'FAILED', 'ERRORED', and 'SKIPPED' members in the TestStatus enum.
-
-        Returns
-        -------
-        None
-        """
-        # 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):
-        """
-        Test that all TestStatus enum member values are unique.
-
-        Collects all values from the TestStatus enum and asserts that there are no duplicate values.
-
-        Returns
-        -------
-        None
-        """
-        # 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):
-        """
-        Test that TestStatus is a subclass of Enum.
-
-        Asserts that TestStatus inherits from the Enum base class.
-
-        Returns
-        -------
-        None
-        """
-        # Assert that TestStatus inherits from Enum
-        self.assertTrue(issubclass(TestStatus, Enum))
-
-    async def testEnumMembersType(self):
-        """
-        Test that each member of TestStatus is an instance of TestStatus.
-
-        Iterates through all members of TestStatus and asserts their type.
-
-        Returns
-        -------
-        None
-        """
-        # 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

@@ -1,29 +0,0 @@
-from orionis.test.cases.asynchronous import AsyncTestCase
-from orionis.test.output.dumper import TestDumper
-
-class TestTestingDumper(AsyncTestCase):
-
-    async def testMethodsExist(self):
-        """
-        Verify the presence of required methods in the TestDumper class.
-
-        This asynchronous test checks whether the TestDumper class implements all methods listed in `required_methods`. 
-        An assertion error is raised if any required method is missing.
-
-        Returns
-        -------
-        None
-        """
-        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

@@ -1,42 +0,0 @@
-from orionis.test.cases.asynchronous import AsyncTestCase
-from orionis.test.output.printer import TestPrinter
-
-class TestTestingPrinter(AsyncTestCase):
-
-    async def testMethodsExist(self):
-        """
-        Verify that all required methods are present in the TestPrinter class.
-
-        This asynchronous test checks whether each method listed in `required_methods`
-        exists as an attribute of the TestPrinter class. An assertion error is raised
-        if any required method is missing.
-
-        Parameters
-        ----------
-        self : TestTestingPrinter
-            Instance of the test case.
-
-        Returns
-        -------
-        None
-        """
-        # 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

@@ -1,171 +0,0 @@
-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):
-        """
-        Test the creation and retrieval of a test report.
-
-        Creates a test report with all required fields, stores it using the
-        TestLogs class, and retrieves the most recent report to verify its
-        contents.
-
-        Returns
-        -------
-        None
-        """
-        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):
-        """
-        Test error handling for missing required fields in report creation.
-
-        Attempts to create a report without the required 'timestamp' field and
-        expects an OrionisTestValueError to be raised.
-
-        Returns
-        -------
-        None
-        """
-        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):
-        """
-        Test the reset functionality of the test logs database.
-
-        Creates a report, stores it, and then resets the logs database.
-        Verifies that the reset operation returns True.
-
-        Returns
-        -------
-        None
-        """
-        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):
-        """
-        Test error handling for invalid parameters in TestLogs.get().
-
-        Checks that passing mutually exclusive or invalid values to get()
-        raises an OrionisTestValueError.
-
-        Returns
-        -------
-        None
-        """
-        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):
-        """
-        Test retrieval of the last N reports and their order.
-
-        Creates multiple reports, retrieves the last two, and checks that the
-        reports are returned in descending order by their identifier.
-
-        Returns
-        -------
-        None
-        """
-        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,164 +0,0 @@
-import unittest
-from unittest.mock import MagicMock
-from orionis.app import Orionis
-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 the correct default configuration values and internal attributes.
-
-        Returns
-        -------
-        None
-        """
-        unit_test = UnitTest(Orionis())
-        # 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:
-        """
-        Test that the `configure` method of `UnitTest` updates internal configuration attributes as expected.
-
-        Returns
-        -------
-        None
-        """
-        unit_test = UnitTest(Orionis())
-        # Configure the UnitTest instance with custom parameters
-        configured = unit_test.configure(
-            verbosity=1,
-            execution_mode=ExecutionMode.PARALLEL,
-            max_workers=4,
-            fail_fast=True,
-            print_result=False,
-            throw_exception=True,
-            persistent=False,
-            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, 4)
-        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)
-        # Ensure the configure method returns the same instance for chaining
-        self.assertIs(configured, unit_test)
-
-    async def testFlattenTestSuite(self) -> None:
-        """
-        Test that the `_flattenTestSuite` method of `UnitTest` flattens nested `TestSuite` instances into a list of test cases.
-
-        Returns
-        -------
-        None
-        """
-        unit_test = UnitTest(Orionis())
-        # 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:
-        """
-        Test that the `_mergeTestResults` method of `UnitTest` correctly aggregates results from an individual `TestResult` into a combined `TestResult`.
-
-        Returns
-        -------
-        None
-        """
-        unit_test = UnitTest(Orionis())
-        # 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')]
-        individual.errors = [('test2', 'error')]
-        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:
-        """
-        Test that the `clearTests` method of `UnitTest` resets the test suite, removing all test cases.
-
-        Returns
-        -------
-        None
-        """
-        unit_test = UnitTest(Orionis())
-        # 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:
-        """
-        Test that the `getTestNames` method of `UnitTest` returns a list of identifiers for all test cases in the suite.
-
-        Returns
-        -------
-        None
-        """
-        unit_test = UnitTest(Orionis())
-        # 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:
-        """
-        Test that the `getTestCount` method of `UnitTest` returns the correct number of test cases in the suite.
-
-        Returns
-        -------
-        None
-        """
-        unit_test = UnitTest(Orionis())
-        # 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()
-        # Assert that the returned count matches the number of test cases added
-        self.assertEqual(count, 2)