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

tests/foundation/config/filesystems/{test_filesystems_aws.py → test_foundation_config_filesystems_aws.py}

@@ -2,14 +2,19 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.foundation.config.filesystems.entitites.aws import S3
 from orionis.unittesting import TestCase
 
-class TestConfigS3(TestCase):
+class TestFoundationConfigFilesystemsAws(TestCase):
     """
     Test cases for the S3 storage configuration class.
+
+    This class contains unit tests for the S3 configuration entity, ensuring
+    correct default values, field validation, custom value handling, dictionary
+    conversion, hashability, and keyword-only initialization.
     """
 
     async def testDefaultValues(self):
         """
         Test that S3 instance is created with correct default values.
+
         Verifies all default values match expected defaults from class definition.
         """
         s3 = S3()
@@ -25,7 +30,13 @@ class TestConfigS3(TestCase):
     async def testRequiredFieldValidation(self):
         """
         Test validation of required fields.
-        Verifies that region must be a non-empty string.
+
+        Ensures that the 'region' field must be a non-empty string.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If 'region' is empty or not a string.
         """
         # Test empty region
         with self.assertRaises(OrionisIntegrityException):
@@ -38,7 +49,13 @@ class TestConfigS3(TestCase):
     async def testOptionalFieldValidation(self):
         """
         Test validation of optional fields.
-        Verifies that optional fields accept None or proper types.
+
+        Ensures that optional fields accept None or proper types.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If optional fields are not of the correct type.
         """
         # Valid optional configurations
         try:
@@ -56,7 +73,13 @@ class TestConfigS3(TestCase):
     async def testBooleanFieldValidation(self):
         """
         Test validation of boolean fields.
-        Verifies that boolean fields only accept boolean values.
+
+        Ensures that boolean fields only accept boolean values.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If boolean fields are not of type bool.
         """
         # Test use_path_style_endpoint
         with self.assertRaises(OrionisIntegrityException):
@@ -69,7 +92,9 @@ class TestConfigS3(TestCase):
     async def testCustomValues(self):
         """
         Test that custom values are properly stored and validated.
-        Verifies custom configuration values are correctly handled.
+
+        Ensures custom configuration values are correctly handled.
+
         """
         custom_s3 = S3(
             key="AKIAEXAMPLE",
@@ -94,7 +119,13 @@ class TestConfigS3(TestCase):
     async def testToDictMethod(self):
         """
         Test that toDict returns proper dictionary representation.
-        Verifies all attributes are correctly included in dictionary.
+
+        Ensures all attributes are correctly included in the dictionary.
+
+        Returns
+        -------
+        dict
+            Dictionary representation of the S3 instance.
         """
         s3 = S3()
         s3_dict = s3.toDict()
@@ -112,7 +143,8 @@ class TestConfigS3(TestCase):
     async def testHashability(self):
         """
         Test that S3 maintains hashability due to unsafe_hash=True.
-        Verifies that S3 instances can be used in sets and as dictionary keys.
+
+        Ensures that S3 instances can be used in sets and as dictionary keys.
         """
         s3_1 = S3()
         s3_2 = S3()
@@ -127,7 +159,13 @@ class TestConfigS3(TestCase):
     async def testKwOnlyInitialization(self):
         """
         Test that S3 enforces keyword-only initialization.
-        Verifies that positional arguments are not allowed for initialization.
+
+        Ensures that positional arguments are not allowed for initialization.
+
+        Raises
+        ------
+        TypeError
+            If positional arguments are used for initialization.
         """
         with self.assertRaises(TypeError):
             S3("key", "secret", "region")  # Should fail as it requires keyword arguments

tests/foundation/config/filesystems/{test_filesystems_disks.py → test_foundation_config_filesystems_disks.py}

@@ -5,15 +5,44 @@ from orionis.foundation.config.filesystems.entitites.public import Public
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestConfigDisks(TestCase):
+class TestFoundationConfigFilesystemsDisks(TestCase):
     """
     Test cases for the Disks filesystem configuration class.
+
+    This class contains unit tests to validate the behavior and integrity of the
+    `Disks` configuration class, ensuring correct type validation, default values,
+    custom configuration handling, dictionary conversion, hashability, and
+    keyword-only initialization.
+
+    Methods
+    -------
+    testDefaultValues()
+        Test that Disks instance is created with correct default values.
+    testLocalTypeValidation()
+        Test local attribute type validation.
+    testPublicTypeValidation()
+        Test public attribute type validation.
+    testAwsTypeValidation()
+        Test aws attribute type validation.
+    testCustomDiskConfigurations()
+        Test that custom disk configurations are properly stored and validated.
+    testToDictMethod()
+        Test that toDict returns proper dictionary representation.
+    testHashability()
+        Test that Disks maintains hashability due to unsafe_hash=True.
+    testKwOnlyInitialization()
+        Test that Disks enforces keyword-only initialization.
     """
 
     async def testDefaultValues(self):
         """
         Test that Disks instance is created with correct default values.
-        Verifies all default disk configurations are properly initialized.
+
+        Ensures that all default disk configurations are properly initialized.
+
+        Returns
+        -------
+        None
         """
         disks = Disks()
         self.assertIsInstance(disks.local, Local)
@@ -23,7 +52,13 @@ class TestConfigDisks(TestCase):
     async def testLocalTypeValidation(self):
         """
         Test local attribute type validation.
-        Verifies that only Local instances are accepted for local attribute.
+
+        Ensures that only `Local` instances are accepted for the `local` attribute.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the `local` attribute is not a `Local` instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Disks(local="not_a_local_instance")
@@ -35,7 +70,13 @@ class TestConfigDisks(TestCase):
     async def testPublicTypeValidation(self):
         """
         Test public attribute type validation.
-        Verifies that only Public instances are accepted for public attribute.
+
+        Ensures that only `Public` instances are accepted for the `public` attribute.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the `public` attribute is not a `Public` instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Disks(public="not_a_public_instance")
@@ -47,7 +88,13 @@ class TestConfigDisks(TestCase):
     async def testAwsTypeValidation(self):
         """
         Test aws attribute type validation.
-        Verifies that only S3 instances are accepted for aws attribute.
+
+        Ensures that only `S3` instances are accepted for the `aws` attribute.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the `aws` attribute is not an `S3` instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Disks(aws="not_an_s3_instance")
@@ -59,7 +106,13 @@ class TestConfigDisks(TestCase):
     async def testCustomDiskConfigurations(self):
         """
         Test that custom disk configurations are properly stored and validated.
-        Verifies custom disk configurations are correctly handled.
+
+        Ensures that custom disk configurations are correctly handled and their
+        attributes are properly set.
+
+        Returns
+        -------
+        None
         """
         custom_local = Local(path="custom/local/path")
         custom_public = Public(path="custom/public/path", url="assets")
@@ -80,7 +133,13 @@ class TestConfigDisks(TestCase):
     async def testToDictMethod(self):
         """
         Test that toDict returns proper dictionary representation.
-        Verifies all disk configurations are correctly included in dictionary.
+
+        Ensures that all disk configurations are correctly included in the
+        dictionary representation.
+
+        Returns
+        -------
+        None
         """
         disks = Disks()
         disks_dict = disks.toDict()
@@ -93,7 +152,12 @@ class TestConfigDisks(TestCase):
     async def testHashability(self):
         """
         Test that Disks maintains hashability due to unsafe_hash=True.
-        Verifies that Disks instances can be used in sets and as dictionary keys.
+
+        Ensures that `Disks` instances can be used in sets and as dictionary keys.
+
+        Returns
+        -------
+        None
         """
         disks1 = Disks()
         disks2 = Disks()
@@ -108,7 +172,13 @@ class TestConfigDisks(TestCase):
     async def testKwOnlyInitialization(self):
         """
         Test that Disks enforces keyword-only initialization.
-        Verifies that positional arguments are not allowed for initialization.
+
+        Ensures that positional arguments are not allowed for initialization.
+
+        Raises
+        ------
+        TypeError
+            If positional arguments are used for initialization.
         """
         with self.assertRaises(TypeError):
             Disks(Local(), Public(), S3())

tests/foundation/config/filesystems/{test_filesystems_local.py → test_foundation_config_filesystems_local.py}

@@ -2,23 +2,36 @@ from orionis.foundation.config.filesystems.entitites.local import Local
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestConfigLocal(TestCase):
+class TestFoundationConfigFilesystemsLocal(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 → test_foundation_config_filesystems_public.py}

@@ -2,14 +2,42 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.foundation.config.filesystems.entitites.public import Public
 from orionis.unittesting import TestCase
 
-class TestConfigPublic(TestCase):
+class TestFoundationConfigFilesystemsPublic(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_foundation_config_logging.py

@@ -0,0 +1,112 @@
+from orionis.foundation.config.logging.entities.logging import Logging
+from orionis.foundation.config.logging.entities.channels import Channels
+from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestFoundationConfigLogging(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 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")
+        self.assertIsInstance(logging.channels, Channels)
+
+    async def testToDictMethod(self):
+        """
+        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()
+        self.assertIsInstance(result, dict)
+        self.assertIn("default", result)
+        self.assertIn("channels", result)
+
+    async def testPostInitValidation(self):
+        """
+        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")
+
+        with self.assertRaises(OrionisIntegrityException):
+            Logging(channels="invalid_channels")
+
+    async def testKwOnlyInitialization(self):
+        """
+        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())