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

tests/container/core/test_container.py

@@ -1,453 +0,0 @@
-from orionis.container.container import Container
-from orionis.container.facades.facade import Facade
-from orionis.foundation.application import Application
-from orionis.test.cases.asynchronous import AsyncTestCase
-from tests.container.mocks.mock_simple_classes import Car, ICar
-
-class TestContainer(AsyncTestCase):
-
-    async def testTransientRegistration(self) -> None:
-        """
-        Tests the transient registration of a service in the container.
-
-        This method verifies the following behaviors:
-            - The `container.transient()` method correctly registers a transient binding from an abstract type (`ICar`) to a concrete implementation (`Car`).
-            - Each call to `container.make(ICar)` returns a new instance of `Car`, confirming transient behavior.
-            - The resolved instances are of the correct type (`Car`), and each instance is a distinct object.
-
-        Parameters
-        ----------
-        self : TestContainer
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate expected behavior.
-
-        Notes
-        -----
-        After the test, the registration for `ICar` is dropped from the container to clean up.
-        """
-
-        # Create a new container instance
-        container = Container()
-
-        # Register ICar as a transient binding to Car
-        container.transient(ICar, Car)
-
-        # Resolve two instances of ICar (should be different objects)
-        instance1 = container.make(ICar)
-        instance2 = container.make(ICar)
-
-        # Assert both instances are of type Car
-        self.assertIsInstance(instance1, Car)
-        self.assertIsInstance(instance2, Car)
-
-        # Assert that the instances are not the same object (transient behavior)
-        self.assertIsNot(instance1, instance2)
-
-        # Clean up registration
-        container.drop(abstract=ICar)
-
-    async def testSingletonRegistration(self) -> None:
-        """
-        Tests singleton registration and resolution from the container.
-
-        This method ensures:
-            - A class (`Car`) can be registered as a singleton implementation of an interface (`ICar`).
-            - The container returns an instance of the registered implementation.
-            - Multiple requests for the same interface return the same instance, confirming singleton behavior.
-
-        Parameters
-        ----------
-        self : TestContainer
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate expected behavior.
-
-        Notes
-        -----
-        The registration for `ICar` is dropped after the test.
-        """
-
-        # Create a new container instance
-        container = Container()
-
-        # Register ICar as a singleton binding to Car
-        container.singleton(ICar, Car)
-
-        # Resolve two instances of ICar (should be the same object)
-        instance1 = container.make(ICar)
-        instance2 = container.make(ICar)
-
-        # Assert both instances are of type Car
-        self.assertIsInstance(instance1, Car)
-        self.assertIsInstance(instance2, Car)
-
-        # Assert that both instances are the same object (singleton behavior)
-        self.assertIs(instance1, instance2)
-
-        # Clean up registration
-        container.drop(abstract=ICar)
-
-    async def testScopedRegistration(self) -> None:
-        """
-        Tests the scoped registration functionality of the container.
-
-        This method verifies:
-            - Within a single context, scoped registrations return the same instance when the same interface is requested multiple times.
-            - Different contexts produce different instances of the same registration.
-
-        Parameters
-        ----------
-        self : TestContainer
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate expected behavior.
-
-        Notes
-        -----
-        The registration for `ICar` is dropped after the test.
-        """
-
-        # Create a new container instance
-        container = Container()
-
-        # First context: instances should be the same
-        with container.createContext():
-            container.scoped(ICar, Car)
-            instance1 = container.make(ICar)
-            instance2 = container.make(ICar)
-
-            self.assertIsInstance(instance1, Car)
-            self.assertIsInstance(instance2, Car)
-            self.assertIs(instance1, instance2)
-
-        # Second context: instance should be different from previous context
-        with container.createContext():
-            container.scoped(ICar, Car)
-            instance3 = container.make(ICar)
-            self.assertIsNot(instance1, instance3)
-
-        # Clean up registration
-        container.drop(abstract=ICar)
-
-    async def testInstanceRegistration(self) -> None:
-        """
-        Tests instance registration in the container.
-
-        This method ensures:
-            - When an instance is registered to a service in the container, the container returns exactly the same instance when resolving that service.
-
-        Parameters
-        ----------
-        self : TestContainer
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate expected behavior.
-
-        Notes
-        -----
-        The registration for `ICar` is dropped after the test.
-        """
-
-        # Create a specific instance of Car
-        car_instance = Car()
-        container = Container()
-
-        # Register a specific instance of Car to ICar
-        container.instance(ICar, car_instance)
-
-        # Resolve ICar and check that it returns the same instance
-        resolved = container.make(ICar)
-        self.assertIs(resolved, car_instance)
-
-        # Clean up registration
-        container.drop(abstract=ICar)
-
-    async def testCallableRegistration(self) -> None:
-        """
-        Tests that callables can be registered and resolved from the container.
-
-        This method verifies:
-            - Functions can be registered in the container using the `callable()` method.
-            - Registered functions can be resolved and executed using the `make()` method.
-            - Arguments can be passed to the resolved functions as positional and keyword arguments.
-
-        Parameters
-        ----------
-        self : TestContainer
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate expected behavior.
-
-        Notes
-        -----
-        The registrations for 'add' and 'multiply' are dropped after the test.
-        """
-
-        # Define some simple functions to register
-        def add(a: int, b: int) -> int:
-            return a + b
-
-
-        # Define another function to register
-        def multiply(a: int, b: int) -> int:
-            return a * b
-
-        # Create a new container instance
-        container = Container()
-
-        # Register callables
-        container.callable('add', add)
-        container.callable('multiply', multiply)
-
-        # Test resolution and execution with positional and keyword arguments
-        self.assertEqual(container.make('add', 1, 2), 3)
-        self.assertEqual(container.make('multiply', 3, 4), 12)
-        self.assertEqual(container.make('add', a=5, b=7), 12)
-
-        # Clean up registrations
-        container.drop(alias='add')
-        container.drop(alias='multiply')
-
-    async def testTransientFacade(self) -> None:
-        """
-        Tests transient instance resolution using the Facade pattern.
-
-        This method validates:
-            - The container can register a transient binding between an interface and a class.
-            - The Facade pattern correctly resolves instances of the registered interface.
-            - Multiple calls to the Facade's `resolve()` method return different instances, confirming transient behavior.
-
-        Parameters
-        ----------
-        self : TestContainer
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate expected behavior.
-
-        Notes
-        -----
-        The registration for `ICar` is dropped after the test.
-        """
-
-        # Create a new container instance
-        container = Application()
-
-        # Register ICar as a transient binding to Car
-        container.transient(ICar, Car)
-
-        # Define a Facade class to access the ICar binding
-        class CarFacade(Facade):
-            @classmethod
-            def getFacadeAccessor(cls):
-                return ICar
-
-        # Resolve two instances via Facade (should be different objects)
-        instance1 = CarFacade.resolve()
-        instance2 = CarFacade.resolve()
-
-        self.assertIsInstance(instance1, Car)
-        self.assertIsInstance(instance2, Car)
-        self.assertIsNot(instance1, instance2)
-
-        # Clean up registration
-        container.drop(abstract=ICar)
-
-    async def testSingletonFacade(self) -> None:
-        """
-        Tests singleton instance resolution using the Facade pattern.
-
-        This method verifies:
-            - A singleton binding can be registered in the container.
-            - A Facade class can be created to access this binding.
-            - Multiple resolutions through the Facade return the same instance, confirming singleton behavior.
-            - The resolved instances are of the correct type (`Car`).
-
-        Parameters
-        ----------
-        self : TestContainer
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate expected behavior.
-
-        Notes
-        -----
-        The registration for `ICar` is dropped after the test.
-        """
-
-        # Create a new container instance
-        container = Application()
-
-        # Register ICar as a singleton binding to Car
-        container.singleton(ICar, Car)
-
-        # Define a Facade class to access the ICar binding
-        class CarFacade(Facade):
-            @classmethod
-            def getFacadeAccessor(cls):
-                return ICar
-
-        # Resolve two instances via Facade (should be the same object)
-        instance1 = CarFacade.resolve()
-        instance2 = CarFacade.resolve()
-
-        # Assert both instances are of type Car and are the same object
-        self.assertIsInstance(instance1, Car)
-        self.assertIsInstance(instance2, Car)
-        self.assertIs(instance1, instance2)
-
-        # Clean up registration
-        container.drop(abstract=ICar)
-
-    async def testScopedFacade(self) -> None:
-        """
-        Tests the functionality of a Facade accessing a scoped service within a container context.
-
-        This method verifies:
-            - The Facade can properly resolve a scoped service.
-            - Multiple resolves within the same scope return the same instance, confirming scoped behavior.
-            - The resolved instance is of the correct type (`Car`).
-
-        Parameters
-        ----------
-        self : TestContainer
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate expected behavior.
-
-        Notes
-        -----
-        The registration for `ICar` is dropped after the test.
-        """
-
-        # Create a new container instance
-        container = Application()
-
-        # Create a new scope/context
-        with container.createContext():
-
-            # Register ICar as a scoped binding to Car
-            container.scoped(ICar, Car)
-
-            # Define a Facade class to access the ICar binding
-            class CarFacade(Facade):
-                @classmethod
-                def getFacadeAccessor(cls):
-                    return ICar
-
-            # Resolve two instances via Facade (should be the same object within the scope)
-            instance1 = CarFacade.resolve()
-            instance2 = CarFacade.resolve()
-
-            # Assert both instances are of type Car and are the same object
-            self.assertIsInstance(instance1, Car)
-            self.assertIsInstance(instance2, Car)
-            self.assertIs(instance1, instance2)
-
-        # Clean up registration
-        container.drop(abstract=ICar)
-
-    async def testResolvingUnregisteredType(self) -> None:
-        """
-        Tests that attempting to resolve an unregistered type from the container raises an exception.
-
-        This method ensures:
-            - The container correctly validates that a type is registered before attempting to resolve it.
-            - An exception is raised when attempting to resolve an unregistered type.
-
-        Parameters
-        ----------
-        self : TestContainer
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate expected behavior.
-
-        Raises
-        ------
-        Exception
-            Raised when attempting to resolve an unregistered type.
-        """
-
-        # Create a new container instance
-        container = Container()
-
-        # Attempt to resolve an unregistered type; should raise Exception
-        with self.assertRaises(Exception):
-            container.make('ICar')
-
-    async def testOverridingRegistration(self) -> None:
-        """
-        Tests the ability of the container to override existing registrations.
-
-        This method verifies:
-            - When a class is registered as a singleton for an interface.
-            - A different class can later be registered for the same interface.
-            - The container returns the new class when resolving the interface.
-            - The new instance is different from the previous instance, confirming the override.
-
-        Parameters
-        ----------
-        self : TestContainer
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate expected behavior.
-
-        Notes
-        -----
-        The registration for `ICar` is dropped after the test.
-        """
-
-        # Create a new container instance
-        class SportsCar(Car):
-            def start(self):
-                return f"{self.brand} {self.model} is starting."
-            def stop(self):
-                return f"{self.brand} {self.model} is stopping."
-
-        # Create a new container instance
-        container = Container()
-
-        # Register ICar as a singleton binding to Car
-        container.singleton(ICar, Car)
-        first = container.make(ICar)
-        self.assertIsInstance(first, Car)
-        self.assertNotIsInstance(first, SportsCar)
-
-        # Override registration: register ICar as a singleton binding to SportsCar
-        container.singleton(ICar, SportsCar)
-        second = container.make(ICar)
-        self.assertIsInstance(second, SportsCar)
-        self.assertIsNot(first, second)
-
-        # Clean up registration
-        container.drop(abstract=ICar)

tests/container/core/test_singleton.py

@@ -1,122 +0,0 @@
-import threading
-import time
-from orionis.foundation.application import Application as Orionis
-from orionis.container.container import Container
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestSingleton(AsyncTestCase):
-
-    async def testSingletonBasicFunctionality(self) -> None:
-        """
-        Tests the fundamental behavior of the singleton pattern for `Container` and `Orionis` classes.
-
-        This method verifies the following:
-        - Multiple instances of `Container` refer to the same object.
-        - Multiple instances of `Orionis` refer to the same object.
-        - The singleton instances of `Container` and `Orionis` are distinct from each other.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate singleton behavior.
-        """
-
-        # Create multiple instances of Container and Orionis
-        container1 = Container()
-        container2 = Container()
-        orionis1 = Orionis()
-        orionis2 = Orionis()
-
-        # Assert that all Container instances are the same object
-        self.assertIs(container1, container2)
-        self.assertEqual(id(container1), id(container2))
-
-        # Assert that all Orionis instances are the same object
-        self.assertIs(orionis1, orionis2)
-        self.assertEqual(id(orionis1), id(orionis2))
-
-        # Assert that Container and Orionis are different singleton instances
-        self.assertIsNot(container1, orionis1)
-
-    async def testSingletonThreadingSafety(self) -> None:
-        """
-        Validates the thread safety of the singleton pattern for `Container` and `Orionis` classes.
-
-        This method ensures that, even when multiple threads attempt to instantiate
-        `Container` and `Orionis` simultaneously, only one instance of each class is created.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate thread-safe singleton behavior.
-        """
-
-        # List to hold instances created in threads
-        container_instances = []
-        orionis_instances = []
-
-        def create_container():
-            """Create and append a Container instance in a thread."""
-            time.sleep(0.01)  # Increase chance of race condition
-            container_instances.append(Container())
-
-        def create_orionis():
-            """Create and append an Orionis instance in a thread."""
-            time.sleep(0.01)  # Increase chance of race condition
-            orionis_instances.append(Orionis())
-
-        # Create threads for concurrent instantiation
-        threads = []
-        for i in range(10):
-            t1 = threading.Thread(target=create_container)
-            t2 = threading.Thread(target=create_orionis)
-            threads.extend([t1, t2])
-
-        # Start all threads
-        for t in threads:
-            t.start()
-
-        # Wait for all threads to complete
-        for t in threads:
-            t.join()
-
-        # Collect instance IDs for verification
-        container_ids = [id(c) for c in container_instances]
-        orionis_ids = [id(o) for o in orionis_instances]
-
-        # Assert that only one unique instance exists for each class
-        self.assertEqual(len(set(container_ids)), 1)
-        self.assertEqual(len(set(orionis_ids)), 1)
-        self.assertEqual(len(container_instances), 10)
-        self.assertEqual(len(orionis_instances), 10)
-
-    async def testInheritanceSeparation(self) -> None:
-        """
-        Ensures that singleton instances are maintained separately for `Container` and `Orionis` classes.
-
-        This method checks that:
-        - Each class maintains its own singleton instance.
-        - Data added to one singleton does not affect the other.
-        - Both classes correctly implement the singleton pattern independently.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate singleton separation.
-        """
-
-        # Create instances of Container and Orionis
-        container = Container()
-        orionis = Orionis()
-
-        # Add a callable to the Container singleton
-        container.callable("test_container", lambda: "container_value")
-
-        # Verify that Container and Orionis are distinct singletons
-        self.assertEqual(type(container).__name__, "Container")
-        self.assertEqual(type(orionis).__name__, "Application")
-        self.assertIsNot(container, orionis)
-
-        # Check that the callable is bound only to Container
-        self.assertTrue(container.bound('test_container'))
-        self.assertFalse(orionis.bound('test_container'))

tests/container/core/test_thread_safety.py

@@ -1,90 +0,0 @@
-import time
-import random
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from orionis.foundation.application import Application as Orionis
-from orionis.container.container import Container
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestThreadSafety(AsyncTestCase):
-
-    async def testStressSingleton(self) -> None:
-        """
-        Stress test singleton behavior under extreme concurrent conditions.
-
-        This method creates a large number of threads that simultaneously attempt to
-        instantiate singleton objects (`Container` and `Orionis`). It verifies that
-        only one unique instance of each singleton exists, regardless of concurrent
-        access, and that the singleton instances are distinct from each other.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate
-            singleton behavior under stress.
-
-        Notes
-        -----
-        - Random delays are introduced to increase the likelihood of race conditions.
-        - ThreadPoolExecutor is used to simulate high concurrency.
-        - The test ensures that singleton integrity is maintained even under heavy load.
-        """
-
-        # Create lists to hold instances created in threads
-        container_instances = []
-        orionis_instances = []
-
-        def create_container_with_delay():
-            """Create a Container instance after a random delay to simulate real-world concurrency."""
-            # Random delay to increase chance of race conditions
-            time.sleep(random.uniform(0.001, 0.01))
-            container = Container()
-            container_instances.append(container)
-            return id(container)
-
-        def create_orionis_with_delay():
-            """Create an Orionis instance after a random delay to simulate real-world concurrency."""
-            # Random delay to increase chance of race conditions
-            time.sleep(random.uniform(0.001, 0.01))
-            orionis = Orionis()
-            orionis_instances.append(orionis)
-            return id(orionis)
-
-        # Number of concurrent threads to simulate
-        num_threads = 100
-
-        # Use ThreadPoolExecutor to run tasks concurrently
-        with ThreadPoolExecutor(max_workers=50) as executor:
-            # Submit container creation tasks
-            container_futures = [
-                executor.submit(create_container_with_delay)
-                for _ in range(num_threads)
-            ]
-
-            # Submit orionis creation tasks
-            orionis_futures = [
-                executor.submit(create_orionis_with_delay)
-                for _ in range(num_threads)
-            ]
-
-            # Wait for all tasks to complete and collect instance IDs
-            container_ids = [future.result() for future in as_completed(container_futures)]
-            orionis_ids = [future.result() for future in as_completed(orionis_futures)]
-
-        # Verify all instances are the same (singleton property)
-        unique_container_ids = set(container_ids)
-        unique_orionis_ids = set(orionis_ids)
-
-        self.assertEqual(len(container_instances), num_threads)
-        self.assertEqual(len(unique_container_ids), 1)
-        self.assertEqual(len(orionis_instances), num_threads)
-        self.assertEqual(len(unique_orionis_ids), 1)
-
-        # Verify that Container and Orionis are different singletons
-        container_id = list(unique_container_ids)[0] if unique_container_ids else None
-        orionis_id = list(unique_orionis_ids)[0] if unique_orionis_ids else None
-
-        self.assertNotEqual(container_id, orionis_id)