orionis 0.471.0__py3-none-any.whl → 0.473.0__py3-none-any.whl

tests/container/core/test_advanced_async.py

@@ -0,0 +1,234 @@
+import time
+from orionis.container.container import Container
+from orionis.test.cases.asynchronous import AsyncTestCase
+from tests.container.mocks.mock_advanced_async import ErrorService, IPerformanceService, MixedConsumer, PerformanceService, simple_async, sync_returns_coroutine
+
+class TestContainer(AsyncTestCase):
+
+    async def testPerformanceComparison(self):
+        """
+        Measures and verifies the performance of synchronous service calls within the container.
+
+        This test performs the following steps:
+            - Instantiates a container and registers `PerformanceService` as a singleton for the `IPerformanceService` interface.
+            - Resolves the registered service from the container.
+            - Executes the synchronous operation multiple times using the container's `call` method, measuring the total elapsed time.
+            - Asserts that the synchronous operation returns the expected result.
+            - Asserts that the measured execution time is greater than zero, confirming that the operation duration is measurable.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate expected behavior.
+        """
+        # Create a container instance
+        container = Container()
+
+        # Register the PerformanceService as a singleton for the IPerformanceService interface
+        container.singleton(IPerformanceService, PerformanceService)
+
+        # Resolve the service instance from the container
+        service = container.make(IPerformanceService)
+
+        # Start timing the synchronous calls
+        start_time = time.time()
+
+        # Call the sync operation multiple times to measure performance
+        for i in range(3):
+            result = container.call(service, 'sync_operation')
+
+        # Calculate the total elapsed time for synchronous calls
+        sync_time = time.time() - start_time
+
+        # Assert that the sync operation returns the expected result
+        self.assertEqual(result, "Sync operation completed")
+
+        # Assert that the measured time is greater than zero
+        self.assertGreater(sync_time, 0, "Sync operation should take some time")
+
+    async def testAsyncPerformance(self):
+        """
+        Measures and verifies the performance of asynchronous service calls within the container.
+
+        This test performs the following steps:
+            - Instantiates a container and registers `PerformanceService` as a singleton for the `IPerformanceService` interface.
+            - Resolves the registered service from the container.
+            - Executes the asynchronous operation multiple times using both `call` and `callAsync` methods, measuring the total elapsed time.
+            - Asserts that the asynchronous operation returns the expected result.
+            - Asserts that the measured execution time is greater than zero, confirming that the operation duration is measurable.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate expected behavior.
+
+        Raises
+        ------
+        AssertionError
+            If the asynchronous operation does not return the expected result or if the measured time is not greater than zero.
+        """
+
+        # Create a container instance
+        container = Container()
+
+        # Register the PerformanceService as a singleton for the IPerformanceService interface
+        container.singleton(IPerformanceService, PerformanceService)
+
+        # Resolve the service instance from the container
+        service = container.make(IPerformanceService)
+
+        # Start timing the asynchronous calls
+        start_time = time.time()
+
+        # Call the async operation multiple times using the container's call method
+        for i in range(3):
+
+            # Await the result of the async operation
+            result = container.call(service, 'async_operation')
+
+        # Calculate the total elapsed time for asynchronous calls
+        async_time = time.time() - start_time
+
+        # Assert that the async operation returns the expected result
+        self.assertEqual(result, "Async operation completed")
+
+        # Call the async operation multiple times using the container's callAsync method
+        for i in range(3):
+            result = await container.callAsync(service, 'async_operation')
+
+        # Assert that the async operation returns the expected result
+        self.assertEqual(result, "Async operation completed")
+
+        # Assert that the measured time is greater than zero
+        self.assertGreater(async_time, 0, "Async operation should take some time")
+
+    async def testErrorHandling(self):
+        """
+        Tests the error handling capabilities of the container for both synchronous and asynchronous service methods.
+
+        This method performs the following steps:
+            - Instantiates a container and resolves the `ErrorService`.
+            - Invokes a synchronous method that is expected to raise an exception and asserts that the exception is raised.
+            - (Asynchronous error handling is tested elsewhere.)
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate that exceptions are properly raised.
+        """
+
+        # Create a container instance
+        container = Container()
+
+        # Resolve the ErrorService instance from the container
+        service = container.make(ErrorService)
+
+        # Test synchronous error handling: expect an exception to be raised
+        with self.assertRaises(Exception) as context:
+            container.call(service, 'sync_error_method')
+
+    async def testAsyncErrors(self):
+
+        # Create a container instance
+        container = Container()
+
+        # Resolve the ErrorService instance from the container
+        service = container.make(ErrorService)
+
+        # Call the async error method and await its result
+        with self.assertRaises(Exception) as context:
+            await container.callAsync(service, 'async_error_method')
+
+    async def testMixedDependencyInjection(self):
+        """
+        Tests the container's ability to perform mixed synchronous and asynchronous dependency injection.
+
+        This test performs the following steps:
+            - Instantiates a container and uses it to auto-resolve dependencies for the `MixedConsumer` class.
+            - Invokes a synchronous method with dependency injection and verifies its return value.
+            - (Asynchronous methods are tested elsewhere.)
+
+        The test asserts that:
+            - The synchronous method returns a string starting with "Sync:".
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate expected behavior.
+        """
+
+        # Create an instance of the container
+        container = Container()
+
+        # Auto-resolve dependencies for MixedConsumer
+        consumer = container.make(MixedConsumer)
+
+        # Test synchronous method with dependency injection
+        sync_result: str = container.call(consumer, 'sync_method')
+
+        # Assert that the result starts with "Sync:"
+        self.assertTrue(sync_result.startswith("Sync:"))
+
+    async def testAsyncWithDI(self):
+        """
+        Tests the container's capability to perform asynchronous dependency injection.
+
+        This test performs the following steps:
+            - Instantiates a container and uses it to auto-resolve dependencies for the `MixedConsumer` class.
+            - Invokes an asynchronous method with dependency injection and verifies its return value.
+
+        The test asserts that:
+            - The asynchronous method returns a string starting with "Mixed: ".
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate expected behavior.
+        """
+
+        # Create an instance of the container
+        container = Container()
+
+        # Auto-resolve dependencies for MixedConsumer
+        consumer = container.make(MixedConsumer)
+
+        # Call the asynchronous method with dependency injection
+        async_result: str = await container.callAsync(consumer, 'async_method')
+
+        # Assert that the result starts with "Mixed: "
+        self.assertTrue(async_result.startswith("Mixed: "))
+
+    async def testCallableAsyncSync(self):
+        """
+        Tests the container's ability to register and resolve both synchronous and asynchronous callable functions,
+        ensuring that both types return coroutine objects when resolved.
+
+        This method performs the following steps:
+            - Instantiates a container and registers two callable functions:
+                - A synchronous function that returns a coroutine.
+                - An asynchronous function.
+            - Resolves each callable from the container.
+            - Asserts that the resolved objects are coroutine objects by checking for the '__await__' attribute.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate that the resolved callables are coroutine objects.
+        """
+
+        # Create a container instance
+        container = Container()
+
+        # Register a synchronous function that returns a coroutine
+        container.callable("sync_returns_coro", sync_returns_coroutine)
+
+        # Register an asynchronous function
+        container.callable("simple_async", simple_async)
+
+        # Resolve the synchronous function and check if it returns a coroutine object
+        result1 = container.make("sync_returns_coro")
+        self.assertTrue(result1 == "Sync function returning coroutine")
+
+        # Resolve the asynchronous function and check if it returns a coroutine object
+        result2 = container.make("simple_async")
+        self.assertTrue(result2 == "Simple async callable")

tests/container/core/test_async_optimizations.py

@@ -0,0 +1,268 @@
+from orionis.container.container import Container
+from orionis.test.cases.asynchronous import AsyncTestCase
+from tests.container.mocks.mock_async_optimizations import AsyncTestService, AsyncTestServiceWithDependency, IAsyncTestService, IAsyncTestServiceWithDependency, ITestService, ITestServiceWithDependency, MixedService, TestService, TestServiceWithDependency, async_callable, async_callable_with_dependency, sync_callable, sync_callable_with_dependency
+
+class TestContainer(AsyncTestCase):
+
+    async def testSyncServices(self):
+        """
+        Tests the registration and resolution of synchronous services in the container.
+
+        This method verifies that singleton and transient services can be registered and resolved correctly.
+        It checks that the singleton service returns the same instance on multiple resolutions, and that
+        the service with a dependency is properly constructed.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate behavior.
+        """
+
+        # Create a new container instance
+        container = Container()
+
+        # Register a singleton service and a transient service with dependency
+        container.singleton(ITestService, TestService)
+        container.transient(ITestServiceWithDependency, TestServiceWithDependency)
+
+        # Resolve the singleton service and verify its method output
+        service: ITestService = container.make(ITestService)
+        self.assertEqual(service.get_message(), "Hello from sync service")
+
+        # Resolve the transient service with dependency and check its output
+        service_with_dep: ITestServiceWithDependency = container.make(ITestServiceWithDependency)
+        self.assertTrue(service_with_dep.get_combined_message().startswith("Combined: "))
+
+        # Ensure that singleton returns the same instance on multiple resolutions
+        service2: ITestService = container.make(ITestService)
+        self.assertIs(service, service2, "Singleton service should return the same instance")
+
+    async def testAsyncServices(self):
+        """
+        Tests the registration and resolution of asynchronous services in the dependency injection container.
+
+        This method ensures that asynchronous services can be registered as singletons or transients and resolved correctly.
+        It verifies that the resolved service instance matches the expected implementation type.
+
+        Parameters
+        ----------
+        self : TestContainer
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate correct behavior.
+        """
+
+        # Create a new container instance
+        container = Container()
+
+        # Register an asynchronous singleton service
+        container.singleton(IAsyncTestService, AsyncTestService)
+
+        # Register an asynchronous transient service with dependency
+        container.transient(IAsyncTestServiceWithDependency, AsyncTestServiceWithDependency)
+
+        # Resolve the asynchronous singleton service and check its type
+        async_service = container.make(IAsyncTestService)
+        self.assertIsInstance(async_service, AsyncTestService)
+
+    async def testAsyncCalls(self):
+        """
+        Tests asynchronous service resolution and asynchronous method invocation in the dependency injection container.
+
+        This method verifies that asynchronous services can be registered, resolved, and their asynchronous methods invoked correctly.
+        It checks both singleton and transient registrations, and asserts that the returned values are as expected.
+
+        Parameters
+        ----------
+        self : TestContainer
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate correct behavior.
+        """
+
+        # Create a new container instance
+        container = Container()
+
+        # Register an asynchronous singleton service
+        container.singleton(IAsyncTestService, AsyncTestService)
+
+        # Register an asynchronous transient service with dependency
+        container.transient(IAsyncTestServiceWithDependency, AsyncTestServiceWithDependency)
+
+        # Resolve the asynchronous singleton service
+        async_service: IAsyncTestService = container.make(IAsyncTestService)
+
+        # Call an asynchronous method on the resolved service and check the result
+        result = await container.callAsync(async_service, 'get_async_message')
+        self.assertEqual(result, "Hello from async service")
+
+        # Resolve the asynchronous transient service with dependency
+        service_with_dep: IAsyncTestServiceWithDependency = container.make(IAsyncTestServiceWithDependency)
+
+        # Call an asynchronous method that combines results from dependencies and check the result
+        result2: str = await container.callAsync(service_with_dep, 'get_combined_async_message')
+        self.assertTrue(result2.startswith("Combined: "))
+
+    async def testCallableRegistration(self):
+        """
+        Tests the registration and resolution of synchronous and asynchronous callables in the dependency injection container.
+
+        This method verifies that:
+        - Synchronous services can be registered as singletons.
+        - Synchronous callables can be registered and resolved by name.
+        - Callables with dependencies are correctly resolved and invoked.
+        - The resolved callables return the expected results.
+
+        Parameters
+        ----------
+        self : TestContainer
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate correct behavior.
+        """
+
+        # Create a new container instance
+        container = Container()
+
+        # Register base services as singletons
+        container.singleton(ITestService, TestService)
+        container.singleton(IAsyncTestService, AsyncTestService)
+
+        # Register synchronous callables, including one with a dependency
+        container.callable("sync_func", sync_callable)
+        container.callable("sync_func_with_dep", sync_callable_with_dependency)
+
+        # Resolve and invoke the synchronous callable, then check its result
+        result1: str = container.make("sync_func")
+        self.assertEqual(result1, "Sync callable result")
+
+        # Resolve and invoke the callable with dependency, then check its result
+        result2: str = container.make("sync_func_with_dep")
+        self.assertTrue(result2.startswith("Callable with dependency: "))
+
+    async def testAsyncCallables(self):
+        """
+        Tests registration, resolution, and invocation of asynchronous callables in the dependency injection container.
+
+        This method ensures that:
+            - Asynchronous callables can be registered using the `callable` method.
+            - Registered asynchronous callables are resolved correctly from the container.
+            - Dependencies for asynchronous callables are properly injected by the container.
+            - The results returned by the asynchronous callables match the expected output.
+
+        Parameters
+        ----------
+        self : TestContainer
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate correct behavior.
+        """
+
+        # Create a new container instance
+        container = Container()
+
+        # Register base services as singletons for dependency injection
+        container.singleton(ITestService, TestService)
+        container.singleton(IAsyncTestService, AsyncTestService)
+
+        # Register asynchronous callables, including one with a dependency
+        container.callable("async_func", async_callable)
+        container.callable("async_func_with_dep", async_callable_with_dependency)
+
+        # Resolve and invoke the asynchronous callable, then check its result
+        result1: str = container.make("async_func")
+        self.assertEqual(result1, "Async callable result")
+
+        # Resolve and invoke the asynchronous callable with dependency, then check its result
+        result2: str = container.make("async_func_with_dep")
+        self.assertTrue(result2.startswith("Async callable with dependency: "))
+
+    async def testMixedSyncAsync(self):
+        """
+        Tests the container's ability to integrate synchronous and asynchronous services and dependencies.
+
+        This method registers both a synchronous service (`TestService`) and an asynchronous service (`AsyncTestService`)
+        as singletons in the container. It then resolves a `MixedService` instance, which depends on both types of services,
+        and invokes its synchronous method `get_sync_message` using the container's `call` method. The test asserts that
+        the returned message from the synchronous method starts with "Mixed sync: ", verifying that the container can
+        correctly handle and inject both synchronous and asynchronous dependencies into a mixed service.
+
+        Parameters
+        ----------
+        self : TestContainer
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate correct behavior.
+        """
+
+        # Create a new container instance
+        container = Container()
+
+        # Register synchronous and asynchronous services as singletons
+        container.singleton(ITestService, TestService)
+        container.singleton(IAsyncTestService, AsyncTestService)
+
+        # Resolve the mixed service, which depends on both sync and async services
+        mixed_service = container.make(MixedService)
+
+        # Invoke the synchronous method and check the result
+        sync_result: str = container.call(mixed_service, 'get_sync_message')
+        self.assertTrue(sync_result.startswith("Mixed sync: "))
+
+    async def testMixedAsync(self):
+        """
+        Tests the container's ability to integrate synchronous and asynchronous services and dependencies,
+        focusing on asynchronous method invocation.
+
+        This method performs the following verifications:
+            - Registers both a synchronous service (`TestService`) and an asynchronous service (`AsyncTestService`)
+              as singletons in the container.
+            - Resolves a `MixedService` instance, which depends on both types of services.
+            - Invokes the asynchronous method `get_async_message` on the mixed service using `callAsync` and asserts
+              that the returned message starts with "Mixed async: ".
+            - Invokes the asynchronous method `get_both_messages` on the mixed service using `callAsync` and asserts
+              that the returned message starts with "Both: ".
+
+        Parameters
+        ----------
+        self : TestContainer
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return a value. Assertions are used to validate correct behavior.
+        """
+
+        # Create a new container instance
+        container = Container()
+
+        # Register synchronous and asynchronous services as singletons
+        container.singleton(ITestService, TestService)
+        container.singleton(IAsyncTestService, AsyncTestService)
+
+        # Resolve the mixed service, which depends on both sync and async services
+        mixed_service = container.make(MixedService)
+
+        # Invoke the asynchronous method and check the result
+        async_result: str = await container.callAsync(mixed_service, 'get_async_message')
+        self.assertTrue(async_result.startswith("Mixed async: "))
+
+        # Invoke the asynchronous method that combines both sync and async dependencies and check the result
+        both_result = await container.callAsync(mixed_service, 'get_both_messages')
+        self.assertTrue(both_result.startswith("Both: "))