orionis 0.545.0__py3-none-any.whl → 0.547.0__py3-none-any.whl

tests/support/standard/test_services_std.py

@@ -1,226 +0,0 @@
-from orionis.support.standard.exceptions import OrionisStdValueException
-from orionis.support.standard.std import StdClass
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestSupportStd(AsyncTestCase):
-
-    async def testInitializationAndAccess(self):
-        """
-        Test initialization and attribute access of StdClass.
-
-        Parameters
-        ----------
-        self : TestSupportStd
-            The test case instance.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Verifies that StdClass can be instantiated with specific attributes and
-        that those attributes are accessible after initialization.
-        """
-        obj = StdClass(
-            first_name='Raul',
-            last_name='Uñate',
-            age=31
-        )
-        self.assertEqual(obj.first_name, 'Raul')
-        self.assertEqual(obj.age, 31)
-
-    async def testToDictReturnsCorrectData(self):
-        """
-        Test that StdClass.toDict returns a dictionary with correct attribute data.
-
-        Parameters
-        ----------
-        self : TestSupportStd
-            The test case instance.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Ensures that toDict() returns a dictionary containing all attributes and their values.
-        """
-        obj = StdClass(a=1, b=2)
-        expected = {'a': 1, 'b': 2}
-        self.assertEqual(obj.toDict(), expected)
-
-    async def testUpdateAttributes(self):
-        """
-        Test updating multiple attributes using StdClass.update.
-
-        Parameters
-        ----------
-        self : TestSupportStd
-            The test case instance.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Verifies that update() sets multiple attributes as expected.
-        """
-        obj = StdClass()
-        obj.update(foo='bar', number=42)
-        self.assertEqual(obj.foo, 'bar')
-        self.assertEqual(obj.number, 42)
-
-    async def testUpdateReservedAttributeRaisesError(self):
-        """
-        Test that updating a reserved attribute raises OrionisStdValueException.
-
-        Parameters
-        ----------
-        self : TestSupportStd
-            The test case instance.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Ensures that attempting to update a reserved attribute (e.g., '__init__')
-        raises the appropriate exception.
-        """
-        obj = StdClass()
-        with self.assertRaises(OrionisStdValueException):
-            obj.update(__init__='bad')
-
-    async def testUpdateConflictingAttributeRaisesError(self):
-        """
-        Test that updating with a conflicting attribute name raises OrionisStdValueException.
-
-        Parameters
-        ----------
-        self : TestSupportStd
-            The test case instance.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Ensures that updating with a name that conflicts with an existing method
-        or reserved attribute (e.g., 'toDict') raises an exception.
-        """
-        obj = StdClass()
-        with self.assertRaises(OrionisStdValueException):
-            obj.update(toDict='oops')
-
-    async def testRemoveExistingAttributes(self):
-        """
-        Test removal of an existing attribute using StdClass.remove.
-
-        Parameters
-        ----------
-        self : TestSupportStd
-            The test case instance.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Removes an attribute and checks that it no longer exists, while others remain.
-        """
-        obj = StdClass(x=1, y=2)
-        obj.remove('x')
-        self.assertFalse(hasattr(obj, 'x'))
-        self.assertTrue(hasattr(obj, 'y'))
-
-    async def testRemoveNonExistingAttributeRaisesError(self):
-        """
-        Test that removing a non-existing attribute raises AttributeError.
-
-        Parameters
-        ----------
-        self : TestSupportStd
-            The test case instance.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Ensures that attempting to remove an attribute that does not exist raises an error.
-        """
-        obj = StdClass()
-        with self.assertRaises(AttributeError):
-            obj.remove('not_there')
-
-    async def testFromDictCreatesEquivalentInstance(self):
-        """
-        Test creation of StdClass instance from a dictionary using fromDict.
-
-        Parameters
-        ----------
-        self : TestSupportStd
-            The test case instance.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Verifies that fromDict creates an instance whose attributes match the input dictionary.
-        """
-        data = {'a': 10, 'b': 20}
-        obj = StdClass.fromDict(data)
-        self.assertEqual(obj.toDict(), data)
-
-    async def testReprAndStr(self):
-        """
-        Test __repr__ and __str__ methods of StdClass for expected output.
-
-        Parameters
-        ----------
-        self : TestSupportStd
-            The test case instance.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Checks that __repr__ includes the class name and __str__ includes attribute key-value pairs.
-        """
-        obj = StdClass(x=5)
-        self.assertIn("StdClass", repr(obj))
-        self.assertIn("'x': 5", str(obj))
-
-    async def testEquality(self):
-        """
-        Test equality and inequality operations for StdClass instances.
-
-        Parameters
-        ----------
-        self : TestSupportStd
-            The test case instance.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Verifies that instances with identical attributes are equal and those with different attributes are not.
-        """
-        a = StdClass(x=1, y=2)
-        b = StdClass(x=1, y=2)
-        c = StdClass(x=3)
-        self.assertEqual(a, b)
-        self.assertNotEqual(a, c)

tests/support/wrapper/test_services_wrapper_docdict.py

@@ -1,202 +0,0 @@
-from orionis.support.wrapper import DotDict
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestSupportWrapperDocDict(AsyncTestCase):
-
-    async def testDotNotationAccess(self):
-        """
-        Test dot notation access for dictionary values.
-
-        Checks that values in a DotDict instance can be accessed using dot notation,
-        including nested dictionaries via chained dot notation. Also verifies that
-        accessing a non-existent key returns None.
-
-        Returns
-        -------
-        None
-        """
-        # Create a DotDict instance with initial values
-        dd = DotDict({'key1': 'value1', 'nested': {'inner': 42}})
-
-        # Access existing key using dot notation
-        self.assertEqual(dd.key1, 'value1')
-
-        # Access nested dictionary value using chained dot notation
-        self.assertEqual(dd.nested.inner, 42)
-
-        # Access non-existent key, should return None
-        self.assertIsNone(dd.non_existent)
-
-    async def testDotNotationAssignment(self):
-        """
-        Test assignment of dictionary values using dot notation.
-
-        Verifies that new keys can be added and existing keys updated using dot notation.
-        Also checks that nested dictionaries assigned via dot notation are automatically
-        converted to DotDict instances.
-
-        Returns
-        -------
-        None
-        """
-        # Create a DotDict instance and assign values using dot notation
-        dd = DotDict()
-
-        # Assign new key using dot notation
-        dd.key1 = 'value1'
-
-        # Assign nested dictionary, should convert to DotDict
-        dd.nested = {'inner': 42}
-
-        # Verify the assignments
-        self.assertEqual(dd['key1'], 'value1')
-        self.assertIsInstance(dd.nested, DotDict)
-        self.assertEqual(dd.nested.inner, 42)
-
-    async def testDotNotationDeletion(self):
-        """
-        Test deletion of dictionary keys using dot notation.
-
-        Ensures that existing keys can be deleted using dot notation and that attempting
-        to delete a non-existent key raises an AttributeError.
-
-        Returns
-        -------
-        None
-        """
-        # Create a DotDict instance and delete an existing key
-        dd = DotDict({'key1': 'value1', 'key2': 'value2'})
-
-        # Delete existing key using dot notation
-        del dd.key1
-        self.assertNotIn('key1', dd)
-
-        # Attempt to delete non-existent key, should raise AttributeError
-        with self.assertRaises(AttributeError):
-            del dd.non_existent
-
-    async def testGetMethod(self):
-        """
-        Test the `get` method with automatic DotDict conversion.
-
-        Verifies that the `get` method returns the correct value for a given key,
-        returns the provided default for missing keys, and converts nested dictionaries
-        to DotDict instances when accessed.
-
-        Returns
-        -------
-        None
-        """
-        # Create a DotDict instance and test the `get` method
-        dd = DotDict({'key1': 'value1', 'nested': {'inner': 42}})
-
-        self.assertEqual(dd.get('key1'), 'value1')
-        self.assertEqual(dd.get('non_existent', 'default'), 'default')
-
-        # Nested dictionary should be returned as DotDict
-        self.assertIsInstance(dd.get('nested'), DotDict)
-        self.assertEqual(dd.get('nested').inner, 42)
-
-    async def testExportMethod(self):
-        """
-        Test the `export` method for recursive conversion to regular dict.
-
-        Ensures that calling `export` on a DotDict instance recursively converts
-        all nested DotDict objects back to regular Python dictionaries.
-
-        Returns
-        -------
-        None
-        """
-        # Create a DotDict instance and export it
-        dd = DotDict({
-            'key1': 'value1',
-            'nested': DotDict({
-                'inner': 42,
-                'deep': DotDict({'a': 1})
-            })
-        })
-
-        exported = dd.export()
-
-        # Top-level and nested DotDicts should be converted to dicts
-        self.assertIsInstance(exported, dict)
-        self.assertIsInstance(exported['nested'], dict)
-        self.assertIsInstance(exported['nested']['deep'], dict)
-        self.assertEqual(exported['nested']['inner'], 42)
-
-    async def testCopyMethod(self):
-        """
-        Test the `copy` method for deep copy with DotDict conversion.
-
-        Verifies that copying a DotDict instance produces an independent copy,
-        with all nested dictionaries converted to DotDict instances. Checks that
-        changes to the copy do not affect the original.
-
-        Returns
-        -------
-        None
-        """
-        # Create a DotDict instance and copy it
-        original = DotDict({
-            'key1': 'value1',
-            'nested': {'inner': 42}
-        })
-
-        # Copy the original DotDict
-        copied = original.copy()
-
-        # Modify the copy and verify original is unchanged
-        copied.key1 = 'modified'
-        copied.nested.inner = 100
-
-        # Check that original remains unchanged
-        self.assertEqual(original.key1, 'value1')
-        self.assertEqual(original.nested.inner, 42)
-        self.assertEqual(copied.key1, 'modified')
-        self.assertEqual(copied.nested.inner, 100)
-        self.assertIsInstance(copied.nested, DotDict)
-
-    async def testNestedDictConversion(self):
-        """
-        Test automatic conversion of nested dictionaries to DotDict.
-
-        Verifies that nested dictionaries are converted to DotDict instances
-        both during initialization and dynamic assignment.
-
-        Returns
-        -------
-        None
-        """
-        dd = DotDict({
-            'level1': {
-                'level2': {
-                    'value': 42
-                }
-            }
-        })
-
-        # Nested dicts should be DotDict instances
-        self.assertIsInstance(dd.level1, DotDict)
-        self.assertIsInstance(dd.level1.level2, DotDict)
-        self.assertEqual(dd.level1.level2.value, 42)
-
-        # Test dynamic assignment of nested dict
-        dd.new_nested = {'a': {'b': 1}}
-        self.assertIsInstance(dd.new_nested, DotDict)
-        self.assertIsInstance(dd.new_nested.a, DotDict)
-
-    async def testReprMethod(self):
-        """
-        Test the string representation of DotDict.
-
-        Verifies that the `__repr__` method of DotDict returns a string
-        representation that includes the DotDict prefix.
-
-        Returns
-        -------
-        None
-        """
-        # Create a DotDict instance and test its string representation
-        dd = DotDict({'key': 'value'})
-        self.assertEqual(repr(dd), "{'key': 'value'}")

tests/testing/cases/test_testing_asynchronous.py

@@ -1,63 +0,0 @@
-from orionis.test.cases.asynchronous import AsyncTestCase
-import inspect
-
-class TestAsyncTestCase(AsyncTestCase):
-
-    async def testMethodsExist(self):
-        """
-        Verify that AsyncTestCase defines the required asynchronous lifecycle methods.
-
-        Parameters
-        ----------
-        self : TestAsyncTestCase
-            Instance of the test case.
-
-        Returns
-        -------
-        None
-            This method does not return a value.
-
-        Raises
-        ------
-        AssertionError
-            If any of the required methods do not exist in AsyncTestCase.
-        """
-        required_methods = [
-            "asyncSetUp",
-            "asyncTearDown",
-            "onAsyncSetup",
-            "onAsyncTeardown"
-        ]
-        # Assert that each required method exists in AsyncTestCase
-        for method_name in required_methods:
-            self.assertTrue(hasattr(AsyncTestCase, method_name), f"{method_name} does not exist")
-
-    async def testMethodsAreCoroutines(self):
-        """
-        Check that all required asynchronous lifecycle methods in AsyncTestCase are coroutine functions.
-
-        Parameters
-        ----------
-        self : TestAsyncTestCase
-            Instance of the test case.
-
-        Returns
-        -------
-        None
-            This method does not return a value.
-
-        Raises
-        ------
-        AssertionError
-            If any of the required methods are not coroutine functions.
-        """
-        required_methods = [
-            "asyncSetUp",
-            "asyncTearDown",
-            "onAsyncSetup",
-            "onAsyncTeardown"
-        ]
-        # Assert that each required method is a coroutine function
-        for method_name in required_methods:
-            method = getattr(AsyncTestCase, method_name)
-            self.assertTrue(inspect.iscoroutinefunction(method), f"{method_name} is not a coroutine function")

tests/testing/cases/test_testing_synchronous.py

@@ -1,57 +0,0 @@
-from orionis.test.cases.asynchronous import AsyncTestCase
-from orionis.test.cases.synchronous import SyncTestCase
-import inspect
-
-class TestSyncTestCase(AsyncTestCase):
-
-    async def testHasMethods(self):
-        """
-        Verify that SyncTestCase defines the required synchronous lifecycle methods.
-
-        This method asserts the presence of the following methods in SyncTestCase:
-        - setUp
-        - tearDown
-        - onSetup
-        - onTeardown
-
-        Returns
-        -------
-        None
-        """
-        # Assert that SyncTestCase has a setUp method
-        self.assertTrue(hasattr(SyncTestCase, "setUp"))
-
-        # Assert that SyncTestCase has a tearDown method
-        self.assertTrue(hasattr(SyncTestCase, "tearDown"))
-
-        # Assert that SyncTestCase has an onSetup method
-        self.assertTrue(hasattr(SyncTestCase, "onSetup"))
-
-        # Assert that SyncTestCase has an onTeardown method
-        self.assertTrue(hasattr(SyncTestCase, "onTeardown"))
-
-    async def testMethodsAreNotCoroutines(self):
-        """
-        Ensure that the lifecycle methods of SyncTestCase are synchronous functions.
-
-        This method checks that the following methods are not coroutine functions:
-        - setUp
-        - tearDown
-        - onSetup
-        - onTeardown
-
-        Returns
-        -------
-        None
-        """
-        # Assert that setUp is not a coroutine function
-        self.assertFalse(inspect.iscoroutinefunction(SyncTestCase.setUp))
-
-        # Assert that tearDown is not a coroutine function
-        self.assertFalse(inspect.iscoroutinefunction(SyncTestCase.tearDown))
-
-        # Assert that onSetup is not a coroutine function
-        self.assertFalse(inspect.iscoroutinefunction(SyncTestCase.onSetup))
-
-        # Assert that onTeardown is not a coroutine function
-        self.assertFalse(inspect.iscoroutinefunction(SyncTestCase.onTeardown))

tests/testing/entities/test_testing_result.py

@@ -1,146 +0,0 @@
-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:
-        """
-        Test that optional fields in TestResult are set to None by default.
-
-        Checks that the fields `error_message`, `traceback`, `class_name`, `method`, `module`, and `file_path`
-        are None when not provided during initialization.
-
-        Parameters
-        ----------
-        self : TestTestingResult
-            The test case instance.
-
-        Returns
-        -------
-        None
-        """
-        # 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:
-        """
-        Test that TestResult enforces required fields during initialization.
-
-        Verifies that omitting required fields raises a TypeError.
-
-        Parameters
-        ----------
-        self : TestTestingResult
-            The test case instance.
-
-        Returns
-        -------
-        None
-        """
-        # 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:
-        """
-        Test that TestResult instances are immutable.
-
-        Ensures that modifying an attribute of a TestResult instance raises an exception.
-
-        Parameters
-        ----------
-        self : TestTestingResult
-            The test case instance.
-
-        Returns
-        -------
-        None
-        """
-        # 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:
-        """
-        Test that all TestStatus enum values can be assigned to TestResult.
-
-        Iterates through each TestStatus value and checks assignment to the status field.
-
-        Parameters
-        ----------
-        self : TestTestingResult
-            The test case instance.
-
-        Returns
-        -------
-        None
-        """
-        # 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:
-        """
-        Test that error_message and traceback fields are stored correctly in TestResult.
-
-        Verifies that providing values for error_message and traceback sets them as expected.
-
-        Parameters
-        ----------
-        self : TestTestingResult
-            The test case instance.
-
-        Returns
-        -------
-        None
-        """
-        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)