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

tests/container/entities/test_binding.py

@@ -1,242 +0,0 @@
-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 TestEntities(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"])

tests/container/enums/test_lifetimes.py

@@ -1,97 +0,0 @@
-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)

tests/container/facades/test_facade.py

@@ -1,78 +0,0 @@
-import inspect
-from orionis.container.facades.facade import FacadeMeta, Facade
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFacadeMethods(AsyncTestCase):
-
-    async def testFacadeMethodsExist(self):
-        """
-        Verify the existence of essential methods in the Facade and FacadeMeta classes.
-
-        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
-
-        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),
-        ]
-
-        # Iterate through each expected method and assert its existence
-        for method_name, cls in expected_methods:
-            self.assertTrue(
-                hasattr(cls, method_name),
-                f"Method '{method_name}' does not exist in {cls.__name__}."
-            )
-
-    async def testFacadeMethodSignatures(self):
-        """
-        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.
-
-        The method asserts correct method signatures and raises AssertionError if any signature does not match expectations.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
-            Returns None. The method performs assertions to validate method signatures.
-        """
-
-        # Check that getFacadeAccessor has no parameters
-        sig = inspect.signature(Facade.getFacadeAccessor)
-        params = list(sig.parameters.values())
-        self.assertEqual(len(params), 0)
-
-        # Check that resolve has *args and **kwargs as parameters
-        sig = inspect.signature(Facade.resolve)
-        params = list(sig.parameters.values())
-        self.assertEqual(params[0].name, "args")
-        self.assertEqual(params[1].kind, inspect.Parameter.VAR_KEYWORD)
-
-        # Check that __getattr__ has 'cls' and 'name' as parameters
-        sig = inspect.signature(FacadeMeta.__getattr__)
-        params = list(sig.parameters.values())
-        self.assertEqual(params[0].name, "cls")
-        self.assertEqual(params[1].name, "name")