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

tests/foundation/config/logging/test_logging_stack.py

@@ -6,12 +6,18 @@ from orionis.unittesting import TestCase
 class TestConfigStack(TestCase):
     """
     Test cases for the Stack logging configuration class.
+
+    This class contains asynchronous unit tests for the Stack class, 
+    validating default values, attribute validation, dictionary representation, 
+    hashability, and keyword-only initialization.
     """
 
     async def testDefaultValues(self):
         """
-        Test that Stack instance is created with correct default values.
-        Verifies default path and level match expected values from class definition.
+        Test default values of Stack.
+
+        Ensures that a Stack instance is created with the correct default values.
+        Verifies that the default path and level match the expected values from the class definition.
         """
         stack = Stack()
         self.assertEqual(stack.path, "storage/log/application.log")
@@ -19,8 +25,14 @@ class TestConfigStack(TestCase):
 
     async def testPathValidation(self):
         """
-        Test path attribute validation.
-        Verifies that empty or non-string paths raise exceptions.
+        Test validation of the path attribute.
+
+        Checks that empty or non-string paths raise exceptions, and that valid paths are accepted.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the path is empty or not a string.
         """
         # Test empty path
         with self.assertRaises(OrionisIntegrityException):
@@ -36,8 +48,14 @@ class TestConfigStack(TestCase):
 
     async def testLevelValidation(self):
         """
-        Test level attribute validation with different input types.
-        Verifies string, int and enum level values are properly handled.
+        Test validation of the level attribute with different input types.
+
+        Verifies that string, int, and enum level values are properly handled.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the level is invalid or of an unsupported type.
         """
         # Test string level
         stack = Stack(level="debug")
@@ -65,8 +83,9 @@ class TestConfigStack(TestCase):
 
     async def testWhitespaceHandling(self):
         """
-        Test whitespace handling in path and level attributes.
-        Verifies whitespace is preserved in path and trimmed in level strings.
+        Test handling of whitespace in path and level attributes.
+
+        Ensures that whitespace is preserved in the path and trimmed in level strings.
         """
         # Test path with whitespace
         spaced_path = "  logs/app.log  "
@@ -79,8 +98,14 @@ class TestConfigStack(TestCase):
 
     async def testToDictMethod(self):
         """
-        Test that toDict returns proper dictionary representation.
-        Verifies both path and level are correctly included in dictionary.
+        Test the toDict method for dictionary representation.
+
+        Ensures that both path and level are correctly included in the dictionary.
+
+        Returns
+        -------
+        dict
+            Dictionary representation of the Stack instance.
         """
         stack = Stack()
         stack_dict = stack.toDict()
@@ -91,7 +116,9 @@ class TestConfigStack(TestCase):
 
     async def testCustomValuesToDict(self):
         """
-        Test that custom values are properly included in dictionary representation.
+        Test custom values in dictionary representation.
+
+        Ensures that custom path and level values are properly included in the dictionary.
         """
         custom_stack = Stack(
             path="custom/logs/app.log",
@@ -103,8 +130,9 @@ class TestConfigStack(TestCase):
 
     async def testHashability(self):
         """
-        Test that Stack maintains hashability due to unsafe_hash=True.
-        Verifies Stack instances can be used in sets and as dictionary keys.
+        Test hashability of Stack instances.
+
+        Ensures that Stack instances can be used in sets and as dictionary keys due to unsafe_hash=True.
         """
         stack1 = Stack()
         stack2 = Stack()
@@ -118,7 +146,14 @@ class TestConfigStack(TestCase):
 
     async def testKwOnlyInitialization(self):
         """
-        Test that Stack enforces keyword-only initialization.
+        Test enforcement of keyword-only initialization.
+
+        Ensures that Stack cannot be initialized with positional arguments.
+
+        Raises
+        ------
+        TypeError
+            If positional arguments are used for initialization.
         """
         with self.assertRaises(TypeError):
             Stack("path.log", "info")

tests/foundation/config/logging/test_logging_weekly.py

@@ -6,12 +6,47 @@ from orionis.unittesting import TestCase
 class TestConfigWeekly(TestCase):
     """
     Test cases for the Weekly logging configuration class.
+
+    This class contains unit tests for the `Weekly` logging configuration entity,
+    including validation of default values, attribute validation, dictionary conversion,
+    hashability, and keyword-only initialization.
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    testDefaultValues()
+        Test that Weekly instance is created with correct default values.
+    testPathValidation()
+        Test path attribute validation.
+    testLevelValidation()
+        Test level attribute validation with different input types.
+    testRetentionWeeksValidation()
+        Test retention_weeks attribute validation.
+    testWhitespaceHandling()
+        Test whitespace handling in path and level attributes.
+    testToDictMethod()
+        Test that toDict returns proper dictionary representation.
+    testCustomValuesToDict()
+        Test that custom values are properly included in dictionary.
+    testHashability()
+        Test that Weekly maintains hashability due to unsafe_hash=True.
+    testKwOnlyInitialization()
+        Test that Weekly enforces keyword-only initialization.
     """
 
     async def testDefaultValues(self):
         """
         Test that Weekly instance is created with correct default values.
-        Verifies default path, level and retention_weeks match expected values.
+
+        Verifies that the default `path`, `level`, and `retention_weeks` attributes
+        of a `Weekly` instance match the expected values.
+
+        Returns
+        -------
+        None
         """
         weekly = Weekly()
         self.assertEqual(weekly.path, "storage/log/application.log")
@@ -21,7 +56,13 @@ class TestConfigWeekly(TestCase):
     async def testPathValidation(self):
         """
         Test path attribute validation.
-        Verifies that empty or non-string paths raise exceptions.
+
+        Verifies that empty or non-string `path` values raise exceptions,
+        and that a valid path does not raise an exception.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             Weekly(path="")
@@ -35,6 +76,13 @@ class TestConfigWeekly(TestCase):
     async def testLevelValidation(self):
         """
         Test level attribute validation with different input types.
+
+        Checks that the `level` attribute accepts string, integer, and enum values,
+        and raises exceptions for invalid types or values.
+
+        Returns
+        -------
+        None
         """
         # Test string level
         weekly = Weekly(level="debug")
@@ -59,6 +107,13 @@ class TestConfigWeekly(TestCase):
     async def testRetentionWeeksValidation(self):
         """
         Test retention_weeks attribute validation.
+
+        Ensures that valid `retention_weeks` values are accepted and invalid
+        values raise exceptions.
+
+        Returns
+        -------
+        None
         """
         # Test valid values
         try:
@@ -81,6 +136,13 @@ class TestConfigWeekly(TestCase):
     async def testWhitespaceHandling(self):
         """
         Test whitespace handling in path and level attributes.
+
+        Verifies that leading and trailing whitespace in `path` and `level`
+        attributes are handled as expected.
+
+        Returns
+        -------
+        None
         """
         weekly = Weekly(path="  logs/app.log  ", level="  debug  ")
         self.assertEqual(weekly.path, "  logs/app.log  ")
@@ -89,6 +151,13 @@ class TestConfigWeekly(TestCase):
     async def testToDictMethod(self):
         """
         Test that toDict returns proper dictionary representation.
+
+        Ensures that the `toDict` method returns a dictionary with the correct
+        keys and values for a default `Weekly` instance.
+
+        Returns
+        -------
+        None
         """
         weekly = Weekly()
         weekly_dict = weekly.toDict()
@@ -100,6 +169,13 @@ class TestConfigWeekly(TestCase):
     async def testCustomValuesToDict(self):
         """
         Test that custom values are properly included in dictionary.
+
+        Checks that custom attribute values are correctly represented in the
+        dictionary returned by `toDict`.
+
+        Returns
+        -------
+        None
         """
         custom_weekly = Weekly(
             path="custom/logs/app.log",
@@ -114,6 +190,13 @@ class TestConfigWeekly(TestCase):
     async def testHashability(self):
         """
         Test that Weekly maintains hashability due to unsafe_hash=True.
+
+        Verifies that `Weekly` instances are hashable and can be used in sets,
+        and that identical instances are considered equal.
+
+        Returns
+        -------
+        None
         """
         weekly1 = Weekly()
         weekly2 = Weekly()
@@ -128,6 +211,13 @@ class TestConfigWeekly(TestCase):
     async def testKwOnlyInitialization(self):
         """
         Test that Weekly enforces keyword-only initialization.
+
+        Ensures that providing positional arguments to the `Weekly` constructor
+        raises a TypeError.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(TypeError):
             Weekly("path.log", "info", 4)

tests/foundation/config/mail/test_mail.py

@@ -4,11 +4,24 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.unittesting import TestCase
 
 class TestMail(TestCase):
+    """
+    Test suite for the Mail class, covering initialization, validation, and utility methods.
+    """
 
     async def testDefaultInitialization(self):
         """
-        Test that Mail instance is initialized with correct default values.
-        Verifies that default mailer is 'smtp' and mailers is an instance of Mailers.
+        Test default initialization of Mail.
+
+        Tests that a Mail instance is initialized with the correct default values.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        AssertionError
+            If the default mailer is not 'smtp' or mailers is not an instance of Mailers.
         """
         mail = Mail()
         self.assertEqual(mail.default, "smtp")
@@ -16,8 +29,18 @@ class TestMail(TestCase):
 
     async def testDefaultValidation(self):
         """
-        Test validation of default mailer against available options.
-        Verifies that invalid default mailer raises OrionisIntegrityException.
+        Test validation of the default mailer.
+
+        Ensures that providing an invalid default mailer raises an exception.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the default mailer is invalid or not a string.
         """
         with self.assertRaises(OrionisIntegrityException):
             Mail(default="invalid_mailer")
@@ -26,16 +49,36 @@ class TestMail(TestCase):
 
     async def testMailersTypeValidation(self):
         """
-        Test validation of mailers attribute type.
-        Verifies that non-Mailers objects raise OrionisIntegrityException.
+        Test type validation for the mailers attribute.
+
+        Ensures that assigning a non-Mailers object to mailers raises an exception.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If mailers is not an instance of Mailers.
         """
         with self.assertRaises(OrionisIntegrityException):
             Mail(mailers="invalid_mailers_object")
 
     async def testToDictMethod(self):
         """
-        Test the toDict method returns proper dictionary representation.
-        Verifies the method returns a dict containing all fields.
+        Test the toDict method.
+
+        Checks that the toDict method returns a dictionary representation of the Mail instance.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        AssertionError
+            If the returned value is not a dict or missing expected fields.
         """
         mail = Mail()
         result = mail.toDict()
@@ -46,8 +89,18 @@ class TestMail(TestCase):
 
     async def testHashability(self):
         """
-        Test that Mail instances are hashable due to unsafe_hash=True.
-        Verifies instances can be used in sets or as dictionary keys.
+        Test hashability of Mail instances.
+
+        Ensures that Mail instances are hashable and can be used in sets or as dictionary keys.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        AssertionError
+            If Mail instances are not hashable or set behavior is incorrect.
         """
         mail1 = Mail()
         mail2 = Mail(default="smtp")
@@ -56,18 +109,37 @@ class TestMail(TestCase):
 
     async def testKwOnlyInitialization(self):
         """
-        Test that Mail requires keyword arguments for initialization.
-        Verifies the class enforces kw_only=True in its dataclass decorator.
+        Test keyword-only initialization enforcement.
+
+        Ensures that Mail requires keyword arguments for initialization.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        TypeError
+            If positional arguments are used for initialization.
         """
         with self.assertRaises(TypeError):
             Mail("smtp", Mailers())
 
     async def testValidCustomInitialization(self):
         """
-        Test valid custom initialization with proper values.
-        Verifies instance can be created with valid non-default values.
+        Test valid custom initialization.
+
+        Checks that a Mail instance can be created with valid, non-default values.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        AssertionError
+            If the instance is not initialized with the provided values.
         """
-        # Assuming 'smtp' is a valid mailer option from Mailers
         mail = Mail(default="smtp", mailers=Mailers())
         self.assertEqual(mail.default, "smtp")
         self.assertIsInstance(mail.mailers, Mailers)

tests/foundation/config/mail/test_mail_file.py

@@ -3,10 +3,16 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.unittesting import TestCase
 
 class TestMailFile(TestCase):
+    """
+    Unit tests for the File entity in the mail configuration module.
+    """
 
     async def testDefaultPathValue(self):
         """
         Test that the File instance is initialized with the correct default path.
+
+        Notes
+        -----
         Verifies that a new File object has 'storage/mail' as the default path.
         """
         file = File()
@@ -14,8 +20,16 @@ class TestMailFile(TestCase):
 
     async def testPathValidation(self):
         """
-        Test the path validation in __post_init__ method.
-        Verifies that non-string paths raise OrionisIntegrityException.
+        Test the path validation in the __post_init__ method.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the path is not a string or is an empty string.
+
+        Notes
+        -----
+        Verifies that non-string paths or empty strings raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
             File(path=123)
@@ -25,6 +39,9 @@ class TestMailFile(TestCase):
     async def testValidPathAssignment(self):
         """
         Test that valid path assignments work correctly.
+
+        Notes
+        -----
         Verifies that string paths are accepted and stored properly.
         """
         test_path = "custom/path/to/mail"
@@ -34,8 +51,16 @@ class TestMailFile(TestCase):
     async def testToDictMethod(self):
         """
         Test the toDict method returns a proper dictionary representation.
-        Checks that the toDict method converts the File instance
-        into a dictionary with the expected path field.
+
+        Returns
+        -------
+        dict
+            Dictionary representation of the File instance.
+
+        Notes
+        -----
+        Checks that the toDict method converts the File instance into a dictionary
+        with the expected path field.
         """
         file = File()
         result = file.toDict()
@@ -45,6 +70,9 @@ class TestMailFile(TestCase):
     async def testHashability(self):
         """
         Test that File instances are hashable due to unsafe_hash=True.
+
+        Notes
+        -----
         Verifies that instances can be used in sets or as dictionary keys.
         """
         file1 = File()
@@ -55,6 +83,14 @@ class TestMailFile(TestCase):
     async def testKwOnlyInitialization(self):
         """
         Test that File requires keyword arguments for initialization.
+
+        Raises
+        ------
+        TypeError
+            If positional arguments are used for initialization.
+
+        Notes
+        -----
         Verifies that the class enforces kw_only=True in its dataclass decorator.
         """
         with self.assertRaises(TypeError):

tests/foundation/config/mail/test_mail_mailers.py

@@ -5,11 +5,25 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.unittesting import TestCase
 
 class TestMailers(TestCase):
+    """
+    Unit tests for the Mailers class.
+
+    This test suite verifies the correct initialization, type validation,
+    custom initialization, dictionary conversion, and keyword-only enforcement
+    of the Mailers class.
+    """
 
     async def testDefaultInitialization(self):
         """
-        Test that Mailers instance is initialized with correct default factories.
-        Verifies that smtp and file attributes are properly initialized with their respective types.
+        Test default initialization of Mailers.
+
+        Ensures that a Mailers instance is initialized with default factories
+        and that the `smtp` and `file` attributes are instances of their
+        respective types.
+
+        Returns
+        -------
+        None
         """
         mailers = Mailers()
         self.assertIsInstance(mailers.smtp, Smtp)
@@ -18,7 +32,18 @@ class TestMailers(TestCase):
     async def testTypeValidation(self):
         """
         Test type validation for smtp and file attributes.
-        Verifies that invalid types raise OrionisIntegrityException.
+
+        Ensures that providing invalid types for `smtp` or `file` raises
+        an OrionisIntegrityException.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If an invalid type is provided for `smtp` or `file`.
         """
         with self.assertRaises(OrionisIntegrityException):
             Mailers(smtp="invalid_smtp")
@@ -28,7 +53,13 @@ class TestMailers(TestCase):
     async def testCustomInitialization(self):
         """
         Test custom initialization with valid parameters.
-        Verifies that valid Smtp and File instances are accepted.
+
+        Ensures that valid Smtp and File instances can be provided to the
+        Mailers constructor and are correctly assigned.
+
+        Returns
+        -------
+        None
         """
         custom_smtp = Smtp()
         custom_file = File()
@@ -38,8 +69,14 @@ class TestMailers(TestCase):
 
     async def testToDictMethod(self):
         """
-        Test the toDict method returns proper dictionary representation.
-        Verifies the method returns a dict containing all fields with correct values.
+        Test the toDict method of Mailers.
+
+        Ensures that the `toDict` method returns a dictionary representation
+        containing all fields with correct values and types.
+
+        Returns
+        -------
+        None
         """
         mailers = Mailers()
         result = mailers.toDict()
@@ -51,8 +88,19 @@ class TestMailers(TestCase):
 
     async def testKwOnlyInitialization(self):
         """
-        Test that Mailers requires keyword arguments for initialization.
-        Verifies the class enforces kw_only=True in its dataclass decorator.
+        Test keyword-only initialization enforcement.
+
+        Ensures that the Mailers class enforces keyword-only arguments
+        during initialization (i.e., `kw_only=True` in its dataclass decorator).
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        TypeError
+            If positional arguments are provided to the constructor.
         """
         with self.assertRaises(TypeError):
             Mailers(Smtp(), File())