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

tests/container/mocks/mock_simple_classes.py

@@ -1,98 +0,0 @@
-from abc import ABC, abstractmethod
-
-class ICar(ABC):
-    """
-    Interface for car objects.
-
-    Defines the required methods for car objects, including starting and stopping the car.
-
-    Methods
-    -------
-    start() -> str
-        Start the car and return a message indicating the car has started.
-    stop() -> str
-        Stop the car and return a message indicating the car has stopped.
-    """
-
-    @abstractmethod
-    def start(self) -> str:
-        """
-        Start the car.
-
-        Returns
-        -------
-        str
-            Message indicating the car has started.
-        """
-        pass
-
-    @abstractmethod
-    def stop(self) -> str:
-        """
-        Stop the car.
-
-        Returns
-        -------
-        str
-            Message indicating the car has stopped.
-        """
-        pass
-
-class Car(ICar):
-    """
-    Concrete implementation of the ICar interface.
-
-    Parameters
-    ----------
-    brand : str, optional
-        The brand of the car (default is 'a').
-    model : str, optional
-        The model of the car (default is 'b').
-
-    Attributes
-    ----------
-    brand : str
-        The brand of the car.
-    model : str
-        The model of the car.
-    """
-
-    def __init__(self, brand: str = 'a', model: str = 'b'):
-        """
-        Initialize a new Car instance with the specified brand and model.
-
-        Parameters
-        ----------
-        brand : str, optional
-            The brand of the car. Default is 'a'.
-        model : str, optional
-            The model of the car. Default is 'b'.
-
-        Notes
-        -----
-        This constructor sets the brand and model attributes for the Car object.
-        """
-        self.brand = brand  # Set the brand of the car
-        self.model = model  # Set the model of the car
-
-    def start(self):
-        """
-        Start the car.
-
-        Returns
-        -------
-        str
-            Message indicating the car is starting.
-        """
-        return f"{self.brand} {self.model} is starting."
-
-    def stop(self):
-        """
-        Stop the car.
-
-        Returns
-        -------
-        str
-            Message indicating the car is stopping.
-        """
-        return f"{self.brand} {self.model} is stopping."

tests/container/providers/test_providers.py

@@ -1,55 +0,0 @@
-import inspect
-from orionis.container.contracts.service_provider import IServiceProvider
-from orionis.container.providers.service_provider import ServiceProvider
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestServiceProviderMethods(AsyncTestCase):
-
-    async def testMethodsExist(self):
-        """
-        Validates the implementation of required methods and inheritance in the ServiceProvider class.
-
-        This test performs the following checks:
-        - Verifies that the ServiceProvider class defines the '__init__', 'register', and 'boot' methods.
-        - Ensures that the 'register' and 'boot' methods are asynchronous coroutine functions.
-        - Confirms that ServiceProvider is a subclass of IServiceProvider.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
-            The method does not return any value. Assertions are used to validate class structure and method types.
-        """
-
-        # List of required methods and their associated class
-        expected_methods = [
-            ("__init__", ServiceProvider),
-            ("register", ServiceProvider),
-            ("boot", ServiceProvider),
-        ]
-
-        # Check that each required method exists in ServiceProvider
-        for method_name, cls in expected_methods:
-            self.assertTrue(
-                hasattr(cls, method_name),
-                f"Method '{method_name}' does not exist in {cls.__name__}."
-            )
-
-        # Ensure 'register' and 'boot' are asynchronous methods
-        self.assertTrue(
-            inspect.iscoroutinefunction(ServiceProvider.register),
-            "'register' must be an async coroutine function."
-        )
-        self.assertTrue(
-            inspect.iscoroutinefunction(ServiceProvider.boot),
-            "'boot' must be an async coroutine function."
-        )
-
-        # Ensure ServiceProvider inherits from IServiceProvider
-        self.assertTrue(
-            issubclass(ServiceProvider, IServiceProvider),
-            "ServiceProvider must inherit from IServiceProvider."
-        )

tests/container/validators/test_implements.py

@@ -1,186 +0,0 @@
-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):
-
-    async def asyncSetUp(self) -> None:
-        """
-        Set up test fixtures for ImplementsAbstractMethods validator tests.
-
-        This method defines several abstract and concrete classes to be used in the test cases:
-        - An abstract base class with two abstract methods.
-        - A concrete class that correctly implements all abstract methods.
-        - A concrete class that does not implement all abstract methods.
-        - A non-abstract base class for negative test cases.
-
-        The defined classes are assigned to instance attributes for use in subsequent tests.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-        # Define an abstract base class with two abstract methods
-        class AbstractBase(ABC):
-            @abstractmethod
-            def abstract_method(self) -> None:
-                pass
-
-            @abstractmethod
-            def another_abstract_method(self) -> str:
-                pass
-
-        # Concrete class that implements all abstract methods
-        class ConcreteCorrect(AbstractBase):
-            def abstract_method(self) -> None:
-                pass
-
-            def another_abstract_method(self) -> str:
-                return "implemented"
-
-        # Concrete class that does not implement all abstract methods
-        class ConcreteIncomplete(AbstractBase):
-            def abstract_method(self) -> None:
-                pass
-
-        # Non-abstract base class for negative test cases
-        class NonAbstractBase:
-            def regular_method(self) -> None:
-                pass
-
-        # Assign classes to instance attributes for use in tests
-        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.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-        # 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.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-        # Test with class missing an abstract method
-        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 missing an abstract method
-        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.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-        # Should raise exception if abstract class is not 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.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-        # Should raise exception if neither concrete 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.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-        # Should raise exception if abstract class does not define any 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.
-
-        This test verifies that the validator correctly handles cases where abstract methods
-        are renamed with class name prefixes in the concrete implementation.
-
-        Returns
-        -------
-        None
-            This method does not return any value.
-        """
-        # Define an abstract class with a prefixed abstract method
-        class AbstractWithPrefix(ABC):
-            @abstractmethod
-            def _AbstractWithPrefix_method(self) -> None:
-                pass
-
-        # Concrete class with a similarly prefixed method
-        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

@@ -1,147 +0,0 @@
-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):
-
-    async def testValidAbstractClass(self) -> None:
-        """
-        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 an abstract class with an abstract method
-        class AbstractBase(ABC):
-            @abstractmethod
-            def abstract_method(self):
-                pass
-
-        # 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:
-        """
-        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
-
-        # 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")
-
-            self.assertIn("Unexpected error registering scoped service", str(context.exception))
-            mock_ensure.assert_called_once_with(ConcreteClass)
-
-    async def testWithInheritedAbstractClass(self) -> None:
-        """
-        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
-
-        # 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:
-        """
-        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"
-
-        # 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")
-
-            self.assertIn("Unexpected error registering singleton service", str(context.exception))
-            mock_ensure.assert_called_once_with(ConcreteImplementation)
-
-    async def testWithNonClassTypes(self) -> None:
-        """
-        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 various non-class types
-        for invalid_value in [1, "string", [], {}, lambda: None]:
-            # 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

@@ -1,102 +0,0 @@
-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):
-
-    async def testValidCallables(self) -> None:
-        """
-        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  # Simple user-defined function
-
-        class ClassWithCall:
-            def __call__(self):
-                pass  # Class instance with __call__ method
-
-        lambda_func = lambda x: x  # Lambda function
-
-        # These should not raise exceptions as they are all callable
-        IsCallable(simple_function)
-        IsCallable(ClassWithCall())
-        IsCallable(lambda_func)
-        IsCallable(len)
-        IsCallable(print)
-
-    async def testNonCallables(self) -> None:
-        """
-        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,                # 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."
-            self.assertEqual(str(context.exception), expected_message)
-
-    async def testClassesAsCallables(self) -> None:
-        """
-        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  # Simple class definition
-
-        # Should not raise an exception since classes are callable
-        IsCallable(SimpleClass)
-
-    async def testBuiltinFunctions(self) -> None:
-        """
-        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 built-in functions should not raise exceptions
-        IsCallable(sum)
-        IsCallable(map)
-        IsCallable(filter)
-        IsCallable(sorted)