orionis 0.287.0__py3-none-any.whl → 0.288.0__py3-none-any.whl

tests/services/wrapper/{test_wrapper_doc_dict.py → test_services_wrapper_docdict.py}

@@ -1,16 +1,23 @@
 from orionis.services.wrapper.dicts.dot_dict import DotDict
 from orionis.unittesting import TestCase
 
-class TestDotDict(TestCase):
+class TestServicesWrapperDocDict(TestCase):
     """
     Test cases for the DotDict class which provides dictionary with dot notation access.
+
+    Notes
+    -----
+    These tests cover dot notation access, assignment, deletion, and utility methods
+    for the DotDict class, ensuring correct behavior and compatibility with nested
+    dictionaries.
     """
 
     async def testDotNotationAccess(self):
         """
-        Test that dictionary values can be accessed using dot notation.
+        Test dot notation access for dictionary values.
+
         Verifies that both existing and non-existing keys can be accessed via dot notation,
-        with None returned for missing keys.
+        with `None` returned for missing keys.
         """
         dd = DotDict({'key1': 'value1', 'nested': {'inner': 42}})
         self.assertEqual(dd.key1, 'value1')
@@ -19,7 +26,8 @@ class TestDotDict(TestCase):
 
     async def testDotNotationAssignment(self):
         """
-        Test that dictionary values can be set using dot notation.
+        Test assignment of dictionary values using dot notation.
+
         Verifies that new keys can be added and existing keys can be updated using dot notation,
         with automatic conversion of nested dictionaries to DotDict.
         """
@@ -33,8 +41,9 @@ class TestDotDict(TestCase):
 
     async def testDotNotationDeletion(self):
         """
-        Test that dictionary keys can be deleted using dot notation.
-        Verifies that existing keys can be deleted and appropriate AttributeError is raised
+        Test deletion of dictionary keys using dot notation.
+
+        Verifies that existing keys can be deleted and an AttributeError is raised
         when trying to delete non-existent keys.
         """
         dd = DotDict({'key1': 'value1', 'key2': 'value2'})
@@ -46,8 +55,9 @@ class TestDotDict(TestCase):
 
     async def testGetMethod(self):
         """
-        Test that the get method works with automatic DotDict conversion.
-        Verifies that the get method returns the correct value or default,
+        Test the `get` method with automatic DotDict conversion.
+
+        Verifies that the `get` method returns the correct value or default,
         and converts nested dictionaries to DotDict instances.
         """
         dd = DotDict({'key1': 'value1', 'nested': {'inner': 42}})
@@ -59,7 +69,8 @@ class TestDotDict(TestCase):
 
     async def testExportMethod(self):
         """
-        Test that the export method converts to regular dictionary recursively.
+        Test the `export` method for recursive conversion to regular dict.
+
         Verifies that all nested DotDict instances are converted back to regular dicts.
         """
         dd = DotDict({
@@ -78,7 +89,8 @@ class TestDotDict(TestCase):
 
     async def testCopyMethod(self):
         """
-        Test that the copy method creates a deep copy with DotDict conversion.
+        Test the `copy` method for deep copy with DotDict conversion.
+
         Verifies that the copy is independent of the original and maintains DotDict structure.
         """
         original = DotDict({
@@ -98,7 +110,8 @@ class TestDotDict(TestCase):
 
     async def testNestedDictConversion(self):
         """
-        Test that nested dictionaries are automatically converted to DotDict.
+        Test automatic conversion of nested dictionaries to DotDict.
+
         Verifies that nested dicts are converted both during initialization and assignment.
         """
         dd = DotDict({
@@ -120,10 +133,9 @@ class TestDotDict(TestCase):
 
     async def testReprMethod(self):
         """
-        Test that the string representation correctly identifies as DotDict.
-        Verifies that the __repr__ method includes the DotDict prefix.
+        Test the string representation of DotDict.
+
+        Verifies that the `__repr__` method includes the DotDict prefix.
         """
         dd = DotDict({'key': 'value'})
-        self.assertTrue(repr(dd).startswith('DotDict({'))
-        self.assertTrue(repr(dd).endswith('})'))
-        self.assertIn("'key': 'value'", repr(dd))
+        self.assertEqual(repr(dd), "{'key': 'value'}")

tests/testing/test_testing_result.py

@@ -1,6 +1,6 @@
 from orionis.unittesting import TestCase, TestResult, TestStatus
 
-class TestTestResult(TestCase):
+class TestTestingResult(TestCase):
 
     async def testDefaultValues(self) -> None:
         """

tests/testing/test_testing_unit.py

@@ -1,7 +1,7 @@
 from orionis.test.cases.test_case import TestCase
-from orionis.unittesting import UnitTest, ExecutionMode, UnittestTestLoader, UnittestTestSuite, unittest_mock_patch, UnittestMagicMock, UnittestTestResult
+from orionis.unittesting import UnitTest, ExecutionMode, TestLoader, StandardTestSuite, patch, MagicMock, StandardTestResult
 
-class TestUnitTest(TestCase):
+class TestTestingUnit(TestCase):
 
     async def testDefaultConfiguration(self) -> None:
         """
@@ -17,8 +17,8 @@ class TestUnitTest(TestCase):
         self.assertEqual(unit_test.max_workers, 4)
         self.assertFalse(unit_test.fail_fast)
         self.assertTrue(unit_test.print_result)
-        self.assertIsInstance(unit_test.loader, UnittestTestLoader)
-        self.assertIsInstance(unit_test.suite, UnittestTestSuite)
+        self.assertIsInstance(unit_test.loader, TestLoader)
+        self.assertIsInstance(unit_test.suite, StandardTestSuite)
 
     async def testConfigureMethod(self) -> None:
         """
@@ -74,8 +74,8 @@ class TestUnitTest(TestCase):
         returned suite is handled as expected.
         """
         unit_test = UnitTest()
-        with unittest_mock_patch.object(unit_test.loader, 'loadTestsFromName') as mock_load:
-            mock_load.return_value = UnittestTestSuite()
+        with patch.object(unit_test.loader, 'loadTestsFromName') as mock_load:
+            mock_load.return_value = StandardTestSuite()
             result = unit_test.discoverTestsInModule('test_module')
 
             mock_load.assert_called_once_with('test_module')
@@ -100,14 +100,14 @@ class TestUnitTest(TestCase):
         - Asserts that all test cases from nested suites are present in the flattened result.
         """
         unit_test = UnitTest()
-        test_case1 = UnittestMagicMock()
-        test_case2 = UnittestMagicMock()
+        test_case1 = MagicMock()
+        test_case2 = MagicMock()
 
-        nested_suite = UnittestTestSuite()
+        nested_suite = StandardTestSuite()
         nested_suite.addTest(test_case1)
         nested_suite.addTest(test_case2)
 
-        main_suite = UnittestTestSuite()
+        main_suite = StandardTestSuite()
         main_suite.addTest(nested_suite)
 
         flattened = unit_test._flattenTestSuite(main_suite)
@@ -127,8 +127,8 @@ class TestUnitTest(TestCase):
         - Checks that failures and errors are merged without loss of information.
         """
         unit_test = UnitTest()
-        combined = UnittestTestResult()
-        individual = UnittestTestResult()
+        combined = StandardTestResult()
+        individual = StandardTestResult()
 
         individual.testsRun = 2
         individual.failures = [('test1', 'failure')]
@@ -157,7 +157,7 @@ class TestUnitTest(TestCase):
         - The length of the test suite should be zero after calling clearTests.
         """
         unit_test = UnitTest()
-        mock_test = UnittestMagicMock()
+        mock_test = MagicMock()
         unit_test.suite.addTest(mock_test)
 
         unit_test.clearTests()
@@ -175,7 +175,7 @@ class TestUnitTest(TestCase):
         - Asserts that the returned list of test names matches the expected value.
         """
         unit_test = UnitTest()
-        mock_test = UnittestMagicMock()
+        mock_test = MagicMock()
         mock_test.id.return_value = 'test_id'
         unit_test.suite.addTest(mock_test)
 
@@ -198,8 +198,8 @@ class TestUnitTest(TestCase):
         None
         """
         unit_test = UnitTest()
-        mock_test1 = UnittestMagicMock()
-        mock_test2 = UnittestMagicMock()
+        mock_test1 = MagicMock()
+        mock_test2 = MagicMock()
         unit_test.suite.addTest(mock_test1)
         unit_test.suite.addTest(mock_test2)
 

orionis/services/standard/exceptions/path_value_exceptions.py

@@ -1,28 +0,0 @@
-class OrionisStdValueException(Exception):
-    """
-    Exception raised for standard value errors in the Orionis framework.
-
-    Args:
-        msg (str): A detailed message describing the value error.
-
-    Example:
-        raise OrionisStdValueException("Invalid value for parameter 'timeout'.")
-    """
-
-    def __init__(self, msg: str):
-        """
-        Initializes the exception with a custom error message.
-
-        Args:
-            msg (str): The error message describing the exception.
-        """
-        super().__init__(msg)
-
-    def __str__(self) -> str:
-        """
-        Return a string representation of the exception, including the class name and the first argument.
-
-        Returns:
-            str: A formatted string with the exception class name and the first argument.
-        """
-        return f"{self.__class__.__name__}: {self.args[0]}"

tests/services/environment/test_env.py

@@ -1,154 +0,0 @@
-from orionis.services.environment.dot_env import DotEnv
-from orionis.services.environment.env import Env
-from orionis.unittesting import TestCase, unittest_mock_patch
-
-class TestEnv(TestCase):
-    """
-    Test cases for the Env class which provides environment variable management.
-    """
-
-    async def testGetMethod(self):
-        """
-        Test that the get method retrieves values correctly.
-        Verifies that Env.get() properly delegates to DotEnv.get() and returns the expected value.
-        """
-
-        # Set test key in.env
-        Env.set('TEST_KEY', 'test_value')
-
-    async def testGetMethodWithDefault(self):
-        """
-        Test that the get method returns default value when key not found.
-        Verifies that the default parameter is properly passed to DotEnv.get().
-        """
-        with unittest_mock_patch.object(DotEnv, 'get', return_value='default_value') as mock_get:
-            result = Env.get('NON_EXISTENT_KEY', 'default_value')
-            mock_get.assert_called_once_with('NON_EXISTENT_KEY', 'default_value', False)
-            self.assertEqual(result, 'default_value')
-
-    async def testSetMethod(self):
-        """
-        Test that the set method updates environment variables.
-        Verifies that Env.set() properly delegates to DotEnv.set() and returns True on success.
-        """
-        with unittest_mock_patch.object(DotEnv, 'set', return_value=True) as mock_set:
-            result = Env.set('TEST_KEY', 'test_value')
-            mock_set.assert_called_once_with('TEST_KEY', 'test_value', False)
-            self.assertTrue(result)
-
-    async def testUnsetMethod(self):
-        """
-        Test that the unset method removes environment variables.
-        Verifies that Env.unset() properly delegates to DotEnv.unset() and returns True on success.
-        """
-        with unittest_mock_patch.object(DotEnv, 'unset', return_value=True) as mock_unset:
-            result = Env.unset('TEST_KEY')
-            mock_unset.assert_called_once_with('TEST_KEY')
-            self.assertTrue(result)
-
-    async def testAllMethod(self):
-        """
-        Test that the all method retrieves all environment variables.
-        Verifies that Env.all() properly delegates to DotEnv.all() and returns the expected dictionary.
-        """
-        mock_env = {'KEY1': 'value1', 'KEY2': 'value2'}
-        with unittest_mock_patch.object(DotEnv, 'all', return_value=mock_env) as mock_all:
-            result = Env.all()
-            mock_all.assert_called_once()
-            self.assertEqual(result, mock_env)
-
-    async def testToJsonMethod(self):
-        """
-        Test that the toJson method serializes environment variables to JSON.
-        Verifies that Env.toJson() properly delegates to DotEnv.toJson() and returns a JSON string.
-        """
-        mock_json = '{"KEY": "value"}'
-        with unittest_mock_patch.object(DotEnv, 'toJson', return_value=mock_json) as mock_to_json:
-            result = Env.toJson()
-            mock_to_json.assert_called_once()
-            self.assertEqual(result, mock_json)
-
-    async def testToBase64Method(self):
-        """
-        Test that the toBase64 method encodes environment variables in Base64.
-        Verifies that Env.toBase64() properly delegates to DotEnv.toBase64() and returns a Base64 string.
-        """
-        mock_b64 = 'base64encodedstring'
-        with unittest_mock_patch.object(DotEnv, 'toBase64', return_value=mock_b64) as mock_to_b64:
-            result = Env.toBase64()
-            mock_to_b64.assert_called_once()
-            self.assertEqual(result, mock_b64)
-
-    async def testDotenvInstanceManagement(self):
-        """
-        Test that the Env._dotenv() method implements singleton behavior by ensuring
-        that multiple calls return the same instance. Also verifies that resetting
-        Env._dotenv_instance allows for a new instance to be created.
-        """
-
-        # Clear any existing instance
-        Env._dotenv_instance = None
-
-        # First call should create instance
-        instance1 = Env._dotenv()
-        instance2 = Env._dotenv()
-
-        # Verify that the same instance is returned
-        self.assertEqual(instance1, instance2)
-
-    async def testHelperFunctionEnv(self):
-        """
-        Test that the env helper function works correctly.
-        Verifies that the env() function properly delegates to DotEnv.get().
-        """
-        with unittest_mock_patch.object(DotEnv, 'get', return_value='test_value') as mock_get:
-            from orionis.services.environment.env import env
-            result = env('TEST_KEY', 'default_value')
-            mock_get.assert_called_once_with('TEST_KEY', 'default_value')
-            self.assertEqual(result, 'test_value')
-
-    async def testOrionisConstants(self):
-        """
-        Test that Orionis framework constants are correctly set and retrieved via Env.
-
-        This test imports a set of well-known constants from the Orionis framework and ensures:
-        - Each constant can be set as an environment variable using Env.set().
-        - Each constant can be retrieved using Env.get() and matches the original value.
-        - The Env.get() method returns None for a non-existent key.
-        - All constants are present in the dictionary returned by Env.all().
-        """
-        from orionis.metadata.framework import (
-            NAME, VERSION, AUTHOR, AUTHOR_EMAIL, DESCRIPTION,
-            SKELETON, FRAMEWORK, DOCS, API, PYTHON_REQUIRES
-        )
-        constants = {
-            "NAME": NAME,
-            "VERSION": VERSION,
-            "AUTHOR": AUTHOR,
-            "AUTHOR_EMAIL": AUTHOR_EMAIL,
-            "DESCRIPTION": DESCRIPTION,
-            "SKELETON": SKELETON,
-            "FRAMEWORK": FRAMEWORK,
-            "DOCS": DOCS,
-            "API": API,
-            "PYTHON_REQUIRES": PYTHON_REQUIRES
-        }
-
-        # Set all constants as environment variables
-        for key, value in constants.items():
-            result = Env.set(key, value)
-            self.assertTrue(result, f"Env.set() should return True for key '{key}'")
-
-        # Retrieve and verify each constant
-        for key, value in constants.items():
-            retrieved = Env.get(key)
-            self.assertEqual(retrieved, value, f"Env.get('{key}') should return '{value}'")
-
-        # Check that a non-existent key returns None
-        self.assertIsNone(Env.get("NON_EXISTENT_ORIONIS_KEY"), "Env.get() should return None for missing keys")
-
-        # Ensure all constants are present in Env.all()
-        env_all = Env.all()
-        for key, value in constants.items():
-            self.assertIn(key, env_all, f"'{key}' should be present in Env.all()")
-            self.assertEqual(env_all[key], value, f"Env.all()['{key}'] should be '{value}'")