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

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/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/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/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.dist-info → orionis-0.408.0.dist-info}/METADATA

@@ -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.dist-info → orionis-0.408.0.dist-info}/RECORD

@@ -114,7 +114,7 @@ orionis/console/output/contracts/console.py,sha256=phaQhCLWa81MLzB5ydOSaUfEIdDq7
 orionis/console/output/enums/__init__.py,sha256=LAaAxg-DpArCjf_jqZ0_9s3p8899gntDYkSU_ppTdC8,66
 orionis/console/output/enums/styles.py,sha256=6a4oQCOBOKMh2ARdeq5GlIskJ3wjiylYmh66tUKKmpQ,4053
 orionis/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/container/container.py,sha256=mnhvm_PZEyHik1rQYBkSrvF-_40hMuWk5mBlRRaHqZU,23174
+orionis/container/container.py,sha256=ICKSeaXA_IL15jV6Ofe1wIb1QyX-F-8oaGuk7hj955I,22773
 orionis/container/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/container/context/manager.py,sha256=9yODWkHBoJ2kgJZ5ONLqcEcex50vaWuMcxsvmDgnQo4,2437
 orionis/container/context/scope.py,sha256=jhRGGO6oZcWNa3eCaurGwPngTUsCuMm7asIa24d6q3Q,962
@@ -125,7 +125,7 @@ orionis/container/contracts/service_provider.py,sha256=qYBWCw55pudk8QnbjX0_FRKsz
 orionis/container/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/container/entities/binding.py,sha256=sY0ioHbRcjp9TSQjfrFHxkO3vRn_VOrbHK62_QEGe1U,3717
 orionis/container/enums/__init__.py,sha256=BRpTC9sY0dWlGsGfE96uZ8TZqU28kXTP0HEH8DdC9c8,65
-orionis/container/enums/lifetimes.py,sha256=4TNXtj3rqQRuJ0XRmJN1yBD0hIXrI2A1I9gmmRDxfaA,1043
+orionis/container/enums/lifetimes.py,sha256=ntvF_cmmOWA0ujyxwdUmgJK7O6M9kCYlmrfcEmhwarM,1047
 orionis/container/exceptions/__init__.py,sha256=uJU8ncq66d26tWRFZfxBzs6AyYu5eIuDe-N3mcFg4vw,354
 orionis/container/exceptions/attribute.py,sha256=ysYKvXfunH-bywK_e02inY94s8aZ3vUZA6jATbDcQmk,480
 orionis/container/exceptions/exception.py,sha256=goTDEwC70xTMD2qppN8KV-xyR0Nps218OD4D1LZ2-3s,470
@@ -137,7 +137,7 @@ orionis/container/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 orionis/container/providers/service_provider.py,sha256=j0-8p7210YKb1HhI9Bug1TZ165rcrpdyEGenw-dfCPY,1946
 orionis/container/resolver/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/container/resolver/resolver.py,sha256=8mTouPo9hhMwz1CxZcqmzZlg3vHoLCs5HEWtreZ-KWk,23523
-orionis/container/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/container/validators/__init__.py,sha256=iJ_cY8U0EkpnZOU4_LANGKHFkvHeV0vH5bjbYr1fdSg,609
 orionis/container/validators/implements.py,sha256=xDXK7yhG5GGGRT9Mj1UbbVrcVTgifmjFZdaAJG4Ke8o,3110
 orionis/container/validators/is_abstract_class.py,sha256=vJqUPn610YZS0sEkV8c_gPZskIgWmFHjg3D3MF2OTs8,1141
 orionis/container/validators/is_callable.py,sha256=ZW-e3ljJGXbD9GUEfPNqVcyBbpVHFlfYaTf9rSmJmBk,824
@@ -258,7 +258,7 @@ orionis/foundation/providers/progress_bar_provider.py,sha256=WW3grNgH-yV2meSSTeO
 orionis/foundation/providers/testing_provider.py,sha256=iJSN2RIChbYIL-1ue6vmPmDMCSrvERDkti4Er9MPiLA,1102
 orionis/foundation/providers/workers_provider.py,sha256=kiQjQRyUEyiBX2zcbF_KmqRgvc7Bvxsvg5oMtIvYniM,1075
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=sxmczNtZqJR0Rs5IYehyU1JvfxRfRsuHwLo1m8wI70g,4960
+orionis/metadata/framework.py,sha256=lyVpWF0MG5Xr2V2hDnMRTAMzJ-rQJ2v7c8oWkA1Dmno,4960
 orionis/metadata/package.py,sha256=tqLfBRo-w1j_GN4xvzUNFyweWYFS-qhSgAEc-AmCH1M,5452
 orionis/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/asynchrony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -428,38 +428,38 @@ orionis/test/validators/web_report.py,sha256=-h3Fe9jY93_kzUhd2NBIqEfCcBpu-8Ei9x3
 orionis/test/validators/workers.py,sha256=LGffDKtK6SKixFKzIYPQpI5aFeQPAGXpv_LUtmEu6g4,1102
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=3ICz68l-WF3BtnYqH5m-ktN9UD00MELMbmMnyJDV74A,4768
-orionis-0.407.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.408.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/container/test_container.py,sha256=INLMHbcQzB7SQi6W0xO_nKCMUw50VK7NQMPRDuYnU5Q,10781
-tests/container/test_singleton.py,sha256=ZLFtoR0VJa_PJVp9Gzh9NdhvpquTAqxlGYr_CZ90Bbg,3741
-tests/container/test_thread_safety.py,sha256=BfFMKggQmRqfVo1KdGVP6jD3wP1Pqoh0FEEmNjI4GTw,7934
+tests/container/test_container.py,sha256=asv8TkkupVoex6SWod74NBl4dSs7wb9mLmu_glNdNy8,14815
+tests/container/test_singleton.py,sha256=GkwFaLtRvOQCNMpaCXfQiPu6tJWRm3gkDaJ0vzQn1ko,4689
+tests/container/test_thread_safety.py,sha256=0gn6kawiSMSMP1iTGWZP-4cQcO2RWXo9Ay4skcihKEM,3740
 tests/container/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/container/context/test_manager.py,sha256=jj7c7TPUU8EkvI0I4uiWgts-Ahl53rcHd-H307KiDOk,862
-tests/container/context/test_scope.py,sha256=xqRvoon0FY2ECymuAqrTGdpcHiziZ8RtxifG6M8zY64,769
+tests/container/context/test_manager.py,sha256=QfzhzkK5LFmtI7AEE-dzceBROTo7VNnQfL3EGgYqK64,1354
+tests/container/context/test_scope.py,sha256=2ykGAmey5xu3cXASseIiOHosJ4QwABbQqRU3_WahO8c,1221
 tests/container/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/container/entities/test_binding.py,sha256=ESM8nk0_YNnCSmEqDO9bH6FfhofyCQfbV2z1Uu7cwBs,4754
+tests/container/entities/test_binding.py,sha256=AZ5jUF0MMwTXueevZnYbLpF73g7qrAcvx51jlKMfqkg,9708
 tests/container/enums/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/container/enums/test_lifetimes.py,sha256=tLiWZCeMtcvhX9mCfn5Ug2kDeVdjf5f-CPzQsaAsMB8,2479
+tests/container/enums/test_lifetimes.py,sha256=JFb4q1rgo10C5ibQ6LS-776NevxCMNLSq_cd7D1O8Ps,3511
 tests/container/facades/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/container/facades/test_facade.py,sha256=EBhxxecOYZxQCaoDe7fz11jm4920w-9FFZDaA6eSz9I,2503
+tests/container/facades/test_facade.py,sha256=aCy0S6YaaiswGoodJEAhNkqJrMaEQL-CcWh2AgXMvvQ,2938
 tests/container/mocks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/container/mocks/mock_complex_classes.py,sha256=DKBD2Wd8n_dDPXRo-HepEOy3L6w7ACfFpeQKVuIFlRA,15026
 tests/container/mocks/mock_simple_classes.py,sha256=rvHFEYAzEnLvL79WWS-YCNwIEPsx14FEo2v3wrdibzE,841
 tests/container/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/container/providers/test_providers.py,sha256=4BujCYLHoesG5jpArknplBi0rqiA4DAKcB_sjGWcFFw,1914
+tests/container/providers/test_providers.py,sha256=qGh2vtrLYp_S7u3U64I22Fzr86NsDZw0tXtJioSDdms,2149
 tests/container/resolver/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/container/resolver/test_resolver.py,sha256=_QGfGYiA-DubioBkuH6HOFBnrFB6aS_ughYFurKT_qk,2175
+tests/container/resolver/test_resolver.py,sha256=6p3XMIme53QLEbPpTBfs3dLzESMK_5fGYbr2TNPolTI,2313
 tests/container/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/container/validators/test_implements.py,sha256=B85sAAqzoIbI-i4ZsjDm1pTGsFbLJQJFJKYbKUvh0Mc,5025
-tests/container/validators/test_is_abstract_class.py,sha256=9QqKHZ3pKVsjvvsPn3vkiwL6bDdB0GWCsxrWaRHDoRI,4464
-tests/container/validators/test_is_callable.py,sha256=d8ZsPFriZtoqNPlZIU-1bgwy6sqXc5-swahjgEoP7ds,2284
-tests/container/validators/test_is_concrete_class.py,sha256=76gDFaXKD0LSiEro-KPsjERfVKQYiFQ_dSqeSidG6z8,3638
-tests/container/validators/test_is_instance.py,sha256=wanHMUebe8MxW0TuK_mwg63q_EsVbOm6ixvMNuNMH3Q,3540
-tests/container/validators/test_is_not_subclass.py,sha256=t1spircP5AYQbaQyoKT8oXflSAxoA0FgF7PWbCw9xAg,3996
-tests/container/validators/test_is_subclass.py,sha256=iid5n1B6GDYqwtSlmRG0lJBH6gXeZ4legcOqiAM8EL0,3750
-tests/container/validators/test_is_valid_alias.py,sha256=mRkdDLHZuM0ogJn38lV35gwnxXP3J-a-1EWaoij-qUM,3957
-tests/container/validators/test_lifetime.py,sha256=2iOO8Leo7VHb9ZrbiwaTptFC4hHv3QStomcFMO3qSH0,3191
+tests/container/validators/test_implements.py,sha256=XquLuD3WGRPfSj2Jfd5uBTV48h8FPU0E-cJeEjZohEo,6759
+tests/container/validators/test_is_abstract_class.py,sha256=_xW8NrnrmG5tKocaGs83r118S-t-YbaMTal-cWXtM0k,6868
+tests/container/validators/test_is_callable.py,sha256=VbQNKZ4sVQeWnqAIZ7R2E-6uFnT78Gcdaxf7Gq-qWlw,3767
+tests/container/validators/test_is_concrete_class.py,sha256=bD8F_fbeWLf61I-7sCeapugvXl1-oSx8iVawuYF4tY4,6362
+tests/container/validators/test_is_instance.py,sha256=skRLexi-31IxJrW0nSYwTW84iqXvi0IVqxHm0X-YfC0,5255
+tests/container/validators/test_is_not_subclass.py,sha256=1OCPtCRuysm7OKL6XhuXJPZQPumtZZqfoiYtC4HzNFA,1983
+tests/container/validators/test_is_subclass.py,sha256=0Uc8uIR69ZX7G5Nrex0LMQXrueTdncdDxfQoila3h3U,5834
+tests/container/validators/test_is_valid_alias.py,sha256=egVf6IfSXurIdu8hKo03rwsM1P-bxGOFd1_9JjDHJIk,5657
+tests/container/validators/test_lifetime.py,sha256=5PequjXAcIcp0Q4TIki7THSU31XftGpI0u1mVGqHmpU,4692
 tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/test_example.py,sha256=XJEcsro3vCO5m4zvMiWUGphvd0C7oIkBtUfQgTDsdUU,25568
 tests/foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -559,8 +559,8 @@ tests/support/wrapper/test_services_wrapper_docdict.py,sha256=nTNrvJkMSPx_aopEQ9
 tests/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/test_testing_result.py,sha256=aWOOJiHji_U7gcJHbDukgMmfBEEQCLQdyqpXJD5q4BE,4643
 tests/testing/test_testing_unit.py,sha256=Krz0Bw1toI9qvLtKtYe_slNvi7fYmZbHK1i4DRPMfUM,7952
-orionis-0.407.0.dist-info/METADATA,sha256=x5LuteMx1-CBNPvZWGQE24vZVBlrwoXIfo-QOGJDJFw,4772
-orionis-0.407.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-orionis-0.407.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.407.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.407.0.dist-info/RECORD,,
+orionis-0.408.0.dist-info/METADATA,sha256=n5ql9Cat7kQbHjFV3goNTgyUPgouORkrqTgZuMIwjjE,4772
+orionis-0.408.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orionis-0.408.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.408.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.408.0.dist-info/RECORD,,

tests/container/context/test_manager.py

@@ -2,14 +2,23 @@ from orionis.container.context.manager import ScopeManager
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestScopeManagerMethods(AsyncTestCase):
-    """
-    Test suite to ensure all required methods exist in ScopeManager and their signatures are preserved.
-    """
 
     def testMethodsExist(self):
         """
-        Verify that all required methods exist in the ScopeManager class.
+        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__",
@@ -20,8 +29,9 @@ class TestScopeManagerMethods(AsyncTestCase):
             "__exit__"
         ]
 
+        # Check each method for existence in ScopeManager
         for method in expected_methods:
             self.assertTrue(
-                hasattr(ScopeManager, method),
+                hasattr(ScopeManager, method),  # Assert method exists
                 f"Method '{method}' does not exist in ScopeManager class."
             )

tests/container/context/test_scope.py

@@ -2,20 +2,28 @@ from orionis.container.context.scope import ScopedContext
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestScopedContextMethods(AsyncTestCase):
-    """
-    Test suite to ensure all required methods exist in ScopedContext and their signatures are preserved.
-    """
 
     def testMethodsExist(self):
         """
-        Verify that all required methods exist in the ScopedContext class.
+        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),

tests/container/entities/test_binding.py

@@ -7,37 +7,73 @@ class TestBinding(AsyncTestCase):
 
     async def testBindingInitialization(self):
         """
-        Test that a Binding can be initialized with default values.
+        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 the Binding initialization fails or default values are incorrect.
+            If any of the default values are incorrect or the Binding initialization fails.
         """
+
+        # Create a Binding instance with default parameters
         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)
+
+        # 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 that a Binding can be initialized with custom values.
+        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,
@@ -48,6 +84,7 @@ class TestBinding(AsyncTestCase):
             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)
@@ -58,37 +95,72 @@ class TestBinding(AsyncTestCase):
 
     async def testBindingPostInitValidation(self):
         """
-        Test that __post_init__ validation works correctly.
+        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 validation errors are not raised appropriately.
+            If the expected `OrionisContainerTypeError` is not raised when invalid types
+            are provided for the attributes.
         """
-        # Test invalid lifetime
+
+        # Attempt to initialize Binding with an invalid lifetime type (should raise exception)
         with self.assertRaises(OrionisContainerTypeError):
             Binding(lifetime="not_a_lifetime")
 
-        # Test invalid enforce_decoupling
+        # Attempt to initialize Binding with an invalid enforce_decoupling type (should raise exception)
         with self.assertRaises(OrionisContainerTypeError):
             Binding(enforce_decoupling="not_a_bool")
 
-        # Test invalid alias
+        # Attempt to initialize Binding with an invalid alias type (should raise exception)
         with self.assertRaises(OrionisContainerTypeError):
             Binding(alias=123)
 
     async def testToDictMethod(self):
         """
-        Test that toDict method returns a correct dictionary representation.
+        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.
+            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,
@@ -97,37 +169,74 @@ class TestBinding(AsyncTestCase):
             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):
         """
-        Test that getFields method returns correct field information.
+        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.
+            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"]
+        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))
 
-        # Test specific field information
+        # 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

@@ -2,62 +2,96 @@ 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.
+        Checks that the `Lifetime` enum contains the expected lifecycle values.
+
+        This test verifies the presence of the following enum members:
+        - `TRANSIENT`
+        - `SINGLETON`
+        - `SCOPED`
 
-        Verifies that TRANSIENT, SINGLETON, and SCOPED values are present in the enum.
+        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:
         """
-        Test that all Lifetime enum values are unique.
+        Ensures that all `Lifetime` enum values are unique.
 
-        Ensures that each enum value has a distinct integer value.
+        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:
         """
-        Test that the Lifetime enum has exactly 3 members.
+        Validates that the `Lifetime` enum defines exactly three lifecycle types.
 
-        Verifies that no additional or missing lifecycle types exist.
+        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:
         """
-        Test the string representation of Lifetime enum values.
+        Verifies the string representation of `Lifetime` enum members.
+
+        This test checks that converting each enum member to a string yields the expected format.
 
-        Verifies that the string representation of enum values matches their names.
+        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:
         """
-        Test comparison operations between Lifetime enum values.
+        Tests comparison operations between `Lifetime` enum members.
+
+        This test verifies that each enum member is only equal to itself and not to others.
 
-        Verifies that enum values can be correctly compared with each other.
+        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)