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

tests/foundation/config/database/test_database_pgsql.py

@@ -0,0 +1,187 @@
+from orionis.luminate.foundation.config.database.entities.pgsql import PGSQL
+from orionis.luminate.foundation.config.database.enums.pgsql_charsets import PGSQLCharset
+from orionis.luminate.foundation.config.database.enums.pgsql_mode import PGSQLSSLMode
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigPGSQL(TestCase):
+    """
+    Test cases for the PGSQL database configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that PGSQL instance is created with correct default values.
+        Verifies all default values match expected defaults from class definition.
+        """
+        pgsql = PGSQL()
+        self.assertEqual(pgsql.driver, 'pgsql')
+        self.assertEqual(pgsql.host, '127.0.0.1')
+        self.assertEqual(pgsql.port, '5432')
+        self.assertEqual(pgsql.database, 'orionis')
+        self.assertEqual(pgsql.username, 'root')
+        self.assertEqual(pgsql.password, '')
+        self.assertEqual(pgsql.charset, PGSQLCharset.UTF8.value)
+        self.assertEqual(pgsql.prefix, '')
+        self.assertTrue(pgsql.prefix_indexes)
+        self.assertEqual(pgsql.search_path, 'public')
+        self.assertEqual(pgsql.sslmode, PGSQLSSLMode.PREFER.value)
+
+    async def testDriverValidation(self):
+        """
+        Test driver attribute validation.
+        Verifies that empty or non-string drivers raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(driver='')
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(driver=123)
+
+    async def testHostValidation(self):
+        """
+        Test host attribute validation.
+        Verifies that empty or non-string hosts raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(host='')
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(host=123)
+
+    async def testPortValidation(self):
+        """
+        Test port attribute validation.
+        Verifies that non-numeric string ports raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(port='abc')
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(port=5432)  # Should be string
+
+    async def testDatabaseValidation(self):
+        """
+        Test database attribute validation.
+        Verifies that empty or non-string database names raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(database='')
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(database=123)
+
+    async def testUsernameValidation(self):
+        """
+        Test username attribute validation.
+        Verifies that empty or non-string usernames raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(username='')
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(username=123)
+
+    async def testPasswordValidation(self):
+        """
+        Test password attribute validation.
+        Verifies that non-string passwords raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(password=123)
+
+    async def testCharsetValidation(self):
+        """
+        Test charset attribute validation.
+        Verifies enum conversion and invalid value handling.
+        """
+        # Test string conversion
+        pgsql = PGSQL(charset='UTF8')
+        self.assertEqual(pgsql.charset, PGSQLCharset.UTF8.value)
+
+        # Test enum assignment
+        pgsql = PGSQL(charset=PGSQLCharset.LATIN1)
+        self.assertEqual(pgsql.charset, PGSQLCharset.LATIN1.value)
+
+        # Test invalid value
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(charset='INVALID')
+
+    async def testPrefixIndexesValidation(self):
+        """
+        Test prefix_indexes attribute validation.
+        Verifies that non-boolean values raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(prefix_indexes='true')
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(prefix_indexes=1)
+
+    async def testSearchPathValidation(self):
+        """
+        Test search_path attribute validation.
+        Verifies that empty or non-string search paths raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(search_path='')
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(search_path=123)
+
+    async def testSSLModeValidation(self):
+        """
+        Test sslmode attribute validation.
+        Verifies enum conversion and invalid value handling.
+        """
+        # Test string conversion
+        pgsql = PGSQL(sslmode='REQUIRE')
+        self.assertEqual(pgsql.sslmode, PGSQLSSLMode.REQUIRE.value)
+
+        # Test enum assignment
+        pgsql = PGSQL(sslmode=PGSQLSSLMode.DISABLE)
+        self.assertEqual(pgsql.sslmode, PGSQLSSLMode.DISABLE.value)
+
+        # Test invalid value
+        with self.assertRaises(OrionisIntegrityException):
+            PGSQL(sslmode='INVALID')
+
+    async def testToDictMethod(self):
+        """
+        Test that toDict returns proper dictionary representation.
+        Verifies all attributes are correctly included in dictionary.
+        """
+        pgsql = PGSQL()
+        pgsql_dict = pgsql.toDict()
+        self.assertEqual(pgsql_dict['driver'], 'pgsql')
+        self.assertEqual(pgsql_dict['host'], '127.0.0.1')
+        self.assertEqual(pgsql_dict['port'], '5432')
+        self.assertEqual(pgsql_dict['database'], 'orionis')
+        self.assertEqual(pgsql_dict['username'], 'root')
+        self.assertEqual(pgsql_dict['password'], '')
+        self.assertEqual(pgsql_dict['charset'], PGSQLCharset.UTF8.value)
+        self.assertEqual(pgsql_dict['prefix'], '')
+        self.assertTrue(pgsql_dict['prefix_indexes'])
+        self.assertEqual(pgsql_dict['search_path'], 'public')
+        self.assertEqual(pgsql_dict['sslmode'], PGSQLSSLMode.PREFER.value)
+
+    async def testCustomValues(self):
+        """
+        Test that custom values are properly stored and validated.
+        Verifies custom configuration values are correctly handled.
+        """
+        custom_pgsql = PGSQL(
+            host='db.example.com',
+            port='6432',
+            database='custom_db',
+            username='admin',
+            password='secure123',
+            charset='LATIN1',
+            prefix='app_',
+            prefix_indexes=False,
+            search_path='app_schema',
+            sslmode='VERIFY_FULL'
+        )
+        self.assertEqual(custom_pgsql.host, 'db.example.com')
+        self.assertEqual(custom_pgsql.port, '6432')
+        self.assertEqual(custom_pgsql.database, 'custom_db')
+        self.assertEqual(custom_pgsql.username, 'admin')
+        self.assertEqual(custom_pgsql.password, 'secure123')
+        self.assertEqual(custom_pgsql.charset, PGSQLCharset.LATIN1.value)
+        self.assertEqual(custom_pgsql.prefix, 'app_')
+        self.assertFalse(custom_pgsql.prefix_indexes)
+        self.assertEqual(custom_pgsql.search_path, 'app_schema')
+        self.assertEqual(custom_pgsql.sslmode, PGSQLSSLMode.VERIFY_FULL.value)

tests/foundation/config/database/test_database_sqlite.py

@@ -0,0 +1,153 @@
+from orionis.luminate.foundation.config.database.entities.sqlite import SQLite
+from orionis.luminate.foundation.config.database.enums.sqlite_foreign_key import SQLiteForeignKey
+from orionis.luminate.foundation.config.database.enums.sqlite_journal import SQLiteJournalMode
+from orionis.luminate.foundation.config.database.enums.sqlite_synchronous import SQLiteSynchronous
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigSQLite(TestCase):
+    """
+    Test cases for the SQLite database configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that SQLite instance is created with correct default values.
+        Verifies all default values match expected defaults from class definition.
+        """
+        sqlite = SQLite()
+        self.assertEqual(sqlite.driver, 'sqlite')
+        self.assertTrue(sqlite.url.startswith('sqlite:///'))
+        self.assertEqual(sqlite.database, 'database.sqlite')
+        self.assertEqual(sqlite.prefix, '')
+        self.assertEqual(sqlite.foreign_key_constraints, SQLiteForeignKey.OFF.value)
+        self.assertEqual(sqlite.busy_timeout, 5000)
+        self.assertEqual(sqlite.journal_mode, SQLiteJournalMode.DELETE.value)
+        self.assertEqual(sqlite.synchronous, SQLiteSynchronous.NORMAL.value)
+
+    async def testDriverValidation(self):
+        """
+        Test driver attribute validation.
+        Verifies that empty or non-string drivers raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            SQLite(driver='')
+        with self.assertRaises(OrionisIntegrityException):
+            SQLite(driver=123)
+
+    async def testUrlValidation(self):
+        """
+        Test URL attribute validation.
+        Verifies that empty or non-string URLs raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            SQLite(url='')
+        with self.assertRaises(OrionisIntegrityException):
+            SQLite(url=123)
+
+    async def testDatabaseValidation(self):
+        """
+        Test database attribute validation.
+        Verifies that empty or non-string database paths raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            SQLite(database='')
+        with self.assertRaises(OrionisIntegrityException):
+            SQLite(database=123)
+
+    async def testForeignKeyConstraintsValidation(self):
+        """
+        Test foreign_key_constraints attribute validation.
+        Verifies enum conversion and invalid value handling.
+        """
+        # Test string conversion
+        sqlite = SQLite(foreign_key_constraints='ON')
+        self.assertEqual(sqlite.foreign_key_constraints, SQLiteForeignKey.ON.value)
+
+        # Test enum assignment
+        sqlite = SQLite(foreign_key_constraints=SQLiteForeignKey.OFF)
+        self.assertEqual(sqlite.foreign_key_constraints, SQLiteForeignKey.OFF.value)
+
+        # Test invalid value
+        with self.assertRaises(OrionisIntegrityException):
+            SQLite(foreign_key_constraints='INVALID')
+
+    async def testBusyTimeoutValidation(self):
+        """
+        Test busy_timeout attribute validation.
+        Verifies non-negative integer requirement.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            SQLite(busy_timeout=-1)
+        with self.assertRaises(OrionisIntegrityException):
+            SQLite(busy_timeout='invalid')
+
+    async def testJournalModeValidation(self):
+        """
+        Test journal_mode attribute validation.
+        Verifies enum conversion and invalid value handling.
+        """
+        # Test string conversion
+        sqlite = SQLite(journal_mode='WAL')
+        self.assertEqual(sqlite.journal_mode, SQLiteJournalMode.WAL.value)
+
+        # Test enum assignment
+        sqlite = SQLite(journal_mode=SQLiteJournalMode.TRUNCATE)
+        self.assertEqual(sqlite.journal_mode, SQLiteJournalMode.TRUNCATE.value)
+
+        # Test invalid value
+        with self.assertRaises(OrionisIntegrityException):
+            SQLite(journal_mode='INVALID')
+
+    async def testSynchronousValidation(self):
+        """
+        Test synchronous attribute validation.
+        Verifies enum conversion and invalid value handling.
+        """
+        # Test string conversion
+        sqlite = SQLite(synchronous='FULL')
+        self.assertEqual(sqlite.synchronous, SQLiteSynchronous.FULL.value)
+
+        # Test enum assignment
+        sqlite = SQLite(synchronous=SQLiteSynchronous.OFF)
+        self.assertEqual(sqlite.synchronous, SQLiteSynchronous.OFF.value)
+
+        # Test invalid value
+        with self.assertRaises(OrionisIntegrityException):
+            SQLite(synchronous='INVALID')
+
+    async def testToDictMethod(self):
+        """
+        Test that toDict returns proper dictionary representation.
+        Verifies all attributes are correctly included in dictionary.
+        """
+        sqlite = SQLite()
+        sqlite_dict = sqlite.toDict()
+        self.assertEqual(sqlite_dict['driver'], 'sqlite')
+        self.assertTrue(sqlite_dict['url'].startswith('sqlite:///'))
+        self.assertEqual(sqlite_dict['database'], 'database.sqlite')
+        self.assertEqual(sqlite_dict['prefix'], '')
+        self.assertEqual(sqlite_dict['foreign_key_constraints'], SQLiteForeignKey.OFF.value)
+        self.assertEqual(sqlite_dict['busy_timeout'], 5000)
+        self.assertEqual(sqlite_dict['journal_mode'], SQLiteJournalMode.DELETE.value)
+        self.assertEqual(sqlite_dict['synchronous'], SQLiteSynchronous.NORMAL.value)
+
+    async def testCustomValues(self):
+        """
+        Test that custom values are properly stored and validated.
+        Verifies custom configuration values are correctly handled.
+        """
+        custom_sqlite = SQLite(
+            database='custom.db',
+            prefix='app_',
+            foreign_key_constraints='ON',
+            busy_timeout=10000,
+            journal_mode='MEMORY',
+            synchronous='OFF'
+        )
+        self.assertEqual(custom_sqlite.database, 'custom.db')
+        self.assertEqual(custom_sqlite.prefix, 'app_')
+        self.assertEqual(custom_sqlite.foreign_key_constraints, SQLiteForeignKey.ON.value)
+        self.assertEqual(custom_sqlite.busy_timeout, 10000)
+        self.assertEqual(custom_sqlite.journal_mode, SQLiteJournalMode.MEMORY.value)
+        self.assertEqual(custom_sqlite.synchronous, SQLiteSynchronous.OFF.value)

tests/foundation/config/exceptions/test_exceptions_integrity.py

@@ -0,0 +1,83 @@
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestOrionisIntegrityException(TestCase):
+    """
+    Test cases for the OrionisIntegrityException class.
+    """
+
+    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_msg = "Test integrity violation message"
+        exception = OrionisIntegrityException(test_msg)
+        self.assertEqual(str(exception), f"OrionisIntegrityException: {test_msg}")
+        self.assertEqual(exception.args[0], test_msg)
+
+    async def testExceptionInheritance(self):
+        """
+        Test that OrionisIntegrityException properly inherits from Exception.
+        Verifies the exception hierarchy is correctly implemented.
+        """
+        exception = OrionisIntegrityException("Test")
+        self.assertIsInstance(exception, Exception)
+        self.assertTrue(issubclass(OrionisIntegrityException, Exception))
+
+    async def testExceptionStringRepresentation(self):
+        """
+        Test the string representation of OrionisIntegrityException.
+        Verifies the __str__ method returns the expected format.
+        """
+        test_msg = "Configuration validation failed"
+        exception = OrionisIntegrityException(test_msg)
+        self.assertEqual(str(exception), f"OrionisIntegrityException: {test_msg}")
+
+    async def testExceptionWithEmptyMessage(self):
+        """
+        Test OrionisIntegrityException with an empty message.
+        Verifies the exception handles empty messages correctly.
+        """
+        exception = OrionisIntegrityException("")
+        self.assertEqual(str(exception), "OrionisIntegrityException: ")
+
+    async def testExceptionWithNonStringMessage(self):
+        """
+        Test OrionisIntegrityException with non-string message types.
+        Verifies the exception converts non-string messages to strings.
+        """
+        # Test with integer
+        exception = OrionisIntegrityException(123)
+        self.assertEqual(str(exception), "OrionisIntegrityException: 123")
+
+        # Test with list
+        exception = OrionisIntegrityException(["error1", "error2"])
+        self.assertEqual(str(exception), "OrionisIntegrityException: ['error1', 'error2']")
+
+    async def testExceptionRaiseAndCatch(self):
+        """
+        Test raising and catching OrionisIntegrityException.
+        Verifies the exception can be properly raised and caught.
+        """
+        test_msg = "Test exception handling"
+        try:
+            raise OrionisIntegrityException(test_msg)
+        except OrionisIntegrityException as e:
+            self.assertEqual(str(e), f"OrionisIntegrityException: {test_msg}")
+        except Exception:
+            self.fail("OrionisIntegrityException should be caught by its specific handler")
+
+    async def testExceptionChaining(self):
+        """
+        Test exception chaining with OrionisIntegrityException.
+        Verifies the exception works correctly in chained exception scenarios.
+        """
+        try:
+            try:
+                raise ValueError("Original error")
+            except ValueError as ve:
+                raise OrionisIntegrityException("Wrapper error") from ve
+        except OrionisIntegrityException as oe:
+            self.assertIsInstance(oe.__cause__, ValueError)
+            self.assertEqual(str(oe.__cause__), "Original error")

tests/foundation/config/filesystems/test_filesystems.py

@@ -0,0 +1,110 @@
+from orionis.luminate.foundation.config.filesystems.entitites.disks import Disks
+from orionis.luminate.foundation.config.filesystems.entitites.filesystems import Filesystems
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigFilesystems(TestCase):
+    """
+    Test cases for the Filesystems configuration class.
+    """
+
+    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.
+        """
+        fs = Filesystems()
+        self.assertEqual(fs.default, "local")
+        self.assertIsInstance(fs.disks, Disks)
+
+    async def testDefaultDiskValidation(self):
+        """
+        Test default disk attribute validation.
+        Verifies that only valid disk types are accepted as default.
+        """
+        # Test valid disk types
+        valid_disks = ["local", "public", "aws"]
+        for disk in valid_disks:
+            try:
+                Filesystems(default=disk)
+            except OrionisIntegrityException:
+                self.fail(f"Valid disk type '{disk}' should not raise exception")
+
+        # Test invalid disk type
+        with self.assertRaises(OrionisIntegrityException):
+            Filesystems(default="invalid_disk")
+
+        # Test empty default
+        with self.assertRaises(OrionisIntegrityException):
+            Filesystems(default="")
+
+        # Test non-string default
+        with self.assertRaises(OrionisIntegrityException):
+            Filesystems(default=123)
+
+    async def testDisksValidation(self):
+        """
+        Test disks attribute validation.
+        Verifies that only Disks instances are accepted.
+        """
+        # Test invalid disks type
+        with self.assertRaises(OrionisIntegrityException):
+            Filesystems(disks="not_a_disks_instance")
+
+        # Test None disks
+        with self.assertRaises(OrionisIntegrityException):
+            Filesystems(disks=None)
+
+        # Test valid disks
+        try:
+            Filesystems(disks=Disks())
+        except OrionisIntegrityException:
+            self.fail("Valid Disks instance should not raise exception")
+
+    async def testToDictMethod(self):
+        """
+        Test that toDict returns proper dictionary representation.
+        Verifies all attributes are correctly included in dictionary.
+        """
+        fs = Filesystems()
+        fs_dict = fs.toDict()
+
+        self.assertIsInstance(fs_dict, dict)
+        self.assertEqual(fs_dict['default'], "local")
+        self.assertIsInstance(fs_dict['disks'], dict)
+
+    async def testCustomValues(self):
+        """
+        Test that custom values are properly stored and validated.
+        Verifies custom configurations are correctly handled.
+        """
+        custom_disks = Disks()
+        custom_fs = Filesystems(
+            default="aws",
+            disks=custom_disks
+        )
+        self.assertEqual(custom_fs.default, "aws")
+        self.assertIs(custom_fs.disks, custom_disks)
+
+    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.
+        """
+        fs1 = Filesystems()
+        fs2 = Filesystems()
+        fs_set = {fs1, fs2}
+
+        self.assertEqual(len(fs_set), 1)
+
+        custom_fs = Filesystems(default="public")
+        fs_set.add(custom_fs)
+        self.assertEqual(len(fs_set), 2)
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that Filesystems enforces keyword-only initialization.
+        Verifies that positional arguments are not allowed for initialization.
+        """
+        with self.assertRaises(TypeError):
+            Filesystems("local", Disks())

tests/foundation/config/filesystems/test_filesystems_aws.py

@@ -0,0 +1,133 @@
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.luminate.foundation.config.filesystems.entitites.aws import S3
+from orionis.unittesting import TestCase
+
+class TestConfigS3(TestCase):
+    """
+    Test cases for the S3 storage configuration class.
+    """
+
+    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()
+        self.assertEqual(s3.key, "")
+        self.assertEqual(s3.secret, "")
+        self.assertEqual(s3.region, "us-east-1")
+        self.assertEqual(s3.bucket, "")
+        self.assertIsNone(s3.url)
+        self.assertIsNone(s3.endpoint)
+        self.assertFalse(s3.use_path_style_endpoint)
+        self.assertFalse(s3.throw)
+
+    async def testRequiredFieldValidation(self):
+        """
+        Test validation of required fields.
+        Verifies that region must be a non-empty string.
+        """
+        # Test empty region
+        with self.assertRaises(OrionisIntegrityException):
+            S3(region="")
+
+        # Test non-string region
+        with self.assertRaises(OrionisIntegrityException):
+            S3(region=123)
+
+    async def testOptionalFieldValidation(self):
+        """
+        Test validation of optional fields.
+        Verifies that optional fields accept None or proper types.
+        """
+        # Valid optional configurations
+        try:
+            S3(url=None, endpoint=None)
+            S3(url="https://example.com", endpoint="https://s3.example.com")
+        except OrionisIntegrityException:
+            self.fail("Valid optional configurations should not raise exceptions")
+
+        # Invalid optional configurations
+        with self.assertRaises(OrionisIntegrityException):
+            S3(url=123)
+        with self.assertRaises(OrionisIntegrityException):
+            S3(endpoint=[])
+
+    async def testBooleanFieldValidation(self):
+        """
+        Test validation of boolean fields.
+        Verifies that boolean fields only accept boolean values.
+        """
+        # Test use_path_style_endpoint
+        with self.assertRaises(OrionisIntegrityException):
+            S3(use_path_style_endpoint="true")
+
+        # Test throw
+        with self.assertRaises(OrionisIntegrityException):
+            S3(throw=1)
+
+    async def testCustomValues(self):
+        """
+        Test that custom values are properly stored and validated.
+        Verifies custom configuration values are correctly handled.
+        """
+        custom_s3 = S3(
+            key="AKIAEXAMPLE",
+            secret="secret123",
+            region="eu-west-1",
+            bucket="my-bucket",
+            url="https://my-bucket.s3.amazonaws.com",
+            endpoint="https://s3.eu-west-1.amazonaws.com",
+            use_path_style_endpoint=True,
+            throw=True
+        )
+
+        self.assertEqual(custom_s3.key, "AKIAEXAMPLE")
+        self.assertEqual(custom_s3.secret, "secret123")
+        self.assertEqual(custom_s3.region, "eu-west-1")
+        self.assertEqual(custom_s3.bucket, "my-bucket")
+        self.assertEqual(custom_s3.url, "https://my-bucket.s3.amazonaws.com")
+        self.assertEqual(custom_s3.endpoint, "https://s3.eu-west-1.amazonaws.com")
+        self.assertTrue(custom_s3.use_path_style_endpoint)
+        self.assertTrue(custom_s3.throw)
+
+    async def testToDictMethod(self):
+        """
+        Test that toDict returns proper dictionary representation.
+        Verifies all attributes are correctly included in dictionary.
+        """
+        s3 = S3()
+        s3_dict = s3.toDict()
+
+        self.assertIsInstance(s3_dict, dict)
+        self.assertEqual(s3_dict['key'], "")
+        self.assertEqual(s3_dict['secret'], "")
+        self.assertEqual(s3_dict['region'], "us-east-1")
+        self.assertEqual(s3_dict['bucket'], "")
+        self.assertIsNone(s3_dict['url'])
+        self.assertIsNone(s3_dict['endpoint'])
+        self.assertFalse(s3_dict['use_path_style_endpoint'])
+        self.assertFalse(s3_dict['throw'])
+
+    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.
+        """
+        s3_1 = S3()
+        s3_2 = S3()
+        s3_set = {s3_1, s3_2}
+
+        self.assertEqual(len(s3_set), 1)
+
+        custom_s3 = S3(bucket="custom-bucket")
+        s3_set.add(custom_s3)
+        self.assertEqual(len(s3_set), 2)
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that S3 enforces keyword-only initialization.
+        Verifies that positional arguments are not allowed for initialization.
+        """
+        with self.assertRaises(TypeError):
+            S3("key", "secret", "region")  # Should fail as it requires keyword arguments