orionis 0.415.0__tar.gz → 0.417.0__tar.gz

{orionis-0.415.0/orionis.egg-info → orionis-0.417.0}/PKG-INFO

@@ -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 → orionis-0.417.0}/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 → orionis-0.417.0/orionis.egg-info}/PKG-INFO

@@ -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 → orionis-0.417.0}/orionis.egg-info/SOURCES.txt

@@ -577,4 +577,8 @@ tests/testing/enums/__init__.py
 tests/testing/enums/test_testing_status.py
 tests/testing/output/__init__.py
 tests/testing/output/test_testing_dumper.py
-tests/testing/output/test_testing_printer.py
+tests/testing/output/test_testing_printer.py
+tests/testing/records/__init__.py
+tests/testing/records/test_testing_records.py
+tests/testing/validators/__init__.py
+tests/testing/validators/test_testing_validators.py

orionis-0.417.0/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])

orionis-0.417.0/tests/testing/test_testing_unit.py

@@ -0,0 +1,249 @@
+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:
+        """
+        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 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,
+            max_workers=8,
+            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, 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)
+        # 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 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 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')]
+        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:
+        """
+        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 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 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()
+        # Assert that the returned count matches the number of test cases added
+        self.assertEqual(count, 2)