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

tests/foundation/config/database/test_database_connections.py

@@ -9,12 +9,21 @@ from orionis.unittesting import TestCase
 class TestConfigConnections(TestCase):
     """
     Test cases for the Connections configuration class.
+
+    This class contains unit tests to validate the behavior and integrity of the
+    Connections class, ensuring correct type validation, default values, dictionary
+    representation, custom connection handling, hashability, and keyword-only initialization.
     """
 
     async def testDefaultValues(self):
         """
         Test that Connections instance is created with correct default values.
+
         Verifies all default connections are properly initialized with their respective types.
+
+        Returns
+        -------
+        None
         """
         connections = Connections()
         self.assertIsInstance(connections.sqlite, SQLite)
@@ -25,7 +34,17 @@ class TestConfigConnections(TestCase):
     async def testSqliteTypeValidation(self):
         """
         Test sqlite attribute type validation.
-        Verifies that only SQLite instances are accepted for sqlite attribute.
+
+        Verifies that only SQLite instances are accepted for the sqlite attribute.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the sqlite attribute is not a valid SQLite instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Connections(sqlite="not_a_sqlite_instance")
@@ -37,7 +56,17 @@ class TestConfigConnections(TestCase):
     async def testMysqlTypeValidation(self):
         """
         Test mysql attribute type validation.
-        Verifies that only MySQL instances are accepted for mysql attribute.
+
+        Verifies that only MySQL instances are accepted for the mysql attribute.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the mysql attribute is not a valid MySQL instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Connections(mysql="not_a_mysql_instance")
@@ -49,7 +78,17 @@ class TestConfigConnections(TestCase):
     async def testPgsqlTypeValidation(self):
         """
         Test pgsql attribute type validation.
-        Verifies that only PGSQL instances are accepted for pgsql attribute.
+
+        Verifies that only PGSQL instances are accepted for the pgsql attribute.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the pgsql attribute is not a valid PGSQL instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Connections(pgsql="not_a_pgsql_instance")
@@ -61,7 +100,17 @@ class TestConfigConnections(TestCase):
     async def testOracleTypeValidation(self):
         """
         Test oracle attribute type validation.
-        Verifies that only Oracle instances are accepted for oracle attribute.
+
+        Verifies that only Oracle instances are accepted for the oracle attribute.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the oracle attribute is not a valid Oracle instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Connections(oracle="not_an_oracle_instance")
@@ -73,7 +122,12 @@ class TestConfigConnections(TestCase):
     async def testToDictMethod(self):
         """
         Test that toDict returns proper dictionary representation.
-        Verifies all connections are correctly included in dictionary.
+
+        Verifies all connections are correctly included in the dictionary.
+
+        Returns
+        -------
+        None
         """
         connections = Connections()
         connections_dict = connections.toDict()
@@ -86,7 +140,12 @@ class TestConfigConnections(TestCase):
     async def testCustomConnections(self):
         """
         Test that custom connections are properly stored and validated.
+
         Verifies custom connection configurations are correctly handled.
+
+        Returns
+        -------
+        None
         """
         custom_sqlite = SQLite(database='custom.db')
         custom_mysql = MySQL(database='custom_db')
@@ -108,7 +167,12 @@ class TestConfigConnections(TestCase):
     async def testHashability(self):
         """
         Test that Connections maintains hashability due to unsafe_hash=True.
+
         Verifies that Connections instances can be used in sets and as dictionary keys.
+
+        Returns
+        -------
+        None
         """
         conn1 = Connections()
         conn2 = Connections()
@@ -123,7 +187,17 @@ class TestConfigConnections(TestCase):
     async def testKwOnlyInitialization(self):
         """
         Test that Connections enforces keyword-only initialization.
+
         Verifies that positional arguments are not allowed for initialization.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        TypeError
+            If positional arguments are used for initialization.
         """
         with self.assertRaises(TypeError):
             Connections(SQLite(), MySQL(), PGSQL(), Oracle())

tests/foundation/config/database/test_database_mysql.py

@@ -8,11 +8,54 @@ from orionis.unittesting import TestCase
 class TestConfigMySQL(TestCase):
     """
     Test cases for the MySQL database configuration class.
+
+    This class contains asynchronous unit tests for validating the behavior,
+    default values, and input validation of the `MySQL` configuration entity.
+
+    Attributes
+    ----------
+    None
+
+    Methods
+    -------
+    testDefaultValues()
+        Test that MySQL instance is created with correct default values.
+    testDriverValidation()
+        Test driver attribute validation.
+    testHostValidation()
+        Test host attribute validation.
+    testPortValidation()
+        Test port attribute validation.
+    testDatabaseValidation()
+        Test database attribute validation.
+    testUsernameValidation()
+        Test username attribute validation.
+    testPasswordValidation()
+        Test password attribute validation.
+    testUnixSocketValidation()
+        Test unix_socket attribute validation.
+    testCharsetValidation()
+        Test charset attribute validation.
+    testCollationValidation()
+        Test collation attribute validation.
+    testPrefixValidation()
+        Test prefix attribute validation.
+    testPrefixIndexesValidation()
+        Test prefix_indexes attribute validation.
+    testStrictValidation()
+        Test strict attribute validation.
+    testEngineValidation()
+        Test engine attribute validation.
+    testToDictMethod()
+        Test that toDict returns proper dictionary representation.
+    testCustomValues()
+        Test that custom values are properly stored and validated.
     """
 
     async def testDefaultValues(self):
         """
         Test that MySQL instance is created with correct default values.
+
         Verifies all default values match expected defaults from class definition.
         """
         mysql = MySQL()
@@ -33,7 +76,13 @@ class TestConfigMySQL(TestCase):
     async def testDriverValidation(self):
         """
         Test driver attribute validation.
-        Verifies that only 'mysql' value is accepted for driver.
+
+        Ensures that only 'mysql' value is accepted for driver.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the driver value is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             MySQL(driver='')
@@ -45,7 +94,13 @@ class TestConfigMySQL(TestCase):
     async def testHostValidation(self):
         """
         Test host attribute validation.
-        Verifies that empty or non-string hosts raise exceptions.
+
+        Ensures that empty or non-string hosts raise exceptions.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the host value is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             MySQL(host='')
@@ -55,7 +110,13 @@ class TestConfigMySQL(TestCase):
     async def testPortValidation(self):
         """
         Test port attribute validation.
-        Verifies invalid port numbers raise exceptions.
+
+        Ensures invalid port numbers raise exceptions.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the port value is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             MySQL(port=0)
@@ -67,7 +128,13 @@ class TestConfigMySQL(TestCase):
     async def testDatabaseValidation(self):
         """
         Test database attribute validation.
-        Verifies that empty or non-string database names raise exceptions.
+
+        Ensures that empty or non-string database names raise exceptions.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the database value is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             MySQL(database='')
@@ -77,7 +144,13 @@ class TestConfigMySQL(TestCase):
     async def testUsernameValidation(self):
         """
         Test username attribute validation.
-        Verifies that empty or non-string usernames raise exceptions.
+
+        Ensures that empty or non-string usernames raise exceptions.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the username value is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             MySQL(username='')
@@ -87,7 +160,13 @@ class TestConfigMySQL(TestCase):
     async def testPasswordValidation(self):
         """
         Test password attribute validation.
-        Verifies that non-string passwords raise exceptions.
+
+        Ensures that non-string passwords raise exceptions.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the password value is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             MySQL(password=123)
@@ -95,7 +174,13 @@ class TestConfigMySQL(TestCase):
     async def testUnixSocketValidation(self):
         """
         Test unix_socket attribute validation.
-        Verifies that non-string socket paths raise exceptions.
+
+        Ensures that non-string socket paths raise exceptions.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the unix_socket value is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             MySQL(unix_socket=123)
@@ -103,7 +188,13 @@ class TestConfigMySQL(TestCase):
     async def testCharsetValidation(self):
         """
         Test charset attribute validation.
-        Verifies enum conversion and invalid value handling.
+
+        Ensures enum conversion and invalid value handling.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the charset value is invalid.
         """
         # Test string conversion
         mysql = MySQL(charset='UTF8')
@@ -119,7 +210,13 @@ class TestConfigMySQL(TestCase):
     async def testCollationValidation(self):
         """
         Test collation attribute validation.
-        Verifies enum conversion and invalid value handling.
+
+        Ensures enum conversion and invalid value handling.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the collation value is invalid.
         """
         # Test string conversion
         mysql = MySQL(collation='UTF8_GENERAL_CI')
@@ -135,7 +232,13 @@ class TestConfigMySQL(TestCase):
     async def testPrefixValidation(self):
         """
         Test prefix attribute validation.
-        Verifies that non-string prefixes raise exceptions.
+
+        Ensures that non-string prefixes raise exceptions.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the prefix value is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             MySQL(prefix=123)
@@ -143,7 +246,13 @@ class TestConfigMySQL(TestCase):
     async def testPrefixIndexesValidation(self):
         """
         Test prefix_indexes attribute validation.
-        Verifies that non-boolean values raise exceptions.
+
+        Ensures that non-boolean values raise exceptions.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the prefix_indexes value is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             MySQL(prefix_indexes='true')
@@ -153,7 +262,13 @@ class TestConfigMySQL(TestCase):
     async def testStrictValidation(self):
         """
         Test strict attribute validation.
-        Verifies that non-boolean values raise exceptions.
+
+        Ensures that non-boolean values raise exceptions.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the strict value is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             MySQL(strict='true')
@@ -163,7 +278,13 @@ class TestConfigMySQL(TestCase):
     async def testEngineValidation(self):
         """
         Test engine attribute validation.
-        Verifies enum conversion and invalid value handling.
+
+        Ensures enum conversion and invalid value handling.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the engine value is invalid.
         """
         # Test string conversion
         mysql = MySQL(engine='MYISAM')
@@ -180,7 +301,8 @@ class TestConfigMySQL(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 dictionary.
         """
         mysql = MySQL()
         mysql_dict = mysql.toDict()
@@ -201,7 +323,8 @@ class TestConfigMySQL(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_mysql = MySQL(
             host='db.example.com',

tests/foundation/config/database/test_database_oracle.py

@@ -7,12 +7,24 @@ from orionis.unittesting import TestCase
 class TestConfigOracle(TestCase):
     """
     Test cases for the Oracle database configuration class.
+
+    Notes
+    -----
+    This class contains asynchronous unit tests for the `Oracle` configuration entity,
+    validating its attributes, value constraints, and dictionary serialization.
     """
 
     async def testDefaultValues(self):
         """
-        Test that Oracle instance is created with correct default values.
-        Verifies all default values match expected defaults from class definition.
+        Test Oracle instance creation with default values.
+
+        Ensures that all default attribute values match the expected defaults
+        as defined in the class.
+
+        Raises
+        ------
+        AssertionError
+            If any default value does not match the expected value.
         """
         oracle = Oracle()
         self.assertEqual(oracle.driver, 'oracle')
@@ -29,8 +41,14 @@ class TestConfigOracle(TestCase):
 
     async def testDriverValidation(self):
         """
-        Test driver attribute validation.
-        Verifies that only 'oracle' value is accepted for driver.
+        Test validation of the `driver` attribute.
+
+        Ensures that only the value 'oracle' is accepted for the driver.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the driver value is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             Oracle(driver='')
@@ -41,8 +59,14 @@ class TestConfigOracle(TestCase):
 
     async def testUsernameValidation(self):
         """
-        Test username attribute validation.
-        Verifies that empty or non-string usernames raise exceptions.
+        Test validation of the `username` attribute.
+
+        Ensures that empty or non-string usernames raise exceptions.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the username is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             Oracle(username='')
@@ -51,16 +75,28 @@ class TestConfigOracle(TestCase):
 
     async def testPasswordValidation(self):
         """
-        Test password attribute validation.
-        Verifies that non-string passwords raise exceptions.
+        Test validation of the `password` attribute.
+
+        Ensures that non-string passwords raise exceptions.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the password is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             Oracle(password=123)
 
     async def testHostValidation(self):
         """
-        Test host attribute validation when not using DSN/TNS.
-        Verifies that empty or non-string hosts raise exceptions.
+        Test validation of the `host` attribute when not using DSN/TNS.
+
+        Ensures that empty or non-string hosts raise exceptions.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the host is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             Oracle(host='', dsn=None, tns_name=None)
@@ -69,8 +105,14 @@ class TestConfigOracle(TestCase):
 
     async def testPortValidation(self):
         """
-        Test port attribute validation when not using DSN/TNS.
-        Verifies invalid port numbers raise exceptions.
+        Test validation of the `port` attribute when not using DSN/TNS.
+
+        Ensures that invalid port numbers raise exceptions.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the port is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             Oracle(port=0, dsn=None, tns_name=None)
@@ -81,8 +123,14 @@ class TestConfigOracle(TestCase):
 
     async def testServiceNameAndSidValidation(self):
         """
-        Test service_name and sid validation when not using DSN/TNS.
-        Verifies at least one of service_name or sid is required.
+        Test validation of `service_name` and `sid` attributes when not using DSN/TNS.
+
+        Ensures that at least one of `service_name` or `sid` is required.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If both `service_name` and `sid` are missing.
         """
         # Test with neither service_name nor sid
         with self.assertRaises(OrionisIntegrityException):
@@ -102,8 +150,14 @@ class TestConfigOracle(TestCase):
 
     async def testDsnValidation(self):
         """
-        Test dsn attribute validation.
-        Verifies that dsn must be non-empty string or None.
+        Test validation of the `dsn` attribute.
+
+        Ensures that `dsn` must be a non-empty string or None.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the dsn is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             Oracle(dsn='')
@@ -114,8 +168,14 @@ class TestConfigOracle(TestCase):
 
     async def testTnsNameValidation(self):
         """
-        Test tns_name attribute validation.
-        Verifies that tns_name must be non-empty string or None.
+        Test validation of the `tns_name` attribute.
+
+        Ensures that `tns_name` must be a non-empty string or None.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the tns_name is invalid.
         """
         with self.assertRaises(OrionisIntegrityException):
             Oracle(tns_name='')
@@ -126,8 +186,14 @@ class TestConfigOracle(TestCase):
 
     async def testEncodingValidation(self):
         """
-        Test encoding attribute validation.
-        Verifies enum conversion and invalid value handling.
+        Test validation of the `encoding` attribute.
+
+        Ensures correct enum conversion and invalid value handling.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the encoding value is invalid.
         """
         # Test enum assignment
         oracle = Oracle(encoding=OracleEncoding.WE8ISO8859P1)
@@ -139,8 +205,14 @@ class TestConfigOracle(TestCase):
 
     async def testNencodingValidation(self):
         """
-        Test nencoding attribute validation.
-        Verifies enum conversion and invalid value handling.
+        Test validation of the `nencoding` attribute.
+
+        Ensures correct enum conversion and invalid value handling.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the nencoding value is invalid.
         """
         # Test string conversion
         oracle = Oracle(nencoding='EE8MSWIN1250')
@@ -156,8 +228,14 @@ class TestConfigOracle(TestCase):
 
     async def testToDictMethod(self):
         """
-        Test that toDict returns proper dictionary representation.
-        Verifies all attributes are correctly included in dictionary.
+        Test the `toDict` method for dictionary representation.
+
+        Ensures that all attributes are correctly included in the dictionary.
+
+        Raises
+        ------
+        AssertionError
+            If any attribute is missing or incorrect in the dictionary.
         """
         oracle = Oracle()
         oracle_dict = oracle.toDict()
@@ -176,8 +254,14 @@ class TestConfigOracle(TestCase):
 
     async def testConnectionMethods(self):
         """
-        Test that different connection methods are properly handled.
-        Verifies that either DSN, TNS, or host/port/service/sid combinations work.
+        Test handling of different Oracle connection methods.
+
+        Ensures that DSN, TNS, or host/port/service/sid combinations are valid.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If a valid connection method raises an exception.
         """
         # Test DSN connection
         try: