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

tests/container/providers/test_providers.py

@@ -7,16 +7,23 @@ class TestServiceProviderMethods(AsyncTestCase):
 
     async def testMethodsExist(self):
         """
-        Checks that the ServiceProvider class implements the required methods and constructor.
+        Validates the implementation of required methods and inheritance in the ServiceProvider class.
 
-        This test verifies the following:
-        - The existence of the '__init__', 'register', and 'boot' methods in ServiceProvider.
-        - That 'register' and 'boot' are asynchronous methods.
-        - That ServiceProvider inherits from IServiceProvider.
+        This test performs the following checks:
+        - Verifies that the ServiceProvider class defines the '__init__', 'register', and 'boot' methods.
+        - Ensures that the 'register' and 'boot' methods are asynchronous coroutine functions.
+        - Confirms that ServiceProvider is a subclass of IServiceProvider.
 
-        Returns:
-            None. The method uses assertions to validate class structure and method types.
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            The method does not return any value. Assertions are used to validate class structure and method types.
         """
+
         # List of required methods and their associated class
         expected_methods = [
             ("__init__", ServiceProvider),
@@ -34,15 +41,15 @@ class TestServiceProviderMethods(AsyncTestCase):
         # Ensure 'register' and 'boot' are asynchronous methods
         self.assertTrue(
             inspect.iscoroutinefunction(ServiceProvider.register),
-            "register must be async"
+            "'register' must be an async coroutine function."
         )
         self.assertTrue(
             inspect.iscoroutinefunction(ServiceProvider.boot),
-            "boot must be async"
+            "'boot' must be an async coroutine function."
         )
 
         # Ensure ServiceProvider inherits from IServiceProvider
         self.assertTrue(
             issubclass(ServiceProvider, IServiceProvider),
-            "ServiceProvider must inherit from IServiceProvider"
+            "ServiceProvider must inherit from IServiceProvider."
         )

tests/container/resolver/test_resolver.py

@@ -7,15 +7,22 @@ class TestResolverMethods(AsyncTestCase):
 
     async def testMethodsExist(self):
         """
-        Checks that the `Resolver` class implements all required methods and inherits from `IResolver`.
+        Validates the implementation and structure of the `Resolver` class.
 
-        This test verifies the presence of specific methods in the `Resolver` class, ensures that
-        `Resolver` is a subclass of `IResolver`, and confirms that the main public methods are not asynchronous.
+        This test checks that the `Resolver` class:
+            - Implements all required methods.
+            - Inherits from the `IResolver` interface.
+            - Has main public methods (`resolve`, `resolveType`, `resolveSignature`) that are synchronous.
+
+        Parameters
+        ----------
+        self : TestResolverMethods
+            The test case instance.
 
         Returns
         -------
         None
-            This method does not return a value. Assertions are used to validate class structure.
+            The method does not return any value. Assertions are used to validate the class structure.
         """
 
         # List of required method names that must be implemented by Resolver
@@ -34,20 +41,20 @@ class TestResolverMethods(AsyncTestCase):
             "_Resolver__resolveDependencies",
         ]
 
-        # Assert that each required method exists in Resolver
+        # Check that each required method exists in Resolver
         for method in required_methods:
             self.assertTrue(
                 hasattr(Resolver, method),
                 f"Resolver must implement the method '{method}'"
             )
 
-        # Assert that Resolver inherits from IResolver
+        # Ensure Resolver inherits from IResolver
         self.assertTrue(
             issubclass(Resolver, IResolver),
             "Resolver must inherit from IResolver"
         )
 
-        # Assert that main public methods are not asynchronous
+        # Verify that main public methods are not asynchronous
         for method in ["resolve", "resolveType", "resolveSignature"]:
             self.assertFalse(
                 inspect.iscoroutinefunction(getattr(Resolver, method)),

tests/container/test_container.py

@@ -5,63 +5,109 @@ 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)
+
+        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.
         """
         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:
         """
-        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)
+        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.
         """
         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 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.
-        """
 
+        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.
+        """
         container = Container()
+        # First context: instances should be the same
         with container.createContext():
             container.scoped(ICar, Car)
             instance1 = container.make(ICar)
@@ -71,43 +117,70 @@ class TestContainer(AsyncTestCase):
             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:
         """
-        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
+        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.
         """
         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:
         """
-        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.
+        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.
         """
         def add(a: int, b: int) -> int:
             return a + b
@@ -116,28 +189,44 @@ class TestContainer(AsyncTestCase):
             return a * b
 
         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:
         """
-        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.
+        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.
         """
         container = Application()
+        # Register ICar as a transient binding to Car
         container.transient(ICar, Car)
 
         class CarFacade(Facade):
@@ -145,6 +234,7 @@ class TestContainer(AsyncTestCase):
             def getFacadeAccessor(cls):
                 return ICar
 
+        # Resolve two instances via Facade (should be different objects)
         instance1 = CarFacade.resolve()
         instance2 = CarFacade.resolve()
 
@@ -152,20 +242,35 @@ class TestContainer(AsyncTestCase):
         self.assertIsInstance(instance2, Car)
         self.assertIsNot(instance1, instance2)
 
+        # Clean up registration
         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.
+        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.
         """
         container = Application()
+        # Register ICar as a singleton binding to Car
         container.singleton(ICar, Car)
 
         class CarFacade(Facade):
@@ -173,6 +278,7 @@ class TestContainer(AsyncTestCase):
             def getFacadeAccessor(cls):
                 return ICar
 
+        # Resolve two instances via Facade (should be the same object)
         instance1 = CarFacade.resolve()
         instance2 = CarFacade.resolve()
 
@@ -180,22 +286,36 @@ class TestContainer(AsyncTestCase):
         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 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)
+
+        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.
         """
         container = Application()
+        # Create a new scope/context
         with container.createContext():
+            # Register ICar as a scoped binding to Car
             container.scoped(ICar, Car)
 
             class CarFacade(Facade):
@@ -203,6 +323,7 @@ class TestContainer(AsyncTestCase):
                 def getFacadeAccessor(cls):
                     return ICar
 
+            # Resolve two instances via Facade (should be the same object within the scope)
             instance1 = CarFacade.resolve()
             instance2 = CarFacade.resolve()
 
@@ -210,29 +331,60 @@ class TestContainer(AsyncTestCase):
             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 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.
+        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.
         """
         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 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.
+
+        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.
         """
         class SportsCar(Car):
             def start(self):
@@ -241,14 +393,17 @@ class TestContainer(AsyncTestCase):
                 return f"{self.brand} {self.model} is stopping."
 
         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)