orionis 0.405.0__py3-none-any.whl → 0.406.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/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

@@ -24,7 +24,7 @@ class TestMetadataFramework(AsyncTestCase):
             NAME, VERSION, AUTHOR, AUTHOR_EMAIL, DESCRIPTION,
             SKELETON, FRAMEWORK, DOCS, API, PYTHON_REQUIRES
         ]:
-            assert isinstance(const, str)
+            self.assertIsInstance(const, str)
 
     async def testClassifiersStructure(self):
         """
@@ -35,10 +35,10 @@ class TestMetadataFramework(AsyncTestCase):
         AssertionError
             If `CLASSIFIERS` is not a list of tuples of strings.
         """
-        assert isinstance(CLASSIFIERS, list)
+        self.assertIsInstance(CLASSIFIERS, list)
         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):
         """
@@ -50,10 +50,10 @@ class TestMetadataFramework(AsyncTestCase):
             If the returned value is not a list of strings containing '::'.
         """
         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):
         """
@@ -64,11 +64,11 @@ class TestMetadataFramework(AsyncTestCase):
         AssertionError
             If `KEYWORDS` is not a list of strings or required keywords are missing.
         """
-        assert isinstance(KEYWORDS, list)
+        self.assertIsInstance(KEYWORDS, list)
         for kw in KEYWORDS:
-            assert isinstance(kw, str)
-        assert "orionis" in KEYWORDS
-        assert "framework" in KEYWORDS
+            self.assertIsInstance(kw, str)
+        self.assertIn("orionis", KEYWORDS)
+        self.assertIn("framework", KEYWORDS)
 
     async def testRequiresStructure(self):
         """
@@ -79,11 +79,11 @@ class TestMetadataFramework(AsyncTestCase):
         AssertionError
             If `REQUIRES` is not a list of 2-element tuples of strings.
         """
-        assert isinstance(REQUIRES, list)
+        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):
         """
@@ -95,7 +95,7 @@ class TestMetadataFramework(AsyncTestCase):
             If the returned value is not a list of strings containing '>='.
         """
         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/testing/test_testing_result.py

@@ -1,131 +1,131 @@
-from orionis.test.cases.asynchronous import AsyncTestCase
-from orionis.test.entities.result import TestResult
-from orionis.test.enums import TestStatus
+# from orionis.test.cases.asynchronous import AsyncTestCase
+# from orionis.test.entities.result import TestResult
+# from orionis.test.enums import TestStatus
 
-class TestTestingResult(AsyncTestCase):
+# class TestTestingResult(AsyncTestCase):
 
-    async def testDefaultValues(self) -> None:
-        """
-        Ensures that when optional fields are not provided during initialization of a TestResult
-        instance, they are set to None.
+#     async def testDefaultValues(self) -> None:
+#         """
+#         Ensures that when optional fields are not provided during initialization of a TestResult
+#         instance, they are set to None.
 
-        Notes
-        -----
-        This test verifies the default behavior of the following optional fields:
-            - error_message
-            - traceback
-            - class_name
-            - method
-            - module
-            - file_path
+#         Notes
+#         -----
+#         This test verifies the default behavior of the following optional fields:
+#             - error_message
+#             - traceback
+#             - class_name
+#             - method
+#             - module
+#             - file_path
 
-        Assertions
-        ----------
-        Each optional field is checked to confirm it is None after initialization.
-        """
-        result = TestResult(
-            id=1,
-            name="Sample Test",
-            status=TestStatus.PASSED,
-            execution_time=0.5
-        )
-        self.assertIsNone(result.error_message)
-        self.assertIsNone(result.traceback)
-        self.assertIsNone(result.class_name)
-        self.assertIsNone(result.method)
-        self.assertIsNone(result.module)
-        self.assertIsNone(result.file_path)
+#         Assertions
+#         ----------
+#         Each optional field is checked to confirm it is None after initialization.
+#         """
+#         result = TestResult(
+#             id=1,
+#             name="Sample Test",
+#             status=TestStatus.PASSED,
+#             execution_time=0.5
+#         )
+#         self.assertIsNone(result.error_message)
+#         self.assertIsNone(result.traceback)
+#         self.assertIsNone(result.class_name)
+#         self.assertIsNone(result.method)
+#         self.assertIsNone(result.module)
+#         self.assertIsNone(result.file_path)
 
-    async def testRequiredFields(self) -> None:
-        """
-        Test that TestResult enforces the presence of all required (non-optional) fields during initialization.
-        This test verifies that omitting any required field when creating a TestResult instance raises a TypeError.
+#     async def testRequiredFields(self) -> None:
+#         """
+#         Test that TestResult enforces the presence of all required (non-optional) fields during initialization.
+#         This test verifies that omitting any required field when creating a TestResult instance raises a TypeError.
 
-        Notes
-        -----
-        - Attempts to instantiate TestResult with no arguments.
-        - Attempts to instantiate TestResult missing the 'id' field.
-        - Expects a TypeError to be raised in both cases.
-        """
-        with self.assertRaises(TypeError):
-            TestResult()  # Missing all required fields
+#         Notes
+#         -----
+#         - Attempts to instantiate TestResult with no arguments.
+#         - Attempts to instantiate TestResult missing the 'id' field.
+#         - Expects a TypeError to be raised in both cases.
+#         """
+#         with self.assertRaises(TypeError):
+#             TestResult()  # Missing all required fields
 
-        with self.assertRaises(TypeError):
-            # Missing id
-            TestResult(
-                name="Sample Test",
-                status=TestStatus.PASSED,
-                execution_time=0.5
-            )
+#         with self.assertRaises(TypeError):
+#             # Missing id
+#             TestResult(
+#                 name="Sample Test",
+#                 status=TestStatus.PASSED,
+#                 execution_time=0.5
+#             )
 
-    async def testImmutable(self) -> None:
-        """
-        Test the immutability of TestResult instances.
-        This test ensures that TestResult, implemented as a frozen dataclass, does not allow
-        modification of its attributes after instantiation.
+#     async def testImmutable(self) -> None:
+#         """
+#         Test the immutability of TestResult instances.
+#         This test ensures that TestResult, implemented as a frozen dataclass, does not allow
+#         modification of its attributes after instantiation.
 
-        Parameters
-        ----------
-        self : TestCase
-            The test case instance.
+#         Parameters
+#         ----------
+#         self : TestCase
+#             The test case instance.
 
-        Raises
-        ------
-        FrozenInstanceError
-            If an attempt is made to modify an attribute of a frozen TestResult instance.
-        """
-        result = TestResult(
-            id=1,
-            name="Sample Test",
-            status=TestStatus.PASSED,
-            execution_time=0.5
-        )
-        with self.assertRaises(Exception):
-            result.name = "Modified Name"
+#         Raises
+#         ------
+#         FrozenInstanceError
+#             If an attempt is made to modify an attribute of a frozen TestResult instance.
+#         """
+#         result = TestResult(
+#             id=1,
+#             name="Sample Test",
+#             status=TestStatus.PASSED,
+#             execution_time=0.5
+#         )
+#         with self.assertRaises(Exception):
+#             result.name = "Modified Name"
 
-    async def testStatusValues(self) -> None:
-        """
-        Parameters
-        ----------
-        self : TestCase
-            The test case instance.
+#     async def testStatusValues(self) -> None:
+#         """
+#         Parameters
+#         ----------
+#         self : TestCase
+#             The test case instance.
 
-        Notes
-        -----
-        This test iterates over all possible values of the `TestStatus` enum and verifies
-        that each value can be assigned to the `status` field of a `TestResult` instance.
-        It asserts that the assigned status matches the expected value.
-        """
-        for status in TestStatus:
-            result = TestResult(
-                id=1,
-                name="Status Test",
-                status=status,
-                execution_time=0.1
-            )
-            self.assertEqual(result.status, status)
+#         Notes
+#         -----
+#         This test iterates over all possible values of the `TestStatus` enum and verifies
+#         that each value can be assigned to the `status` field of a `TestResult` instance.
+#         It asserts that the assigned status matches the expected value.
+#         """
+#         for status in TestStatus:
+#             result = TestResult(
+#                 id=1,
+#                 name="Status Test",
+#                 status=status,
+#                 execution_time=0.1
+#             )
+#             self.assertEqual(result.status, status)
 
-    async def testErrorFields(self) -> None:
-        """
-        Parameters
-        ----------
-        self : TestCase
-            The test case instance.
+#     async def testErrorFields(self) -> None:
+#         """
+#         Parameters
+#         ----------
+#         self : TestCase
+#             The test case instance.
 
-        Notes
-        -----
-        Verifies that the `error_message` and `traceback` fields are correctly stored in the `TestResult`
-        object when provided during initialization.
-        """
-        error_msg = "Test failed"
-        traceback = "Traceback info"
-        result = TestResult(
-            id=1,
-            name="Failing Test",
-            status=TestStatus.FAILED,
-            execution_time=0.2,
-            error_message=error_msg,
-            traceback=traceback
-        )
-        self.assertEqual(result.error_message, error_msg)
-        self.assertEqual(result.traceback, traceback)
+#         Notes
+#         -----
+#         Verifies that the `error_message` and `traceback` fields are correctly stored in the `TestResult`
+#         object when provided during initialization.
+#         """
+#         error_msg = "Test failed"
+#         traceback = "Traceback info"
+#         result = TestResult(
+#             id=1,
+#             name="Failing Test",
+#             status=TestStatus.FAILED,
+#             execution_time=0.2,
+#             error_message=error_msg,
+#             traceback=traceback
+#         )
+#         self.assertEqual(result.error_message, error_msg)
+#         self.assertEqual(result.traceback, traceback)