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

tests/foundation/config/database/test_database_pgsql.py

@@ -7,12 +7,21 @@ from orionis.unittesting import TestCase
 class TestConfigPGSQL(TestCase):
     """
     Test cases for the PGSQL database configuration class.
+
+    This class contains asynchronous unit tests for validating the behavior,
+    default values, and integrity checks of the PGSQL configuration entity.
     """
 
     async def testDefaultValues(self):
         """
-        Test that PGSQL instance is created with correct default values.
-        Verifies all default values match expected defaults from class definition.
+        Test default values of PGSQL instance.
+
+        Ensures that a PGSQL instance is created with the correct default values
+        as defined in the class.
+
+        Returns
+        -------
+        None
         """
         pgsql = PGSQL()
         self.assertEqual(pgsql.driver, 'pgsql')
@@ -29,8 +38,13 @@ class TestConfigPGSQL(TestCase):
 
     async def testDriverValidation(self):
         """
-        Test driver attribute validation.
-        Verifies that empty or non-string drivers raise exceptions.
+        Test validation of the driver attribute.
+
+        Checks that empty or non-string driver values raise an exception.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             PGSQL(driver='')
@@ -39,8 +53,13 @@ class TestConfigPGSQL(TestCase):
 
     async def testHostValidation(self):
         """
-        Test host attribute validation.
-        Verifies that empty or non-string hosts raise exceptions.
+        Test validation of the host attribute.
+
+        Checks that empty or non-string host values raise an exception.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             PGSQL(host='')
@@ -49,8 +68,13 @@ class TestConfigPGSQL(TestCase):
 
     async def testPortValidation(self):
         """
-        Test port attribute validation.
-        Verifies that non-numeric string ports raise exceptions.
+        Test validation of the port attribute.
+
+        Checks that non-numeric string ports or non-string ports raise an exception.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             PGSQL(port='abc')
@@ -59,8 +83,13 @@ class TestConfigPGSQL(TestCase):
 
     async def testDatabaseValidation(self):
         """
-        Test database attribute validation.
-        Verifies that empty or non-string database names raise exceptions.
+        Test validation of the database attribute.
+
+        Checks that empty or non-string database names raise an exception.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             PGSQL(database='')
@@ -69,8 +98,13 @@ class TestConfigPGSQL(TestCase):
 
     async def testUsernameValidation(self):
         """
-        Test username attribute validation.
-        Verifies that empty or non-string usernames raise exceptions.
+        Test validation of the username attribute.
+
+        Checks that empty or non-string usernames raise an exception.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             PGSQL(username='')
@@ -79,16 +113,26 @@ class TestConfigPGSQL(TestCase):
 
     async def testPasswordValidation(self):
         """
-        Test password attribute validation.
-        Verifies that non-string passwords raise exceptions.
+        Test validation of the password attribute.
+
+        Checks that non-string passwords raise an exception.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             PGSQL(password=123)
 
     async def testCharsetValidation(self):
         """
-        Test charset attribute validation.
-        Verifies enum conversion and invalid value handling.
+        Test validation of the charset attribute.
+
+        Ensures correct enum conversion and handling of invalid values.
+
+        Returns
+        -------
+        None
         """
         # Test string conversion
         pgsql = PGSQL(charset='UTF8')
@@ -104,8 +148,13 @@ class TestConfigPGSQL(TestCase):
 
     async def testPrefixIndexesValidation(self):
         """
-        Test prefix_indexes attribute validation.
-        Verifies that non-boolean values raise exceptions.
+        Test validation of the prefix_indexes attribute.
+
+        Checks that non-boolean values raise an exception.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             PGSQL(prefix_indexes='true')
@@ -114,8 +163,13 @@ class TestConfigPGSQL(TestCase):
 
     async def testSearchPathValidation(self):
         """
-        Test search_path attribute validation.
-        Verifies that empty or non-string search paths raise exceptions.
+        Test validation of the search_path attribute.
+
+        Checks that empty or non-string search paths raise an exception.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             PGSQL(search_path='')
@@ -124,8 +178,13 @@ class TestConfigPGSQL(TestCase):
 
     async def testSSLModeValidation(self):
         """
-        Test sslmode attribute validation.
-        Verifies enum conversion and invalid value handling.
+        Test validation of the sslmode attribute.
+
+        Ensures correct enum conversion and handling of invalid values.
+
+        Returns
+        -------
+        None
         """
         # Test string conversion
         pgsql = PGSQL(sslmode='REQUIRE')
@@ -141,8 +200,14 @@ class TestConfigPGSQL(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 PGSQL.
+
+        Ensures that the dictionary representation contains all attributes
+        with correct values.
+
+        Returns
+        -------
+        None
         """
         pgsql = PGSQL()
         pgsql_dict = pgsql.toDict()
@@ -160,8 +225,13 @@ class TestConfigPGSQL(TestCase):
 
     async def testCustomValues(self):
         """
-        Test that custom values are properly stored and validated.
-        Verifies custom configuration values are correctly handled.
+        Test custom configuration values for PGSQL.
+
+        Ensures that custom values are properly stored and validated.
+
+        Returns
+        -------
+        None
         """
         custom_pgsql = PGSQL(
             host='db.example.com',

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