orionis 0.546.0__py3-none-any.whl → 0.548.0__py3-none-any.whl

tests/services/system/test_services_system_imports.py

@@ -1,204 +0,0 @@
-import sys
-import types
-from orionis.services.system.imports import Imports
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestServicesSystemImports(AsyncTestCase):
-
-    async def testImportModule(self) -> None:
-        """
-        Tests that an Imports instance can be created and that the collect() method
-        successfully populates its imports list.
-
-        This test verifies the basic instantiation of the Imports class and ensures
-        that the collect() method executes without errors.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-
-        # Create an instance of Imports
-        imports = Imports()
-
-        # Populate the imports list
-        imports.collect()
-
-        # Assert that the instance is of type Imports
-        self.assertIsInstance(imports, Imports)
-
-    async def testCollectPopulatesImports(self):
-        """
-        Tests that the `collect()` method of the Imports class populates the imports list with modules.
-
-        This test creates a dummy module, adds it to `sys.modules`, and verifies that after calling
-        `collect()`, the dummy module appears in the `imports` list of the Imports instance.
-
-        Parameters
-        ----------
-        self : TestServicesSystemImports
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-
-        # Create a dummy module and set its __file__ attribute
-        dummy_mod = types.ModuleType("dummy_mod")
-        dummy_mod.__file__ = __file__
-
-        # Add a dummy function to the module and set its __module__ attribute
-        def dummy_func(): pass
-        dummy_mod.dummy_func = dummy_func
-        dummy_func.__module__ = "dummy_mod"
-
-        # Register the dummy module in sys.modules
-        sys.modules["dummy_mod"] = dummy_mod
-
-        # Create Imports instance and collect imports
-        imports = Imports()
-        imports.collect()
-
-        # Check if the dummy module was collected
-        found = any(imp["name"] == "dummy_mod" for imp in imports.imports)
-        self.assertTrue(found)
-
-        # Cleanup: remove the dummy module from sys.modules
-        del sys.modules["dummy_mod"]
-
-    async def testCollectExcludesStdlibAndSpecialModules(self):
-        """
-        Tests that the `collect()` method of the Imports class excludes standard library modules and special modules.
-
-        This test verifies that after calling `collect()`, the resulting imports list does not contain entries for
-        standard library modules such as `__main__` or modules whose names start with `_distutils`. This ensures
-        that the Imports class correctly filters out modules that should not be included in the imports list.
-
-        Parameters
-        ----------
-        self : TestServicesSystemImports
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-
-        # Create Imports instance and collect imports
-        imports = Imports()
-        imports.collect()
-
-        # Extract the names of collected modules
-        names = [imp["name"] for imp in imports.imports]
-
-        # Assert that '__main__' is not in the collected imports
-        self.assertNotIn("__main__", names)
-
-        # Assert that modules starting with '_distutils' are not in the collected imports
-        self.assertFalse(any(n.startswith("_distutils") for n in names))
-
-    async def testClearEmptiesImports(self):
-        """
-        Tests that the `clear()` method of the Imports class empties the imports list.
-
-        This test manually populates the `imports` attribute of an Imports instance,
-        calls the `clear()` method, and verifies that the imports list is empty afterward.
-
-        Parameters
-        ----------
-        self : TestServicesSystemImports
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-        # Create Imports instance and manually populate the imports list
-        imports = Imports()
-        imports.imports = [{"name": "test", "file": "test.py", "symbols": ["a"]}]
-
-        # Call clear() to empty the imports list
-        imports.clear()
-
-        # Assert that the imports list is now empty
-        self.assertEqual(imports.imports, [])
-
-    async def testCollectHandlesModulesWithoutFile(self):
-        """
-        Tests that the `collect()` method of the Imports class correctly handles modules that do not have a `__file__` attribute.
-
-        This test creates a dummy module without a `__file__` attribute, registers it in `sys.modules`, and verifies that after calling
-        `collect()`, the module does not appear in the `imports` list of the Imports instance. This ensures that the Imports class
-        properly skips modules lacking a `__file__` attribute, which are typically built-in or dynamically created modules.
-
-        Parameters
-        ----------
-        self : TestServicesSystemImports
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-        # Create a dummy module without a __file__ attribute
-        mod = types.ModuleType("mod_without_file")
-        sys.modules["mod_without_file"] = mod
-
-        # Create Imports instance and collect imports
-        imports = Imports()
-        imports.collect()
-
-        # Extract the names of collected modules
-        names = [imp["name"] for imp in imports.imports]
-
-        # Assert that the dummy module is not in the collected imports
-        self.assertNotIn("mod_without_file", names)
-
-        # Cleanup: remove the dummy module from sys.modules
-        del sys.modules["mod_without_file"]
-
-    async def testCollectSkipsBinaryExtensions(self):
-        """
-        Tests that the `collect()` method of the Imports class skips binary extension modules.
-
-        This test creates a dummy module with a `.pyd` file extension (representing a binary extension),
-        registers it in `sys.modules`, and verifies that after calling `collect()`, the module does not
-        appear in the `imports` list of the Imports instance. This ensures that the Imports class
-        properly excludes binary extension modules from its collected imports.
-
-        Parameters
-        ----------
-        self : TestServicesSystemImports
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-
-        # Create a dummy module with a .pyd file extension to simulate a binary extension
-        mod = types.ModuleType("bin_mod")
-        mod.__file__ = "bin_mod.pyd"
-
-        # Register the dummy binary module in sys.modules
-        sys.modules["bin_mod"] = mod
-
-        # Create Imports instance and collect imports
-        imports = Imports()
-        imports.collect()
-
-        # Extract the names of collected modules
-        names = [imp["name"] for imp in imports.imports]
-
-        # Assert that the binary module is not in the collected imports
-        self.assertNotIn("bin_mod", names)
-
-        # Cleanup: remove the dummy binary module from sys.modules
-        del sys.modules["bin_mod"]

tests/services/system/test_services_system_workers.py

@@ -1,131 +0,0 @@
-from unittest.mock import patch
-from orionis.services.system.workers import Workers
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestServicesSystemWorkers(AsyncTestCase):
-
-    @patch('multiprocessing.cpu_count', return_value=8)
-    @patch('psutil.virtual_memory')
-    def testCalculateCpuLimited(self, mockVm, mockCpuCount):
-        """
-        Tests worker calculation when CPU count is the limiting factor.
-
-        Simulates a system with 8 CPUs and 16 GB RAM, where each worker requires 1 GB of RAM.
-        Although the available RAM could support up to 16 workers, the CPU count restricts the number
-        of workers to 8.
-
-        Parameters
-        ----------
-        mockVm : unittest.mock.Mock
-            Mock object for `psutil.virtual_memory`.
-        mockCpuCount : unittest.mock.Mock
-            Mock object for `multiprocessing.cpu_count`.
-
-        Returns
-        -------
-        None
-            Asserts that the calculated number of workers is limited by CPU count.
-        """
-
-        # Set the mocked total RAM to 16 GB
-        mockVm.return_value.total = 16 * 1024 ** 3
-
-        # Create Workers instance with 1 GB RAM required per worker
-        workers = Workers(ram_per_worker=1)
-
-        # Assert that the number of workers is limited to 8 by CPU count
-        self.assertEqual(workers.calculate(), 8)
-
-    @patch('multiprocessing.cpu_count', return_value=32)
-    @patch('psutil.virtual_memory')
-    def testCalculateRamLimited(self, mockVm, mockCpuCount):
-        """
-        Tests worker calculation when RAM is the limiting factor.
-
-        Simulates a system with 32 CPUs and 4 GB RAM, where each worker requires 1 GB of RAM.
-        Although the CPU count could support up to 32 workers, the available RAM restricts the number
-        of workers to 4.
-
-        Parameters
-        ----------
-        mockVm : unittest.mock.Mock
-            Mock object for `psutil.virtual_memory`.
-        mockCpuCount : unittest.mock.Mock
-            Mock object for `multiprocessing.cpu_count`.
-
-        Returns
-        -------
-        None
-            Asserts that the calculated number of workers is limited by available RAM.
-        """
-
-        # Set the mocked total RAM to 4 GB
-        mockVm.return_value.total = 4 * 1024 ** 3
-
-        # Create Workers instance with 1 GB RAM required per worker
-        workers = Workers(ram_per_worker=1)
-
-        # Assert that the number of workers is limited to 4 by available RAM
-        self.assertEqual(workers.calculate(), 4)
-
-    @patch('multiprocessing.cpu_count', return_value=4)
-    @patch('psutil.virtual_memory')
-    def testCalculateExactFit(self, mockVm, mockCpuCount):
-        """
-        Tests worker calculation when both CPU count and available RAM allow for the same number of workers.
-
-        Simulates a system with 4 CPUs and 2 GB RAM, where each worker requires 0.5 GB of RAM.
-        Both CPU and RAM resources permit exactly 4 workers, so the calculation should return 4.
-
-        Parameters
-        ----------
-        mockVm : unittest.mock.Mock
-            Mock object for `psutil.virtual_memory`.
-        mockCpuCount : unittest.mock.Mock
-            Mock object for `multiprocessing.cpu_count`.
-
-        Returns
-        -------
-        None
-            Asserts that the calculated number of workers is 4, matching both CPU and RAM constraints.
-        """
-        # Set the mocked total RAM to 2 GB
-        mockVm.return_value.total = 2 * 1024 ** 3
-
-        # Create Workers instance with 0.5 GB RAM required per worker
-        workers = Workers(ram_per_worker=0.5)
-
-        # Assert that the number of workers is limited to 4 by both CPU and RAM
-        self.assertEqual(workers.calculate(), 4)
-
-    @patch('multiprocessing.cpu_count', return_value=2)
-    @patch('psutil.virtual_memory')
-    def testCalculateLowRam(self, mockVm, mockCpuCount):
-        """
-        Tests worker calculation when available RAM is lower than CPU count, restricting the number of workers.
-
-        Simulates a system with 2 CPUs and 0.7 GB RAM, where each worker requires 0.5 GB of RAM.
-        Although the CPU count could support up to 2 workers, the available RAM restricts the number
-        of workers to 1.
-
-        Parameters
-        ----------
-        mockVm : unittest.mock.Mock
-            Mock object for `psutil.virtual_memory`.
-        mockCpuCount : unittest.mock.Mock
-            Mock object for `multiprocessing.cpu_count`.
-
-        Returns
-        -------
-        None
-            Asserts that the calculated number of workers is limited to 1 by available RAM.
-        """
-
-        # Set the mocked total RAM to 0.7 GB
-        mockVm.return_value.total = 0.7 * 1024 ** 3
-
-        # Create Workers instance with 0.5 GB RAM required per worker
-        workers = Workers(ram_per_worker=0.5)
-
-        # Assert that the number of workers is limited to 1 by available RAM
-        self.assertEqual(workers.calculate(), 1)

tests/support/entities/mock_dataclass.py

@@ -1,40 +0,0 @@
-from dataclasses import dataclass, field
-from enum import Enum
-from orionis.support.entities.base import BaseEntity
-
-class Color(Enum):
-    """Enumeration for available colors."""
-    RED = 1
-    GREEN = 2
-
-@dataclass
-class ExampleEntity(BaseEntity):
-    """
-    Data structure representing an example entity with an identifier, name, color, and tags.
-
-    Parameters
-    ----------
-    id : int, optional
-        Unique identifier for the entity. Default is 0.
-    name : str, optional
-        Name of the entity. Default is 'default'.
-    color : Color, optional
-        Color associated with the entity. Default is Color.RED.
-    tags : list, optional
-        List of tags associated with the entity. Default is an empty list.
-
-    Attributes
-    ----------
-    id : int
-        Unique identifier for the entity.
-    name : str
-        Name of the entity.
-    color : Color
-        Color associated with the entity.
-    tags : list
-        List of tags associated with the entity.
-    """
-    id: int = 0                                                                         # Default id is 0
-    name: str = "default"                                                               # Default name is 'default'
-    color: Color = Color.RED                                                            # Default color is RED
-    tags: list = field(default_factory=list, metadata={"default": ["tag1", "tag2"]})    # Default tags list

tests/support/entities/test_base.py

@@ -1,64 +0,0 @@
-from orionis.test.cases.asynchronous import AsyncTestCase
-from tests.support.entities.mock_dataclass import Color, ExampleEntity
-
-class TestBaseEntity(AsyncTestCase):
-
-    async def asyncSetUp(self):
-        """
-        Asynchronously initializes the test environment before each test.
-
-        Initializes an ExampleEntity instance with predefined attributes and assigns it to self.entity.
-
-        Returns
-        -------
-        None
-        """
-        # Create an ExampleEntity instance for use in tests
-        self.entity = ExampleEntity(id=42, name="test", color=Color.GREEN, tags=["a", "b"])
-
-    async def testToDict(self):
-        """
-        Tests the toDict method of ExampleEntity.
-
-        Verifies that toDict returns a dictionary with correct field values for the entity.
-
-        Returns
-        -------
-        None
-        """
-        # Convert entity to dictionary
-        result = self.entity.toDict()
-        self.assertIsInstance(result, dict)
-
-        # Check individual field values
-        self.assertEqual(result["id"], 42)
-        self.assertEqual(result["name"], "test")
-        self.assertEqual(result["color"], Color.GREEN)
-        self.assertEqual(result["tags"], ["a", "b"])
-
-    async def testGetFields(self):
-        """
-        Tests the getFields method of ExampleEntity.
-
-        Ensures getFields returns a list of dictionaries, each containing field name, types, default value, and metadata.
-
-        Returns
-        -------
-        None
-        """
-        # Retrieve field information from entity
-        fields_info = self.entity.getFields()
-        self.assertIsInstance(fields_info, list)
-
-        # Extract field names for verification
-        names = [f["name"] for f in fields_info]
-        self.assertIn("id", names)
-        self.assertIn("name", names)
-        self.assertIn("color", names)
-        self.assertIn("tags", names)
-
-        # Check that each field info contains required keys
-        for f in fields_info:
-            self.assertIn("types", f)
-            self.assertIn("default", f)
-            self.assertIn("metadata", f)

tests/support/patterns/singleton/test_patterns_singleton.py

@@ -1,39 +0,0 @@
-from orionis.support.patterns.singleton import Singleton
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestPatternsSingleton(AsyncTestCase):
-
-    async def testSingleton(self):
-        """
-        Test the Singleton metaclass to ensure only one instance is created.
-
-        This test verifies that a class using the Singleton metaclass will always return
-        the same instance, regardless of how many times it is instantiated. It also checks
-        that the initial state of the singleton instance does not change after subsequent
-        instantiations with different arguments.
-
-        Parameters
-        ----------
-        self : TestPatternsSingleton
-            Instance of the test case.
-
-        Returns
-        -------
-        None
-        """
-        # Define a class using the Singleton metaclass
-        class SingletonClass(metaclass=Singleton):
-            def __init__(self, value):
-                self.value = value
-
-        # Create the first instance of SingletonClass
-        instance1 = SingletonClass(1)
-
-        # Attempt to create a second instance with a different value
-        instance2 = SingletonClass(2)
-
-        # Assert that both instances are actually the same object
-        self.assertIs(instance1, instance2)
-
-        # Assert that the value remains as set by the first instantiation
-        self.assertEqual(instance1.value, 1)