orionis 0.407.0__tar.gz → 0.408.0__tar.gz

{orionis-0.407.0/orionis.egg-info → orionis-0.408.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.407.0
+Version: 0.408.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

{orionis-0.407.0 → orionis-0.408.0}/orionis/container/container.py

@@ -6,15 +6,17 @@ from orionis.container.entities.binding import Binding
 from orionis.container.enums.lifetimes import Lifetime
 from orionis.container.exceptions import OrionisContainerException
 from orionis.container.resolver.resolver import Resolver
-from orionis.container.validators.implements import ImplementsAbstractMethods
-from orionis.container.validators.is_abstract_class import IsAbstractClass
-from orionis.container.validators.is_callable import IsCallable
-from orionis.container.validators.is_concrete_class import IsConcreteClass
-from orionis.container.validators.is_instance import IsInstance
-from orionis.container.validators.is_not_subclass import IsNotSubclass
-from orionis.container.validators.is_subclass import IsSubclass
-from orionis.container.validators.is_valid_alias import IsValidAlias
-from orionis.container.validators.lifetime import LifetimeValidator
+from orionis.container.validators import (
+    ImplementsAbstractMethods,
+    IsAbstractClass,
+    IsCallable,
+    IsConcreteClass,
+    IsInstance,
+    IsNotSubclass,
+    IsSubclass,
+    IsValidAlias,
+    LifetimeValidator
+)
 from orionis.services.introspection.abstract.reflection import ReflectionAbstract
 from orionis.services.introspection.callables.reflection import ReflectionCallable
 

{orionis-0.407.0 → orionis-0.408.0}/orionis/container/enums/lifetimes.py

@@ -23,7 +23,9 @@ class Lifetime(Enum):
 
     # A new instance is provided every time the dependency is requested.
     TRANSIENT = auto()
+
     # A single shared instance is provided for the entire application lifetime.
     SINGLETON = auto()
+
     # An instance is provided per scope (e.g., per request or session).
     SCOPED = auto()

orionis-0.408.0/orionis/container/validators/__init__.py

@@ -0,0 +1,21 @@
+from .implements import ImplementsAbstractMethods
+from .is_abstract_class import IsAbstractClass
+from .is_concrete_class import IsConcreteClass
+from .is_instance import IsInstance
+from .is_callable import IsCallable
+from .is_subclass import IsSubclass
+from .is_not_subclass import IsNotSubclass
+from .is_valid_alias import IsValidAlias
+from .lifetime import LifetimeValidator
+
+__all__ = [
+    "ImplementsAbstractMethods",
+    "IsAbstractClass",
+    "IsConcreteClass",
+    "IsInstance",
+    "IsCallable",
+    "IsSubclass",
+    "IsNotSubclass",
+    "IsValidAlias",
+    "LifetimeValidator",
+]

{orionis-0.407.0 → orionis-0.408.0}/orionis/metadata/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.407.0"
+VERSION = "0.408.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"

{orionis-0.407.0 → orionis-0.408.0/orionis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orionis
-Version: 0.407.0
+Version: 0.408.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

orionis-0.408.0/tests/container/context/test_manager.py

@@ -0,0 +1,37 @@
+from orionis.container.context.manager import ScopeManager
+from orionis.test.cases.asynchronous import AsyncTestCase
+
+class TestScopeManagerMethods(AsyncTestCase):
+
+    def testMethodsExist(self):
+        """
+        Checks that all required methods are present in the ScopeManager class.
+
+        This test verifies the existence of a predefined list of methods that are
+        essential for the correct functioning of ScopeManager. The methods checked
+        include initialization, item access, containment, clearing, and context
+        management methods.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts the existence of methods
+            and fails the test if any are missing.
+        """
+        # List of expected method names in ScopeManager
+        expected_methods = [
+            "__init__",
+            "__getitem__",
+            "__setitem__",
+            "__contains__",
+            "clear",
+            "__enter__",
+            "__exit__"
+        ]
+
+        # Check each method for existence in ScopeManager
+        for method in expected_methods:
+            self.assertTrue(
+                hasattr(ScopeManager, method),  # Assert method exists
+                f"Method '{method}' does not exist in ScopeManager class."
+            )

orionis-0.408.0/tests/container/context/test_scope.py

@@ -0,0 +1,31 @@
+from orionis.container.context.scope import ScopedContext
+from orionis.test.cases.asynchronous import AsyncTestCase
+
+class TestScopedContextMethods(AsyncTestCase):
+
+    def testMethodsExist(self):
+        """
+        Checks that all required methods are present in the ScopedContext class.
+
+        This test verifies the existence of specific methods that are essential for the correct
+        operation of ScopedContext. It ensures that the class interface is complete and that
+        method names have not been changed or removed.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts the existence of methods and fails the test if any are missing.
+        """
+        # List of method names expected to be present in ScopedContext
+        expected_methods = [
+            "getCurrentScope",
+            "setCurrentScope",
+            "clear"
+        ]
+
+        # Iterate through each expected method and assert its existence
+        for method in expected_methods:
+            self.assertTrue(
+                hasattr(ScopedContext, method),
+                f"Method '{method}' does not exist in ScopedContext class."
+            )

orionis-0.408.0/tests/container/entities/test_binding.py

@@ -0,0 +1,242 @@
+from orionis.container.entities.binding import Binding
+from orionis.container.enums.lifetimes import Lifetime
+from orionis.container.exceptions.type import OrionisContainerTypeError
+from orionis.test.cases.asynchronous import AsyncTestCase
+
+class TestBinding(AsyncTestCase):
+
+    async def testBindingInitialization(self):
+        """
+        Test initialization of a Binding object with default values.
+
+        This test verifies that when a Binding instance is created without any arguments,
+        all attributes are set to their expected default values.
+
+        Parameters
+        ----------
+        self : TestBinding
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return anything. Assertions are used to validate behavior.
+
+        Raises
+        ------
+        AssertionError
+            If any of the default values are incorrect or the Binding initialization fails.
+        """
+
+        # Create a Binding instance with default parameters
+        binding: Binding = Binding()
+
+        # Assert that all attributes are set to their default values
+        self.assertIsNone(binding.contract)                         # Default contract should be None
+        self.assertIsNone(binding.concrete)                         # Default concrete should be None
+        self.assertIsNone(binding.instance)                         # Default instance should be None
+        self.assertIsNone(binding.function)                         # Default function should be None
+        self.assertEqual(binding.lifetime, Lifetime.TRANSIENT)      # Default lifetime should be TRANSIENT
+        self.assertFalse(binding.enforce_decoupling)                # Default enforce_decoupling should be False
+        self.assertIsNone(binding.alias)                            # Default alias should be None
+
+    async def testBindingCustomValues(self):
+        """
+        Test initialization of a Binding object with custom values.
+
+        This test verifies that when a Binding instance is created with explicit arguments,
+        all attributes are set to the provided custom values, and the object reflects the intended configuration.
+
+        Parameters
+        ----------
+        self : TestBinding
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return anything. Assertions are used to validate correct attribute assignment.
+
+        Raises
+        ------
+        AssertionError
+            If the Binding initialization fails or custom values are not set correctly.
+        """
+
+        # Define dummy contract and concrete classes for testing
+        class TestContract: pass
+        class TestConcrete: pass
+
+        # Create an instance for the 'instance' attribute
+        instance = TestConcrete()
+
+        # Define a factory function for the 'function' attribute
+        factory_func = lambda: TestConcrete()
+
+        # Initialize Binding with custom values
+        binding = Binding(
+            contract=TestContract,
+            concrete=TestConcrete,
+            instance=instance,
+            function=factory_func,
+            lifetime=Lifetime.SINGLETON,
+            enforce_decoupling=True,
+            alias="test_binding"
+        )
+
+        # Assert that all attributes are set to the provided custom values
+        self.assertIs(binding.contract, TestContract)
+        self.assertIs(binding.concrete, TestConcrete)
+        self.assertIs(binding.instance, instance)
+        self.assertIs(binding.function, factory_func)
+        self.assertEqual(binding.lifetime, Lifetime.SINGLETON)
+        self.assertTrue(binding.enforce_decoupling)
+        self.assertEqual(binding.alias, "test_binding")
+
+    async def testBindingPostInitValidation(self):
+        """
+        Validates that the `__post_init__` method of the `Binding` class raises appropriate
+        exceptions when invalid types are provided for certain attributes.
+
+        This test ensures that type validation is enforced for the `lifetime`, `enforce_decoupling`,
+        and `alias` attributes during initialization. If an invalid type is passed, the
+        `OrionisContainerTypeError` should be raised.
+
+        Parameters
+        ----------
+        self : TestBinding
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return anything. Assertions are used to validate that
+            exceptions are raised for invalid input types.
+
+        Raises
+        ------
+        AssertionError
+            If the expected `OrionisContainerTypeError` is not raised when invalid types
+            are provided for the attributes.
+        """
+
+        # Attempt to initialize Binding with an invalid lifetime type (should raise exception)
+        with self.assertRaises(OrionisContainerTypeError):
+            Binding(lifetime="not_a_lifetime")
+
+        # Attempt to initialize Binding with an invalid enforce_decoupling type (should raise exception)
+        with self.assertRaises(OrionisContainerTypeError):
+            Binding(enforce_decoupling="not_a_bool")
+
+        # Attempt to initialize Binding with an invalid alias type (should raise exception)
+        with self.assertRaises(OrionisContainerTypeError):
+            Binding(alias=123)
+
+    async def testToDictMethod(self):
+        """
+        Tests the `toDict` method of the `Binding` class to ensure it returns a correct dictionary representation
+        of the binding's attributes.
+
+        This test verifies that the dictionary contains all expected keys and that their values match the attributes
+        set during initialization. It also checks that the types and values are correctly preserved.
+
+        Parameters
+        ----------
+        self : TestBinding
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return anything. Assertions are used to validate the correctness of the dictionary representation.
+
+        Raises
+        ------
+        AssertionError
+            If the dictionary representation is incorrect or any attribute does not match the expected value.
+        """
+
+        # Define dummy contract and concrete classes for testing
+        class TestContract: pass
+        class TestConcrete: pass
+
+        # Create a Binding instance with custom values
+        binding = Binding(
+            contract=TestContract,
+            concrete=TestConcrete,
+            lifetime=Lifetime.SINGLETON,
+            enforce_decoupling=True,
+            alias="test_binding"
+        )
+
+        # Get the dictionary representation of the binding
+        result = binding.toDict()
+
+        # Assert that the result is a dictionary
+        self.assertIsInstance(result, dict)
+
+        # Assert that contract and concrete are correctly set
+        self.assertIs(result["contract"], TestContract)
+        self.assertIs(result["concrete"], TestConcrete)
+
+        # Assert that instance and function are None by default
+        self.assertIsNone(result["instance"])
+        self.assertIsNone(result["function"])
+
+        # Assert that lifetime, enforce_decoupling, and alias are correctly set
+        self.assertEqual(result["lifetime"], Lifetime.SINGLETON)
+        self.assertTrue(result["enforce_decoupling"])
+        self.assertEqual(result["alias"], "test_binding")
+
+    async def testGetFieldsMethod(self):
+        """
+        Tests the `getFields` method of the `Binding` class to ensure it returns accurate field metadata.
+
+        This test verifies that the returned list contains the expected number of fields, that all expected
+        field names are present, and that specific field metadata (such as default values and descriptions)
+        are correctly provided for the `lifetime` field.
+
+        Parameters
+        ----------
+        self : TestBinding
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return anything. Assertions are used to validate the correctness of the
+            field metadata returned by `getFields`.
+
+        Raises
+        ------
+        AssertionError
+            If the field information is incorrect, such as missing fields, incorrect defaults, or missing metadata.
+        """
+
+        # Create a Binding instance with default parameters
+        binding = Binding()
+
+        # Retrieve field metadata using getFields
+        fields_info = binding.getFields()
+
+        # Assert that the returned value is a list
+        self.assertIsInstance(fields_info, list)
+
+        # Assert that there are exactly 7 fields
+        self.assertEqual(len(fields_info), 7)
+
+        # Extract field names from the metadata
+        field_names = [field["name"] for field in fields_info]
+        expected_names = ["contract", "concrete", "instance", "function", "lifetime", "enforce_decoupling", "alias"]
+
+        # Assert that all expected field names are present
+        self.assertTrue(all(name in field_names for name in expected_names))
+
+        # Find the metadata for the 'lifetime' field
+        lifetime_field = next(field for field in fields_info if field["name"] == "lifetime")
+
+        # Assert that the default value for 'lifetime' is correct
+        self.assertEqual(lifetime_field["default"], Lifetime.TRANSIENT.value)
+
+        # Assert that the 'lifetime' field contains a description in its metadata
+        self.assertIn("description", lifetime_field["metadata"])

orionis-0.408.0/tests/container/enums/test_lifetimes.py

@@ -0,0 +1,97 @@
+from orionis.container.enums.lifetimes import Lifetime
+from orionis.test.cases.asynchronous import AsyncTestCase
+
+class TestLifetime(AsyncTestCase):
+
+    async def testLifetimeValuesExist(self) -> None:
+        """
+        Checks that the `Lifetime` enum contains the expected lifecycle values.
+
+        This test verifies the presence of the following enum members:
+        - `TRANSIENT`
+        - `SINGLETON`
+        - `SCOPED`
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts the existence of enum members.
+        """
+
+        # Assert that each expected enum member exists in Lifetime
+        self.assertIn(Lifetime.TRANSIENT, Lifetime)
+        self.assertIn(Lifetime.SINGLETON, Lifetime)
+        self.assertIn(Lifetime.SCOPED, Lifetime)
+
+    async def testLifetimeValuesAreUnique(self) -> None:
+        """
+        Ensures that all `Lifetime` enum values are unique.
+
+        This test collects the integer values of all enum members and checks that
+        there are no duplicates.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts uniqueness of enum values.
+        """
+
+        # Gather all enum values
+        values = [member.value for member in Lifetime]
+
+        # Assert that all values are unique
+        self.assertEqual(len(values), len(set(values)))
+
+    async def testLifetimeCount(self) -> None:
+        """
+        Validates that the `Lifetime` enum defines exactly three lifecycle types.
+
+        This test ensures that no additional or missing enum members exist.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts the count of enum members.
+        """
+
+        # Assert that there are exactly three members in the Lifetime enum
+        self.assertEqual(len(list(Lifetime)), 3)
+
+    async def testLifetimeStringRepresentation(self) -> None:
+        """
+        Verifies the string representation of `Lifetime` enum members.
+
+        This test checks that converting each enum member to a string yields the expected format.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts string representations.
+        """
+
+        # Assert that string representations match expected format
+        self.assertEqual(str(Lifetime.TRANSIENT), "Lifetime.TRANSIENT")
+        self.assertEqual(str(Lifetime.SINGLETON), "Lifetime.SINGLETON")
+        self.assertEqual(str(Lifetime.SCOPED), "Lifetime.SCOPED")
+
+    async def testLifetimeComparison(self) -> None:
+        """
+        Tests comparison operations between `Lifetime` enum members.
+
+        This test verifies that each enum member is only equal to itself and not to others.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts comparison results.
+        """
+
+        # Assert that different enum members are not equal
+        self.assertNotEqual(Lifetime.TRANSIENT, Lifetime.SINGLETON)
+        self.assertNotEqual(Lifetime.SINGLETON, Lifetime.SCOPED)
+        self.assertNotEqual(Lifetime.TRANSIENT, Lifetime.SCOPED)
+
+        # Assert that each enum member is equal to itself
+        self.assertEqual(Lifetime.TRANSIENT, Lifetime.TRANSIENT)
+        self.assertEqual(Lifetime.SINGLETON, Lifetime.SINGLETON)
+        self.assertEqual(Lifetime.SCOPED, Lifetime.SCOPED)

{orionis-0.407.0 → orionis-0.408.0}/tests/container/facades/test_facade.py

@@ -8,22 +8,31 @@ class TestFacadeMethods(AsyncTestCase):
         """
         Verify the existence of essential methods in the Facade and FacadeMeta classes.
 
-        This test ensures that the following methods are implemented:
-        - 'getFacadeAccessor' in the Facade class
-        - 'resolve' in the Facade class
-        - '__getattr__' in the FacadeMeta class
+        This test checks for the implementation of the following methods:
+            - 'getFacadeAccessor' in the Facade class
+            - 'resolve' in the Facade class
+            - '__getattr__' in the FacadeMeta class
 
-        Returns:
-            None. The method asserts the presence of required methods and raises AssertionError if any are missing.
+        The method asserts the presence of these required methods and raises an AssertionError if any are missing.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            Returns None. The method performs assertions to validate method existence.
         """
 
+        # List of expected methods and their corresponding classes
         expected_methods = [
             ("getFacadeAccessor", Facade),
             ("resolve", Facade),
             ("__getattr__", FacadeMeta),
         ]
 
-        # Check each expected method for existence in its respective class
+        # Iterate through each expected method and assert its existence
         for method_name, cls in expected_methods:
             self.assertTrue(
                 hasattr(cls, method_name),
@@ -35,12 +44,20 @@ class TestFacadeMethods(AsyncTestCase):
         Validate the method signatures of key Facade and FacadeMeta class methods.
 
         This test checks that:
-        - 'getFacadeAccessor' in Facade accepts no parameters.
-        - 'resolve' in Facade accepts variable positional and keyword arguments.
-        - '__getattr__' in FacadeMeta accepts 'cls' and 'name' as parameters.
+            - 'getFacadeAccessor' in Facade accepts no parameters.
+            - 'resolve' in Facade accepts variable positional and keyword arguments.
+            - '__getattr__' in FacadeMeta accepts 'cls' and 'name' as parameters.
+
+        The method asserts correct method signatures and raises AssertionError if any signature does not match expectations.
+
+        Parameters
+        ----------
+        None
 
-        Returns:
-            None. The method asserts correct method signatures and raises AssertionError if any signature does not match expectations.
+        Returns
+        -------
+        None
+            Returns None. The method performs assertions to validate method signatures.
         """
 
         # Check that getFacadeAccessor has no parameters

{orionis-0.407.0 → orionis-0.408.0}/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."
         )

{orionis-0.407.0 → orionis-0.408.0}/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)),