orionis 0.545.0__py3-none-any.whl → 0.547.0__py3-none-any.whl

tests/foundation/config/database/test_foundation_config_database_sqlite.py

@@ -1,207 +0,0 @@
-from orionis.foundation.config.database.entities.sqlite import SQLite
-from orionis.foundation.config.database.enums.sqlite_foreign_key import SQLiteForeignKey
-from orionis.foundation.config.database.enums.sqlite_journal import SQLiteJournalMode
-from orionis.foundation.config.database.enums.sqlite_synchronous import SQLiteSynchronous
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigDatabaseSqlite(AsyncTestCase):
-    """
-    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.
-
-        Ensures all default values match expected defaults from the class definition.
-
-        Returns
-        -------
-        None
-        """
-        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.
-
-        Returns
-        -------
-        None
-        """
-        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.
-
-        Returns
-        -------
-        None
-        """
-        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.
-
-        Returns
-        -------
-        None
-        """
-        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.
-
-        Returns
-        -------
-        None
-        """
-        # 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.
-
-        Returns
-        -------
-        None
-        """
-        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.
-
-        Returns
-        -------
-        None
-        """
-        # 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.
-
-        Returns
-        -------
-        None
-        """
-        # 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 the dictionary.
-
-        Returns
-        -------
-        None
-        """
-        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.
-
-        Returns
-        -------
-        None
-        """
-        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/filesystems/test_foundation_config_filesystems.py

@@ -1,160 +0,0 @@
-from orionis.foundation.config.filesystems.entitites.disks import Disks
-from orionis.foundation.config.filesystems.entitites.filesystems import Filesystems
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigFilesystems(AsyncTestCase):
-    """
-    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 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")
-        self.assertIsInstance(fs.disks, Disks)
-
-    async def testDefaultDiskValidation(self):
-        """
-        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"]
-        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):
-        """
-        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):
-            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 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()
-
-        self.assertIsInstance(fs_dict, dict)
-        self.assertEqual(fs_dict['default'], "local")
-        self.assertIsInstance(fs_dict['disks'], dict)
-
-    async def testCustomValues(self):
-        """
-        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(
-            default="aws",
-            disks=custom_disks
-        )
-        self.assertEqual(custom_fs.default, "aws")
-        self.assertIs(custom_fs.disks, custom_disks)
-
-    async def testHashability(self):
-        """
-        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()
-        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 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_foundation_config_filesystems_aws.py

@@ -1,189 +0,0 @@
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.foundation.config.filesystems.entitites.aws import S3
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigFilesystemsAws(AsyncTestCase):
-    """
-    Unit tests for the S3 storage configuration entity.
-
-    This test class validates the behavior of the S3 configuration entity, including
-    default value assignment, field validation, custom value handling, dictionary
-    conversion, hashability, and enforcement of keyword-only initialization.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Validate default values of S3 configuration fields.
-
-        Ensures that a newly created S3 instance has the expected default values
-        for all attributes as defined in the class.
-
-        Returns
-        -------
-        None
-        """
-        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):
-        """
-        Validate required field constraints for S3 configuration.
-
-        Checks that the 'region' field must be a non-empty string and raises
-        OrionisIntegrityException if the constraint is violated.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If 'region' is empty or not a 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):
-        """
-        Validate optional field types for S3 configuration.
-
-        Ensures that optional fields accept None or valid types, and raises
-        OrionisIntegrityException for invalid types.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If optional fields are not of the correct type.
-        """
-        # 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):
-        """
-        Validate boolean field types for S3 configuration.
-
-        Ensures that boolean fields accept only boolean values and raises
-        OrionisIntegrityException for invalid types.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If boolean fields are not of type bool.
-        """
-        # 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):
-        """
-        Validate assignment and storage of custom values in S3 configuration.
-
-        Ensures that custom values provided during initialization are correctly
-        stored and validated in the S3 instance.
-
-        Returns
-        -------
-        None
-        """
-        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):
-        """
-        Validate dictionary conversion of S3 configuration.
-
-        Ensures that the toDict method returns a dictionary containing all
-        attributes of the S3 instance with correct values.
-
-        Returns
-        -------
-        None
-        """
-        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):
-        """
-        Validate hashability of S3 configuration instances.
-
-        Ensures that S3 instances are hashable and can be used in sets and as
-        dictionary keys due to unsafe_hash=True.
-
-        Returns
-        -------
-        None
-        """
-        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):
-        """
-        Validate enforcement of keyword-only initialization for S3.
-
-        Ensures that S3 cannot be initialized with positional arguments and
-        raises TypeError if attempted.
-
-        Raises
-        ------
-        TypeError
-            If positional arguments are used for initialization.
-        """
-        with self.assertRaises(TypeError):
-            S3("key", "secret", "region")  # Should fail as it requires keyword arguments