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

tests/container/validators/test_is_subclass.py

@@ -0,0 +1,115 @@
+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):
+    """
+    Test cases for the IsSubclass validator in orionis.container.validators.is_subclass.
+
+    Notes
+    -----
+    This test suite validates the functionality of the IsSubclass validator
+    which ensures that a concrete class is a subclass of an abstract class.
+    """
+
+    async def testValidSubclass(self) -> None:
+        """
+        Test that validation passes when concrete class is a valid subclass.
+        """
+        # Define test classes
+        class AbstractClass(ABC):
+            pass
+
+        class ConcreteClass(AbstractClass):
+            pass
+
+        class SubConcreteClass(ConcreteClass):
+            pass
+
+        # These should not raise exceptions
+        IsSubclass(AbstractClass, ConcreteClass)
+        IsSubclass(AbstractClass, SubConcreteClass)
+        IsSubclass(ConcreteClass, SubConcreteClass)
+
+    async def testInvalidSubclass(self) -> None:
+        """
+        Test that validation fails when concrete class is not a subclass.
+        """
+        # Define test classes
+        class AbstractClass1(ABC):
+            pass
+
+        class AbstractClass2(ABC):
+            pass
+
+        class ConcreteClass1(AbstractClass1):
+            pass
+
+        class ConcreteClass2(AbstractClass2):
+            pass
+
+        # These should raise exceptions
+        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:
+        """
+        Test validation when abstract and concrete are the same class.
+        """
+        class TestClass:
+            pass
+
+        # A class is considered a subclass of itself
+        IsSubclass(TestClass, TestClass)
+
+    async def testBuiltinTypes(self) -> None:
+        """
+        Test validation with built-in types.
+        """
+        # Valid subclass relationships
+        IsSubclass(Exception, ValueError)
+        IsSubclass(BaseException, Exception)
+
+        # Invalid subclass relationships
+        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:
+        """
+        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):
+                IsSubclass(TestClass, arg)
+
+            with self.assertRaises(TypeError):
+                IsSubclass(arg, TestClass)

tests/container/validators/test_is_valid_alias.py

@@ -0,0 +1,113 @@
+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):
+    """
+    Test cases for the IsValidAlias validator in orionis.container.validators.is_valid_alias.
+
+    Notes
+    -----
+    This test suite validates the functionality of the IsValidAlias validator
+    which ensures that alias values are valid strings without invalid characters.
+    """
+
+    async def testValidAliases(self) -> None:
+        """
+        Test that validation passes when valid aliases are provided.
+        """
+        valid_aliases = [
+            "valid",
+            "valid_alias",
+            "validAlias",
+            "valid123",
+            "valid_123",
+            "v",
+            "1",
+            "_",
+            "valid_alias_with_underscores",
+            "ValidAliasWithMixedCase",
+            "VALID_UPPERCASE_ALIAS"
+        ]
+
+        for alias in valid_aliases:
+            IsValidAlias(alias)
+
+    async def testInvalidAliasTypes(self) -> None:
+        """
+        Test that validation fails when non-string types are provided.
+        """
+        invalid_types = [
+            123,
+            3.14,
+            None,
+            True,
+            False,
+            [],
+            {},
+            (),
+            set()
+        ]
+
+        for value in invalid_types:
+            with self.assertRaises(OrionisContainerTypeError) as context:
+                IsValidAlias(value)
+
+    async def testAliasWithInvalidCharacters(self) -> None:
+        """
+        Test that validation fails when aliases contain invalid characters.
+        """
+        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
+        ]
+
+        for alias in invalid_aliases:
+            with self.assertRaises(OrionisContainerTypeError) as context:
+                IsValidAlias(alias)
+
+            expected_msg_start = f"Alias '{alias}' contains invalid characters."
+            self.assertTrue(str(context.exception).startswith(expected_msg_start))
+            self.assertIn("Aliases must not contain whitespace or special symbols", str(context.exception))
+
+    async def testEmptyAlias(self) -> None:
+        """
+        Test that validation fails with an empty string.
+        """
+        # 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."
+        )

tests/container/validators/test_lifetime.py

@@ -0,0 +1,75 @@
+from orionis.container.validators.lifetime import LifetimeValidator
+from orionis.container.enums.lifetimes import Lifetime
+from orionis.container.exceptions.type import OrionisContainerTypeError
+from orionis.test.cases.asynchronous import AsyncTestCase
+
+class TestLifetimeValidator(AsyncTestCase):
+    """
+    Test cases for the LifetimeValidator in orionis.container.validators.lifetime.
+
+    Notes
+    -----
+    This test suite validates the functionality of the LifetimeValidator
+    which ensures that lifetime values are correctly validated and converted.
+    """
+
+    async def testValidLifetimeEnumValues(self) -> None:
+        """
+        Test that validation passes when Lifetime enum values are provided.
+        """
+        self.assertEqual(LifetimeValidator(Lifetime.TRANSIENT), Lifetime.TRANSIENT)
+        self.assertEqual(LifetimeValidator(Lifetime.SINGLETON), Lifetime.SINGLETON)
+        self.assertEqual(LifetimeValidator(Lifetime.SCOPED), Lifetime.SCOPED)
+
+    async def testValidLifetimeStringValues(self) -> None:
+        """
+        Test that validation passes when valid string representations are provided.
+        """
+        self.assertEqual(LifetimeValidator("TRANSIENT"), Lifetime.TRANSIENT)
+        self.assertEqual(LifetimeValidator("SINGLETON"), Lifetime.SINGLETON)
+        self.assertEqual(LifetimeValidator("SCOPED"), Lifetime.SCOPED)
+
+        # Test with lowercase and mixed case
+        self.assertEqual(LifetimeValidator("transient"), Lifetime.TRANSIENT)
+        self.assertEqual(LifetimeValidator("Singleton"), Lifetime.SINGLETON)
+        self.assertEqual(LifetimeValidator("scoped"), Lifetime.SCOPED)
+
+        # Test with extra whitespace
+        self.assertEqual(LifetimeValidator(" TRANSIENT "), Lifetime.TRANSIENT)
+        self.assertEqual(LifetimeValidator("  singleton  "), Lifetime.SINGLETON)
+
+    async def testInvalidLifetimeStringValue(self) -> None:
+        """
+        Test that validation fails when invalid string representations are provided.
+        """
+        with self.assertRaises(OrionisContainerTypeError) as context:
+            LifetimeValidator("INVALID_LIFETIME")
+
+        self.assertIn("Invalid lifetime 'INVALID_LIFETIME'", str(context.exception))
+        self.assertIn("Valid options are:", str(context.exception))
+        self.assertIn("TRANSIENT", str(context.exception))
+        self.assertIn("SINGLETON", str(context.exception))
+        self.assertIn("SCOPED", str(context.exception))
+
+    async def testInvalidLifetimeType(self) -> None:
+        """
+        Test that validation fails when invalid types are provided.
+        """
+        invalid_values = [
+            123,
+            3.14,
+            None,
+            True,
+            False,
+            [],
+            {},
+            (),
+            set()
+        ]
+
+        for value in invalid_values:
+            with self.assertRaises(OrionisContainerTypeError) as context:
+                LifetimeValidator(value)
+
+            expected_msg = f"Lifetime must be of type str or Lifetime enum, got {type(value).__name__}."
+            self.assertEqual(str(context.exception), expected_msg)

tests/example/test_example.py

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

tests/foundation/config/testing/test_foundation_config_testing.py

@@ -1,6 +1,6 @@
 from orionis.foundation.config.testing.entities.testing import Testing
+from orionis.foundation.config.testing.enums.mode import ExecutionMode
 from orionis.foundation.exceptions import OrionisIntegrityException
-from orionis.test.enums.execution_mode import ExecutionMode
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestFoundationConfigTesting(AsyncTestCase):

tests/metadata/test_metadata_framework.py

@@ -13,89 +13,154 @@ class TestMetadataFramework(AsyncTestCase):
 
     async def testConstantsExistAndAreStr(self):
         """
-        Test that all metadata constants exist and are of type `str`.
+        Validate that all metadata constants exist and are of type `str`.
+
+        This test iterates over a predefined list of metadata constants and checks
+        that each constant is present and its type is `str`.
 
         Raises
         ------
         AssertionError
             If any constant is not a string.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
         """
+
+        # Check each metadata constant for type str
         for const in [
             NAME, VERSION, AUTHOR, AUTHOR_EMAIL, DESCRIPTION,
             SKELETON, FRAMEWORK, DOCS, API, PYTHON_REQUIRES
         ]:
-            assert isinstance(const, str)
+            self.assertIsInstance(const, str)
 
     async def testClassifiersStructure(self):
         """
-        Test that `CLASSIFIERS` is a list of tuples of strings.
+        Ensure that `CLASSIFIERS` is a list of tuples containing strings.
+
+        This test verifies the structure of the `CLASSIFIERS` constant, ensuring
+        it is a list where each element is a tuple, and each tuple contains only strings.
 
         Raises
         ------
         AssertionError
             If `CLASSIFIERS` is not a list of tuples of strings.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
         """
-        assert isinstance(CLASSIFIERS, list)
+
+        # Confirm CLASSIFIERS is a list
+        self.assertIsInstance(CLASSIFIERS, list)
+
+        # Check each item in CLASSIFIERS for tuple of strings
         for item in CLASSIFIERS:
-            assert isinstance(item, tuple)
-            assert all(isinstance(part, str) for part in item)
+            self.assertIsInstance(item, tuple)
+            self.assertTrue(all(isinstance(part, str) for part in item))
 
     async def testGetClassifiers(self):
         """
-        Test that `get_classifiers` returns a list of classifier strings.
+        Verify that `get_classifiers` returns a list of classifier strings.
+
+        This test calls the `get_classifiers` utility function and checks that
+        the returned value is a list of strings, each representing a classifier.
 
         Raises
         ------
         AssertionError
             If the returned value is not a list of strings containing '::'.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
         """
+
+        # Retrieve classifiers and validate their format
         classifiers = get_classifiers()
-        assert isinstance(classifiers, list)
+        self.assertIsInstance(classifiers, list)
         for c in classifiers:
-            assert isinstance(c, str)
-            assert " :: " in c or len(c.split(" :: ")) > 1
+            self.assertIsInstance(c, str)
+            self.assertTrue(" :: " in c or len(c.split(" :: ")) > 1)
 
     async def testKeywords(self):
         """
-        Test that `KEYWORDS` is a list of strings and contains specific keywords.
+        Check that `KEYWORDS` is a list of strings and contains required keywords.
+
+        This test ensures that the `KEYWORDS` constant is a list of strings and
+        verifies the presence of specific keywords relevant to the framework.
 
         Raises
         ------
         AssertionError
             If `KEYWORDS` is not a list of strings or required keywords are missing.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
         """
-        assert isinstance(KEYWORDS, list)
+
+        # Confirm KEYWORDS is a list of strings
+        self.assertIsInstance(KEYWORDS, list)
         for kw in KEYWORDS:
-            assert isinstance(kw, str)
-        assert "orionis" in KEYWORDS
-        assert "framework" in KEYWORDS
+            self.assertIsInstance(kw, str)
+
+        # Check for required keywords
+        self.assertIn("orionis", KEYWORDS)
+        self.assertIn("framework", KEYWORDS)
 
     async def testRequiresStructure(self):
         """
-        Test that `REQUIRES` is a list of 2-element tuples of strings.
+        Validate that `REQUIRES` is a list of 2-element tuples of strings.
+
+        This test checks the structure of the `REQUIRES` constant, ensuring it is
+        a list where each element is a tuple of length 2, and both elements are strings.
 
         Raises
         ------
         AssertionError
             If `REQUIRES` is not a list of 2-element tuples of strings.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
         """
-        assert isinstance(REQUIRES, list)
+
+        # Confirm REQUIRES is a list of 2-element tuples of strings
+        self.assertIsInstance(REQUIRES, list)
         for req in REQUIRES:
-            assert isinstance(req, tuple)
-            assert len(req) == 2
-            assert all(isinstance(part, str) for part in req)
+            self.assertIsInstance(req, tuple)
+            self.assertEqual(len(req), 2)
+            self.assertTrue(all(isinstance(part, str) for part in req))
 
     async def testGetRequires(self):
         """
-        Test that `get_requires` returns a list of requirement strings.
+        Ensure that `get_requires` returns a list of requirement strings.
+
+        This test calls the `get_requires` utility function and checks that the
+        returned value is a list of strings, each representing a requirement and
+        containing the '>=' version specifier.
 
         Raises
         ------
         AssertionError
             If the returned value is not a list of strings containing '>='.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
         """
+
+        # Retrieve requirements and validate their format
         requires = get_requires()
-        assert isinstance(requires, list)
+        self.assertIsInstance(requires, list)
         for req in requires:
-            assert isinstance(req, str)
-            assert ">=" in req
+            self.assertIsInstance(req, str)
+            self.assertIn(">=", req)

tests/metadata/test_metadata_package.py

@@ -6,89 +6,134 @@ class TestPypiPackageApi(AsyncTestCase):
     @patch("orionis.metadata.package.PypiPackageApi")
     async def testGetName(self, MockPypiPackageApi):
         """
-        Test for the getName method.
+        Tests the `getName` method of the `PypiPackageApi` class.
+
+        This test verifies that the mocked `getName` method returns the expected package name.
 
         Parameters
         ----------
         MockPypiPackageApi : MagicMock
-            Mocked PypiPackageApi class.
+            Mocked `PypiPackageApi` class.
 
         Returns
         -------
         None
+            This method does not return anything. It asserts the expected behavior.
         """
+
+        # Get the mocked API instance
         api = MockPypiPackageApi.return_value
+
+        # Set the return value for getName
         api.getName.return_value = "orionis"
+
+        # Assert that getName returns the expected value
         self.assertEqual(api.getName(), "orionis")
 
     @patch("orionis.metadata.package.PypiPackageApi")
     async def testGetAuthor(self, MockPypiPackageApi):
         """
-        Test for the getAuthor method.
+        Tests the `getAuthor` method of the `PypiPackageApi` class.
+
+        This test checks that the mocked `getAuthor` method returns the correct author name.
 
         Parameters
         ----------
         MockPypiPackageApi : MagicMock
-            Mocked PypiPackageApi class.
+            Mocked `PypiPackageApi` class.
 
         Returns
         -------
         None
+            This method does not return anything. It asserts the expected behavior.
         """
+
+        # Get the mocked API instance
         api = MockPypiPackageApi.return_value
+
+        # Set the return value for getAuthor
         api.getAuthor.return_value = "Raul Mauricio Uñate Castro"
+
+        # Assert that getAuthor returns the expected value
         self.assertEqual(api.getAuthor(), "Raul Mauricio Uñate Castro")
 
     @patch("orionis.metadata.package.PypiPackageApi")
     async def testGetAuthorEmail(self, MockPypiPackageApi):
         """
-        Test for the getAuthorEmail method.
+        Tests the `getAuthorEmail` method of the `PypiPackageApi` class.
+
+        This test ensures that the mocked `getAuthorEmail` method returns the correct author email address.
 
         Parameters
         ----------
         MockPypiPackageApi : MagicMock
-            Mocked PypiPackageApi class.
+            Mocked `PypiPackageApi` class.
 
         Returns
         -------
         None
+            This method does not return anything. It asserts the expected behavior.
         """
+
+        # Get the mocked API instance
         api = MockPypiPackageApi.return_value
+
+        # Set the return value for getAuthorEmail
         api.getAuthorEmail.return_value = "raulmauriciounate@gmail.com"
+
+        # Assert that getAuthorEmail returns the expected value
         self.assertEqual(api.getAuthorEmail(), "raulmauriciounate@gmail.com")
 
     @patch("orionis.metadata.package.PypiPackageApi")
     async def testGetDescription(self, MockPypiPackageApi):
         """
-        Test for the getDescription method.
+        Tests the `getDescription` method of the `PypiPackageApi` class.
+
+        This test verifies that the mocked `getDescription` method returns the expected package description.
 
         Parameters
         ----------
         MockPypiPackageApi : MagicMock
-            Mocked PypiPackageApi class.
+            Mocked `PypiPackageApi` class.
 
         Returns
         -------
         None
+            This method does not return anything. It asserts the expected behavior.
         """
+
+        # Get the mocked API instance
         api = MockPypiPackageApi.return_value
+
+        # Set the return value for getDescription
         api.getDescription.return_value = "Orionis Framework – Elegant, Fast, and Powerful."
+
+        # Assert that getDescription returns the expected value
         self.assertEqual(api.getDescription(), "Orionis Framework – Elegant, Fast, and Powerful.")
 
     @patch("orionis.metadata.package.PypiPackageApi")
     async def testGetPythonVersion(self, MockPypiPackageApi):
         """
-        Test for the getPythonVersion method.
+        Tests the `getPythonVersion` method of the `PypiPackageApi` class.
+
+        This test checks that the mocked `getPythonVersion` method returns the correct Python version requirement.
 
         Parameters
         ----------
         MockPypiPackageApi : MagicMock
-            Mocked PypiPackageApi class.
+            Mocked `PypiPackageApi` class.
 
         Returns
         -------
         None
+            This method does not return anything. It asserts the expected behavior.
         """
+
+        # Get the mocked API instance
         api = MockPypiPackageApi.return_value
+
+        # Set the return value for getPythonVersion
         api.getPythonVersion.return_value = ">=3.12"
+
+        # Assert that getPythonVersion returns the expected value
         self.assertEqual(api.getPythonVersion(), ">=3.12")