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

tests/container/validators/test_is_not_subclass.py

@@ -4,114 +4,47 @@ from orionis.container.exceptions.exception import OrionisContainerException
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestIsNotSubclass(AsyncTestCase):
-    """
-    Test cases for the IsNotSubclass validator in orionis.container.validators.is_not_subclass.
-
-    Notes
-    -----
-    This test suite validates the functionality of the IsNotSubclass validator
-    which ensures that a concrete class is NOT a subclass of an abstract class.
-    """
 
     async def testValidNonSubclass(self) -> None:
         """
-        Test that validation passes when concrete class is not a subclass.
-        """
-        # Define test classes
-        class AbstractClass1(ABC):
-            pass
+        Validate that `IsNotSubclass` does not raise an exception when the second argument
+        is not a subclass of the first argument.
 
-        class AbstractClass2(ABC):
-            pass
+        This test covers various scenarios including unrelated abstract classes, concrete classes,
+        and built-in types to ensure that only true subclass relationships trigger validation errors.
 
-        class ConcreteClass1(AbstractClass1):
-            pass
+        Parameters
+        ----------
+        self : TestIsNotSubclass
+            The test case instance.
 
-        class ConcreteClass2(AbstractClass2):
-            pass
-
-        # These should not raise exceptions
-        IsNotSubclass(AbstractClass1, AbstractClass2)
-        IsNotSubclass(AbstractClass1, ConcreteClass2)
-        IsNotSubclass(ConcreteClass1, AbstractClass1)
-        IsNotSubclass(int, str)
-        IsNotSubclass(list, dict)
+        Returns
+        -------
+        None
+            This method does not return any value.
 
-    async def testInvalidNonSubclass(self) -> None:
+        Raises
+        ------
+        AssertionError
+            If `IsNotSubclass` raises an exception for valid non-subclass relationships.
         """
-        Test that validation fails when concrete class IS a subclass.
-        """
-        # Define test classes
-        class AbstractClass(ABC):
-            pass
-
-        class ConcreteClass(AbstractClass):
+        # Define abstract base classes
+        class AbstractClass1(ABC):
             pass
 
-        class SubConcreteClass(ConcreteClass):
+        class AbstractClass2(ABC):
             pass
 
-        # These should raise exceptions
-        with self.assertRaises(OrionisContainerException) as context:
-            IsNotSubclass(AbstractClass, ConcreteClass)
-        self.assertIn("must NOT inherit", str(context.exception))
-
-        with self.assertRaises(OrionisContainerException) as context:
-            IsNotSubclass(AbstractClass, SubConcreteClass)
-        self.assertIn("must NOT inherit", str(context.exception))
-
-        with self.assertRaises(OrionisContainerException) as context:
-            IsNotSubclass(ConcreteClass, SubConcreteClass)
-        self.assertIn("must NOT inherit", str(context.exception))
-
-    async def testSameClass(self) -> None:
-        """
-        Test validation when abstract and concrete are the same class.
-        """
-        class TestClass:
+        # Define concrete classes inheriting from abstract base classes
+        class ConcreteClass1(AbstractClass1):
             pass
 
-        # A class is considered a subclass of itself, so this should raise an exception
-        with self.assertRaises(OrionisContainerException) as context:
-            IsNotSubclass(TestClass, TestClass)
-        self.assertIn("must NOT inherit", str(context.exception))
-
-    async def testBuiltinTypes(self) -> None:
-        """
-        Test validation with built-in types.
-        """
-        # Valid non-subclass relationships
-        IsNotSubclass(ValueError, Exception)
-        IsNotSubclass(int, str)
-        IsNotSubclass(list, dict)
-
-        # Invalid non-subclass relationships (are actually subclasses)
-        with self.assertRaises(OrionisContainerException):
-            IsNotSubclass(Exception, ValueError)
-
-        with self.assertRaises(OrionisContainerException):
-            IsNotSubclass(BaseException, Exception)
-
-    async def testNonClassArguments(self) -> None:
-        """
-        Test validation with non-class arguments which should raise TypeError.
-        """
-        class TestClass:
+        class ConcreteClass2(AbstractClass2):
             pass
 
-        # These should raise TypeError when passed to issubclass()
-        non_class_args = [
-            None,
-            123,
-            "string",
-            [],
-            {},
-            lambda x: x
-        ]
-
-        for arg in non_class_args:
-            with self.assertRaises(TypeError):
-                IsNotSubclass(TestClass, arg)
-
-            with self.assertRaises(TypeError):
-                IsNotSubclass(arg, TestClass)
+        # These calls should NOT raise exceptions since there is no subclass relationship
+        IsNotSubclass(AbstractClass1, AbstractClass2)  # Unrelated abstract classes
+        IsNotSubclass(AbstractClass1, ConcreteClass2)  # Unrelated concrete class
+        IsNotSubclass(ConcreteClass1, AbstractClass1)  # Concrete is not subclass of unrelated abstract
+        IsNotSubclass(int, str)                        # Built-in types, no subclass relationship
+        IsNotSubclass(list, dict)                      # Built-in types, no subclass relationship

tests/container/validators/test_is_subclass.py

@@ -4,52 +4,73 @@ from orionis.container.exceptions.exception import OrionisContainerException
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestIsSubclass(AsyncTestCase):
-    """
-    Test cases for the IsSubclass validator in orionis.container.validators.is_subclass.
-
-    Notes
-    -----
-    This test suite validates the functionality of the IsSubclass validator
-    which ensures that a concrete class is a subclass of an abstract class.
-    """
 
     async def testValidSubclass(self) -> None:
         """
-        Test that validation passes when concrete class is a valid subclass.
+        Validate that `IsSubclass` does not raise an exception when the concrete class is a valid subclass of the abstract class.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return anything. It passes if no exception is raised.
+
+        Notes
+        -----
+        The test covers direct and indirect subclass relationships.
         """
-        # Define test classes
+        # Define an abstract base class
         class AbstractClass(ABC):
             pass
 
+        # Define a concrete class inheriting from AbstractClass
         class ConcreteClass(AbstractClass):
             pass
 
+        # Define a subclass of ConcreteClass
         class SubConcreteClass(ConcreteClass):
             pass
 
-        # These should not raise exceptions
+        # These calls should not raise exceptions since subclass relationships are valid
         IsSubclass(AbstractClass, ConcreteClass)
         IsSubclass(AbstractClass, SubConcreteClass)
         IsSubclass(ConcreteClass, SubConcreteClass)
 
     async def testInvalidSubclass(self) -> None:
         """
-        Test that validation fails when concrete class is not a subclass.
+        Validate that `IsSubclass` raises `OrionisContainerException` when the concrete class is not a subclass of the abstract class.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return anything. It passes if the expected exception is raised.
+
+        Notes
+        -----
+        The test covers cases where classes are unrelated or the inheritance direction is incorrect.
         """
-        # Define test classes
+        # Define two unrelated abstract base classes
         class AbstractClass1(ABC):
             pass
 
         class AbstractClass2(ABC):
             pass
 
+        # Define concrete classes inheriting from each abstract class
         class ConcreteClass1(AbstractClass1):
             pass
 
         class ConcreteClass2(AbstractClass2):
             pass
 
-        # These should raise exceptions
+        # These calls should raise exceptions due to invalid subclass relationships
         with self.assertRaises(OrionisContainerException) as context:
             IsSubclass(AbstractClass1, AbstractClass2)
         self.assertIn("concrete class must inherit", str(context.exception))
@@ -64,23 +85,50 @@ class TestIsSubclass(AsyncTestCase):
 
     async def testSameClass(self) -> None:
         """
-        Test validation when abstract and concrete are the same class.
+        Validate that `IsSubclass` does not raise an exception when the abstract and concrete classes are the same.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return anything. It passes if no exception is raised.
+
+        Notes
+        -----
+        In Python, a class is considered a subclass of itself.
         """
+        # Define a test class
         class TestClass:
             pass
 
-        # A class is considered a subclass of itself
+        # Should not raise since a class is a subclass of itself
         IsSubclass(TestClass, TestClass)
 
     async def testBuiltinTypes(self) -> None:
         """
-        Test validation with built-in types.
+        Validate `IsSubclass` behavior with built-in types, ensuring correct subclass relationships and exception raising.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return anything. It passes if exceptions are raised or not as expected.
+
+        Notes
+        -----
+        The test covers both valid and invalid subclass relationships among built-in types.
         """
-        # Valid subclass relationships
+        # Valid subclass relationships for built-in types
         IsSubclass(Exception, ValueError)
         IsSubclass(BaseException, Exception)
 
-        # Invalid subclass relationships
+        # Invalid subclass relationships should raise exceptions
         with self.assertRaises(OrionisContainerException):
             IsSubclass(ValueError, Exception)
 
@@ -92,12 +140,26 @@ class TestIsSubclass(AsyncTestCase):
 
     async def testNonClassArguments(self) -> None:
         """
-        Test validation with non-class arguments which should raise TypeError.
+        Validate that `IsSubclass` raises `TypeError` when non-class arguments are provided.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+            This method does not return anything. It passes if `TypeError` is raised for non-class arguments.
+
+        Notes
+        -----
+        The test covers various non-class types such as None, int, str, list, dict, and function.
         """
+        # Define a valid test class
         class TestClass:
             pass
 
-        # These should raise TypeError when passed to issubclass()
+        # List of non-class arguments to test
         non_class_args = [
             None,
             123,
@@ -107,6 +169,7 @@ class TestIsSubclass(AsyncTestCase):
             lambda x: x
         ]
 
+        # Each non-class argument should raise TypeError when used as either abstract or concrete class
         for arg in non_class_args:
             with self.assertRaises(TypeError):
                 IsSubclass(TestClass, arg)

tests/container/validators/test_is_valid_alias.py

@@ -3,18 +3,19 @@ from orionis.container.exceptions.type import OrionisContainerTypeError
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestIsValidAlias(AsyncTestCase):
-    """
-    Test cases for the IsValidAlias validator in orionis.container.validators.is_valid_alias.
-
-    Notes
-    -----
-    This test suite validates the functionality of the IsValidAlias validator
-    which ensures that alias values are valid strings without invalid characters.
-    """
 
     async def testValidAliases(self) -> None:
         """
-        Test that validation passes when valid aliases are provided.
+        Validates that the IsValidAlias validator accepts valid alias strings.
+
+        This test iterates over a list of valid alias strings and ensures that
+        the IsValidAlias validator does not raise any exceptions for these values.
+        Valid aliases include strings with letters, numbers, and underscores.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It passes if no exception is raised.
         """
         valid_aliases = [
             "valid",
@@ -30,12 +31,22 @@ class TestIsValidAlias(AsyncTestCase):
             "VALID_UPPERCASE_ALIAS"
         ]
 
+        # Ensure each valid alias passes validation without raising an exception
         for alias in valid_aliases:
             IsValidAlias(alias)
 
     async def testInvalidAliasTypes(self) -> None:
         """
-        Test that validation fails when non-string types are provided.
+        Ensures that IsValidAlias raises an exception for non-string types.
+
+        This test checks that passing values of types other than string (such as
+        integers, floats, None, booleans, lists, dictionaries, tuples, and sets)
+        to the IsValidAlias validator results in an OrionisContainerTypeError.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It passes if the expected exception is raised.
         """
         invalid_types = [
             123,
@@ -49,13 +60,24 @@ class TestIsValidAlias(AsyncTestCase):
             set()
         ]
 
+        # Ensure each invalid type raises the expected exception
         for value in invalid_types:
             with self.assertRaises(OrionisContainerTypeError) as context:
                 IsValidAlias(value)
 
     async def testAliasWithInvalidCharacters(self) -> None:
         """
-        Test that validation fails when aliases contain invalid characters.
+        Verifies that aliases containing invalid characters are rejected.
+
+        This test iterates over a list of alias strings containing whitespace,
+        control characters, and special symbols, and asserts that the
+        IsValidAlias validator raises an OrionisContainerTypeError for each.
+        It also checks that the exception message is descriptive.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It passes if the expected exception and message are raised.
         """
         invalid_aliases = [
             "invalid alias",  # space
@@ -82,17 +104,29 @@ class TestIsValidAlias(AsyncTestCase):
             "invalid'alias"    # single quote
         ]
 
+        # Ensure each invalid alias raises the expected exception and message
         for alias in invalid_aliases:
             with self.assertRaises(OrionisContainerTypeError) as context:
                 IsValidAlias(alias)
 
             expected_msg_start = f"Alias '{alias}' contains invalid characters."
+            # Check that the exception message starts as expected
             self.assertTrue(str(context.exception).startswith(expected_msg_start))
+            # Check that the message contains additional guidance
             self.assertIn("Aliases must not contain whitespace or special symbols", str(context.exception))
 
     async def testEmptyAlias(self) -> None:
         """
-        Test that validation fails with an empty string.
+        Checks that empty or whitespace-only aliases are rejected.
+
+        This test verifies that passing an empty string or a string containing
+        only whitespace to the IsValidAlias validator raises an
+        OrionisContainerTypeError with the correct error message.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It passes if the expected exception and message are raised.
         """
         # Empty string should be rejected
         with self.assertRaises(OrionisContainerTypeError) as context:

tests/container/validators/test_lifetime.py

@@ -4,47 +4,68 @@ from orionis.container.exceptions.type import OrionisContainerTypeError
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestLifetimeValidator(AsyncTestCase):
-    """
-    Test cases for the LifetimeValidator in orionis.container.validators.lifetime.
-
-    Notes
-    -----
-    This test suite validates the functionality of the LifetimeValidator
-    which ensures that lifetime values are correctly validated and converted.
-    """
 
     async def testValidLifetimeEnumValues(self) -> None:
         """
-        Test that validation passes when Lifetime enum values are provided.
+        Validate that LifetimeValidator correctly accepts Lifetime enum values.
+
+        This test checks that the validator returns the corresponding Lifetime enum
+        when provided with valid enum values.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts correctness via test assertions.
         """
+        # Assert that each Lifetime enum value is accepted and returned as expected
         self.assertEqual(LifetimeValidator(Lifetime.TRANSIENT), Lifetime.TRANSIENT)
         self.assertEqual(LifetimeValidator(Lifetime.SINGLETON), Lifetime.SINGLETON)
         self.assertEqual(LifetimeValidator(Lifetime.SCOPED), Lifetime.SCOPED)
 
     async def testValidLifetimeStringValues(self) -> None:
         """
-        Test that validation passes when valid string representations are provided.
+        Validate that LifetimeValidator correctly accepts valid string representations.
+
+        This test verifies that the validator returns the correct Lifetime enum when
+        provided with valid string representations, including different cases and extra whitespace.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts correctness via test assertions.
         """
+        # Assert that valid uppercase string representations are accepted
         self.assertEqual(LifetimeValidator("TRANSIENT"), Lifetime.TRANSIENT)
         self.assertEqual(LifetimeValidator("SINGLETON"), Lifetime.SINGLETON)
         self.assertEqual(LifetimeValidator("SCOPED"), Lifetime.SCOPED)
 
-        # Test with lowercase and mixed case
+        # Assert that lowercase and mixed case strings are accepted
         self.assertEqual(LifetimeValidator("transient"), Lifetime.TRANSIENT)
         self.assertEqual(LifetimeValidator("Singleton"), Lifetime.SINGLETON)
         self.assertEqual(LifetimeValidator("scoped"), Lifetime.SCOPED)
 
-        # Test with extra whitespace
+        # Assert that strings with extra whitespace are accepted
         self.assertEqual(LifetimeValidator(" TRANSIENT "), Lifetime.TRANSIENT)
         self.assertEqual(LifetimeValidator("  singleton  "), Lifetime.SINGLETON)
 
     async def testInvalidLifetimeStringValue(self) -> None:
         """
-        Test that validation fails when invalid string representations are provided.
+        Validate that LifetimeValidator raises an error for invalid string values.
+
+        This test ensures that the validator raises OrionisContainerTypeError when
+        provided with an invalid string representation, and that the error message
+        contains information about valid options.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts correctness via test assertions.
         """
+        # Attempt to validate an invalid string and check for the expected exception
         with self.assertRaises(OrionisContainerTypeError) as context:
             LifetimeValidator("INVALID_LIFETIME")
 
+        # Assert that the error message contains relevant information
         self.assertIn("Invalid lifetime 'INVALID_LIFETIME'", str(context.exception))
         self.assertIn("Valid options are:", str(context.exception))
         self.assertIn("TRANSIENT", str(context.exception))
@@ -53,8 +74,17 @@ class TestLifetimeValidator(AsyncTestCase):
 
     async def testInvalidLifetimeType(self) -> None:
         """
-        Test that validation fails when invalid types are provided.
+        Validate that LifetimeValidator raises an error for invalid input types.
+
+        This test checks that the validator raises OrionisContainerTypeError when
+        provided with values of types other than str or Lifetime enum.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts correctness via test assertions.
         """
+        # List of invalid types to test
         invalid_values = [
             123,
             3.14,
@@ -67,6 +97,7 @@ class TestLifetimeValidator(AsyncTestCase):
             set()
         ]
 
+        # Assert that each invalid type raises the expected exception
         for value in invalid_values:
             with self.assertRaises(OrionisContainerTypeError) as context:
                 LifetimeValidator(value)

tests/example/test_example.py

@@ -6,7 +6,7 @@ This module contains comprehensive test examples demonstrating the capabilities
 of the Orionis testing framework, including both synchronous and asynchronous
 testing patterns with dependency injection.
 
-Examples
+Examples:
 --------
     Run synchronous tests:
         >>> from tests.example.test_example import TestSynchronousExample
@@ -20,7 +20,7 @@ Examples
         >>> await test.asyncSetUp()
         >>> await test.testAsyncBasicOperations()
 
-Notes
+Notes:
 -----
     These examples showcase:
     - Dependency injection patterns