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

tests/container/validators/test_implements.py

@@ -0,0 +1,140 @@
+from abc import ABC, abstractmethod
+from orionis.test.cases.asynchronous import AsyncTestCase
+from orionis.container.validators.implements import ImplementsAbstractMethods
+from orionis.container.exceptions.exception import OrionisContainerException
+
+class TestImplementsAbstractMethods(AsyncTestCase):
+    """
+    Test cases for the ImplementsAbstractMethods validator in orionis.container.validators.implements.
+
+    Notes
+    -----
+    This test suite validates the functionality of the ImplementsAbstractMethods validator
+    which ensures that concrete classes correctly implement abstract methods.
+    """
+
+    async def asyncSetUp(self) -> None:
+        """
+        Set up test fixtures.
+        """
+        # Define abstract classes for testing
+        class AbstractBase(ABC):
+            @abstractmethod
+            def abstract_method(self) -> None:
+                pass
+
+            @abstractmethod
+            def another_abstract_method(self) -> str:
+                pass
+
+        class ConcreteCorrect(AbstractBase):
+            def abstract_method(self) -> None:
+                pass
+
+            def another_abstract_method(self) -> str:
+                return "implemented"
+
+        class ConcreteIncomplete(AbstractBase):
+            def abstract_method(self) -> None:
+                pass
+
+        class NonAbstractBase:
+            def regular_method(self) -> None:
+                pass
+
+        self.AbstractBase = AbstractBase
+        self.ConcreteCorrect = ConcreteCorrect
+        self.ConcreteIncomplete = ConcreteIncomplete
+        self.NonAbstractBase = NonAbstractBase
+
+    async def testValidImplementation(self) -> None:
+        """
+        Test that validation passes when all abstract methods are implemented.
+        """
+        # Test with class
+        ImplementsAbstractMethods(
+            abstract=self.AbstractBase,
+            concrete=self.ConcreteCorrect
+        )
+
+        # Test with instance
+        instance = self.ConcreteCorrect()
+        ImplementsAbstractMethods(
+            abstract=self.AbstractBase,
+            instance=instance
+        )
+
+    async def testIncompleteImplementation(self) -> None:
+        """
+        Test that validation fails when not all abstract methods are implemented.
+        """
+        # Test with class
+        with self.assertRaises(OrionisContainerException) as context:
+            ImplementsAbstractMethods(
+                abstract=self.AbstractBase,
+                concrete=self.ConcreteIncomplete
+            )
+
+        self.assertIn("does not implement the following abstract methods", str(context.exception))
+        self.assertIn("another_abstract_method", str(context.exception))
+
+        # Test with instance
+        with self.assertRaises(TypeError):
+            ImplementsAbstractMethods(
+                abstract=self.AbstractBase,
+                instance=self.ConcreteIncomplete()
+            )
+
+    async def testMissingAbstractClass(self) -> None:
+        """
+        Test that validation fails when no abstract class is provided.
+        """
+        with self.assertRaises(OrionisContainerException) as context:
+            ImplementsAbstractMethods(
+                concrete=self.ConcreteCorrect
+            )
+
+        self.assertIn("Abstract class must be provided", str(context.exception))
+
+    async def testMissingConcreteImplementation(self) -> None:
+        """
+        Test that validation fails when neither concrete class nor instance is provided.
+        """
+        with self.assertRaises(OrionisContainerException) as context:
+            ImplementsAbstractMethods(
+                abstract=self.AbstractBase
+            )
+
+        self.assertIn("Either concrete class or instance must be provided", str(context.exception))
+
+    async def testNonAbstractClass(self) -> None:
+        """
+        Test that validation fails when the provided abstract class has no abstract methods.
+        """
+        with self.assertRaises(OrionisContainerException) as context:
+            ImplementsAbstractMethods(
+                abstract=self.NonAbstractBase,
+                concrete=self.ConcreteCorrect
+            )
+
+        self.assertIn("does not define any abstract methods", str(context.exception))
+
+    async def testRenamedAbstractMethods(self) -> None:
+        """
+        Test handling of renamed abstract methods with class name prefixes.
+        """
+        # Define classes with renamed methods
+        class AbstractWithPrefix(ABC):
+            @abstractmethod
+            def _AbstractWithPrefix_method(self) -> None:
+                pass
+
+        class ConcreteWithPrefix:
+            def _ConcreteWithPrefix_method(self) -> None:
+                pass
+
+        # Should pass validation because the method is renamed according to class name
+        ImplementsAbstractMethods(
+            abstract=AbstractWithPrefix,
+            concrete=ConcreteWithPrefix
+        )

tests/container/validators/test_is_abstract_class.py

@@ -0,0 +1,99 @@
+from abc import ABC, abstractmethod
+import unittest.mock
+from orionis.container.validators.is_abstract_class import IsAbstractClass
+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.
+        """
+        # Create abstract class
+        class AbstractBase(ABC):
+            @abstractmethod
+            def abstract_method(self):
+                pass
+
+        # Should pass without raising an exception
+        with unittest.mock.patch('orionis.services.introspection.abstract.reflection.ReflectionAbstract.ensureIsAbstractClass') as mock_ensure:
+            IsAbstractClass(AbstractBase, "singleton")
+            mock_ensure.assert_called_once_with(AbstractBase)
+
+    async def testNonAbstractClass(self) -> None:
+        """
+        Test that validation fails for non-abstract classes.
+        """
+        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:
+            with self.assertRaises(OrionisContainerTypeError) as context:
+                IsAbstractClass(ConcreteClass, "scoped")
+
+            self.assertIn("Unexpected error registering scoped service", str(context.exception))
+            mock_ensure.assert_called_once_with(ConcreteClass)
+
+    async def testWithInheritedAbstractClass(self) -> None:
+        """
+        Test validation with classes that inherit from abstract classes but are still abstract.
+        """
+        class BaseAbstract(ABC):
+            @abstractmethod
+            def method1(self):
+                pass
+
+        class DerivedAbstract(BaseAbstract):
+            @abstractmethod
+            def method2(self):
+                pass
+
+        # Should pass if the derived class is still abstract
+        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.
+        """
+        class BaseAbstract(ABC):
+            @abstractmethod
+            def method(self):
+                pass
+
+        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:
+            with self.assertRaises(OrionisContainerTypeError) as context:
+                IsAbstractClass(ConcreteImplementation, "singleton")
+
+            self.assertIn("Unexpected error registering singleton service", str(context.exception))
+            mock_ensure.assert_called_once_with(ConcreteImplementation)
+
+    async def testWithNonClassTypes(self) -> None:
+        """
+        Test validation with values that aren't classes at all.
+        """
+        # Test with primitive 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:
+                with self.assertRaises(OrionisContainerTypeError):
+                    IsAbstractClass(invalid_value, "transient")

tests/container/validators/test_is_callable.py

@@ -0,0 +1,73 @@
+from orionis.container.validators.is_callable import IsCallable
+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.
+        """
+        def simple_function():
+            pass
+
+        class ClassWithCall:
+            def __call__(self):
+                pass
+
+        lambda_func = lambda x: x
+
+        # These should not raise exceptions
+        IsCallable(simple_function)
+        IsCallable(ClassWithCall())
+        IsCallable(lambda_func)
+        IsCallable(len)
+        IsCallable(print)
+
+    async def testNonCallables(self) -> None:
+        """
+        Test that validation fails for non-callable objects.
+        """
+        non_callables = [
+            42,
+            "string",
+            [1, 2, 3],
+            {"key": "value"},
+            None,
+            True,
+            (1, 2, 3)
+        ]
+
+        for value in non_callables:
+            with self.assertRaises(OrionisContainerTypeError) as context:
+                IsCallable(value)
+            expected_message = f"Expected a callable type, but got {type(value).__name__} instead."
+            self.assertEqual(str(context.exception), expected_message)
+
+    async def testClassesAsCallables(self) -> None:
+        """
+        Test that classes themselves are considered callable (since they can be instantiated).
+        """
+        class SimpleClass:
+            pass
+
+        # This should not raise an exception
+        IsCallable(SimpleClass)
+
+    async def testBuiltinFunctions(self) -> None:
+        """
+        Test that built-in functions are properly identified as callable.
+        """
+        # These should not raise exceptions
+        IsCallable(sum)
+        IsCallable(map)
+        IsCallable(filter)
+        IsCallable(sorted)

tests/container/validators/test_is_concrete_class.py

@@ -0,0 +1,97 @@
+from abc import ABC, abstractmethod
+from orionis.container.validators.is_concrete_class import IsConcreteClass
+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.
+        """
+        class SimpleClass:
+            pass
+
+        class ClassWithInit:
+            def __init__(self, value):
+                self.value = value
+
+        # These should not raise exceptions
+        IsConcreteClass(SimpleClass, "singleton")
+        IsConcreteClass(ClassWithInit, "transient")
+
+    async def testAbstractClasses(self) -> None:
+        """
+        Test that validation fails for abstract classes.
+        """
+        class AbstractBase(ABC):
+            @abstractmethod
+            def abstract_method(self):
+                pass
+
+        with self.assertRaises(OrionisContainerTypeError) as context:
+            IsConcreteClass(AbstractBase, "scoped")
+        self.assertIn("Unexpected error registering scoped service", str(context.exception))
+
+    async def testNonClassTypes(self) -> None:
+        """
+        Test that validation fails for non-class types.
+        """
+        with self.assertRaises(OrionisContainerTypeError) as context:
+            IsConcreteClass(42, "singleton")
+        self.assertIn("Unexpected error registering singleton service", str(context.exception))
+
+        with self.assertRaises(OrionisContainerTypeError) as context:
+            IsConcreteClass("string", "scoped")
+        self.assertIn("Unexpected error registering scoped service", str(context.exception))
+
+        with self.assertRaises(OrionisContainerTypeError) as context:
+            IsConcreteClass(lambda x: x, "transient")
+        self.assertIn("Unexpected error registering transient service", str(context.exception))
+
+    async def testInheritedConcreteClasses(self) -> None:
+        """
+        Test that validation passes for concrete classes that inherit from abstract classes.
+        """
+        class AbstractBase(ABC):
+            @abstractmethod
+            def abstract_method(self):
+                pass
+
+        class ConcreteImplementation(AbstractBase):
+            def abstract_method(self):
+                return "Implemented"
+
+        # This should not raise an exception
+        IsConcreteClass(ConcreteImplementation, "singleton")
+
+    async def testPartialImplementations(self) -> None:
+        """
+        Test that validation fails for classes that don't implement all abstract methods.
+        """
+        class AbstractBase(ABC):
+            @abstractmethod
+            def method1(self):
+                pass
+
+            @abstractmethod
+            def method2(self):
+                pass
+
+        class PartialImplementation(AbstractBase):
+            def method1(self):
+                return "Implemented"
+
+            # method2 is not 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

@@ -0,0 +1,105 @@
+from abc import ABC, abstractmethod
+from orionis.container.validators.is_instance import IsInstance
+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.
+        """
+
+        # Custom class instances
+        class SimpleClass:
+            pass
+
+        # Class with __init__ method
+        class ClassWithInit:
+            def __init__(self, value):
+                self.value = value
+
+        IsInstance(SimpleClass())
+        IsInstance(ClassWithInit(42))
+
+    async def testInvalidClasses(self) -> None:
+        """
+        Test that validation fails when provided with classes instead of instances.
+        """
+        with self.assertRaises(OrionisContainerTypeError) as context:
+            IsInstance(str)
+        self.assertIn("Error registering instance", str(context.exception))
+
+        class TestClass:
+            pass
+
+        with self.assertRaises(OrionisContainerTypeError) as context:
+            IsInstance(TestClass)
+        self.assertIn("Error registering instance", str(context.exception))
+
+    async def testAbstractClasses(self) -> None:
+        """
+        Test that validation fails for abstract classes and their types.
+        """
+        class AbstractBase(ABC):
+            @abstractmethod
+            def abstract_method(self):
+                pass
+
+        class ConcreteImplementation(AbstractBase):
+            def abstract_method(self):
+                return "Implemented"
+
+        # Abstract class should fail
+        with self.assertRaises(OrionisContainerTypeError) as context:
+            IsInstance(AbstractBase)
+        self.assertIn("Error registering instance", str(context.exception))
+
+        # But instance of concrete implementation should pass
+        IsInstance(ConcreteImplementation())
+
+    async def testTypeObjects(self) -> None:
+        """
+        Test validation with various type objects.
+        """
+        with self.assertRaises(OrionisContainerTypeError):
+            IsInstance(type)
+
+        with self.assertRaises(OrionisContainerTypeError):
+            IsInstance(int)
+
+        with self.assertRaises(OrionisContainerTypeError):
+            IsInstance(list)
+
+    async def testNoneValue(self) -> None:
+        """
+        Test validation with None value.
+        """
+        # None is a valid instance in Python
+        with self.assertRaises(OrionisContainerTypeError):
+            IsInstance(None)
+
+    async def testCallables(self) -> None:
+        """
+        Test validation with callable objects.
+        """
+        # Functions and lambdas are valid instances
+        def test_function():
+            pass
+
+        # Lambda functions are also valid instances
+        with self.assertRaises(OrionisContainerTypeError):
+            IsInstance(test_function)
+            IsInstance(lambda x: x * 2)
+
+        # But their types are not
+        with self.assertRaises(OrionisContainerTypeError):
+            IsInstance(type(test_function))

tests/container/validators/test_is_not_subclass.py

@@ -0,0 +1,117 @@
+from abc import ABC
+from orionis.container.validators.is_not_subclass import IsNotSubclass
+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
+
+        class AbstractClass2(ABC):
+            pass
+
+        class ConcreteClass1(AbstractClass1):
+            pass
+
+        class ConcreteClass2(AbstractClass2):
+            pass
+
+        # These should not raise exceptions
+        IsNotSubclass(AbstractClass1, AbstractClass2)
+        IsNotSubclass(AbstractClass1, ConcreteClass2)
+        IsNotSubclass(ConcreteClass1, AbstractClass1)
+        IsNotSubclass(int, str)
+        IsNotSubclass(list, dict)
+
+    async def testInvalidNonSubclass(self) -> None:
+        """
+        Test that validation fails when concrete class IS a subclass.
+        """
+        # Define test classes
+        class AbstractClass(ABC):
+            pass
+
+        class ConcreteClass(AbstractClass):
+            pass
+
+        class SubConcreteClass(ConcreteClass):
+            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:
+            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:
+            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)