orionis 0.285.0__py3-none-any.whl → 0.287.0__py3-none-any.whl

tests/foundation/config/startup/test_config_startup.py

@@ -5,25 +5,60 @@ from orionis.unittesting import TestCase, UnittestMock
 
 class TestConfiguration(TestCase):
     """
-    Test suite for the Configuration dataclass which encapsulates all major
-    configuration sections for the application.
+    Test suite for the Configuration dataclass.
 
-    This test class verifies the proper initialization, type validation,
-    and dictionary conversion of the Configuration class.
+    This class contains unit tests to verify the correct behavior of the
+    Configuration dataclass, including initialization, type validation,
+    dictionary conversion, metadata accessibility, mutability, and equality.
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    testConfigurationIsDataclass()
+        Test that Configuration is properly defined as a dataclass.
+    testDefaultInitialization()
+        Test that Configuration can be initialized with default values.
+    testAllSectionsHaveDefaultFactories()
+        Test that all configuration sections have default factories.
+    testTypeValidationInPostInit()
+        Test that __post_init__ validates types correctly.
+    testToDictReturnsCompleteDictionary()
+        Test that toDict() returns a complete dictionary representation.
+    testToDictReturnsNestedStructures()
+        Test that toDict() properly converts nested dataclasses.
+    testMetadataIsAccessible()
+        Test that field metadata is properly defined and accessible.
+    testConfigurationIsMutable()
+        Test that Configuration is mutable (not frozen).
+    testConfigurationEquality()
+        Test that Configuration instances with same values are equal.
     """
 
     def testConfigurationIsDataclass(self):
         """
         Test that Configuration is properly defined as a dataclass.
-        Verifies that the @dataclass decorator was applied correctly.
+
+        Ensures that the @dataclass decorator was applied correctly.
+
+        Returns
+        -------
+        None
         """
         self.assertTrue(is_dataclass(Configuration))
 
     def testDefaultInitialization(self):
         """
         Test that Configuration can be initialized with default values.
-        Verifies that all default factories work correctly and the
-        instance is properly constructed.
+
+        Verifies that all default factories work correctly and the instance
+        is properly constructed.
+
+        Returns
+        -------
+        None
         """
         config = Configuration()
         self.assertIsInstance(config, Configuration)
@@ -31,8 +66,13 @@ class TestConfiguration(TestCase):
     def testAllSectionsHaveDefaultFactories(self):
         """
         Test that all configuration sections have default factories.
+
         Verifies that each field in the Configuration class has a
         default_factory specified.
+
+        Returns
+        -------
+        None
         """
         config = Configuration()
         for field in config.__dataclass_fields__.values():
@@ -42,8 +82,13 @@ class TestConfiguration(TestCase):
     def testTypeValidationInPostInit(self):
         """
         Test that __post_init__ validates types correctly.
+
         Verifies that the type checking for each configuration section
         works as expected.
+
+        Returns
+        -------
+        None
         """
         # Test with all correct types (should not raise)
         try:
@@ -76,8 +121,13 @@ class TestConfiguration(TestCase):
     def testToDictReturnsCompleteDictionary(self):
         """
         Test that toDict() returns a complete dictionary representation.
+
         Verifies that the returned dictionary contains all configuration
         sections with their current values.
+
+        Returns
+        -------
+        None
         """
         config = Configuration()
         config_dict = config.toDict()
@@ -89,8 +139,13 @@ class TestConfiguration(TestCase):
     def testToDictReturnsNestedStructures(self):
         """
         Test that toDict() properly converts nested dataclasses.
+
         Verifies that the dictionary conversion works recursively for
         all nested configuration sections.
+
+        Returns
+        -------
+        None
         """
         config = Configuration()
         config_dict = config.toDict()
@@ -101,8 +156,13 @@ class TestConfiguration(TestCase):
     def testMetadataIsAccessible(self):
         """
         Test that field metadata is properly defined and accessible.
+
         Verifies that each configuration section field has the expected
         metadata structure with description.
+
+        Returns
+        -------
+        None
         """
         config = Configuration()
         for field in config.__dataclass_fields__.values():
@@ -113,8 +173,13 @@ class TestConfiguration(TestCase):
     def testConfigurationIsMutable(self):
         """
         Test that Configuration is mutable (not frozen).
+
         Verifies that attributes can be modified after creation since
         the dataclass isn't marked as frozen.
+
+        Returns
+        -------
+        None
         """
         config = Configuration()
         new_paths = config.paths.__class__()
@@ -127,7 +192,12 @@ class TestConfiguration(TestCase):
     def testConfigurationEquality(self):
         """
         Test that Configuration instances with same values are equal.
+
         Verifies that dataclass equality comparison works as expected.
+
+        Returns
+        -------
+        None
         """
         config1 = Configuration()
         config2 = Configuration()

tests/foundation/config/testing/test_testing.py

@@ -4,10 +4,21 @@ from orionis.test.enums.test_mode import ExecutionMode
 from orionis.unittesting import TestCase
 
 class TestTestingConfig(TestCase):
+    """
+    Test suite for the Testing configuration entity.
+
+    This class contains asynchronous test cases to validate the default values,
+    custom values, and integrity constraints of the Testing configuration.
+    """
 
     async def testDefaultValues(self):
         """
         Test the default values of the Testing configuration.
+
+        Notes
+        -----
+        Ensures that all default attributes of the Testing configuration are set
+        as expected.
         """
         t = Testing()
         self.assertEqual(t.verbosity, 2)
@@ -25,6 +36,11 @@ class TestTestingConfig(TestCase):
     async def testValidCustomValues(self):
         """
         Test custom valid values for all fields.
+
+        Notes
+        -----
+        Verifies that the Testing configuration accepts and correctly sets
+        custom valid values for all its fields.
         """
         t = Testing(
             verbosity=1,
@@ -54,6 +70,10 @@ class TestTestingConfig(TestCase):
     async def testFolderPathStringAndList(self):
         """
         Test folder_path accepts both string and list of strings.
+
+        Notes
+        -----
+        Checks that the folder_path attribute can be set as a string or a list of strings.
         """
         t1 = Testing(folder_path="integration")
         self.assertEqual(t1.folder_path, "integration")
@@ -63,6 +83,10 @@ class TestTestingConfig(TestCase):
     async def testTagsNoneOrList(self):
         """
         Test tags accepts None or list of strings.
+
+        Notes
+        -----
+        Ensures that the tags attribute can be set to None or a list of strings.
         """
         t1 = Testing(tags=None)
         self.assertIsNone(t1.tags)
@@ -72,6 +96,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidVerbosity(self):
         """
         Test invalid verbosity values.
+
+        Notes
+        -----
+        Verifies that invalid verbosity values raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(verbosity=-1)
@@ -83,6 +111,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidExecutionMode(self):
         """
         Test execution_mode cannot be None.
+
+        Notes
+        -----
+        Ensures that setting execution_mode to None raises OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(execution_mode=None)
@@ -90,6 +122,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidMaxWorkers(self):
         """
         Test invalid max_workers values.
+
+        Notes
+        -----
+        Checks that invalid values for max_workers raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(max_workers=0)
@@ -101,6 +137,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidFailFast(self):
         """
         Test fail_fast must be boolean.
+
+        Notes
+        -----
+        Ensures that non-boolean values for fail_fast raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(fail_fast="yes")
@@ -108,6 +148,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidPrintResult(self):
         """
         Test print_result must be boolean.
+
+        Notes
+        -----
+        Ensures that non-boolean values for print_result raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(print_result=1)
@@ -115,6 +159,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidThrowException(self):
         """
         Test throw_exception must be boolean.
+
+        Notes
+        -----
+        Ensures that non-boolean values for throw_exception raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(throw_exception="no")
@@ -122,6 +170,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidBasePath(self):
         """
         Test base_path must be string.
+
+        Notes
+        -----
+        Ensures that non-string values for base_path raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(base_path=123)
@@ -129,6 +181,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidFolderPath(self):
         """
         Test folder_path must be string or list of strings.
+
+        Notes
+        -----
+        Ensures that invalid types for folder_path raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(folder_path=123)
@@ -140,6 +196,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidPattern(self):
         """
         Test pattern must be string.
+
+        Notes
+        -----
+        Ensures that non-string values for pattern raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(pattern=[])
@@ -149,6 +209,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidTestNamePattern(self):
         """
         Test test_name_pattern must be string or None.
+
+        Notes
+        -----
+        Ensures that invalid types for test_name_pattern raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(test_name_pattern=[])
@@ -158,6 +222,10 @@ class TestTestingConfig(TestCase):
     async def testInvalidTags(self):
         """
         Test tags must be None or list of strings.
+
+        Notes
+        -----
+        Ensures that invalid types for tags raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             Testing(tags="fast")

tests/patterns/singleton/test_singleton.py

@@ -2,10 +2,19 @@ from orionis.patterns.singleton.meta_class import Singleton
 from orionis.test.cases.test_case import TestCase
 
 class TestsAsyncCoroutine(TestCase):
+    """
+    Test cases for the Singleton metaclass.
+
+    This class contains asynchronous test methods to verify the correct behavior
+    of the Singleton metaclass, ensuring that only one instance of a class is created.
+    """
 
     async def testSingleton(self):
         """
-        Test the Singleton metaclass to ensure that only one instance of a class is created.
+        Test the Singleton metaclass.
+
+        Ensures that only one instance of a class using the Singleton metaclass is created,
+        regardless of how many times the class is instantiated.
         """
         class SingletonClass(metaclass=Singleton):
             def __init__(self, value):

tests/services/asynchrony/test_async_io.py

@@ -1,5 +1,5 @@
 
-from orionis.services.asynchrony.coroutines import run_coroutine
+from orionis.services.asynchrony.coroutines import Coroutine
 from orionis.services.asynchrony.exceptions.coroutine_exception import OrionisCoroutineException
 from orionis.unittesting import TestCase
 
@@ -14,7 +14,7 @@ class TestsAsyncIO(TestCase):
         async def sample_coroutine():
             return "Hello, World!"
 
-        result = await run_coroutine(sample_coroutine())
+        result = await Coroutine(sample_coroutine()).run()
         self.assertEqual(result, "Hello, World!")
 
     def testExecuteWithoutActiveEventLoop(self):
@@ -25,7 +25,7 @@ class TestsAsyncIO(TestCase):
         async def sample_coroutine():
             return "Hello, World!"
 
-        result = run_coroutine(sample_coroutine())
+        result = Coroutine(sample_coroutine()).run()
         self.assertEqual(result, "Hello, World!")
 
     def testExecuteWithNonCoroutine(self):
@@ -37,4 +37,4 @@ class TestsAsyncIO(TestCase):
             return "Hello, World!"
 
         with self.assertRaises(OrionisCoroutineException):
-            run_coroutine(sample_no_coroutine())
+            Coroutine(sample_no_coroutine())

tests/services/environment/test_env.py

@@ -12,10 +12,9 @@ class TestEnv(TestCase):
         Test that the get method retrieves values correctly.
         Verifies that Env.get() properly delegates to DotEnv.get() and returns the expected value.
         """
-        with unittest_mock_patch.object(DotEnv, 'get', return_value='test_value') as mock_get:
-            result = Env.get('TEST_KEY')
-            mock_get.assert_called_once_with('TEST_KEY', None, False)
-            self.assertEqual(result, 'test_value')
+
+        # Set test key in.env
+        Env.set('TEST_KEY', 'test_value')
 
     async def testGetMethodWithDefault(self):
         """

tests/testing/test_testing_result.py

@@ -1,16 +1,25 @@
-
 from orionis.unittesting import TestCase, TestResult, TestStatus
 
 class TestTestResult(TestCase):
-    """
-    Test cases for the TestResult dataclass.
-    """
 
-    async def testDefaultValues(self):
+    async def testDefaultValues(self) -> None:
         """
-        Test that TestResult initializes with correct default values for optional fields.
+        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
 
-        Verifies that optional fields are None when not provided during initialization.
+        Assertions
+        ----------
+        Each optional field is checked to confirm it is None after initialization.
         """
         result = TestResult(
             id=1,
@@ -25,11 +34,16 @@ class TestTestResult(TestCase):
         self.assertIsNone(result.module)
         self.assertIsNone(result.file_path)
 
-    async def testRequiredFields(self):
+    async def testRequiredFields(self) -> None:
         """
-        Test that TestResult requires all non-optional fields during initialization.
+        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.
 
-        Ensures that missing any required field 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
@@ -42,11 +56,21 @@ class TestTestResult(TestCase):
                 execution_time=0.5
             )
 
-    async def testImmutable(self):
+    async def testImmutable(self) -> None:
         """
-        Test that TestResult instances are immutable (frozen dataclass).
+        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.
 
-        Verifies that attribute modification after creation raises a FrozenInstanceError.
+        Raises
+        ------
+        FrozenInstanceError
+            If an attempt is made to modify an attribute of a frozen TestResult instance.
         """
         result = TestResult(
             id=1,
@@ -57,11 +81,18 @@ class TestTestResult(TestCase):
         with self.assertRaises(Exception):
             result.name = "Modified Name"
 
-    async def testStatusValues(self):
+    async def testStatusValues(self) -> None:
         """
-        Test that TestResult correctly handles all possible TestStatus values.
+        Parameters
+        ----------
+        self : TestCase
+            The test case instance.
 
-        Verifies that all enum values can be assigned to the status field.
+        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(
@@ -72,11 +103,17 @@ class TestTestResult(TestCase):
             )
             self.assertEqual(result.status, status)
 
-    async def testErrorFields(self):
+    async def testErrorFields(self) -> None:
         """
-        Test that error-related fields are properly stored when provided.
+        Parameters
+        ----------
+        self : TestCase
+            The test case instance.
 
-        Verifies that error_message and traceback are stored correctly when provided.
+        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"