orionis 0.286.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/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"

tests/testing/test_testing_unit.py

@@ -2,13 +2,13 @@ from orionis.test.cases.test_case import TestCase
 from orionis.unittesting import UnitTest, ExecutionMode, UnittestTestLoader, UnittestTestSuite, unittest_mock_patch, UnittestMagicMock, UnittestTestResult
 
 class TestUnitTest(TestCase):
-    """
-    Test cases for the UnitTest class which handles test discovery and execution.
-    """
 
-    async def testDefaultConfiguration(self):
+    async def testDefaultConfiguration(self) -> None:
         """
         Test that UnitTest initializes with correct default configuration values.
+
+        Notes
+        -----
         Verifies that all default attributes are set as expected upon initialization.
         """
         unit_test = UnitTest()
@@ -20,10 +20,28 @@ class TestUnitTest(TestCase):
         self.assertIsInstance(unit_test.loader, UnittestTestLoader)
         self.assertIsInstance(unit_test.suite, UnittestTestSuite)
 
-    async def testConfigureMethod(self):
-        """
-        Test that configure method properly updates configuration values.
-        Verifies that all configuration parameters can be updated through the configure method.
+    async def testConfigureMethod(self) -> None:
+        """
+        Test the `configure` method for correct configuration updates.
+        This test verifies that all configuration parameters of the `UnitTest` class
+        can be updated through the `configure` method and that the changes are
+        reflected in the instance attributes.
+
+        Parameters
+        ----------
+        self : TestCase
+            The test case instance.
+
+        Notes
+        -----
+        The test checks the following configuration parameters:
+        - verbosity
+        - execution_mode
+        - max_workers
+        - fail_fast
+        - print_result
+        - throw_exception
+        It also asserts that the `configure` method returns the instance itself.
         """
         unit_test = UnitTest()
         configured = unit_test.configure(
@@ -43,10 +61,17 @@ class TestUnitTest(TestCase):
         self.assertTrue(unit_test.throw_exception)
         self.assertEqual(configured, unit_test)
 
-    async def testDiscoverTestsInModule(self):
+    async def testDiscoverTestsInModule(self) -> None:
         """
-        Test that discoverTestsInModule correctly loads tests from a module.
+        Test that `discoverTestsInModule` correctly loads tests from a module.
+
         Verifies that tests can be discovered from a module and added to the test suite.
+
+        Notes
+        -----
+        This test mocks the loader's `loadTestsFromName` method to ensure that
+        `discoverTestsInModule` calls it with the correct arguments and that the
+        returned suite is handled as expected.
         """
         unit_test = UnitTest()
         with unittest_mock_patch.object(unit_test.loader, 'loadTestsFromName') as mock_load:
@@ -57,11 +82,22 @@ class TestUnitTest(TestCase):
             self.assertEqual(result, unit_test)
             self.assertEqual(len(unit_test.suite._tests), 0)
 
-    async def testFlattenTestSuite(self):
+    async def testFlattenTestSuite(self) -> None:
         """
-        Test that _flattenTestSuite correctly flattens nested test suites.
+        Test the _flattenTestSuite method for correct flattening of nested test suites.
+        This test verifies that the _flattenTestSuite method of the UnitTest class
+        correctly flattens both simple and nested unittest suites into a single list
+        of test cases.
+
+        Parameters
+        ----------
+        self : TestCase
+            The test case instance.
 
-        Verifies that both simple and nested test suites are properly flattened.
+        Notes
+        -----
+        - Ensures that nested suites are recursively flattened.
+        - Asserts that all test cases from nested suites are present in the flattened result.
         """
         unit_test = UnitTest()
         test_case1 = UnittestMagicMock()
@@ -79,11 +115,16 @@ class TestUnitTest(TestCase):
         self.assertIn(test_case1, flattened)
         self.assertIn(test_case2, flattened)
 
-    async def testMergeTestResults(self):
+    async def testMergeTestResults(self) -> None:
         """
-        Test that _mergeTestResults correctly combines test results.
+        Test the _mergeTestResults method for correct merging of test results.
+        Ensures that the method accurately combines the number of tests run,
+        as well as the lists of failures and errors from individual test results.
 
-        Verifies that test counts, failures, and errors are properly merged.
+        Notes
+        -----
+        - Verifies that the total number of tests run is updated correctly.
+        - Checks that failures and errors are merged without loss of information.
         """
         unit_test = UnitTest()
         combined = UnittestTestResult()
@@ -98,10 +139,22 @@ class TestUnitTest(TestCase):
         self.assertEqual(len(combined.failures), 1)
         self.assertEqual(len(combined.errors), 1)
 
-    async def testClearTests(self):
+    async def testClearTests(self) -> None:
         """
-        Test that clearTests method resets the test suite.
-        Verifies that the test suite is emptied when clearTests is called.
+        Test the clearTests method to ensure it resets the test suite.
+        This test verifies that after adding a mock test to the suite and calling
+        the clearTests method, the suite is emptied as expected.
+
+        Steps
+        -----
+        1. Create an instance of UnitTest.
+        2. Add a mock test to the test suite.
+        3. Call the clearTests method.
+        4. Assert that the test suite is empty.
+
+        Assertions
+        ----------
+        - The length of the test suite should be zero after calling clearTests.
         """
         unit_test = UnitTest()
         mock_test = UnittestMagicMock()
@@ -110,10 +163,16 @@ class TestUnitTest(TestCase):
         unit_test.clearTests()
         self.assertEqual(len(unit_test.suite._tests), 0)
 
-    async def testGetTestNames(self):
+    async def testGetTestNames(self) -> None:
         """
-        Test that getTestNames returns correct test identifiers.
-        Verifies that test names are properly extracted from the test suite.
+        This test verifies that the `getTestNames` method of the `UnitTest` class
+        correctly extracts and returns the identifiers of tests present in the test suite.
+
+        Notes
+        -----
+        - Mocks a test case with a predefined identifier.
+        - Adds the mock test to the test suite.
+        - Asserts that the returned list of test names matches the expected value.
         """
         unit_test = UnitTest()
         mock_test = UnittestMagicMock()
@@ -123,10 +182,20 @@ class TestUnitTest(TestCase):
         names = unit_test.getTestNames()
         self.assertEqual(names, ['test_id'])
 
-    async def testGetTestCount(self):
+    async def testGetTestCount(self) -> None:
         """
-        Test that getTestCount returns the correct number of tests.
+        Test that `getTestCount` returns the correct number of tests.
+
         Verifies that the count matches the number of tests in the suite.
+
+        Notes
+        -----
+        - Adds two mock tests to the suite.
+        - Asserts that `getTestCount` returns 2.
+
+        Returns
+        -------
+        None
         """
         unit_test = UnitTest()
         mock_test1 = UnittestMagicMock()