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

tests/foundation/config/startup/{test_config_startup.py → test_foundation_config_startup.py}

@@ -1,9 +1,9 @@
 from dataclasses import is_dataclass
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.foundation.config.startup import Configuration
-from orionis.unittesting import TestCase, UnittestMock
+from orionis.unittesting import TestCase, Mock
 
-class TestConfiguration(TestCase):
+class TestFoundationConfigStartup(TestCase):
     """
     Test suite for the Configuration dataclass.
 
@@ -98,18 +98,18 @@ class TestConfiguration(TestCase):
 
         # Test each section with wrong type
         sections = [
-            ('paths', UnittestMock()),
-            ('app', UnittestMock()),
-            ('auth', UnittestMock()),
-            ('cache', UnittestMock()),
-            ('cors', UnittestMock()),
-            ('database', UnittestMock()),
-            ('filesystems', UnittestMock()),
-            ('logging', UnittestMock()),
-            ('mail', UnittestMock()),
-            ('queue', UnittestMock()),
-            ('session', UnittestMock()),
-            ('testing', UnittestMock())
+            ('paths', Mock()),
+            ('app', Mock()),
+            ('auth', Mock()),
+            ('cache', Mock()),
+            ('cors', Mock()),
+            ('database', Mock()),
+            ('filesystems', Mock()),
+            ('logging', Mock()),
+            ('mail', Mock()),
+            ('queue', Mock()),
+            ('session', Mock()),
+            ('testing', Mock())
         ]
 
         for section_name, wrong_value in sections:

tests/foundation/config/testing/{test_testing.py → test_foundation_config_testing.py}

@@ -3,7 +3,7 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.test.enums.test_mode import ExecutionMode
 from orionis.unittesting import TestCase
 
-class TestTestingConfig(TestCase):
+class TestFoundationConfigTesting(TestCase):
     """
     Test suite for the Testing configuration entity.
 

tests/patterns/singleton/{test_singleton.py → test_patterns_singleton.py}

@@ -1,7 +1,7 @@
 from orionis.patterns.singleton.meta_class import Singleton
 from orionis.test.cases.test_case import TestCase
 
-class TestsAsyncCoroutine(TestCase):
+class TestPatternsSingleton(TestCase):
     """
     Test cases for the Singleton metaclass.
 

tests/services/asynchrony/{test_async_io.py → test_services_asynchrony_coroutine.py}

@@ -3,7 +3,7 @@ from orionis.services.asynchrony.coroutines import Coroutine
 from orionis.services.asynchrony.exceptions.coroutine_exception import OrionisCoroutineException
 from orionis.unittesting import TestCase
 
-class TestsAsyncIO(TestCase):
+class TestServicesAsynchronyCoroutine(TestCase):
 
     async def testExecuteWithActiveEventLoop(self):
         """

tests/services/environment/test_services_environment.py

@@ -0,0 +1,93 @@
+from orionis.services.environment.env import Env
+from orionis.unittesting import TestCase
+
+class TestServicesEnvironment(TestCase):
+
+    async def testSetAndGetConstants(self):
+        """
+        Test storing and retrieving framework metadata constants using Env.set and Env.get.
+
+        Imports several metadata constants from the `orionis.metadata.framework` module, sets each constant
+        in the Env storage using `Env.set`, and verifies that the operation succeeds. Then retrieves each
+        constant using `Env.get` and asserts that the retrieved value matches the original constant.
+
+        Ensures
+        -------
+        - `Env.set` returns True for each constant.
+        - `Env.get` returns the correct value for each constant.
+        """
+        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
+        }
+        for key, value in constants.items():
+            result = Env.set(key, value)
+            self.assertTrue(result)
+        for key, value in constants.items():
+            retrieved = Env.get(key)
+            self.assertEqual(retrieved, value)
+
+    async def testGetNonExistentKey(self):
+        """
+        Test that Env.get returns None for a non-existent environment key.
+
+        Ensures
+        -------
+        - `Env.get` returns None when the key does not exist.
+        """
+        self.assertIsNone(Env.get("NON_EXISTENT_KEY"))
+
+    async def testTypeHints(self):
+        """
+        Test that Env.set and Env.get correctly handle and preserve Python type hints.
+
+        Sets environment variables with various data types (int, float, bool, str, list, dict, tuple, set)
+        using the `Env.set` method, specifying the type as a string. Then retrieves each variable using
+        `Env.get` and asserts that the returned value is of the expected Python type.
+
+        Ensures
+        -------
+        - The returned value from `Env.get` matches the expected Python type for each variable.
+        """
+
+        # Set environment variables with type hints
+        Env.set("TEST_INT", 42, 'int')
+        Env.set("TEST_FLOAT", 3.14, 'float')
+        Env.set("TEST_BOOL", True, 'bool')
+        Env.set("TEST_STR", "Hello, World!", 'str')
+        Env.set("TEST_LIST", [1, 2, 3], 'list')
+        Env.set("TEST_DICT", {"key": "value"}, 'dict')
+        Env.set("TEST_TUPLE", (1,2,3), 'tuple')
+        Env.set("TEST_SET", {1, 2, 3}, 'set')
+
+        # Retrieve and check types
+        self.assertIsInstance(Env.get("TEST_INT"), int)
+        self.assertIsInstance(Env.get("TEST_FLOAT"), float)
+        self.assertIsInstance(Env.get("TEST_BOOL"), bool)
+        self.assertIsInstance(Env.get("TEST_STR"), str)
+        self.assertIsInstance(Env.get("TEST_LIST"), list)
+        self.assertIsInstance(Env.get("TEST_DICT"), dict)
+        self.assertIsInstance(Env.get("TEST_TUPLE"), tuple)
+        self.assertIsInstance(Env.get("TEST_SET"), set)
+
+        # Clean up environment variables after test
+        Env.unset("TEST_INT")
+        Env.unset("TEST_FLOAT")
+        Env.unset("TEST_BOOL")
+        Env.unset("TEST_STR")
+        Env.unset("TEST_LIST")
+        Env.unset("TEST_DICT")
+        Env.unset("TEST_TUPLE")
+        Env.unset("TEST_SET")

tests/services/path/{test_resolver.py → test_services_resolver.py}

@@ -1,27 +1,42 @@
-import tempfile
 import os
+import tempfile
 from pathlib import Path
+from orionis.services.paths.exceptions.not_found_exceptions import OrionisFileNotFoundException
 from orionis.services.paths.resolver import Resolver
 from orionis.unittesting import TestCase
 
-class TestsResolver(TestCase):
-    """
-    Unit tests for the Resolver class, which resolves file and directory paths relative to a base directory.
-    """
+class TestServicesResolver(TestCase):
 
-    async def test_file_not_found(self):
+    async def testFileNotFound(self):
         """
-        Test that resolving a non-existent file path raises FileNotFoundError.
+        Test that resolving a non-existent file path raises OrionisFileNotFoundException.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisFileNotFoundException
+            If the file does not exist.
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             resolver = Resolver(tmpdir)
             non_existent = "does_not_exist.txt"
-            with self.assertRaises(FileNotFoundError):
+            with self.assertRaises(OrionisFileNotFoundException):
                 resolver.relativePath(non_existent)
 
-    async def test_valid_file_path(self):
+    async def testValidFilePath(self):
         """
         Test that resolving a valid file path returns the correct absolute path.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        The resolved path ends with the file name and is absolute.
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             # Create a temporary file inside the temp directory
@@ -34,9 +49,17 @@ class TestsResolver(TestCase):
             # The resolved path should be absolute
             self.assertTrue(os.path.isabs(resolved))
 
-    async def test_valid_directory_path(self):
+    async def testValidDirectoryPath(self):
         """
         Test that resolving a valid directory path returns the correct absolute path.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        The resolved path ends with the directory name and is absolute.
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             # Create a subdirectory inside the temp directory
@@ -47,9 +70,17 @@ class TestsResolver(TestCase):
             self.assertTrue(resolved.endswith("subdir"))
             self.assertTrue(os.path.isabs(resolved))
 
-    async def test_other_base_path(self):
+    async def testOtherBasePath(self):
         """
         Test that providing a different base path to Resolver works as expected.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        The resolved path ends with the file name and is absolute.
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             # Create a file in a subdirectory
@@ -62,9 +93,17 @@ class TestsResolver(TestCase):
             self.assertTrue(resolved.endswith("file.txt"))
             self.assertTrue(os.path.isabs(resolved))
 
-    async def test_equal_output_string(self):
+    async def testEqualOutputString(self):
         """
         Test that the string representation of the resolved path matches the output of toString().
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        The string representation of the resolved path matches the output of toString().
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             file_path = Path(tmpdir) / "file.txt"

tests/services/standard/{test_std.py → test_services_std.py}

@@ -1,14 +1,16 @@
-
+from orionis.services.standard.exceptions.std_value_exception import OrionisStdValueException
 from orionis.services.standard.std import StdClass
 from orionis.unittesting import TestCase
 
-class TestStdClass(TestCase):
+class TestServicesStd(TestCase):
 
     async def testInitializationAndAccess(self):
         """
         Test the initialization of StdClass and access to its attributes.
 
-        This test verifies that an instance of StdClass can be created with the given
+        Notes
+        -----
+        Verifies that an instance of StdClass can be created with the given
         first name, last name, and age, and that these attributes can be accessed
         correctly after initialization.
         """
@@ -24,7 +26,9 @@ class TestStdClass(TestCase):
         """
         Test that the toDict method of StdClass returns a dictionary with the correct data.
 
-        This test creates an instance of StdClass with specific attributes and verifies
+        Notes
+        -----
+        Creates an instance of StdClass with specific attributes and verifies
         that calling toDict() returns a dictionary containing those attributes and their values.
         """
         obj = StdClass(a=1, b=2)
@@ -35,7 +39,9 @@ class TestStdClass(TestCase):
         """
         Test that the `update` method of `StdClass` correctly sets multiple attributes.
 
-        This test creates an instance of `StdClass`, updates its attributes using the `update` method,
+        Notes
+        -----
+        Creates an instance of `StdClass`, updates its attributes using the `update` method,
         and asserts that the attributes `foo` and `number` are set to the expected values.
         """
         obj = StdClass()
@@ -47,27 +53,36 @@ class TestStdClass(TestCase):
         """
         Test that updating a reserved attribute (such as '__init__') on a StdClass instance
         raises a ValueError exception.
+
+        Notes
+        -----
+        Ensures that updating a reserved attribute raises an OrionisStdValueException.
         """
         obj = StdClass()
-        with self.assertRaises(ValueError):
+        with self.assertRaises(OrionisStdValueException):
             obj.update(__init__='bad')
 
     async def testUpdateConflictingAttributeRaisesError(self):
         """
         Test that updating an object with a conflicting attribute name ('toDict') raises a ValueError.
 
-        This test ensures that attempting to update the StdClass instance with a keyword argument
+        Notes
+        -----
+        Ensures that attempting to update the StdClass instance with a keyword argument
         that conflicts with an existing method or reserved attribute ('toDict') correctly triggers
-        a ValueError, enforcing attribute safety.
+        an OrionisStdValueException, enforcing attribute safety.
         """
         obj = StdClass()
-        with self.assertRaises(ValueError):
+        with self.assertRaises(OrionisStdValueException):
             obj.update(toDict='oops')
 
     async def testRemoveExistingAttributes(self):
         """
-        Tests that the `remove` method of `StdClass` successfully removes an existing attribute ('x') from the object,
-        while leaving other attributes ('y') intact.
+        Test that the `remove` method of `StdClass` successfully removes an existing attribute.
+
+        Notes
+        -----
+        Removes attribute 'x' from the object and checks that 'y' remains.
         """
         obj = StdClass(x=1, y=2)
         obj.remove('x')
@@ -78,7 +93,9 @@ class TestStdClass(TestCase):
         """
         Test that attempting to remove a non-existing attribute from a StdClass instance raises an AttributeError.
 
-        This test verifies that the `remove` method of `StdClass` correctly raises an AttributeError
+        Notes
+        -----
+        Verifies that the `remove` method of `StdClass` raises an AttributeError
         when called with the name of an attribute that does not exist on the object.
         """
         obj = StdClass()
@@ -89,20 +106,23 @@ class TestStdClass(TestCase):
         """
         Test that StdClass.from_dict creates an instance equivalent to the original data.
 
-        This test verifies that when a dictionary is passed to StdClass.from_dict,
+        Notes
+        -----
+        Verifies that when a dictionary is passed to StdClass.from_dict,
         the resulting object's toDict() method returns a dictionary equal to the original input.
         """
         data = {'a': 10, 'b': 20}
-        obj = StdClass.from_dict(data)
+        obj = StdClass.fromDict(data)
         self.assertEqual(obj.toDict(), data)
 
     async def testReprAndStr(self):
         """
         Test that the __repr__ and __str__ methods of StdClass include the class name and the value of 'x' respectively.
 
-        This test verifies:
-        - The string representation produced by repr(obj) contains the class name 'StdClass'.
-        - The string representation produced by str(obj) contains the key-value pair "'x': 5".
+        Notes
+        -----
+        - Checks that repr(obj) contains the class name 'StdClass'.
+        - Checks that str(obj) contains the key-value pair "'x': 5".
         """
         obj = StdClass(x=5)
         self.assertIn("StdClass", repr(obj))
@@ -110,15 +130,18 @@ class TestStdClass(TestCase):
 
     async def testEquality(self):
         """
-        Tests the equality and inequality operations for StdClass instances.
+        Test the equality and inequality operations for StdClass instances.
 
-        This test creates three instances of StdClass:
+        Notes
+        -----
+        Creates three instances of StdClass:
         - 'a' and 'b' with identical attributes (x=1, y=2), which should be considered equal.
         - 'c' with a different attribute (x=3), which should not be equal to 'a'.
 
-        Assertions:
-        - Verifies that 'a' and 'b' are equal.
-        - Verifies that 'a' and 'c' are not equal.
+        Asserts
+        -------
+        - 'a' and 'b' are equal.
+        - 'a' and 'c' are not equal.
         """
         a = StdClass(x=1, y=2)
         b = StdClass(x=1, y=2)

tests/services/system/test_services_system_imports.py

@@ -0,0 +1,101 @@
+from orionis.services.system.imports import Imports
+from orionis.unittesting import TestCase
+import sys
+import types
+
+class TestServicesSystemImports(TestCase):
+
+    def testImportModule(self) -> None:
+        """
+        Test that Imports can be instantiated and collected.
+
+        Returns
+        -------
+        None
+        """
+        imports = Imports()
+        imports.collect()
+        self.assertIsInstance(imports, Imports)
+
+    def testCollectPopulatesImports(self):
+        """
+        Test that collect() populates the imports list with modules.
+
+        Returns
+        -------
+        None
+        """
+        dummy_mod = types.ModuleType("dummy_mod")
+        dummy_mod.__file__ = __file__
+        def dummy_func(): pass
+        dummy_mod.dummy_func = dummy_func
+        dummy_func.__module__ = "dummy_mod"
+        sys.modules["dummy_mod"] = dummy_mod
+
+        imports = Imports()
+        imports.collect()
+        found = any(imp["name"] == "dummy_mod" for imp in imports.imports)
+        self.assertTrue(found)
+
+        # Cleanup
+        del sys.modules["dummy_mod"]
+
+    def testCollectExcludesStdlibAndSpecialModules(self):
+        """
+        Test that collect() excludes standard library and special modules.
+
+        Returns
+        -------
+        None
+        """
+        imports = Imports()
+        imports.collect()
+        names = [imp["name"] for imp in imports.imports]
+        self.assertNotIn("__main__", names)
+        self.assertFalse(any(n.startswith("_distutils") for n in names))
+
+    def testClearEmptiesImports(self):
+        """
+        Test that clear() empties the imports list.
+
+        Returns
+        -------
+        None
+        """
+        imports = Imports()
+        imports.imports = [{"name": "test", "file": "test.py", "symbols": ["a"]}]
+        imports.clear()
+        self.assertEqual(imports.imports, [])
+
+    def testCollectHandlesModulesWithoutFile(self):
+        """
+        Test that collect() handles modules without a __file__ attribute.
+
+        Returns
+        -------
+        None
+        """
+        mod = types.ModuleType("mod_without_file")
+        sys.modules["mod_without_file"] = mod
+        imports = Imports()
+        imports.collect()
+        names = [imp["name"] for imp in imports.imports]
+        self.assertNotIn("mod_without_file", names)
+        del sys.modules["mod_without_file"]
+
+    def testCollectSkipsBinaryExtensions(self):
+        """
+        Test that collect() skips binary extension modules.
+
+        Returns
+        -------
+        None
+        """
+        mod = types.ModuleType("bin_mod")
+        mod.__file__ = "bin_mod.pyd"
+        sys.modules["bin_mod"] = mod
+        imports = Imports()
+        imports.collect()
+        names = [imp["name"] for imp in imports.imports]
+        self.assertNotIn("bin_mod", names)
+        del sys.modules["bin_mod"]

tests/services/system/test_services_system_workers.py

@@ -0,0 +1,89 @@
+from orionis.services.system.workers import Workers
+from orionis.unittesting import TestCase, patch
+
+class TestServicesSystemWorkers(TestCase):
+    """
+    Unit tests for the Workers class.
+
+    This test suite verifies the correct calculation of the number of workers
+    based on available CPU and RAM resources.
+
+    Methods
+    -------
+    testCalculateCpuLimited()
+        Test when the number of workers is limited by CPU count.
+    testCalculateRamLimited()
+        Test when the number of workers is limited by available RAM.
+    testCalculateExactFit()
+        Test when CPU and RAM allow for the same number of workers.
+    testCalculateLowRam()
+        Test when low RAM restricts the number of workers to less than CPU count.
+    """
+
+    @patch('multiprocessing.cpu_count', return_value=8)
+    @patch('psutil.virtual_memory')
+    def testCalculateCpuLimited(self, mockVm, mockCpuCount):
+        """
+        Test when the number of workers is limited by CPU count.
+
+        Simulates 8 CPUs and 16 GB RAM, with ram_per_worker=1.
+        RAM allows 16 workers, but CPU only allows 8.
+
+        Returns
+        -------
+        None
+        """
+        mockVm.return_value.total = 16 * 1024 ** 3
+        workers = Workers(ram_per_worker=1)
+        self.assertEqual(workers.calculate(), 8)
+
+    @patch('multiprocessing.cpu_count', return_value=32)
+    @patch('psutil.virtual_memory')
+    def testCalculateRamLimited(self, mockVm, mockCpuCount):
+        """
+        Test when the number of workers is limited by available RAM.
+
+        Simulates 32 CPUs and 4 GB RAM, with ram_per_worker=1.
+        RAM allows only 4 workers.
+
+        Returns
+        -------
+        None
+        """
+        mockVm.return_value.total = 4 * 1024 ** 3
+        workers = Workers(ram_per_worker=1)
+        self.assertEqual(workers.calculate(), 4)
+
+    @patch('multiprocessing.cpu_count', return_value=4)
+    @patch('psutil.virtual_memory')
+    def testCalculateExactFit(self, mockVm, mockCpuCount):
+        """
+        Test when CPU and RAM allow for the same number of workers.
+
+        Simulates 4 CPUs and 2 GB RAM, with ram_per_worker=0.5.
+        RAM allows 4 workers.
+
+        Returns
+        -------
+        None
+        """
+        mockVm.return_value.total = 2 * 1024 ** 3
+        workers = Workers(ram_per_worker=0.5)
+        self.assertEqual(workers.calculate(), 4)
+
+    @patch('multiprocessing.cpu_count', return_value=2)
+    @patch('psutil.virtual_memory')
+    def testCalculateLowRam(self, mockVm, mockCpuCount):
+        """
+        Test when low RAM restricts the number of workers to less than CPU count.
+
+        Simulates 2 CPUs and 0.7 GB RAM, with ram_per_worker=0.5.
+        RAM allows only 1 worker.
+
+        Returns
+        -------
+        None
+        """
+        mockVm.return_value.total = 0.7 * 1024 ** 3
+        workers = Workers(ram_per_worker=0.5)
+        self.assertEqual(workers.calculate(), 1)