orionis 0.286.0__py3-none-any.whl → 0.288.0__py3-none-any.whl

tests/foundation/config/logging/{test_logging_monthly.py → test_foundation_config_logging_monthly.py}

@@ -3,15 +3,26 @@ from orionis.foundation.config.logging.enums.levels import Level
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestConfigMonthly(TestCase):
+class TestFoundationConfigLoggingMonthly(TestCase):
     """
     Test cases for the Monthly logging configuration class.
+
+    Notes
+    -----
+    This test suite verifies the correct behavior of the `Monthly` logging configuration,
+    including default values, attribute validation, dictionary conversion, hashability,
+    and keyword-only initialization.
     """
 
     async def testDefaultValues(self):
         """
         Test that Monthly instance is created with correct default values.
-        Verifies default path, level and retention_months match expected values.
+
+        Verifies
+        --------
+        - Default path is "storage/log/application.log".
+        - Default level is `Level.INFO.value`.
+        - Default retention_months is 4.
         """
         monthly = Monthly()
         self.assertEqual(monthly.path, "storage/log/application.log")
@@ -21,7 +32,11 @@ class TestConfigMonthly(TestCase):
     async def testPathValidation(self):
         """
         Test path attribute validation.
-        Verifies that empty or non-string paths raise exceptions.
+
+        Verifies
+        --------
+        - Empty or non-string paths raise `OrionisIntegrityException`.
+        - Valid string paths do not raise exceptions.
         """
         with self.assertRaises(OrionisIntegrityException):
             Monthly(path="")
@@ -35,6 +50,11 @@ class TestConfigMonthly(TestCase):
     async def testLevelValidation(self):
         """
         Test level attribute validation with different input types.
+
+        Verifies
+        --------
+        - Accepts string, int, and enum values for level.
+        - Invalid level values raise `OrionisIntegrityException`.
         """
         # Test string level
         monthly = Monthly(level="debug")
@@ -59,6 +79,11 @@ class TestConfigMonthly(TestCase):
     async def testRetentionMonthsValidation(self):
         """
         Test retention_months attribute validation.
+
+        Verifies
+        --------
+        - Accepts valid integer values for retention_months.
+        - Invalid values raise `OrionisIntegrityException`.
         """
         # Test valid values
         try:
@@ -81,6 +106,11 @@ class TestConfigMonthly(TestCase):
     async def testWhitespaceHandling(self):
         """
         Test whitespace handling in path and level attributes.
+
+        Verifies
+        --------
+        - Whitespace in path is preserved.
+        - Whitespace in level is handled correctly.
         """
         monthly = Monthly(path="  logs/app.log  ", level="  debug  ")
         self.assertEqual(monthly.path, "  logs/app.log  ")
@@ -89,6 +119,10 @@ class TestConfigMonthly(TestCase):
     async def testToDictMethod(self):
         """
         Test that toDict returns proper dictionary representation.
+
+        Verifies
+        --------
+        - Output is a dictionary with correct keys and values.
         """
         monthly = Monthly()
         monthly_dict = monthly.toDict()
@@ -100,6 +134,10 @@ class TestConfigMonthly(TestCase):
     async def testCustomValuesToDict(self):
         """
         Test that custom values are properly included in dictionary.
+
+        Verifies
+        --------
+        - Custom path, level, and retention_months are reflected in the output dictionary.
         """
         custom_monthly = Monthly(
             path="custom/logs/app.log",
@@ -114,6 +152,10 @@ class TestConfigMonthly(TestCase):
     async def testHashability(self):
         """
         Test that Monthly maintains hashability due to unsafe_hash=True.
+
+        Verifies
+        --------
+        - Monthly instances can be added to a set and compared by value.
         """
         monthly1 = Monthly()
         monthly2 = Monthly()
@@ -128,6 +170,10 @@ class TestConfigMonthly(TestCase):
     async def testKwOnlyInitialization(self):
         """
         Test that Monthly enforces keyword-only initialization.
+
+        Verifies
+        --------
+        - Positional arguments raise TypeError.
         """
         with self.assertRaises(TypeError):
             Monthly("path.log", "info", 4)

tests/foundation/config/logging/{test_logging_stack.py → test_foundation_config_logging_stack.py}

@@ -3,15 +3,21 @@ from orionis.foundation.config.logging.enums.levels import Level
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestConfigStack(TestCase):
+class TestFoundationConfigLoggingStack(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 → test_foundation_config_logging_weekly.py}

@@ -3,15 +3,50 @@ from orionis.foundation.config.logging.enums.levels import Level
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestConfigWeekly(TestCase):
+class TestFoundationConfigLoggingWeekly(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_foundation_config_mail.py

@@ -0,0 +1,145 @@
+from orionis.foundation.config.mail.entities.mail import Mail
+from orionis.foundation.config.mail.entities.mailers import Mailers
+from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestFoundationConfigMail(TestCase):
+    """
+    Test suite for the Mail class, covering initialization, validation, and utility methods.
+    """
+
+    async def testDefaultInitialization(self):
+        """
+        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")
+        self.assertIsInstance(mail.mailers, Mailers)
+
+    async def testDefaultValidation(self):
+        """
+        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")
+        with self.assertRaises(OrionisIntegrityException):
+            Mail(default=123)
+
+    async def testMailersTypeValidation(self):
+        """
+        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.
+
+        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()
+        self.assertIsInstance(result, dict)
+        self.assertIn("default", result)
+        self.assertIn("mailers", result)
+        self.assertEqual(result["default"], "smtp")
+
+    async def testHashability(self):
+        """
+        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")
+        test_set = {mail1, mail2}
+        self.assertEqual(len(test_set), 1)
+
+    async def testKwOnlyInitialization(self):
+        """
+        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.
+
+        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.
+        """
+        mail = Mail(default="smtp", mailers=Mailers())
+        self.assertEqual(mail.default, "smtp")
+        self.assertIsInstance(mail.mailers, Mailers)

tests/foundation/config/mail/{test_mail_file.py → test_foundation_config_mail_file.py}

@@ -2,11 +2,17 @@ from orionis.foundation.config.mail.entities.file import File
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestMailFile(TestCase):
+class TestFoundationConfigMailFile(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):