orionis 0.545.0__py3-none-any.whl → 0.547.0__py3-none-any.whl

tests/container/validators/test_is_concrete_class.py

@@ -1,160 +0,0 @@
-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):
-
-    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  # A basic concrete class with no methods
-
-        class ClassWithInit:
-            def __init__(self, value):
-                self.value = value  # Concrete class with an initializer
-
-        # 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  # 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))
-
-    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))
-
-    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  # Abstract method
-
-        class ConcreteImplementation(AbstractBase):
-            def abstract_method(self):
-                return "Implemented"  # Implements all abstract methods
-
-        # 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
-            def method1(self):
-                pass
-
-            @abstractmethod
-            def method2(self):
-                pass
-
-        class PartialImplementation(AbstractBase):
-            def method1(self):
-                return "Implemented"  # Only one abstract method is 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

@@ -1,150 +0,0 @@
-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):
-
-    async def testValidInstances(self) -> None:
-        """
-        Validate that IsInstance accepts valid object 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
-
-        # Class with __init__ method
-        class ClassWithInit:
-            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:
-        """
-        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
-
-        with self.assertRaises(OrionisContainerTypeError) as context:
-            IsInstance(TestClass)
-        self.assertIn("Error registering instance", str(context.exception))
-
-    async def testAbstractClasses(self) -> None:
-        """
-        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 raise an error
-        with self.assertRaises(OrionisContainerTypeError) as context:
-            IsInstance(AbstractBase)
-        self.assertIn("Error registering instance", str(context.exception))
-
-        # Instance of concrete implementation should not raise an error
-        IsInstance(ConcreteImplementation())
-
-    async def testTypeObjects(self) -> None:
-        """
-        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)
-
-        with self.assertRaises(OrionisContainerTypeError):
-            IsInstance(int)
-
-        with self.assertRaises(OrionisContainerTypeError):
-            IsInstance(list)
-
-    async def testNoneValue(self) -> None:
-        """
-        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.
-        """
-        # Should raise error for None value
-        with self.assertRaises(OrionisContainerTypeError):
-            IsInstance(None)
-
-    async def testCallables(self) -> None:
-        """
-        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.
-        """
-        # Define a function for testing
-        def test_function():
-            pass
-
-        # Should raise error for function and lambda instances
-        with self.assertRaises(OrionisContainerTypeError):
-            IsInstance(test_function)
-            IsInstance(lambda x: x * 2)
-
-        # Should raise error for type of function
-        with self.assertRaises(OrionisContainerTypeError):
-            IsInstance(type(test_function))

tests/container/validators/test_is_not_subclass.py

@@ -1,49 +0,0 @@
-from abc import ABC
-from orionis.container.validators.is_not_subclass import IsNotSubclass
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestIsNotSubclass(AsyncTestCase):
-
-    async def testValidNonSubclass(self) -> None:
-        """
-        Validate that `IsNotSubclass` does not raise an exception when the second argument
-        is not a subclass of the first argument.
-
-        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.
-
-        Parameters
-        ----------
-        self : TestIsNotSubclass
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-
-        Raises
-        ------
-        AssertionError
-            If `IsNotSubclass` raises an exception for valid non-subclass relationships.
-        """
-        # Define abstract base classes
-        class AbstractClass1(ABC):
-            pass
-
-        class AbstractClass2(ABC):
-            pass
-
-        # Define concrete classes inheriting from abstract base classes
-        class ConcreteClass1(AbstractClass1):
-            pass
-
-        class ConcreteClass2(AbstractClass2):
-            pass
-
-        # 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

@@ -1,178 +0,0 @@
-from abc import ABC
-from orionis.container.validators.is_subclass import IsSubclass
-from orionis.container.exceptions.exception import OrionisContainerException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestIsSubclass(AsyncTestCase):
-
-    async def testValidSubclass(self) -> None:
-        """
-        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 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 calls should not raise exceptions since subclass relationships are valid
-        IsSubclass(AbstractClass, ConcreteClass)
-        IsSubclass(AbstractClass, SubConcreteClass)
-        IsSubclass(ConcreteClass, SubConcreteClass)
-
-    async def testInvalidSubclass(self) -> None:
-        """
-        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 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 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))
-
-        with self.assertRaises(OrionisContainerException) as context:
-            IsSubclass(AbstractClass1, ConcreteClass2)
-        self.assertIn("concrete class must inherit", str(context.exception))
-
-        with self.assertRaises(OrionisContainerException) as context:
-            IsSubclass(ConcreteClass1, AbstractClass1)
-        self.assertIn("concrete class must inherit", str(context.exception))
-
-    async def testSameClass(self) -> None:
-        """
-        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
-
-        # Should not raise since a class is a subclass of itself
-        IsSubclass(TestClass, TestClass)
-
-    async def testBuiltinTypes(self) -> None:
-        """
-        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 for built-in types
-        IsSubclass(Exception, ValueError)
-        IsSubclass(BaseException, Exception)
-
-        # Invalid subclass relationships should raise exceptions
-        with self.assertRaises(OrionisContainerException):
-            IsSubclass(ValueError, Exception)
-
-        with self.assertRaises(OrionisContainerException):
-            IsSubclass(int, str)
-
-        with self.assertRaises(OrionisContainerException):
-            IsSubclass(list, dict)
-
-    async def testNonClassArguments(self) -> None:
-        """
-        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
-
-        # List of non-class arguments to test
-        non_class_args = [
-            None,
-            123,
-            "string",
-            [],
-            {},
-            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)
-
-            with self.assertRaises(TypeError):
-                IsSubclass(arg, TestClass)

tests/container/validators/test_is_valid_alias.py

@@ -1,147 +0,0 @@
-from orionis.container.validators.is_valid_alias import IsValidAlias
-from orionis.container.exceptions.type import OrionisContainerTypeError
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestIsValidAlias(AsyncTestCase):
-
-    async def testValidAliases(self) -> None:
-        """
-        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",
-            "valid_alias",
-            "validAlias",
-            "valid123",
-            "valid_123",
-            "v",
-            "1",
-            "_",
-            "valid_alias_with_underscores",
-            "ValidAliasWithMixedCase",
-            "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:
-        """
-        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,
-            3.14,
-            None,
-            True,
-            False,
-            [],
-            {},
-            (),
-            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:
-        """
-        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
-            "invalid\talias",  # tab
-            "invalid\nalias",  # newline
-            "invalid@alias",   # special character
-            "invalid#alias",   # special character
-            "invalid$alias",   # special character
-            "invalid%alias",   # special character
-            "invalid&alias",   # special character
-            "invalid*alias",   # special character
-            "invalid(alias)",  # parentheses
-            "invalid[alias]",  # brackets
-            "invalid{alias}",  # braces
-            "invalid;alias",   # semicolon
-            "invalid:alias",   # colon
-            "invalid,alias",   # comma
-            "invalid/alias",   # slash
-            "invalid\\alias",  # backslash
-            "invalid<alias>",  # angle brackets
-            "invalid|alias",   # pipe
-            "invalid`alias",   # backtick
-            'invalid"alias',   # double quote
-            "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:
-        """
-        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:
-            IsValidAlias("")
-
-        self.assertEqual(
-            str(context.exception),
-            "Alias cannot be None, empty, or whitespace only."
-        )
-
-        # Whitespace-only string should also be rejected
-        with self.assertRaises(OrionisContainerTypeError) as context:
-            IsValidAlias("   ")
-
-        self.assertEqual(
-            str(context.exception),
-            "Alias cannot be None, empty, or whitespace only."
-        )