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

tests/foundation/config/database/test_database_sqlite.py

@@ -8,12 +8,21 @@ from orionis.unittesting import TestCase
 class TestConfigSQLite(TestCase):
     """
     Test cases for the SQLite database configuration class.
+
+    This class contains unit tests to validate the behavior and integrity of the
+    SQLite configuration entity, ensuring correct default values, validation logic,
+    and dictionary representation.
     """
 
     async def testDefaultValues(self):
         """
         Test that SQLite instance is created with correct default values.
-        Verifies all default values match expected defaults from class definition.
+
+        Ensures all default values match expected defaults from the class definition.
+
+        Returns
+        -------
+        None
         """
         sqlite = SQLite()
         self.assertEqual(sqlite.driver, 'sqlite')
@@ -28,7 +37,12 @@ class TestConfigSQLite(TestCase):
     async def testDriverValidation(self):
         """
         Test driver attribute validation.
+
         Verifies that empty or non-string drivers raise exceptions.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             SQLite(driver='')
@@ -38,7 +52,12 @@ class TestConfigSQLite(TestCase):
     async def testUrlValidation(self):
         """
         Test URL attribute validation.
+
         Verifies that empty or non-string URLs raise exceptions.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             SQLite(url='')
@@ -48,7 +67,12 @@ class TestConfigSQLite(TestCase):
     async def testDatabaseValidation(self):
         """
         Test database attribute validation.
+
         Verifies that empty or non-string database paths raise exceptions.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             SQLite(database='')
@@ -58,7 +82,12 @@ class TestConfigSQLite(TestCase):
     async def testForeignKeyConstraintsValidation(self):
         """
         Test foreign_key_constraints attribute validation.
+
         Verifies enum conversion and invalid value handling.
+
+        Returns
+        -------
+        None
         """
         # Test string conversion
         sqlite = SQLite(foreign_key_constraints='ON')
@@ -75,7 +104,12 @@ class TestConfigSQLite(TestCase):
     async def testBusyTimeoutValidation(self):
         """
         Test busy_timeout attribute validation.
+
         Verifies non-negative integer requirement.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             SQLite(busy_timeout=-1)
@@ -85,7 +119,12 @@ class TestConfigSQLite(TestCase):
     async def testJournalModeValidation(self):
         """
         Test journal_mode attribute validation.
+
         Verifies enum conversion and invalid value handling.
+
+        Returns
+        -------
+        None
         """
         # Test string conversion
         sqlite = SQLite(journal_mode='WAL')
@@ -102,7 +141,12 @@ class TestConfigSQLite(TestCase):
     async def testSynchronousValidation(self):
         """
         Test synchronous attribute validation.
+
         Verifies enum conversion and invalid value handling.
+
+        Returns
+        -------
+        None
         """
         # Test string conversion
         sqlite = SQLite(synchronous='FULL')
@@ -119,7 +163,12 @@ class TestConfigSQLite(TestCase):
     async def testToDictMethod(self):
         """
         Test that toDict returns proper dictionary representation.
-        Verifies all attributes are correctly included in dictionary.
+
+        Verifies all attributes are correctly included in the dictionary.
+
+        Returns
+        -------
+        None
         """
         sqlite = SQLite()
         sqlite_dict = sqlite.toDict()
@@ -135,7 +184,12 @@ class TestConfigSQLite(TestCase):
     async def testCustomValues(self):
         """
         Test that custom values are properly stored and validated.
+
         Verifies custom configuration values are correctly handled.
+
+        Returns
+        -------
+        None
         """
         custom_sqlite = SQLite(
             database='custom.db',

tests/foundation/config/exceptions/test_exceptions_integrity.py

@@ -4,12 +4,21 @@ from orionis.unittesting import TestCase
 class TestOrionisIntegrityException(TestCase):
     """
     Test cases for the OrionisIntegrityException class.
+
+    Notes
+    -----
+    These tests verify the initialization, inheritance, string representation,
+    handling of different message types, raising and catching, and exception
+    chaining behavior of the OrionisIntegrityException.
     """
 
     async def testExceptionInitialization(self):
         """
-        Test that OrionisIntegrityException is properly initialized with a message.
-        Verifies that the exception stores and returns the provided message correctly.
+        Test initialization of OrionisIntegrityException with a message.
+
+        Verifies
+        --------
+        - The exception stores and returns the provided message correctly.
         """
         test_msg = "Test integrity violation message"
         exception = OrionisIntegrityException(test_msg)
@@ -18,8 +27,12 @@ class TestOrionisIntegrityException(TestCase):
 
     async def testExceptionInheritance(self):
         """
-        Test that OrionisIntegrityException properly inherits from Exception.
-        Verifies the exception hierarchy is correctly implemented.
+        Test inheritance of OrionisIntegrityException.
+
+        Verifies
+        --------
+        - OrionisIntegrityException properly inherits from Exception.
+        - The exception hierarchy is correctly implemented.
         """
         exception = OrionisIntegrityException("Test")
         self.assertIsInstance(exception, Exception)
@@ -27,8 +40,11 @@ class TestOrionisIntegrityException(TestCase):
 
     async def testExceptionStringRepresentation(self):
         """
-        Test the string representation of OrionisIntegrityException.
-        Verifies the __str__ method returns the expected format.
+        Test string representation of OrionisIntegrityException.
+
+        Verifies
+        --------
+        - The __str__ method returns the expected format.
         """
         test_msg = "Configuration validation failed"
         exception = OrionisIntegrityException(test_msg)
@@ -37,7 +53,10 @@ class TestOrionisIntegrityException(TestCase):
     async def testExceptionWithEmptyMessage(self):
         """
         Test OrionisIntegrityException with an empty message.
-        Verifies the exception handles empty messages correctly.
+
+        Verifies
+        --------
+        - The exception handles empty messages correctly.
         """
         exception = OrionisIntegrityException("")
         self.assertEqual(str(exception), "OrionisIntegrityException: ")
@@ -45,7 +64,15 @@ class TestOrionisIntegrityException(TestCase):
     async def testExceptionWithNonStringMessage(self):
         """
         Test OrionisIntegrityException with non-string message types.
-        Verifies the exception converts non-string messages to strings.
+
+        Verifies
+        --------
+        - The exception converts non-string messages to strings.
+
+        Tests
+        -----
+        - Integer message
+        - List message
         """
         # Test with integer
         exception = OrionisIntegrityException(123)
@@ -58,7 +85,10 @@ class TestOrionisIntegrityException(TestCase):
     async def testExceptionRaiseAndCatch(self):
         """
         Test raising and catching OrionisIntegrityException.
-        Verifies the exception can be properly raised and caught.
+
+        Verifies
+        --------
+        - The exception can be properly raised and caught.
         """
         test_msg = "Test exception handling"
         try:
@@ -71,7 +101,11 @@ class TestOrionisIntegrityException(TestCase):
     async def testExceptionChaining(self):
         """
         Test exception chaining with OrionisIntegrityException.
-        Verifies the exception works correctly in chained exception scenarios.
+
+        Verifies
+        --------
+        - The exception works correctly in chained exception scenarios.
+        - The __cause__ attribute is set as expected.
         """
         try:
             try:

tests/foundation/config/filesystems/test_filesystems.py

@@ -6,12 +6,18 @@ from orionis.unittesting import TestCase
 class TestConfigFilesystems(TestCase):
     """
     Test cases for the Filesystems configuration class.
+
+    This class contains unit tests for the `Filesystems` configuration class,
+    including validation of default values, disk types, dictionary conversion,
+    custom values, hashability, and keyword-only initialization.
     """
 
     async def testDefaultValues(self):
         """
-        Test that Filesystems instance is created with correct default values.
-        Verifies default disk is 'local' and disks object is properly initialized.
+        Test Filesystems instance creation with default values.
+
+        Ensures that the default disk is set to 'local' and the disks attribute
+        is properly initialized as a Disks instance.
         """
         fs = Filesystems()
         self.assertEqual(fs.default, "local")
@@ -19,8 +25,15 @@ class TestConfigFilesystems(TestCase):
 
     async def testDefaultDiskValidation(self):
         """
-        Test default disk attribute validation.
-        Verifies that only valid disk types are accepted as default.
+        Validate the default disk attribute.
+
+        Checks that only valid disk types are accepted as default and that
+        invalid types raise an OrionisIntegrityException.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If an invalid disk type is provided as default.
         """
         # Test valid disk types
         valid_disks = ["local", "public", "aws"]
@@ -44,8 +57,15 @@ class TestConfigFilesystems(TestCase):
 
     async def testDisksValidation(self):
         """
-        Test disks attribute validation.
-        Verifies that only Disks instances are accepted.
+        Validate the disks attribute.
+
+        Ensures that only instances of Disks are accepted for the disks attribute.
+        Invalid types should raise an OrionisIntegrityException.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If disks is not a Disks instance or is None.
         """
         # Test invalid disks type
         with self.assertRaises(OrionisIntegrityException):
@@ -63,8 +83,15 @@ class TestConfigFilesystems(TestCase):
 
     async def testToDictMethod(self):
         """
-        Test that toDict returns proper dictionary representation.
-        Verifies all attributes are correctly included in dictionary.
+        Test the toDict method of Filesystems.
+
+        Ensures that the method returns a dictionary representation of the
+        Filesystems instance with all attributes correctly included.
+
+        Returns
+        -------
+        dict
+            Dictionary representation of the Filesystems instance.
         """
         fs = Filesystems()
         fs_dict = fs.toDict()
@@ -75,8 +102,18 @@ class TestConfigFilesystems(TestCase):
 
     async def testCustomValues(self):
         """
-        Test that custom values are properly stored and validated.
-        Verifies custom configurations are correctly handled.
+        Test custom values for Filesystems.
+
+        Ensures that custom configurations are properly stored and validated.
+
+        Parameters
+        ----------
+        custom_disks : Disks
+            Custom Disks instance to be used in Filesystems.
+
+        Returns
+        -------
+        None
         """
         custom_disks = Disks()
         custom_fs = Filesystems(
@@ -88,8 +125,14 @@ class TestConfigFilesystems(TestCase):
 
     async def testHashability(self):
         """
-        Test that Filesystems maintains hashability due to unsafe_hash=True.
-        Verifies that Filesystems instances can be used in sets and as dictionary keys.
+        Test hashability of Filesystems instances.
+
+        Ensures that Filesystems instances are hashable and can be used in sets
+        and as dictionary keys due to `unsafe_hash=True`.
+
+        Returns
+        -------
+        None
         """
         fs1 = Filesystems()
         fs2 = Filesystems()
@@ -103,8 +146,15 @@ class TestConfigFilesystems(TestCase):
 
     async def testKwOnlyInitialization(self):
         """
-        Test that Filesystems enforces keyword-only initialization.
-        Verifies that positional arguments are not allowed for initialization.
+        Test keyword-only initialization enforcement.
+
+        Ensures that Filesystems enforces keyword-only arguments and does not
+        allow positional arguments during initialization.
+
+        Raises
+        ------
+        TypeError
+            If positional arguments are used for initialization.
         """
         with self.assertRaises(TypeError):
             Filesystems("local", Disks())

tests/foundation/config/filesystems/test_filesystems_aws.py

@@ -5,11 +5,16 @@ from orionis.unittesting import TestCase
 class TestConfigS3(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

@@ -8,12 +8,41 @@ from orionis.unittesting import TestCase
 class TestConfigDisks(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())