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

tests/container/validators/test_is_abstract_class.py

@@ -5,41 +5,54 @@ from orionis.container.exceptions.type import OrionisContainerTypeError
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestIsAbstractClass(AsyncTestCase):
-    """
-    Test cases for the IsAbstractClass validator in orionis.container.validators.is_abstract_class.
-
-    Notes
-    -----
-    This test suite validates the functionality of the IsAbstractClass validator
-    which ensures that a provided class is an abstract class.
-    """
 
     async def testValidAbstractClass(self) -> None:
         """
-        Test that validation passes for valid abstract classes.
+        Validates that the IsAbstractClass validator accepts a valid abstract class.
+
+        This test creates an abstract class using Python's `abc` module and verifies
+        that the validator does not raise an exception when provided with a proper abstract class.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts correct behavior via exceptions and mocks.
         """
-        # Create abstract class
+        # Create an abstract class with an abstract method
         class AbstractBase(ABC):
             @abstractmethod
             def abstract_method(self):
                 pass
 
-        # Should pass without raising an exception
+        # Patch the reflection method to ensure it is called correctly
         with unittest.mock.patch('orionis.services.introspection.abstract.reflection.ReflectionAbstract.ensureIsAbstractClass') as mock_ensure:
             IsAbstractClass(AbstractBase, "singleton")
+            # Assert that the reflection method was called with the correct class
             mock_ensure.assert_called_once_with(AbstractBase)
 
     async def testNonAbstractClass(self) -> None:
         """
-        Test that validation fails for non-abstract classes.
+        Validates that the IsAbstractClass validator raises an error for non-abstract classes.
+
+        This test provides a concrete class and mocks the reflection method to raise a ValueError,
+        ensuring that the validator responds with an OrionisContainerTypeError.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts correct behavior via exceptions and mocks.
         """
+        # Define a concrete class with no abstract methods
         class ConcreteClass:
             def some_method(self):
                 pass
 
-        # Mock the ensureIsAbstractClass to raise an exception
-        with unittest.mock.patch('orionis.services.introspection.abstract.reflection.ReflectionAbstract.ensureIsAbstractClass', 
-                                side_effect=ValueError("Not an abstract class")) as mock_ensure:
+        # Patch the reflection method to simulate failure for non-abstract classes
+        with unittest.mock.patch(
+            'orionis.services.introspection.abstract.reflection.ReflectionAbstract.ensureIsAbstractClass',
+            side_effect=ValueError("Not an abstract class")
+        ) as mock_ensure:
+            # Assert that the validator raises the expected error
             with self.assertRaises(OrionisContainerTypeError) as context:
                 IsAbstractClass(ConcreteClass, "scoped")
 
@@ -48,39 +61,62 @@ class TestIsAbstractClass(AsyncTestCase):
 
     async def testWithInheritedAbstractClass(self) -> None:
         """
-        Test validation with classes that inherit from abstract classes but are still abstract.
+        Validates that the IsAbstractClass validator accepts classes that inherit from abstract classes and remain abstract.
+
+        This test creates a base abstract class and a derived abstract class, ensuring that the validator
+        does not raise an exception when the derived class is still abstract.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts correct behavior via exceptions and mocks.
         """
+        # Define a base abstract class
         class BaseAbstract(ABC):
             @abstractmethod
             def method1(self):
                 pass
 
+        # Define a derived abstract class that adds another abstract method
         class DerivedAbstract(BaseAbstract):
             @abstractmethod
             def method2(self):
                 pass
 
-        # Should pass if the derived class is still abstract
+        # Patch the reflection method to ensure it is called correctly
         with unittest.mock.patch('orionis.services.introspection.abstract.reflection.ReflectionAbstract.ensureIsAbstractClass') as mock_ensure:
             IsAbstractClass(DerivedAbstract, "transient")
             mock_ensure.assert_called_once_with(DerivedAbstract)
 
     async def testWithConcreteImplementation(self) -> None:
         """
-        Test validation with concrete implementations of abstract classes.
+        Validates that the IsAbstractClass validator raises an error for concrete implementations of abstract classes.
+
+        This test creates a concrete class that implements all abstract methods and mocks the reflection method
+        to raise a TypeError, ensuring that the validator responds with an OrionisContainerTypeError.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts correct behavior via exceptions and mocks.
         """
+        # Define a base abstract class
         class BaseAbstract(ABC):
             @abstractmethod
             def method(self):
                 pass
 
+        # Define a concrete class that implements the abstract method
         class ConcreteImplementation(BaseAbstract):
             def method(self):
                 return "Implemented"
 
-        # Should fail since ConcreteImplementation is not abstract
-        with unittest.mock.patch('orionis.services.introspection.abstract.reflection.ReflectionAbstract.ensureIsAbstractClass', 
-                               side_effect=TypeError("Not an abstract class")) as mock_ensure:
+        # Patch the reflection method to simulate failure for concrete classes
+        with unittest.mock.patch(
+            'orionis.services.introspection.abstract.reflection.ReflectionAbstract.ensureIsAbstractClass',
+            side_effect=TypeError("Not an abstract class")
+        ) as mock_ensure:
+            # Assert that the validator raises the expected error
             with self.assertRaises(OrionisContainerTypeError) as context:
                 IsAbstractClass(ConcreteImplementation, "singleton")
 
@@ -89,11 +125,23 @@ class TestIsAbstractClass(AsyncTestCase):
 
     async def testWithNonClassTypes(self) -> None:
         """
-        Test validation with values that aren't classes at all.
+        Validates that the IsAbstractClass validator raises an error for non-class types.
+
+        This test iterates over several primitive and non-class values, mocking the reflection method
+        to raise a TypeError, and ensures that the validator responds with an OrionisContainerTypeError.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts correct behavior via exceptions and mocks.
         """
-        # Test with primitive types
+        # Test with various non-class types
         for invalid_value in [1, "string", [], {}, lambda: None]:
-            with unittest.mock.patch('orionis.services.introspection.abstract.reflection.ReflectionAbstract.ensureIsAbstractClass', 
-                                   side_effect=TypeError(f"{type(invalid_value)} is not a class")) as mock_ensure:
+            # Patch the reflection method to simulate failure for non-class types
+            with unittest.mock.patch(
+                'orionis.services.introspection.abstract.reflection.ReflectionAbstract.ensureIsAbstractClass',
+                side_effect=TypeError(f"{type(invalid_value)} is not a class")
+            ) as mock_ensure:
+                # Assert that the validator raises the expected error
                 with self.assertRaises(OrionisContainerTypeError):
                     IsAbstractClass(invalid_value, "transient")

tests/container/validators/test_is_callable.py

@@ -3,29 +3,30 @@ from orionis.container.exceptions.type import OrionisContainerTypeError
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestIsCallable(AsyncTestCase):
-    """
-    Test cases for the IsCallable validator in orionis.container.validators.is_callable.
-
-    Notes
-    -----
-    This test suite validates the functionality of the IsCallable validator
-    which ensures that a provided value is callable.
-    """
 
     async def testValidCallables(self) -> None:
         """
-        Test that validation passes for valid callable objects.
+        Validate that IsCallable accepts valid callable objects without raising exceptions.
+
+        This test covers various types of callables, including functions, classes with
+        a __call__ method, lambda functions, and built-in functions.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts that no exception is raised
+            for valid callables.
         """
         def simple_function():
-            pass
+            pass  # Simple user-defined function
 
         class ClassWithCall:
             def __call__(self):
-                pass
+                pass  # Class instance with __call__ method
 
-        lambda_func = lambda x: x
+        lambda_func = lambda x: x  # Lambda function
 
-        # These should not raise exceptions
+        # These should not raise exceptions as they are all callable
         IsCallable(simple_function)
         IsCallable(ClassWithCall())
         IsCallable(lambda_func)
@@ -34,19 +35,29 @@ class TestIsCallable(AsyncTestCase):
 
     async def testNonCallables(self) -> None:
         """
-        Test that validation fails for non-callable objects.
+        Ensure that IsCallable raises OrionisContainerTypeError for non-callable objects.
+
+        This test iterates over a list of non-callable objects and asserts that the
+        expected exception is raised with the correct error message.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts that exceptions are raised
+            for non-callable objects.
         """
         non_callables = [
-            42,
-            "string",
-            [1, 2, 3],
-            {"key": "value"},
-            None,
-            True,
-            (1, 2, 3)
+            42,                # Integer
+            "string",          # String
+            [1, 2, 3],         # List
+            {"key": "value"},  # Dictionary
+            None,              # NoneType
+            True,              # Boolean
+            (1, 2, 3)          # Tuple
         ]
 
         for value in non_callables:
+            # Assert that IsCallable raises the expected exception for non-callables
             with self.assertRaises(OrionisContainerTypeError) as context:
                 IsCallable(value)
             expected_message = f"Expected a callable type, but got {type(value).__name__} instead."
@@ -54,19 +65,37 @@ class TestIsCallable(AsyncTestCase):
 
     async def testClassesAsCallables(self) -> None:
         """
-        Test that classes themselves are considered callable (since they can be instantiated).
+        Verify that classes themselves are considered callable by IsCallable.
+
+        Classes are callable because they can be instantiated. This test ensures
+        that passing a class to IsCallable does not raise an exception.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts that no exception is raised
+            for classes.
         """
         class SimpleClass:
-            pass
+            pass  # Simple class definition
 
-        # This should not raise an exception
+        # Should not raise an exception since classes are callable
         IsCallable(SimpleClass)
 
     async def testBuiltinFunctions(self) -> None:
         """
-        Test that built-in functions are properly identified as callable.
+        Confirm that built-in functions are recognized as callable by IsCallable.
+
+        This test checks several built-in functions to ensure they are accepted
+        without raising exceptions.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It asserts that no exception is raised
+            for built-in functions.
         """
-        # These should not raise exceptions
+        # These built-in functions should not raise exceptions
         IsCallable(sum)
         IsCallable(map)
         IsCallable(filter)

tests/container/validators/test_is_concrete_class.py

@@ -4,39 +4,58 @@ from orionis.container.exceptions.type import OrionisContainerTypeError
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestIsConcreteClass(AsyncTestCase):
-    """
-    Test cases for the IsConcreteClass validator in orionis.container.validators.is_concrete_class.
-
-    Notes
-    -----
-    This test suite validates the functionality of the IsConcreteClass validator
-    which ensures that a provided class is a concrete (non-abstract) class.
-    """
 
     async def testValidConcreteClasses(self) -> None:
         """
         Test that validation passes for valid concrete classes.
+
+        This test verifies that the `IsConcreteClass` validator does not raise an exception
+        when provided with classes that are concrete (i.e., not abstract and fully implemented).
+
+        Parameters
+        ----------
+        self : TestIsConcreteClass
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts that no exception is raised for valid concrete classes.
         """
         class SimpleClass:
-            pass
+            pass  # A basic concrete class with no methods
 
         class ClassWithInit:
             def __init__(self, value):
-                self.value = value
+                self.value = value  # Concrete class with an initializer
 
-        # These should not raise exceptions
+        # These should not raise exceptions since both are concrete classes
         IsConcreteClass(SimpleClass, "singleton")
         IsConcreteClass(ClassWithInit, "transient")
 
     async def testAbstractClasses(self) -> None:
         """
         Test that validation fails for abstract classes.
+
+        This test ensures that the `IsConcreteClass` validator raises an `OrionisContainerTypeError`
+        when provided with an abstract class.
+
+        Parameters
+        ----------
+        self : TestIsConcreteClass
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts that an exception is raised for abstract classes.
         """
         class AbstractBase(ABC):
             @abstractmethod
             def abstract_method(self):
-                pass
+                pass  # Abstract method, making this class abstract
 
+        # Should raise an exception because AbstractBase is abstract
         with self.assertRaises(OrionisContainerTypeError) as context:
             IsConcreteClass(AbstractBase, "scoped")
         self.assertIn("Unexpected error registering scoped service", str(context.exception))
@@ -44,15 +63,31 @@ class TestIsConcreteClass(AsyncTestCase):
     async def testNonClassTypes(self) -> None:
         """
         Test that validation fails for non-class types.
+
+        This test checks that the `IsConcreteClass` validator raises an `OrionisContainerTypeError`
+        when provided with values that are not classes (e.g., integers, strings, functions).
+
+        Parameters
+        ----------
+        self : TestIsConcreteClass
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts that an exception is raised for non-class types.
         """
+        # Should raise an exception for integer input
         with self.assertRaises(OrionisContainerTypeError) as context:
             IsConcreteClass(42, "singleton")
         self.assertIn("Unexpected error registering singleton service", str(context.exception))
 
+        # Should raise an exception for string input
         with self.assertRaises(OrionisContainerTypeError) as context:
             IsConcreteClass("string", "scoped")
         self.assertIn("Unexpected error registering scoped service", str(context.exception))
 
+        # Should raise an exception for function input
         with self.assertRaises(OrionisContainerTypeError) as context:
             IsConcreteClass(lambda x: x, "transient")
         self.assertIn("Unexpected error registering transient service", str(context.exception))
@@ -60,22 +95,49 @@ class TestIsConcreteClass(AsyncTestCase):
     async def testInheritedConcreteClasses(self) -> None:
         """
         Test that validation passes for concrete classes that inherit from abstract classes.
+
+        This test verifies that the `IsConcreteClass` validator does not raise an exception
+        for classes that inherit from abstract base classes but implement all abstract methods,
+        making them concrete.
+
+        Parameters
+        ----------
+        self : TestIsConcreteClass
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts that no exception is raised for concrete subclasses.
         """
         class AbstractBase(ABC):
             @abstractmethod
             def abstract_method(self):
-                pass
+                pass  # Abstract method
 
         class ConcreteImplementation(AbstractBase):
             def abstract_method(self):
-                return "Implemented"
+                return "Implemented"  # Implements all abstract methods
 
-        # This should not raise an exception
+        # Should not raise an exception since all abstract methods are implemented
         IsConcreteClass(ConcreteImplementation, "singleton")
 
     async def testPartialImplementations(self) -> None:
         """
         Test that validation fails for classes that don't implement all abstract methods.
+
+        This test ensures that the `IsConcreteClass` validator raises an `OrionisContainerTypeError`
+        when a class inherits from an abstract base class but does not implement all required abstract methods.
+
+        Parameters
+        ----------
+        self : TestIsConcreteClass
+            The test case instance.
+
+        Returns
+        -------
+        None
+            This method does not return anything. It asserts that an exception is raised for partial implementations.
         """
         class AbstractBase(ABC):
             @abstractmethod
@@ -88,10 +150,11 @@ class TestIsConcreteClass(AsyncTestCase):
 
         class PartialImplementation(AbstractBase):
             def method1(self):
-                return "Implemented"
+                return "Implemented"  # Only one abstract method is implemented
 
-            # method2 is not implemented
+            # method2 is not implemented, so this class remains abstract
 
+        # Should raise an exception since not all abstract methods are implemented
         with self.assertRaises(OrionisContainerTypeError) as context:
             IsConcreteClass(PartialImplementation, "scoped")
         self.assertIn("Unexpected error registering scoped service", str(context.exception))

tests/container/validators/test_is_instance.py

@@ -4,21 +4,20 @@ from orionis.container.exceptions.type import OrionisContainerTypeError
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestIsInstance(AsyncTestCase):
-    """
-    Test cases for the IsInstance validator in orionis.container.validators.is_instance.
-
-    Notes
-    -----
-    This test suite validates the functionality of the IsInstance validator
-    which ensures that a provided object is a valid instance (not a class or abstract type).
-    """
 
     async def testValidInstances(self) -> None:
         """
-        Test that validation passes for valid instances.
-        """
+        Validate that IsInstance accepts valid object instances.
 
-        # Custom class instances
+        This test checks that IsInstance does not raise an exception when provided with
+        instances of user-defined classes, including those with and without an __init__ method.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+        """
+        # Custom class instance
         class SimpleClass:
             pass
 
@@ -27,17 +26,28 @@ class TestIsInstance(AsyncTestCase):
             def __init__(self, value):
                 self.value = value
 
+        # Should not raise an exception for valid instances
         IsInstance(SimpleClass())
         IsInstance(ClassWithInit(42))
 
     async def testInvalidClasses(self) -> None:
         """
-        Test that validation fails when provided with classes instead of instances.
+        Ensure IsInstance raises an error when provided with class objects instead of instances.
+
+        This test verifies that passing class types (rather than instances) to IsInstance
+        results in an OrionisContainerTypeError.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
         """
+        # Passing built-in type should raise an error
         with self.assertRaises(OrionisContainerTypeError) as context:
             IsInstance(str)
         self.assertIn("Error registering instance", str(context.exception))
 
+        # Passing user-defined class should raise an error
         class TestClass:
             pass
 
@@ -47,29 +57,48 @@ class TestIsInstance(AsyncTestCase):
 
     async def testAbstractClasses(self) -> None:
         """
-        Test that validation fails for abstract classes and their types.
+        Test IsInstance behavior with abstract classes and their concrete implementations.
+
+        This test ensures that abstract classes are not accepted as valid instances,
+        but instances of concrete subclasses are accepted.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
         """
+        # Define an abstract base class
         class AbstractBase(ABC):
             @abstractmethod
             def abstract_method(self):
                 pass
 
+        # Concrete implementation of the abstract base
         class ConcreteImplementation(AbstractBase):
             def abstract_method(self):
                 return "Implemented"
 
-        # Abstract class should fail
+        # Abstract class should raise an error
         with self.assertRaises(OrionisContainerTypeError) as context:
             IsInstance(AbstractBase)
         self.assertIn("Error registering instance", str(context.exception))
 
-        # But instance of concrete implementation should pass
+        # Instance of concrete implementation should not raise an error
         IsInstance(ConcreteImplementation())
 
     async def testTypeObjects(self) -> None:
         """
-        Test validation with various type objects.
+        Verify that IsInstance raises errors for type objects.
+
+        This test checks that passing type objects such as `type`, `int`, or `list`
+        to IsInstance results in an OrionisContainerTypeError.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
         """
+        # Should raise error for built-in type objects
         with self.assertRaises(OrionisContainerTypeError):
             IsInstance(type)
 
@@ -81,25 +110,41 @@ class TestIsInstance(AsyncTestCase):
 
     async def testNoneValue(self) -> None:
         """
-        Test validation with None value.
+        Test IsInstance validation with None value.
+
+        This test verifies that passing None to IsInstance raises an OrionisContainerTypeError,
+        even though None is a valid instance in Python.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
         """
-        # None is a valid instance in Python
+        # Should raise error for None value
         with self.assertRaises(OrionisContainerTypeError):
             IsInstance(None)
 
     async def testCallables(self) -> None:
         """
-        Test validation with callable objects.
+        Test IsInstance validation with callable objects.
+
+        This test checks that passing function objects and lambda functions to IsInstance
+        raises an OrionisContainerTypeError, while passing their types also raises an error.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
         """
-        # Functions and lambdas are valid instances
+        # Define a function for testing
         def test_function():
             pass
 
-        # Lambda functions are also valid instances
+        # Should raise error for function and lambda instances
         with self.assertRaises(OrionisContainerTypeError):
             IsInstance(test_function)
             IsInstance(lambda x: x * 2)
 
-        # But their types are not
+        # Should raise error for type of function
         with self.assertRaises(OrionisContainerTypeError):
             IsInstance(type(test_function))