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

tests/container/entities/test_binding.py

@@ -0,0 +1,133 @@
+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 that a Binding can be initialized with default values.
+
+        Raises
+        ------
+        AssertionError
+            If the Binding initialization fails or default values are incorrect.
+        """
+        binding: Binding = Binding()
+        self.assertIsNone(binding.contract)
+        self.assertIsNone(binding.concrete)
+        self.assertIsNone(binding.instance)
+        self.assertIsNone(binding.function)
+        self.assertEqual(binding.lifetime, Lifetime.TRANSIENT)
+        self.assertFalse(binding.enforce_decoupling)
+        self.assertIsNone(binding.alias)
+
+    async def testBindingCustomValues(self):
+        """
+        Test that a Binding can be initialized with custom values.
+
+        Raises
+        ------
+        AssertionError
+            If the Binding initialization fails or custom values are not set correctly.
+        """
+        class TestContract: pass
+        class TestConcrete: pass
+
+        instance = TestConcrete()
+        factory_func = lambda: TestConcrete()
+
+        binding = Binding(
+            contract=TestContract,
+            concrete=TestConcrete,
+            instance=instance,
+            function=factory_func,
+            lifetime=Lifetime.SINGLETON,
+            enforce_decoupling=True,
+            alias="test_binding"
+        )
+
+        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):
+        """
+        Test that __post_init__ validation works correctly.
+
+        Raises
+        ------
+        AssertionError
+            If validation errors are not raised appropriately.
+        """
+        # Test invalid lifetime
+        with self.assertRaises(OrionisContainerTypeError):
+            Binding(lifetime="not_a_lifetime")
+
+        # Test invalid enforce_decoupling
+        with self.assertRaises(OrionisContainerTypeError):
+            Binding(enforce_decoupling="not_a_bool")
+
+        # Test invalid alias
+        with self.assertRaises(OrionisContainerTypeError):
+            Binding(alias=123)
+
+    async def testToDictMethod(self):
+        """
+        Test that toDict method returns a correct dictionary representation.
+
+        Raises
+        ------
+        AssertionError
+            If the dictionary representation is incorrect.
+        """
+        class TestContract: pass
+        class TestConcrete: pass
+
+        binding = Binding(
+            contract=TestContract,
+            concrete=TestConcrete,
+            lifetime=Lifetime.SINGLETON,
+            enforce_decoupling=True,
+            alias="test_binding"
+        )
+
+        result = binding.toDict()
+
+        self.assertIsInstance(result, dict)
+        self.assertIs(result["contract"], TestContract)
+        self.assertIs(result["concrete"], TestConcrete)
+        self.assertIsNone(result["instance"])
+        self.assertIsNone(result["function"])
+        self.assertEqual(result["lifetime"], Lifetime.SINGLETON)
+        self.assertTrue(result["enforce_decoupling"])
+        self.assertEqual(result["alias"], "test_binding")
+
+    async def testGetFieldsMethod(self):
+        """
+        Test that getFields method returns correct field information.
+
+        Raises
+        ------
+        AssertionError
+            If the field information is incorrect.
+        """
+        binding = Binding()
+        fields_info = binding.getFields()
+
+        self.assertIsInstance(fields_info, list)
+        self.assertEqual(len(fields_info), 7)
+
+        field_names = [field["name"] for field in fields_info]
+        expected_names = ["contract", "concrete", "instance", "function","lifetime", "enforce_decoupling", "alias"]
+        self.assertTrue(all(name in field_names for name in expected_names))
+
+        # Test specific field information
+        lifetime_field = next(field for field in fields_info if field["name"] == "lifetime")
+        self.assertEqual(lifetime_field["default"], Lifetime.TRANSIENT.value)
+        self.assertIn("description", lifetime_field["metadata"])

tests/container/enums/test_lifetimes.py

@@ -0,0 +1,63 @@
+from orionis.container.enums.lifetimes import Lifetime
+from orionis.test.cases.asynchronous import AsyncTestCase
+
+class TestLifetime(AsyncTestCase):
+    """
+    Test cases for the Lifetime enum in orionis.container.enums.lifetimes.
+
+    Notes
+    -----
+    This test suite validates the enumeration values and behavior of the Lifetime enum
+    which defines the lifecycle types for dependency injection.
+    """
+
+    async def testLifetimeValuesExist(self) -> None:
+        """
+        Test that the Lifetime enum contains the expected values.
+
+        Verifies that TRANSIENT, SINGLETON, and SCOPED values are present in the enum.
+        """
+        self.assertIn(Lifetime.TRANSIENT, Lifetime)
+        self.assertIn(Lifetime.SINGLETON, Lifetime)
+        self.assertIn(Lifetime.SCOPED, Lifetime)
+
+    async def testLifetimeValuesAreUnique(self) -> None:
+        """
+        Test that all Lifetime enum values are unique.
+
+        Ensures that each enum value has a distinct integer value.
+        """
+        values = [member.value for member in Lifetime]
+        self.assertEqual(len(values), len(set(values)))
+
+    async def testLifetimeCount(self) -> None:
+        """
+        Test that the Lifetime enum has exactly 3 members.
+
+        Verifies that no additional or missing lifecycle types exist.
+        """
+        self.assertEqual(len(list(Lifetime)), 3)
+
+    async def testLifetimeStringRepresentation(self) -> None:
+        """
+        Test the string representation of Lifetime enum values.
+
+        Verifies that the string representation of enum values matches their names.
+        """
+        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:
+        """
+        Test comparison operations between Lifetime enum values.
+
+        Verifies that enum values can be correctly compared with each other.
+        """
+        self.assertNotEqual(Lifetime.TRANSIENT, Lifetime.SINGLETON)
+        self.assertNotEqual(Lifetime.SINGLETON, Lifetime.SCOPED)
+        self.assertNotEqual(Lifetime.TRANSIENT, Lifetime.SCOPED)
+
+        self.assertEqual(Lifetime.TRANSIENT, Lifetime.TRANSIENT)
+        self.assertEqual(Lifetime.SINGLETON, Lifetime.SINGLETON)
+        self.assertEqual(Lifetime.SCOPED, Lifetime.SCOPED)

tests/container/facades/test_facade.py

@@ -0,0 +1,61 @@
+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 ensures that the following methods are implemented:
+        - '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.
+        """
+
+        expected_methods = [
+            ("getFacadeAccessor", Facade),
+            ("resolve", Facade),
+            ("__getattr__", FacadeMeta),
+        ]
+
+        # Check each expected method for existence in its respective class
+        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.
+
+        Returns:
+            None. The method asserts correct method signatures and raises AssertionError if any signature does not match expectations.
+        """
+
+        # 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")