orionis 0.253.0__py3-none-any.whl → 0.266.0__py3-none-any.whl

tests/foundation/config/database/test_database_connections.py

@@ -0,0 +1,129 @@
+from orionis.luminate.foundation.config.database.entities.connections import Connections
+from orionis.luminate.foundation.config.database.entities.mysql import MySQL
+from orionis.luminate.foundation.config.database.entities.oracle import Oracle
+from orionis.luminate.foundation.config.database.entities.pgsql import PGSQL
+from orionis.luminate.foundation.config.database.entities.sqlite import SQLite
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigConnections(TestCase):
+    """
+    Test cases for the Connections configuration class.
+    """
+
+    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.
+        """
+        connections = Connections()
+        self.assertIsInstance(connections.sqlite, SQLite)
+        self.assertIsInstance(connections.mysql, MySQL)
+        self.assertIsInstance(connections.pgsql, PGSQL)
+        self.assertIsInstance(connections.oracle, Oracle)
+
+    async def testSqliteTypeValidation(self):
+        """
+        Test sqlite attribute type validation.
+        Verifies that only SQLite instances are accepted for sqlite attribute.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Connections(sqlite="not_a_sqlite_instance")
+        with self.assertRaises(OrionisIntegrityException):
+            Connections(sqlite=123)
+        with self.assertRaises(OrionisIntegrityException):
+            Connections(sqlite=None)
+
+    async def testMysqlTypeValidation(self):
+        """
+        Test mysql attribute type validation.
+        Verifies that only MySQL instances are accepted for mysql attribute.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Connections(mysql="not_a_mysql_instance")
+        with self.assertRaises(OrionisIntegrityException):
+            Connections(mysql=123)
+        with self.assertRaises(OrionisIntegrityException):
+            Connections(mysql=None)
+
+    async def testPgsqlTypeValidation(self):
+        """
+        Test pgsql attribute type validation.
+        Verifies that only PGSQL instances are accepted for pgsql attribute.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Connections(pgsql="not_a_pgsql_instance")
+        with self.assertRaises(OrionisIntegrityException):
+            Connections(pgsql=123)
+        with self.assertRaises(OrionisIntegrityException):
+            Connections(pgsql=None)
+
+    async def testOracleTypeValidation(self):
+        """
+        Test oracle attribute type validation.
+        Verifies that only Oracle instances are accepted for oracle attribute.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Connections(oracle="not_an_oracle_instance")
+        with self.assertRaises(OrionisIntegrityException):
+            Connections(oracle=123)
+        with self.assertRaises(OrionisIntegrityException):
+            Connections(oracle=None)
+
+    async def testToDictMethod(self):
+        """
+        Test that toDict returns proper dictionary representation.
+        Verifies all connections are correctly included in dictionary.
+        """
+        connections = Connections()
+        connections_dict = connections.toDict()
+        self.assertIsInstance(connections_dict, dict)
+        self.assertIsInstance(connections_dict['sqlite'], dict)
+        self.assertIsInstance(connections_dict['mysql'], dict)
+        self.assertIsInstance(connections_dict['pgsql'], dict)
+        self.assertIsInstance(connections_dict['oracle'], dict)
+
+    async def testCustomConnections(self):
+        """
+        Test that custom connections are properly stored and validated.
+        Verifies custom connection configurations are correctly handled.
+        """
+        custom_sqlite = SQLite(database='custom.db')
+        custom_mysql = MySQL(database='custom_db')
+        custom_pgsql = PGSQL(database='custom_db')
+        custom_oracle = Oracle(service_name='CUSTOM_SID')
+
+        connections = Connections(
+            sqlite=custom_sqlite,
+            mysql=custom_mysql,
+            pgsql=custom_pgsql,
+            oracle=custom_oracle
+        )
+
+        self.assertEqual(connections.sqlite.database, 'custom.db')
+        self.assertEqual(connections.mysql.database, 'custom_db')
+        self.assertEqual(connections.pgsql.database, 'custom_db')
+        self.assertEqual(connections.oracle.service_name, 'CUSTOM_SID')
+
+    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.
+        """
+        conn1 = Connections()
+        conn2 = Connections()
+        conn_set = {conn1, conn2}
+
+        self.assertEqual(len(conn_set), 1)
+
+        custom_conn = Connections(sqlite=SQLite(database='custom.db'))
+        conn_set.add(custom_conn)
+        self.assertEqual(len(conn_set), 2)
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that Connections enforces keyword-only initialization.
+        Verifies that positional arguments are not allowed for initialization.
+        """
+        with self.assertRaises(TypeError):
+            Connections(SQLite(), MySQL(), PGSQL(), Oracle())

tests/foundation/config/database/test_database_mysql.py

@@ -0,0 +1,231 @@
+from orionis.luminate.foundation.config.database.entities.mysql import MySQL
+from orionis.luminate.foundation.config.database.enums.mysql_charsets import MySQLCharset
+from orionis.luminate.foundation.config.database.enums.mysql_collations import MySQLCollation
+from orionis.luminate.foundation.config.database.enums.mysql_engine import MySQLEngine
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigMySQL(TestCase):
+    """
+    Test cases for the MySQL database configuration class.
+    """
+
+    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()
+        self.assertEqual(mysql.driver, 'mysql')
+        self.assertEqual(mysql.host, '127.0.0.1')
+        self.assertEqual(mysql.port, 3306)
+        self.assertEqual(mysql.database, 'orionis')
+        self.assertEqual(mysql.username, 'root')
+        self.assertEqual(mysql.password, '')
+        self.assertEqual(mysql.unix_socket, '')
+        self.assertEqual(mysql.charset, MySQLCharset.UTF8MB4.value)
+        self.assertEqual(mysql.collation, MySQLCollation.UTF8MB4_UNICODE_CI.value)
+        self.assertEqual(mysql.prefix, '')
+        self.assertTrue(mysql.prefix_indexes)
+        self.assertTrue(mysql.strict)
+        self.assertEqual(mysql.engine, MySQLEngine.INNODB.value)
+
+    async def testDriverValidation(self):
+        """
+        Test driver attribute validation.
+        Verifies that only 'mysql' value is accepted for driver.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(driver='')
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(driver='postgres')
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(driver=123)
+
+    async def testHostValidation(self):
+        """
+        Test host attribute validation.
+        Verifies that empty or non-string hosts raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(host='')
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(host=123)
+
+    async def testPortValidation(self):
+        """
+        Test port attribute validation.
+        Verifies invalid port numbers raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(port=0)
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(port=65536)
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(port='3306')
+
+    async def testDatabaseValidation(self):
+        """
+        Test database attribute validation.
+        Verifies that empty or non-string database names raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(database='')
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(database=123)
+
+    async def testUsernameValidation(self):
+        """
+        Test username attribute validation.
+        Verifies that empty or non-string usernames raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(username='')
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(username=123)
+
+    async def testPasswordValidation(self):
+        """
+        Test password attribute validation.
+        Verifies that non-string passwords raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(password=123)
+
+    async def testUnixSocketValidation(self):
+        """
+        Test unix_socket attribute validation.
+        Verifies that non-string socket paths raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(unix_socket=123)
+
+    async def testCharsetValidation(self):
+        """
+        Test charset attribute validation.
+        Verifies enum conversion and invalid value handling.
+        """
+        # Test string conversion
+        mysql = MySQL(charset='UTF8')
+        self.assertEqual(mysql.charset, MySQLCharset.UTF8.value)
+        # Test enum assignment
+        mysql = MySQL(charset=MySQLCharset.LATIN1)
+        self.assertEqual(mysql.charset, MySQLCharset.LATIN1.value)
+
+        # Test invalid value
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(charset='INVALID')
+
+    async def testCollationValidation(self):
+        """
+        Test collation attribute validation.
+        Verifies enum conversion and invalid value handling.
+        """
+        # Test string conversion
+        mysql = MySQL(collation='UTF8_GENERAL_CI')
+        self.assertEqual(mysql.collation, MySQLCollation.UTF8_GENERAL_CI.value)
+        # Test enum assignment
+        mysql = MySQL(collation=MySQLCollation.UTF8MB4_BIN)
+        self.assertEqual(mysql.collation, MySQLCollation.UTF8MB4_BIN.value)
+
+        # Test invalid value
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(collation='INVALID')
+
+    async def testPrefixValidation(self):
+        """
+        Test prefix attribute validation.
+        Verifies that non-string prefixes raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(prefix=123)
+
+    async def testPrefixIndexesValidation(self):
+        """
+        Test prefix_indexes attribute validation.
+        Verifies that non-boolean values raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(prefix_indexes='true')
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(prefix_indexes=1)
+
+    async def testStrictValidation(self):
+        """
+        Test strict attribute validation.
+        Verifies that non-boolean values raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(strict='true')
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(strict=1)
+
+    async def testEngineValidation(self):
+        """
+        Test engine attribute validation.
+        Verifies enum conversion and invalid value handling.
+        """
+        # Test string conversion
+        mysql = MySQL(engine='MYISAM')
+        self.assertEqual(mysql.engine, MySQLEngine.MYISAM.value)
+
+        # Test enum assignment
+        mysql = MySQL(engine=MySQLEngine.MEMORY)
+        self.assertEqual(mysql.engine, MySQLEngine.MEMORY.value)
+
+        # Test invalid value
+        with self.assertRaises(OrionisIntegrityException):
+            MySQL(engine='INVALID')
+
+    async def testToDictMethod(self):
+        """
+        Test that toDict returns proper dictionary representation.
+        Verifies all attributes are correctly included in dictionary.
+        """
+        mysql = MySQL()
+        mysql_dict = mysql.toDict()
+        self.assertEqual(mysql_dict['driver'], 'mysql')
+        self.assertEqual(mysql_dict['host'], '127.0.0.1')
+        self.assertEqual(mysql_dict['port'], 3306)
+        self.assertEqual(mysql_dict['database'], 'orionis')
+        self.assertEqual(mysql_dict['username'], 'root')
+        self.assertEqual(mysql_dict['password'], '')
+        self.assertEqual(mysql_dict['unix_socket'], '')
+        self.assertEqual(mysql_dict['charset'], MySQLCharset.UTF8MB4.value)
+        self.assertEqual(mysql_dict['collation'], MySQLCollation.UTF8MB4_UNICODE_CI.value)
+        self.assertEqual(mysql_dict['prefix'], '')
+        self.assertTrue(mysql_dict['prefix_indexes'])
+        self.assertTrue(mysql_dict['strict'])
+        self.assertEqual(mysql_dict['engine'], MySQLEngine.INNODB.value)
+
+    async def testCustomValues(self):
+        """
+        Test that custom values are properly stored and validated.
+        Verifies custom configuration values are correctly handled.
+        """
+        custom_mysql = MySQL(
+            host='db.example.com',
+            port=3307,
+            database='custom_db',
+            username='admin',
+            password='secure123',
+            unix_socket='/var/run/mysqld/mysqld.sock',
+            charset='LATIN1',
+            collation='LATIN1_GENERAL_CI',
+            prefix='app_',
+            prefix_indexes=False,
+            strict=False,
+            engine='MEMORY'
+        )
+        self.assertEqual(custom_mysql.host, 'db.example.com')
+        self.assertEqual(custom_mysql.port, 3307)
+        self.assertEqual(custom_mysql.database, 'custom_db')
+        self.assertEqual(custom_mysql.username, 'admin')
+        self.assertEqual(custom_mysql.password, 'secure123')
+        self.assertEqual(custom_mysql.unix_socket, '/var/run/mysqld/mysqld.sock')
+        self.assertEqual(custom_mysql.charset, MySQLCharset.LATIN1.value)
+        self.assertEqual(custom_mysql.collation, MySQLCollation.LATIN1_GENERAL_CI.value)
+        self.assertEqual(custom_mysql.prefix, 'app_')
+        self.assertFalse(custom_mysql.prefix_indexes)
+        self.assertFalse(custom_mysql.strict)
+        self.assertEqual(custom_mysql.engine, MySQLEngine.MEMORY.value)

tests/foundation/config/database/test_database_oracle.py

@@ -0,0 +1,204 @@
+from orionis.luminate.foundation.config.database.entities.oracle import Oracle
+from orionis.luminate.foundation.config.database.enums.oracle_encoding import OracleEncoding
+from orionis.luminate.foundation.config.database.enums.oracle_nencoding import OracleNencoding
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigOracle(TestCase):
+    """
+    Test cases for the Oracle database configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that Oracle instance is created with correct default values.
+        Verifies all default values match expected defaults from class definition.
+        """
+        oracle = Oracle()
+        self.assertEqual(oracle.driver, 'oracle')
+        self.assertEqual(oracle.username, 'sys')
+        self.assertEqual(oracle.password, '')
+        self.assertEqual(oracle.host, 'localhost')
+        self.assertEqual(oracle.port, 1521)
+        self.assertEqual(oracle.service_name, 'ORCL')
+        self.assertIsNone(oracle.sid)
+        self.assertIsNone(oracle.dsn)
+        self.assertIsNone(oracle.tns_name)
+        self.assertEqual(oracle.encoding, OracleEncoding.AL32UTF8.value)
+        self.assertEqual(oracle.nencoding, OracleNencoding.AL32UTF8.value)
+
+    async def testDriverValidation(self):
+        """
+        Test driver attribute validation.
+        Verifies that only 'oracle' value is accepted for driver.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(driver='')
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(driver='postgres')
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(driver=123)
+
+    async def testUsernameValidation(self):
+        """
+        Test username attribute validation.
+        Verifies that empty or non-string usernames raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(username='')
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(username=123)
+
+    async def testPasswordValidation(self):
+        """
+        Test password attribute validation.
+        Verifies that non-string passwords raise exceptions.
+        """
+        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.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(host='', dsn=None, tns_name=None)
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(host=123, dsn=None, tns_name=None)
+
+    async def testPortValidation(self):
+        """
+        Test port attribute validation when not using DSN/TNS.
+        Verifies invalid port numbers raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(port=0, dsn=None, tns_name=None)
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(port=65536, dsn=None, tns_name=None)
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(port='1521', dsn=None, tns_name=None)
+
+    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 with neither service_name nor sid
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(service_name=None, sid=None, dsn=None, tns_name=None)
+
+        # Test valid with service_name only
+        try:
+            Oracle(service_name='ORCL', sid=None, dsn=None, tns_name=None)
+        except OrionisIntegrityException:
+            self.fail("Valid service_name should not raise exception")
+
+        # Test valid with sid only
+        try:
+            Oracle(service_name=None, sid='XE', dsn=None, tns_name=None)
+        except OrionisIntegrityException:
+            self.fail("Valid sid should not raise exception")
+
+    async def testDsnValidation(self):
+        """
+        Test dsn attribute validation.
+        Verifies that dsn must be non-empty string or None.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(dsn='')
+        try:
+            Oracle(dsn='valid_dsn_string')
+        except OrionisIntegrityException:
+            self.fail("Valid dsn should not raise exception")
+
+    async def testTnsNameValidation(self):
+        """
+        Test tns_name attribute validation.
+        Verifies that tns_name must be non-empty string or None.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(tns_name='')
+        try:
+            Oracle(tns_name='valid_tns_name')
+        except OrionisIntegrityException:
+            self.fail("Valid tns_name should not raise exception")
+
+    async def testEncodingValidation(self):
+        """
+        Test encoding attribute validation.
+        Verifies enum conversion and invalid value handling.
+        """
+        # Test enum assignment
+        oracle = Oracle(encoding=OracleEncoding.WE8ISO8859P1)
+        self.assertEqual(oracle.encoding, OracleEncoding.WE8ISO8859P1.value)
+
+        # Test invalid value
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(encoding='INVALID')
+
+    async def testNencodingValidation(self):
+        """
+        Test nencoding attribute validation.
+        Verifies enum conversion and invalid value handling.
+        """
+        # Test string conversion
+        oracle = Oracle(nencoding='EE8MSWIN1250')
+        self.assertEqual(oracle.nencoding, OracleNencoding.EE8MSWIN1250.value)
+
+        # Test enum assignment
+        oracle = Oracle(nencoding=OracleNencoding.ZHS16GBK)
+        self.assertEqual(oracle.nencoding, OracleNencoding.ZHS16GBK.value)
+
+        # Test invalid value
+        with self.assertRaises(OrionisIntegrityException):
+            Oracle(nencoding='INVALID')
+
+    async def testToDictMethod(self):
+        """
+        Test that toDict returns proper dictionary representation.
+        Verifies all attributes are correctly included in dictionary.
+        """
+        oracle = Oracle()
+        oracle_dict = oracle.toDict()
+
+        self.assertEqual(oracle_dict['driver'], 'oracle')
+        self.assertEqual(oracle_dict['username'], 'sys')
+        self.assertEqual(oracle_dict['password'], '')
+        self.assertEqual(oracle_dict['host'], 'localhost')
+        self.assertEqual(oracle_dict['port'], 1521)
+        self.assertEqual(oracle_dict['service_name'], 'ORCL')
+        self.assertIsNone(oracle_dict['sid'])
+        self.assertIsNone(oracle_dict['dsn'])
+        self.assertIsNone(oracle_dict['tns_name'])
+        self.assertEqual(oracle_dict['encoding'], OracleEncoding.AL32UTF8.value)
+        self.assertEqual(oracle_dict['nencoding'], OracleNencoding.AL32UTF8.value)
+
+    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 DSN connection
+        try:
+            Oracle(dsn='valid_dsn', host=None, port=None, service_name=None, sid=None)
+        except OrionisIntegrityException:
+            self.fail("Valid DSN connection should not raise exception")
+
+        # Test TNS connection
+        try:
+            Oracle(tns_name='valid_tns', host=None, port=None, service_name=None, sid=None)
+        except OrionisIntegrityException:
+            self.fail("Valid TNS connection should not raise exception")
+
+        # Test host/port/service connection
+        try:
+            Oracle(dsn=None, tns_name=None, host='localhost', port=1521, service_name='ORCL')
+        except OrionisIntegrityException:
+            self.fail("Valid host/port/service connection should not raise exception")
+
+        # Test host/port/sid connection
+        try:
+            Oracle(dsn=None, tns_name=None, host='localhost', port=1521, sid='XE')
+        except OrionisIntegrityException:
+            self.fail("Valid host/port/sid connection should not raise exception")