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

tests/foundation/config/filesystems/test_filesystems_local.py

@@ -5,20 +5,33 @@ from orionis.unittesting import TestCase
 class TestConfigLocal(TestCase):
     """
     Test cases for the Local storage configuration class.
+
+    This class contains asynchronous unit tests for the `Local` storage configuration,
+    validating path handling, dictionary conversion, hashability, and initialization constraints.
     """
 
     async def testDefaultPath(self):
         """
-        Test that Local instance is created with correct default path.
-        Verifies the default path matches the expected value from class definition.
+        Test Local instance creation with default path.
+
+        Ensures that the default path of a Local instance matches the expected value.
+
+        Returns
+        -------
+        None
         """
         local = Local()
         self.assertEqual(local.path, "storage/app/private")
 
     async def testCustomPath(self):
         """
-        Test that custom path can be set during initialization.
-        Verifies the path attribute accepts and stores valid custom paths.
+        Test setting a custom path during initialization.
+
+        Ensures that the path attribute accepts and stores valid custom paths.
+
+        Returns
+        -------
+        None
         """
         custom_path = "custom/storage/path"
         local = Local(path=custom_path)
@@ -26,16 +39,26 @@ class TestConfigLocal(TestCase):
 
     async def testEmptyPathValidation(self):
         """
-        Test that empty paths are rejected.
-        Verifies that an empty path raises OrionisIntegrityException.
+        Test rejection of empty paths.
+
+        Ensures that initializing Local with an empty path raises OrionisIntegrityException.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             Local(path="")
 
     async def testPathTypeValidation(self):
         """
-        Test that non-string paths are rejected.
-        Verifies that non-string path values raise OrionisIntegrityException.
+        Test rejection of non-string paths.
+
+        Ensures that non-string path values raise OrionisIntegrityException.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             Local(path=123)
@@ -46,8 +69,13 @@ class TestConfigLocal(TestCase):
 
     async def testToDictMethod(self):
         """
-        Test that toDict returns proper dictionary representation.
-        Verifies the returned dictionary contains the expected path value.
+        Test dictionary representation of Local.
+
+        Ensures that toDict returns a dictionary containing the expected path value.
+
+        Returns
+        -------
+        None
         """
         local = Local()
         config_dict = local.toDict()
@@ -56,8 +84,13 @@ class TestConfigLocal(TestCase):
 
     async def testCustomPathToDict(self):
         """
-        Test that custom paths are properly included in dictionary representation.
-        Verifies toDict() includes custom path values when specified.
+        Test dictionary representation with custom path.
+
+        Ensures that toDict includes custom path values when specified.
+
+        Returns
+        -------
+        None
         """
         custom_path = "another/storage/location"
         local = Local(path=custom_path)
@@ -66,8 +99,13 @@ class TestConfigLocal(TestCase):
 
     async def testWhitespacePathHandling(self):
         """
-        Test that paths with whitespace are accepted but not automatically trimmed.
-        Verifies the validation allows paths containing whitespace characters.
+        Test handling of paths with whitespace.
+
+        Ensures that paths containing whitespace are accepted and not automatically trimmed.
+
+        Returns
+        -------
+        None
         """
         spaced_path = "  storage/with/space  "
         local = Local(path=spaced_path)
@@ -75,8 +113,13 @@ class TestConfigLocal(TestCase):
 
     async def testHashability(self):
         """
-        Test that Local maintains hashability due to unsafe_hash=True.
-        Verifies that Local instances can be used in sets and as dictionary keys.
+        Test hashability of Local instances.
+
+        Ensures that Local instances can be used in sets and as dictionary keys.
+
+        Returns
+        -------
+        None
         """
         local1 = Local()
         local2 = Local()
@@ -88,8 +131,13 @@ class TestConfigLocal(TestCase):
 
     async def testKwOnlyInitialization(self):
         """
-        Test that Local enforces keyword-only initialization.
-        Verifies that positional arguments are not allowed for initialization.
+        Test enforcement of keyword-only initialization.
+
+        Ensures that positional arguments are not allowed for Local initialization.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(TypeError):
             Local("storage/path")

tests/foundation/config/filesystems/test_filesystems_public.py

@@ -5,11 +5,39 @@ from orionis.unittesting import TestCase
 class TestConfigPublic(TestCase):
     """
     Test cases for the Public storage configuration class.
+
+    This class contains asynchronous unit tests for the `Public` storage configuration,
+    validating default values, custom values, input validation, dictionary conversion,
+    whitespace handling, hashability, and keyword-only initialization.
+
+    Methods
+    -------
+    testDefaultValues()
+        Test that Public instance is created with correct default values.
+    testCustomValues()
+        Test that custom path and url can be set during initialization.
+    testEmptyPathValidation()
+        Test that empty paths are rejected.
+    testEmptyUrlValidation()
+        Test that empty URLs are rejected.
+    testTypeValidation()
+        Test that non-string values are rejected for both attributes.
+    testToDictMethod()
+        Test that toDict returns proper dictionary representation.
+    testCustomValuesToDict()
+        Test that custom values are properly included in dictionary representation.
+    testWhitespaceHandling()
+        Test that values with whitespace are accepted but not automatically trimmed.
+    testHashability()
+        Test that Public maintains hashability due to unsafe_hash=True.
+    testKwOnlyInitialization()
+        Test that Public enforces keyword-only initialization.
     """
 
     async def testDefaultValues(self):
         """
         Test that Public instance is created with correct default values.
+
         Verifies both default path and url match expected values from class definition.
         """
         public = Public()
@@ -19,6 +47,7 @@ class TestConfigPublic(TestCase):
     async def testCustomValues(self):
         """
         Test that custom path and url can be set during initialization.
+
         Verifies both attributes accept and store valid custom values.
         """
         custom_path = "custom/public/path"
@@ -30,6 +59,7 @@ class TestConfigPublic(TestCase):
     async def testEmptyPathValidation(self):
         """
         Test that empty paths are rejected.
+
         Verifies that an empty path raises OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
@@ -38,6 +68,7 @@ class TestConfigPublic(TestCase):
     async def testEmptyUrlValidation(self):
         """
         Test that empty URLs are rejected.
+
         Verifies that an empty url raises OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
@@ -46,6 +77,7 @@ class TestConfigPublic(TestCase):
     async def testTypeValidation(self):
         """
         Test that non-string values are rejected for both attributes.
+
         Verifies that non-string values raise OrionisIntegrityException.
         """
         # Test path validation
@@ -63,6 +95,7 @@ class TestConfigPublic(TestCase):
     async def testToDictMethod(self):
         """
         Test that toDict returns proper dictionary representation.
+
         Verifies the returned dictionary contains both default values.
         """
         public = Public()
@@ -75,6 +108,7 @@ class TestConfigPublic(TestCase):
     async def testCustomValuesToDict(self):
         """
         Test that custom values are properly included in dictionary representation.
+
         Verifies toDict() includes custom values when specified.
         """
         custom_path = "public/assets"
@@ -88,6 +122,7 @@ class TestConfigPublic(TestCase):
     async def testWhitespaceHandling(self):
         """
         Test that values with whitespace are accepted but not automatically trimmed.
+
         Verifies the validation allows values containing whitespace characters.
         """
         spaced_path = "  public/storage  "
@@ -99,6 +134,7 @@ class TestConfigPublic(TestCase):
     async def testHashability(self):
         """
         Test that Public maintains hashability due to unsafe_hash=True.
+
         Verifies that Public instances can be used in sets and as dictionary keys.
         """
         public1 = Public()
@@ -114,6 +150,7 @@ class TestConfigPublic(TestCase):
     async def testKwOnlyInitialization(self):
         """
         Test that Public enforces keyword-only initialization.
+
         Verifies that positional arguments are not allowed for initialization.
         """
         with self.assertRaises(TypeError):

tests/foundation/config/logging/test_logging.py

@@ -4,12 +4,33 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.unittesting import TestCase
 
 class TestLogging(TestCase):
+    """
+    Unit tests for the Logging class.
+
+    This test suite verifies the correct initialization, dictionary conversion,
+    post-initialization validation, and keyword-only argument enforcement of the
+    Logging class.
+    """
 
     async def testDefaultValues(self):
         """
-        Test that the Logging instance is initialized with correct default values.
-        Verifies that a new Logging object has 'stack' as default channel
-        and an instance of Channels as channels attribute.
+        Test default values of Logging.
+
+        Ensures that a new Logging instance is initialized with the correct default values.
+
+        Parameters
+        ----------
+        self : TestLogging
+            The test case instance.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        AssertionError
+            If the default values are not as expected.
         """
         logging = Logging()
         self.assertEqual(logging.default, "stack")
@@ -17,9 +38,23 @@ class TestLogging(TestCase):
 
     async def testToDictMethod(self):
         """
-        Test the toDict method returns a proper dictionary representation.
-        Checks that the toDict method converts the Logging instance
-        into a dictionary with all expected fields.
+        Test the toDict method of Logging.
+
+        Checks that the toDict method returns a dictionary representation with all expected fields.
+
+        Parameters
+        ----------
+        self : TestLogging
+            The test case instance.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        AssertionError
+            If the dictionary representation is not as expected.
         """
         logging = Logging()
         result = logging.toDict()
@@ -29,9 +64,23 @@ class TestLogging(TestCase):
 
     async def testPostInitValidation(self):
         """
-        Test the __post_init__ validation works correctly.
-        Verifies that invalid default channel or channels type
-        raises OrionisIntegrityException.
+        Test post-initialization validation of Logging.
+
+        Verifies that providing an invalid default channel or channels type raises an exception.
+
+        Parameters
+        ----------
+        self : TestLogging
+            The test case instance.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        AssertionError
+            If the expected exception is not raised.
         """
         with self.assertRaises(OrionisIntegrityException):
             Logging(default="invalid_channel")
@@ -41,8 +90,23 @@ class TestLogging(TestCase):
 
     async def testKwOnlyInitialization(self):
         """
-        Test that Logging requires keyword arguments for initialization.
-        Verifies that the class enforces kw_only=True in its dataclass decorator.
+        Test keyword-only initialization enforcement.
+
+        Ensures that Logging requires keyword arguments for initialization.
+
+        Parameters
+        ----------
+        self : TestLogging
+            The test case instance.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        AssertionError
+            If TypeError is not raised when using positional arguments.
         """
         with self.assertRaises(TypeError):
             Logging("stack", Channels())

tests/foundation/config/logging/test_logging_channels.py

@@ -11,12 +11,46 @@ from orionis.unittesting import TestCase
 class TestConfigChannels(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())