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

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)

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,16 +1,25 @@
-
 from orionis.unittesting import TestCase, TestResult, TestStatus
 
-class TestTestResult(TestCase):
-    """
-    Test cases for the TestResult dataclass.
-    """
+class TestTestingResult(TestCase):
 
-    async def testDefaultValues(self):
+    async def testDefaultValues(self) -> None:
         """
-        Test that TestResult initializes with correct default values for optional fields.
+        Ensures that when optional fields are not provided during initialization of a TestResult
+        instance, they are set to None.
+
+        Notes
+        -----
+        This test verifies the default behavior of the following optional fields:
+            - error_message
+            - traceback
+            - class_name
+            - method
+            - module
+            - file_path
 
-        Verifies that optional fields are None when not provided during initialization.
+        Assertions
+        ----------
+        Each optional field is checked to confirm it is None after initialization.
         """
         result = TestResult(
             id=1,
@@ -25,11 +34,16 @@ class TestTestResult(TestCase):
         self.assertIsNone(result.module)
         self.assertIsNone(result.file_path)
 
-    async def testRequiredFields(self):
+    async def testRequiredFields(self) -> None:
         """
-        Test that TestResult requires all non-optional fields during initialization.
+        Test that TestResult enforces the presence of all required (non-optional) fields during initialization.
+        This test verifies that omitting any required field when creating a TestResult instance raises a TypeError.
 
-        Ensures that missing any required field raises a TypeError.
+        Notes
+        -----
+        - Attempts to instantiate TestResult with no arguments.
+        - Attempts to instantiate TestResult missing the 'id' field.
+        - Expects a TypeError to be raised in both cases.
         """
         with self.assertRaises(TypeError):
             TestResult()  # Missing all required fields
@@ -42,11 +56,21 @@ class TestTestResult(TestCase):
                 execution_time=0.5
             )
 
-    async def testImmutable(self):
+    async def testImmutable(self) -> None:
         """
-        Test that TestResult instances are immutable (frozen dataclass).
+        Test the immutability of TestResult instances.
+        This test ensures that TestResult, implemented as a frozen dataclass, does not allow
+        modification of its attributes after instantiation.
+
+        Parameters
+        ----------
+        self : TestCase
+            The test case instance.
 
-        Verifies that attribute modification after creation raises a FrozenInstanceError.
+        Raises
+        ------
+        FrozenInstanceError
+            If an attempt is made to modify an attribute of a frozen TestResult instance.
         """
         result = TestResult(
             id=1,
@@ -57,11 +81,18 @@ class TestTestResult(TestCase):
         with self.assertRaises(Exception):
             result.name = "Modified Name"
 
-    async def testStatusValues(self):
+    async def testStatusValues(self) -> None:
         """
-        Test that TestResult correctly handles all possible TestStatus values.
+        Parameters
+        ----------
+        self : TestCase
+            The test case instance.
 
-        Verifies that all enum values can be assigned to the status field.
+        Notes
+        -----
+        This test iterates over all possible values of the `TestStatus` enum and verifies
+        that each value can be assigned to the `status` field of a `TestResult` instance.
+        It asserts that the assigned status matches the expected value.
         """
         for status in TestStatus:
             result = TestResult(
@@ -72,11 +103,17 @@ class TestTestResult(TestCase):
             )
             self.assertEqual(result.status, status)
 
-    async def testErrorFields(self):
+    async def testErrorFields(self) -> None:
         """
-        Test that error-related fields are properly stored when provided.
+        Parameters
+        ----------
+        self : TestCase
+            The test case instance.
 
-        Verifies that error_message and traceback are stored correctly when provided.
+        Notes
+        -----
+        Verifies that the `error_message` and `traceback` fields are correctly stored in the `TestResult`
+        object when provided during initialization.
         """
         error_msg = "Test failed"
         traceback = "Traceback info"