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

tests/foundation/config/logging/{test_logging_channels.py → test_foundation_config_logging_channels.py}

@@ -8,15 +8,49 @@ from orionis.foundation.config.logging.entities.chunked import Chunked
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestConfigChannels(TestCase):
+class TestFoundationConfigLoggingChannels(TestCase):
     """
     Test cases for the Channels logging configuration class.
+
+    This class contains unit tests for the `Channels` class, ensuring correct
+    initialization, type validation, custom configuration, dictionary conversion,
+    hashability, and keyword-only initialization.
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    testDefaultValues()
+        Test that Channels instance is created with correct default values.
+    testStackValidation()
+        Test stack attribute type validation.
+    testHourlyValidation()
+        Test hourly attribute type validation.
+    testDailyValidation()
+        Test daily attribute type validation.
+    testWeeklyValidation()
+        Test weekly attribute type validation.
+    testMonthlyValidation()
+        Test monthly attribute type validation.
+    testChunkedValidation()
+        Test chunked attribute type validation.
+    testCustomConfigurations()
+        Test that custom channel configurations are properly stored and validated.
+    testToDictMethod()
+        Test that toDict returns proper dictionary representation.
+    testHashability()
+        Test that Channels maintains hashability due to unsafe_hash=True.
+    testKwOnlyInitialization()
+        Test that Channels enforces keyword-only initialization.
     """
 
     async def testDefaultValues(self):
         """
         Test that Channels instance is created with correct default values.
-        Verifies all channel configurations are properly initialized with their default values.
+
+        Ensures all channel configurations are properly initialized with their default values.
         """
         channels = Channels()
         self.assertIsInstance(channels.stack, Stack)
@@ -29,7 +63,13 @@ class TestConfigChannels(TestCase):
     async def testStackValidation(self):
         """
         Test stack attribute type validation.
-        Verifies that only Stack instances are accepted for stack attribute.
+
+        Verifies that only Stack instances are accepted for the stack attribute.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the stack attribute is not a Stack instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Channels(stack="not_a_stack_instance")
@@ -43,6 +83,11 @@ class TestConfigChannels(TestCase):
     async def testHourlyValidation(self):
         """
         Test hourly attribute type validation.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the hourly attribute is not an Hourly instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Channels(hourly="not_an_hourly_instance")
@@ -54,6 +99,11 @@ class TestConfigChannels(TestCase):
     async def testDailyValidation(self):
         """
         Test daily attribute type validation.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the daily attribute is not a Daily instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Channels(daily="not_a_daily_instance")
@@ -65,6 +115,11 @@ class TestConfigChannels(TestCase):
     async def testWeeklyValidation(self):
         """
         Test weekly attribute type validation.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the weekly attribute is not a Weekly instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Channels(weekly="not_a_weekly_instance")
@@ -76,6 +131,11 @@ class TestConfigChannels(TestCase):
     async def testMonthlyValidation(self):
         """
         Test monthly attribute type validation.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the monthly attribute is not a Monthly instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Channels(monthly="not_a_monthly_instance")
@@ -87,6 +147,11 @@ class TestConfigChannels(TestCase):
     async def testChunkedValidation(self):
         """
         Test chunked attribute type validation.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the chunked attribute is not a Chunked instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Channels(chunked="not_a_chunked_instance")
@@ -98,6 +163,9 @@ class TestConfigChannels(TestCase):
     async def testCustomConfigurations(self):
         """
         Test that custom channel configurations are properly stored and validated.
+
+        Ensures that custom channel instances are correctly assigned and their
+        properties are properly set.
         """
         custom_stack = Stack(path="custom/stack.log")
         custom_hourly = Hourly(path="custom/hourly.log")
@@ -124,6 +192,8 @@ class TestConfigChannels(TestCase):
     async def testToDictMethod(self):
         """
         Test that toDict returns proper dictionary representation.
+
+        Ensures that the `toDict` method returns a dictionary with the correct structure.
         """
         channels = Channels()
         channels_dict = channels.toDict()
@@ -138,6 +208,8 @@ class TestConfigChannels(TestCase):
     async def testHashability(self):
         """
         Test that Channels maintains hashability due to unsafe_hash=True.
+
+        Ensures that Channels instances can be used in sets and as dictionary keys.
         """
         channels1 = Channels()
         channels2 = Channels()
@@ -152,6 +224,11 @@ class TestConfigChannels(TestCase):
     async def testKwOnlyInitialization(self):
         """
         Test that Channels enforces keyword-only initialization.
+
+        Raises
+        ------
+        TypeError
+            If positional arguments are used instead of keyword arguments.
         """
         with self.assertRaises(TypeError):
             Channels(Stack(), Hourly(), Daily(), Weekly(), Monthly(), Chunked())

tests/foundation/config/logging/{test_logging_chunked.py → test_foundation_config_logging_chunked.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 TestConfigChunked(TestCase):
+class TestFoundationConfigLoggingChunked(TestCase):
     """
     Test cases for the Chunked logging configuration class.
+
+    Notes
+    -----
+    These tests validate the integrity, default values, and behavior of the
+    `Chunked` logging configuration entity, including its attributes and methods.
     """
 
     async def testDefaultValues(self):
         """
-        Test that Chunked instance is created with correct default values.
-        Verifies default path, level, mb_size and files match expected values.
+        Test default values of Chunked instance.
+
+        Ensures that a `Chunked` instance is created with the correct default values
+        for `path`, `level`, `mb_size`, and `files`.
+
+        Returns
+        -------
+        None
         """
         chunked = Chunked()
         self.assertEqual(chunked.path, "storage/log/application.log")
@@ -21,8 +32,14 @@ class TestConfigChunked(TestCase):
 
     async def testPathValidation(self):
         """
-        Test path attribute validation.
-        Verifies that empty or non-string paths raise exceptions.
+        Test validation of the `path` attribute.
+
+        Verifies that empty or non-string paths raise `OrionisIntegrityException`.
+        Also checks that a valid path does not raise an exception.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             Chunked(path="")
@@ -35,7 +52,14 @@ class TestConfigChunked(TestCase):
 
     async def testLevelValidation(self):
         """
-        Test level attribute validation with different input types.
+        Test validation of the `level` attribute.
+
+        Checks that the `level` can be set using a string, integer, or enum,
+        and that invalid values raise `OrionisIntegrityException`.
+
+        Returns
+        -------
+        None
         """
         # Test string level
         chunked = Chunked(level="debug")
@@ -59,7 +83,14 @@ class TestConfigChunked(TestCase):
 
     async def testMbSizeValidation(self):
         """
-        Test mb_size attribute validation with different input formats.
+        Test validation of the `mb_size` attribute.
+
+        Ensures that valid integer and string formats are accepted, and invalid
+        values raise `OrionisIntegrityException`.
+
+        Returns
+        -------
+        None
         """
         # Test valid integer values
         try:
@@ -90,7 +121,14 @@ class TestConfigChunked(TestCase):
 
     async def testFilesValidation(self):
         """
-        Test files attribute validation.
+        Test validation of the `files` attribute.
+
+        Ensures that valid integer values are accepted, and invalid values raise
+        `OrionisIntegrityException`.
+
+        Returns
+        -------
+        None
         """
         # Test valid values
         try:
@@ -109,7 +147,14 @@ class TestConfigChunked(TestCase):
 
     async def testWhitespaceHandling(self):
         """
-        Test whitespace handling in path and level attributes.
+        Test handling of whitespace in `path` and `level` attributes.
+
+        Ensures that leading and trailing whitespace in `path` and `level` are
+        handled as expected.
+
+        Returns
+        -------
+        None
         """
         chunked = Chunked(path="  logs/app.log  ", level="  debug  ")
         self.assertEqual(chunked.path, "  logs/app.log  ")
@@ -117,7 +162,14 @@ class TestConfigChunked(TestCase):
 
     async def testToDictMethod(self):
         """
-        Test that toDict returns proper dictionary representation.
+        Test the `toDict` method.
+
+        Ensures that `toDict` returns a dictionary representation of the instance
+        with correct values.
+
+        Returns
+        -------
+        None
         """
         chunked = Chunked()
         chunked_dict = chunked.toDict()
@@ -130,7 +182,14 @@ class TestConfigChunked(TestCase):
 
     async def testCustomValuesToDict(self):
         """
-        Test that custom values are properly included in dictionary.
+        Test `toDict` with custom values.
+
+        Ensures that custom values provided to the constructor are correctly
+        reflected in the dictionary representation.
+
+        Returns
+        -------
+        None
         """
         custom_chunked = Chunked(
             path="custom/logs/app.log",
@@ -146,7 +205,14 @@ class TestConfigChunked(TestCase):
 
     async def testHashability(self):
         """
-        Test that Chunked maintains hashability due to unsafe_hash=True.
+        Test hashability of Chunked instances.
+
+        Ensures that `Chunked` instances are hashable and can be used in sets,
+        due to `unsafe_hash=True`.
+
+        Returns
+        -------
+        None
         """
         chunked1 = Chunked()
         chunked2 = Chunked()
@@ -160,7 +226,14 @@ class TestConfigChunked(TestCase):
 
     async def testKwOnlyInitialization(self):
         """
-        Test that Chunked enforces keyword-only initialization.
+        Test enforcement of keyword-only initialization.
+
+        Ensures that `Chunked` cannot be initialized with positional arguments,
+        and raises a `TypeError` if attempted.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(TypeError):
             Chunked("path.log", "info", 10, 5)

tests/foundation/config/logging/{test_logging_daily.py → test_foundation_config_logging_daily.py}

@@ -4,15 +4,25 @@ from orionis.foundation.config.logging.enums.levels import Level
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestConfigDaily(TestCase):
+class TestFoundationConfigLoggingDaily(TestCase):
     """
     Test cases for the Daily logging configuration class.
+
+    This class contains unit tests for the `Daily` logging configuration entity,
+    validating its default values, attribute validation, dictionary conversion,
+    hashability, and keyword-only initialization.
     """
 
     async def testDefaultValues(self):
         """
-        Test that Daily instance is created with correct default values.
-        Verifies default path, level, retention_days and at time match expected values.
+        Test creation of Daily instance with default values.
+
+        Ensures that the default path, level, retention_days, and at time
+        are set as expected.
+
+        Returns
+        -------
+        None
         """
         daily = Daily()
         self.assertEqual(daily.path, "storage/log/application.log")
@@ -22,8 +32,14 @@ class TestConfigDaily(TestCase):
 
     async def testPathValidation(self):
         """
-        Test path attribute validation.
-        Verifies that empty or non-string paths raise exceptions.
+        Test validation of the path attribute.
+
+        Verifies that empty or non-string paths raise exceptions, and that
+        valid paths are accepted.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             Daily(path="")
@@ -36,7 +52,14 @@ class TestConfigDaily(TestCase):
 
     async def testLevelValidation(self):
         """
-        Test level attribute validation with different input types.
+        Test validation of the level attribute.
+
+        Checks that string, integer, and enum values are accepted for level,
+        and that invalid values raise exceptions.
+
+        Returns
+        -------
+        None
         """
         # Test string level
         daily = Daily(level="debug")
@@ -60,7 +83,13 @@ class TestConfigDaily(TestCase):
 
     async def testRetentionDaysValidation(self):
         """
-        Test retention_days attribute validation.
+        Test validation of the retention_days attribute.
+
+        Ensures that valid values are accepted and invalid values raise exceptions.
+
+        Returns
+        -------
+        None
         """
         # Test valid values
         try:
@@ -82,7 +111,14 @@ class TestConfigDaily(TestCase):
 
     async def testAtTimeValidation(self):
         """
-        Test at time attribute validation and conversion.
+        Test validation and conversion of the at attribute.
+
+        Checks that a `datetime.time` object is properly converted and that
+        invalid types raise exceptions.
+
+        Returns
+        -------
+        None
         """
         # Test time object
         daily = Daily(at=time(12, 30))
@@ -96,7 +132,13 @@ class TestConfigDaily(TestCase):
 
     async def testWhitespaceHandling(self):
         """
-        Test whitespace handling in path and level attributes.
+        Test handling of whitespace in path and level attributes.
+
+        Ensures that whitespace in path and level is preserved or handled as expected.
+
+        Returns
+        -------
+        None
         """
         daily = Daily(path="  logs/app.log  ", level="  debug  ")
         self.assertEqual(daily.path, "  logs/app.log  ")
@@ -104,7 +146,14 @@ class TestConfigDaily(TestCase):
 
     async def testToDictMethod(self):
         """
-        Test that toDict returns proper dictionary representation.
+        Test the toDict method for correct dictionary representation.
+
+        Ensures that the dictionary returned by toDict contains the correct
+        default values.
+
+        Returns
+        -------
+        None
         """
         daily = Daily()
         daily_dict = daily.toDict()
@@ -117,7 +166,13 @@ class TestConfigDaily(TestCase):
 
     async def testCustomValuesToDict(self):
         """
-        Test that custom values are properly included in dictionary.
+        Test toDict method with custom values.
+
+        Ensures that custom values are correctly represented in the dictionary.
+
+        Returns
+        -------
+        None
         """
         custom_daily = Daily(
             path="custom/logs/app.log",
@@ -133,7 +188,13 @@ class TestConfigDaily(TestCase):
 
     async def testHashability(self):
         """
-        Test that Daily maintains hashability due to unsafe_hash=True.
+        Test hashability of Daily instances.
+
+        Ensures that Daily instances are hashable and can be used in sets.
+
+        Returns
+        -------
+        None
         """
         daily1 = Daily()
         daily2 = Daily()
@@ -147,7 +208,13 @@ class TestConfigDaily(TestCase):
 
     async def testKwOnlyInitialization(self):
         """
-        Test that Daily enforces keyword-only initialization.
+        Test enforcement of keyword-only initialization.
+
+        Ensures that positional arguments raise a TypeError.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(TypeError):
             Daily("path.log", "info", 7, time(0, 0))

tests/foundation/config/logging/{test_logging_hourly.py → test_foundation_config_logging_hourly.py}

@@ -3,15 +3,25 @@ from orionis.foundation.config.logging.enums.levels import Level
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestConfigHourly(TestCase):
+class TestFoundationConfigLoggingHourly(TestCase):
     """
     Test cases for the Hourly logging configuration class.
+
+    This class contains unit tests for the `Hourly` logging configuration entity,
+    verifying its default values, attribute validation, dictionary representation,
+    hashability, and keyword-only initialization enforcement.
     """
 
     async def testDefaultValues(self):
         """
         Test that Hourly instance is created with correct default values.
-        Verifies default path, level and retention_hours match expected values.
+
+        Verifies that the default `path`, `level`, and `retention_hours` attributes
+        of the Hourly instance match the expected values.
+
+        Returns
+        -------
+        None
         """
         hourly = Hourly()
         self.assertEqual(hourly.path, "storage/log/application.log")
@@ -21,7 +31,14 @@ class TestConfigHourly(TestCase):
     async def testPathValidation(self):
         """
         Test path attribute validation.
-        Verifies that empty or non-string paths raise exceptions.
+
+        Ensures that invalid values for the `path` attribute, such as empty strings
+        or non-string types, raise an `OrionisIntegrityException`. Also verifies that
+        valid paths do not raise exceptions.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             Hourly(path="")
@@ -35,6 +52,13 @@ class TestConfigHourly(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 that invalid values raise an `OrionisIntegrityException`.
+
+        Returns
+        -------
+        None
         """
         # Test string level
         hourly = Hourly(level="debug")
@@ -59,6 +83,13 @@ class TestConfigHourly(TestCase):
     async def testRetentionHoursValidation(self):
         """
         Test retention_hours attribute validation.
+
+        Ensures that valid values for `retention_hours` are accepted and invalid
+        values raise an `OrionisIntegrityException`.
+
+        Returns
+        -------
+        None
         """
         # Test valid values
         try:
@@ -81,6 +112,13 @@ class TestConfigHourly(TestCase):
     async def testWhitespaceHandling(self):
         """
         Test whitespace handling in path and level attributes.
+
+        Verifies that leading and trailing whitespace in the `path` and `level`
+        attributes are handled as expected.
+
+        Returns
+        -------
+        None
         """
         hourly = Hourly(path="  logs/app.log  ", level="  debug  ")
         self.assertEqual(hourly.path, "  logs/app.log  ")
@@ -89,6 +127,13 @@ class TestConfigHourly(TestCase):
     async def testToDictMethod(self):
         """
         Test that toDict returns proper dictionary representation.
+
+        Ensures that the `toDict` method returns a dictionary with the correct
+        attribute values.
+
+        Returns
+        -------
+        None
         """
         hourly = Hourly()
         hourly_dict = hourly.toDict()
@@ -100,6 +145,13 @@ class TestConfigHourly(TestCase):
     async def testCustomValuesToDict(self):
         """
         Test that custom values are properly included in dictionary.
+
+        Verifies that custom values provided to the Hourly instance are correctly
+        reflected in the dictionary returned by `toDict`.
+
+        Returns
+        -------
+        None
         """
         custom_hourly = Hourly(
             path="custom/logs/app.log",
@@ -114,6 +166,13 @@ class TestConfigHourly(TestCase):
     async def testHashability(self):
         """
         Test that Hourly maintains hashability due to unsafe_hash=True.
+
+        Ensures that Hourly instances can be added to a set and that their
+        hashability is preserved.
+
+        Returns
+        -------
+        None
         """
         hourly1 = Hourly()
         hourly2 = Hourly()
@@ -126,6 +185,13 @@ class TestConfigHourly(TestCase):
     async def testKwOnlyInitialization(self):
         """
         Test that Hourly enforces keyword-only initialization.
+
+        Verifies that attempting to initialize Hourly with positional arguments
+        raises a TypeError.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(TypeError):
             Hourly("path.log", "info", 24)