orionis 0.405.0__py3-none-any.whl → 0.407.0__py3-none-any.whl

tests/container/test_container.py

@@ -0,0 +1,254 @@
+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):
+    """Test suite for the Container class functionality."""
+
+    async def testTransientRegistration(self) -> None:
+        """
+        Tests the transient registration of a service in the container.
+        It verifies that:
+        1. The container.transient() method correctly registers a type (ICar) to be resolved as another type (Car)
+        2. The resolved instances are of the correct type (Car)
+        3. Each resolution returns a new instance (instance1 is not the same object as instance2)
+        """
+        container = Container()
+        container.transient(ICar, Car)
+        instance1 = container.make(ICar)
+        instance2 = container.make(ICar)
+
+        self.assertIsInstance(instance1, Car)
+        self.assertIsInstance(instance2, Car)
+        self.assertIsNot(instance1, instance2)
+
+        container.drop(abstract=ICar)
+
+    async def testSingletonRegistration(self) -> None:
+        """
+        Test that verifies singleton registration and resolution from the container.
+        This test ensures that:
+        1. A class can be registered as a singleton implementation of an interface
+        2. The container correctly returns an instance of the registered implementation
+        3. Multiple requests for the same interface return the same instance
+        The test binds the ICar interface to the Car implementation as a singleton,
+        then verifies that two requests for ICar:
+        - Both return instances of Car
+        - Return the exact same instance (object identity)
+        """
+        container = Container()
+        container.singleton(ICar, Car)
+        instance1 = container.make(ICar)
+        instance2 = container.make(ICar)
+
+        self.assertIsInstance(instance1, Car)
+        self.assertIsInstance(instance2, Car)
+        self.assertIs(instance1, instance2)
+
+        container.drop(abstract=ICar)
+
+    async def testScopedRegistration(self) -> None:
+        """
+        Tests the scoped registration functionality of the container.
+        This test verifies that:
+        1. Within a single context, scoped registrations return the same instance
+            when the same interface is requested multiple times
+        2. Different contexts produce different instances of the same registration
+        The test creates two separate contexts and confirms that instances obtained
+        within a single context are identical, but instances from different contexts
+        are distinct.
+        """
+
+        container = Container()
+        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)
+
+        with container.createContext():
+            container.scoped(ICar, Car)
+            instance3 = container.make(ICar)
+            self.assertIsNot(instance1, instance3)
+
+        container.drop(abstract=ICar)
+
+    async def testInstanceRegistration(self) -> None:
+        """
+        Test case for instance registration in the container.
+        This test ensures that when an instance is registered to a service in the container,
+        the container returns exactly the same instance when resolving that service.
+        The test:
+        1. Creates an instance of Car
+        2. Registers this instance to the ICar interface in the container
+        3. Resolves the ICar interface from the container
+        4. Asserts that the resolved instance is exactly the same object as the one registered
+        """
+        car_instance = Car()
+        container = Container()
+        container.instance(ICar, car_instance)
+        resolved = container.make(ICar)
+
+        self.assertIs(resolved, car_instance)
+
+        container.drop(abstract=ICar)
+
+    async def testCallableRegistration(self) -> None:
+        """
+        Test that callables can be registered and resolved from the container.
+        This test verifies that:
+        1. Functions can be registered in the container using the callable() method
+        2. Registered functions can be resolved and executed using the make() method
+        3. Arguments can be passed to the resolved functions as positional arguments
+        4. Arguments can be passed to the resolved functions as keyword arguments
+        The test registers two simple functions (add and multiply) and verifies
+        they can be correctly resolved and executed with the expected results.
+        """
+        def add(a: int, b: int) -> int:
+            return a + b
+
+        def multiply(a: int, b: int) -> int:
+            return a * b
+
+        container = Container()
+        container.callable('add', add)
+        container.callable('multiply', multiply)
+
+        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)
+
+        container.drop(alias='add')
+        container.drop(alias='multiply')
+
+    async def testTransientFacade(self) -> None:
+        """
+        Test case for transient instance resolution using a Facade pattern.
+        This test validates that:
+        1. The container can register a transient binding between an interface and a class
+        2. The Facade pattern correctly resolves instances of the registered interface
+        3. Multiple calls to the Facade's resolve() method return different instances
+            when the binding is transient
+        The test creates a CarFacade that accesses ICar interface which is bound to the Car
+        implementation in a transient manner, ensuring each resolution yields a new instance.
+        """
+        container = Application()
+        container.transient(ICar, Car)
+
+        class CarFacade(Facade):
+            @classmethod
+            def getFacadeAccessor(cls):
+                return ICar
+
+        instance1 = CarFacade.resolve()
+        instance2 = CarFacade.resolve()
+
+        self.assertIsInstance(instance1, Car)
+        self.assertIsInstance(instance2, Car)
+        self.assertIsNot(instance1, instance2)
+
+        container.drop(abstract=ICar)
+
+    async def testSingletonFacade(self) -> None:
+        """
+        Tests if the Facade pattern correctly resolves singleton instances.
+        This test verifies that:
+        1. A singleton binding can be registered in the container
+        2. A Facade class can be created to access this binding
+        3. Multiple resolutions through the Facade return the same instance
+        4. The resolved instances are of the correct type (Car)
+        The test demonstrates how Facades act as static proxies to container bindings,
+        maintaining the singleton behavior defined in the container.
+        """
+        container = Application()
+        container.singleton(ICar, Car)
+
+        class CarFacade(Facade):
+            @classmethod
+            def getFacadeAccessor(cls):
+                return ICar
+
+        instance1 = CarFacade.resolve()
+        instance2 = CarFacade.resolve()
+
+        self.assertIsInstance(instance1, Car)
+        self.assertIsInstance(instance2, Car)
+        self.assertIs(instance1, instance2)
+
+        container.drop(abstract=ICar)
+
+    async def testScopedFacade(self) -> None:
+        """
+        Tests the functionality of a Facade accessing a scoped service within a container context.
+        This test verifies that:
+        1. The Facade can properly resolve a scoped service
+        2. Multiple resolves within the same scope return the same instance
+        3. The resolved instance is of the correct type
+        The test creates a scoped registration for ICar interface to Car implementation,
+        defines a CarFacade class that accesses ICar, and then confirms that:
+        - Resolved instances are of Car type
+        - Multiple resolutions return the same instance (scoped behavior)
+        """
+        container = Application()
+        with container.createContext():
+            container.scoped(ICar, Car)
+
+            class CarFacade(Facade):
+                @classmethod
+                def getFacadeAccessor(cls):
+                    return ICar
+
+            instance1 = CarFacade.resolve()
+            instance2 = CarFacade.resolve()
+
+            self.assertIsInstance(instance1, Car)
+            self.assertIsInstance(instance2, Car)
+            self.assertIs(instance1, instance2)
+
+        container.drop(abstract=ICar)
+
+    async def testResolvingUnregisteredType(self) -> None:
+        """
+        Tests that attempting to resolve an unregistered type from the container raises an exception.
+        This test ensures that the container correctly validates that a type is registered before attempting to resolve it.
+
+        Raises:
+            Exception: Expected to be raised when attempting to resolve an unregistered type.
+        """
+        container = Container()
+        with self.assertRaises(Exception):
+            container.make('ICar')
+
+    async def testOverridingRegistration(self) -> None:
+        """
+        Tests the ability of the container to override existing registrations.
+        This test verifies that:
+        1. When a class is registered as a singleton for an interface
+        2. And later a different class is registered for the same interface
+        3. The container returns the new class when resolving the interface
+        4. The new instance is different from the previous instance
+        This demonstrates the container's support for overriding service implementations.
+        """
+        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."
+
+        container = Container()
+        container.singleton(ICar, Car)
+        first = container.make(ICar)
+        self.assertIsInstance(first, Car)
+        self.assertNotIsInstance(first, SportsCar)
+
+        container.singleton(ICar, SportsCar)
+        second = container.make(ICar)
+        self.assertIsInstance(second, SportsCar)
+        self.assertIsNot(first, second)
+
+        container.drop(abstract=ICar)

tests/container/test_singleton.py

@@ -0,0 +1,98 @@
+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):
+    """Test suite for singleton pattern implementation."""
+
+    async def testSingletonBasicFunctionality(self) -> None:
+        """
+        Test basic singleton functionality.
+
+        This test verifies that:
+        1. Multiple Container instances are the same object
+        2. Multiple Orionis instances are the same object
+        3. Container and Orionis are different singletons
+        """
+        # Create multiple instances
+        container1 = Container()
+        container2 = Container()
+        orionis1 = Orionis()
+        orionis2 = Orionis()
+
+        # Test that Container instances are the same
+        self.assertIs(container1, container2)
+        self.assertEqual(id(container1), id(container2))
+
+        # Test that Orionis instances are the same
+        self.assertIs(orionis1, orionis2)
+        self.assertEqual(id(orionis1), id(orionis2))
+
+        # Test that Container and Orionis are different singletons
+        self.assertIsNot(container1, orionis1)
+
+    async def testSingletonThreadingSafety(self) -> None:
+        """
+        Test singleton in multi-threaded environment.
+
+        This test verifies that singleton pattern works correctly
+        when instances are created from multiple threads simultaneously.
+        """
+        container_instances = []
+        orionis_instances = []
+
+        def create_container():
+            """Create container instance in thread."""
+            time.sleep(0.01)  # Small delay to increase chance of race condition
+            container_instances.append(Container())
+
+        def create_orionis():
+            """Create orionis instance in thread."""
+            time.sleep(0.01)  # Small delay to increase chance of race condition
+            orionis_instances.append(Orionis())
+
+        # Create multiple threads
+        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()
+
+        # Check that all instances are the same
+        container_ids = [id(c) for c in container_instances]
+        orionis_ids = [id(o) for o in orionis_instances]
+
+        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:
+        """
+        Test that Container and Orionis maintain separate singleton instances.
+
+        This test verifies that different singleton classes maintain
+        their own separate instances while both implementing singleton pattern.
+        """
+        container = Container()
+        orionis = Orionis()
+
+        # Add some data to each to verify they're separate
+        container.callable("test_container", lambda: "container_value")
+
+        # Check that they're different instances but both are singletons
+        self.assertEqual(type(container).__name__, "Container")
+        self.assertEqual(type(orionis).__name__, "Application")
+        self.assertIsNot(container, orionis)
+        self.assertTrue(container.bound('test_container'))
+        self.assertFalse(orionis.bound('test_container'))

tests/container/test_thread_safety.py

@@ -0,0 +1,217 @@
+import threading
+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:
+        """
+        Test singleton under extreme concurrent conditions.
+
+        This test creates a large number of threads that simultaneously
+        attempt to create singleton instances to verify thread-safety.
+        """
+        container_instances = []
+        orionis_instances = []
+
+        def create_container_with_delay():
+            """Create container with random delay to simulate real conditions."""
+            # 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 orionis with random delay to simulate real conditions."""
+            # 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)
+
+        # Create a large number of threads
+        num_threads = 100
+
+        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
+            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
+        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)
+
+    async def testRapidAccess(self) -> None:
+        """
+        Test rapid concurrent access to existing singleton instances.
+
+        This test verifies that rapid concurrent access to already
+        created singleton instances maintains consistency.
+        """
+        # Create initial instances
+        initial_container = Container()
+        initial_orionis = Orionis()
+
+        container_ids = []
+        orionis_ids = []
+
+        def rapid_container_access():
+            """Rapidly access container singleton."""
+            for _ in range(100):
+                container = Container()
+                container_ids.append(id(container))
+
+        def rapid_orionis_access():
+            """Rapidly access orionis singleton."""
+            for _ in range(100):
+                orionis = Orionis()
+                orionis_ids.append(id(orionis))
+
+        # Create threads for rapid access
+        threads = []
+        for _ in range(20):
+            t1 = threading.Thread(target=rapid_container_access)
+            t2 = threading.Thread(target=rapid_orionis_access)
+            threads.extend([t1, t2])
+
+        # Start all threads simultaneously
+        start_time = time.time()
+        for t in threads:
+            t.start()
+
+        # Wait for all threads to complete
+        for t in threads:
+            t.join()
+
+        end_time = time.time()
+
+        # Verify consistency
+        unique_container_ids = set(container_ids)
+        unique_orionis_ids = set(orionis_ids)
+
+        self.assertEqual(len(container_ids), 20 * 100)  # 20 threads * 100 accesses each
+        self.assertEqual(len(unique_container_ids), 1)
+        self.assertEqual(len(orionis_ids), 20 * 100)
+        self.assertEqual(len(unique_orionis_ids), 1)
+
+        # Verify performance is reasonable (should complete quickly)
+        self.assertLess(end_time - start_time, 10.0)  # Should complete in less than 10 seconds
+
+    async def testMixedOperations(self) -> None:
+        """
+        Test mixed read/write operations on singletons.
+
+        This test verifies that concurrent read/write operations
+        maintain singleton consistency and data integrity.
+        """
+        errors = []
+
+        def mixed_operations():
+            """Perform mixed operations on containers."""
+            try:
+                # Get instances
+                container = Container()
+                orionis = Orionis()
+
+                # Perform some operations
+                test_key = f"test_func_{threading.current_thread().ident}"
+                container.callable(test_key, lambda: "test_value")
+
+                # Verify the same instance
+                container2 = Container()
+                orionis2 = Orionis()
+
+                if container is not container2:
+                    errors.append("Container singleton violated")
+
+                if orionis is not orionis2:
+                    errors.append("Orionis singleton violated")
+
+                # Check bindings consistency
+                if not container2.bound(test_key):
+                    errors.append("Binding not consistent across instances")
+
+            except Exception as e:
+                errors.append(f"Exception in mixed operations: {e}")
+
+        # Run mixed operations in multiple threads
+        threads = []
+        for _ in range(50):
+            t = threading.Thread(target=mixed_operations)
+            threads.append(t)
+
+        for t in threads:
+            t.start()
+
+        for t in threads:
+            t.join()
+
+        # Assert no errors occurred
+        self.assertEqual(len(errors), 0, f"Errors found: {errors[:5]}")
+
+    async def testMemoryConsistency(self) -> None:
+        """
+        Test memory consistency across threads.
+
+        This test verifies that changes made in one thread
+        are visible in other threads due to singleton behavior.
+        """
+        results = []
+
+        def thread_a():
+            """Thread A - modifies the container."""
+            container = Container()
+            container.callable("thread_a_marker", lambda: "from_thread_a")
+            results.append("A_completed")
+
+        def thread_b():
+            """Thread B - reads from the container."""
+            # Small delay to ensure thread A runs first
+            time.sleep(0.01)
+            container = Container()
+            has_marker = container.bound("thread_a_marker")
+            results.append(f"B_sees_marker: {has_marker}")
+
+        t1 = threading.Thread(target=thread_a)
+        t2 = threading.Thread(target=thread_b)
+
+        t1.start()
+        t2.start()
+
+        t1.join()
+        t2.join()
+
+        # Verify that thread B saw the changes made by thread A
+        a_completed = "A_completed" in results
+        b_saw_marker = any("B_sees_marker: True" in r for r in results)
+
+        self.assertTrue(a_completed, "Thread A should have completed")
+        self.assertTrue(b_saw_marker, "Thread B should see Thread A's changes")