orionis 0.546.0__py3-none-any.whl → 0.548.0__py3-none-any.whl

tests/foundation/config/cache/test_foundation_config_cache_stores.py

@@ -1,156 +0,0 @@
-from orionis.foundation.config.cache.entities.stores import Stores
-from orionis.foundation.config.cache.entities.file import File
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigCacheStores(AsyncTestCase):
-    """
-    Test cases for the Stores cache configuration entity.
-
-    This class contains asynchronous unit tests for the `Stores` entity,
-    validating its initialization, type enforcement, dictionary conversion,
-    hashability, and keyword-only argument enforcement.
-
-    Attributes
-    ----------
-    None
-    """
-
-    async def testDefaultFileStore(self):
-        """
-        Test initialization with default File instance.
-
-        Ensures that `Stores` initializes with a default `File` instance and
-        that the `file` attribute is properly set with the default configuration.
-
-        Returns
-        -------
-        None
-        """
-        stores = Stores()
-        self.assertIsInstance(stores.file, File)
-        self.assertEqual(stores.file.path, 'storage/framework/cache/data')
-
-    async def testCustomFileStore(self):
-        """
-        Test initialization with a custom File configuration.
-
-        Ensures that a custom `File` instance or dict can be provided during
-        initialization and is correctly assigned to the `file` attribute.
-
-        Returns
-        -------
-        None
-        """
-        custom_file = File(path='custom/cache/path')
-        stores = Stores(file=custom_file)
-        self.assertIsInstance(stores.file, File)
-        self.assertEqual(stores.file.path, 'custom/cache/path')
-
-        stores_dict = Stores(file={'path': 'dict/cache/path'})
-        self.assertIsInstance(stores_dict.file, File)
-        self.assertEqual(stores_dict.file.path, 'dict/cache/path')
-
-    async def testFileTypeValidation(self):
-        """
-        Test type validation for the file attribute.
-
-        Ensures that providing a non-`File` instance or dict to the `file` attribute
-        raises an `OrionisIntegrityException`.
-
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the `file` attribute is not a `File` instance or dict.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Stores(file="not_a_file_instance")
-
-        with self.assertRaises(OrionisIntegrityException):
-            Stores(file=123)
-
-        with self.assertRaises(OrionisIntegrityException):
-            Stores(file=None)
-
-    async def testToDictMethodWithDefaults(self):
-        """
-        Test dictionary representation with default values.
-
-        Ensures that `toDict` returns a dictionary with the correct default
-        file path.
-
-        Returns
-        -------
-        None
-        """
-        stores = Stores()
-        stores_dict = stores.toDict()
-
-        self.assertIsInstance(stores_dict, dict)
-        self.assertIsInstance(stores_dict['file'], dict)
-        self.assertEqual(stores_dict['file']['path'], 'storage/framework/cache/data')
-
-    async def testToDictMethodWithCustomFile(self):
-        """
-        Test dictionary representation with custom file configuration.
-
-        Ensures that `toDict` reflects custom file paths in its dictionary
-        representation.
-
-        Returns
-        -------
-        None
-        """
-        custom_file = File(path='alternate/cache/location')
-        stores = Stores(file=custom_file)
-        stores_dict = stores.toDict()
-
-        self.assertEqual(stores_dict['file']['path'], 'alternate/cache/location')
-
-        stores_dict_input = Stores(file={'path': 'dict/location'})
-        stores_dict2 = stores_dict_input.toDict()
-        self.assertEqual(stores_dict2['file']['path'], 'dict/location')
-
-    async def testHashability(self):
-        """
-        Test hashability of Stores instances.
-
-        Ensures that `Stores` instances are hashable and can be used in sets
-        and as dictionary keys.
-
-        Returns
-        -------
-        None
-        """
-        store1 = Stores()
-        store2 = Stores()
-        store_set = {store1, store2}
-
-        self.assertEqual(len(store_set), 1)
-
-        custom_store = Stores(file=File(path='custom/path'))
-        store_set.add(custom_store)
-        self.assertEqual(len(store_set), 2)
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test keyword-only initialization enforcement.
-
-        Ensures that `Stores` enforces keyword-only arguments and does not
-        allow positional arguments during initialization.
-
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        TypeError
-            If positional arguments are provided during initialization.
-        """
-        with self.assertRaises(TypeError):
-            Stores(File())

tests/foundation/config/cors/test_foundation_config_cors.py

@@ -1,190 +0,0 @@
-from orionis.foundation.config.cors.entities.cors import Cors
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigCors(AsyncTestCase):
-    """
-    Unit tests for Cors configuration defaults and validation.
-
-    Notes
-    -----
-    These tests verify the default values, custom value assignment, and type validation
-    for the `Cors` configuration entity.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Test the default values of the Cors configuration.
-
-        Verifies that a newly instantiated Cors object has the expected default settings.
-
-        Expected Defaults
-        -----------------
-        allow_origins : list of str
-            ["*"]
-        allow_origin_regex : None or str
-            None
-        allow_methods : list of str
-            ["*"]
-        allow_headers : list of str
-            ["*"]
-        expose_headers : list of str
-            []
-        allow_credentials : bool
-            False
-        max_age : int
-            600
-        """
-        cors = Cors()
-        self.assertEqual(cors.allow_origins, ["*"])
-        self.assertIsNone(cors.allow_origin_regex)
-        self.assertEqual(cors.allow_methods, ["*"])
-        self.assertEqual(cors.allow_headers, ["*"])
-        self.assertEqual(cors.expose_headers, [])
-        self.assertFalse(cors.allow_credentials)
-        self.assertEqual(cors.max_age, 600)
-
-    async def testCustomValues(self):
-        """
-        Test custom value assignment for all Cors configuration parameters.
-
-        Ensures that the Cors object accurately reflects the provided custom configuration values.
-
-        Parameters
-        ----------
-        allow_origins : list of str
-            Custom list of allowed origins.
-        allow_origin_regex : str
-            Custom regex pattern for allowed origins.
-        allow_methods : list of str
-            Custom list of allowed HTTP methods.
-        allow_headers : list of str
-            Custom list of allowed headers.
-        expose_headers : list of str
-            Custom list of exposed headers.
-        allow_credentials : bool
-            Whether credentials are allowed.
-        max_age : int
-            Custom max age value.
-        """
-        cors = Cors(
-            allow_origins=["https://example.com"],
-            allow_origin_regex="^https://.*\\.example\\.com$",
-            allow_methods=["GET", "POST"],
-            allow_headers=["Authorization", "Content-Type"],
-            expose_headers=["X-Custom-Header"],
-            allow_credentials=True,
-            max_age=3600
-        )
-        self.assertEqual(cors.allow_origins, ["https://example.com"])
-        self.assertEqual(cors.allow_origin_regex, "^https://.*\\.example\\.com$")
-        self.assertEqual(cors.allow_methods, ["GET", "POST"])
-        self.assertEqual(cors.allow_headers, ["Authorization", "Content-Type"])
-        self.assertEqual(cors.expose_headers, ["X-Custom-Header"])
-        self.assertTrue(cors.allow_credentials)
-        self.assertEqual(cors.max_age, 3600)
-
-    async def testInvalidAllowOriginsType(self):
-        """
-        Test type validation for 'allow_origins' parameter.
-
-        Ensures that passing a string instead of a list to the `allow_origins` parameter
-        raises an OrionisIntegrityException.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If `allow_origins` is not a list.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Cors(allow_origins="*")
-
-    async def testInvalidAllowOriginRegexType(self):
-        """
-        Test type validation for 'allow_origin_regex' parameter.
-
-        Ensures that passing a non-string, non-None value (e.g., integer) to the
-        `allow_origin_regex` parameter raises an OrionisIntegrityException.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If `allow_origin_regex` is not a string or None.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Cors(allow_origin_regex=123)
-
-    async def testInvalidAllowMethodsType(self):
-        """
-        Test type validation for 'allow_methods' parameter.
-
-        Ensures that passing a string instead of a list to the `allow_methods` parameter
-        raises an OrionisIntegrityException.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If `allow_methods` is not a list.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Cors(allow_methods="GET")
-
-    async def testInvalidAllowHeadersType(self):
-        """
-        Test type validation for 'allow_headers' parameter.
-
-        Ensures that passing a string instead of a list to the `allow_headers` parameter
-        raises an OrionisIntegrityException.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If `allow_headers` is not a list.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Cors(allow_headers="Authorization")
-
-    async def testInvalidExposeHeadersType(self):
-        """
-        Test type validation for 'expose_headers' parameter.
-
-        Ensures that passing a string instead of a list to the `expose_headers` parameter
-        raises an OrionisIntegrityException.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If `expose_headers` is not a list.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Cors(expose_headers="X-Custom-Header")
-
-    async def testInvalidAllowCredentialsType(self):
-        """
-        Test type validation for 'allow_credentials' parameter.
-
-        Ensures that passing a non-boolean value to the `allow_credentials` parameter
-        raises an OrionisIntegrityException.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If `allow_credentials` is not a boolean.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Cors(allow_credentials="yes")
-
-    async def testInvalidMaxAgeType(self):
-        """
-        Test type validation for 'max_age' parameter.
-
-        Ensures that passing a non-integer value (e.g., string) to the `max_age` parameter
-        raises an OrionisIntegrityException.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If `max_age` is not an integer or None.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Cors(max_age="3600")

tests/foundation/config/database/test_foundation_config_database.py

@@ -1,158 +0,0 @@
-from orionis.foundation.config.database.entities.database import Database
-from orionis.foundation.config.database.entities.connections import Connections
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigDatabase(AsyncTestCase):
-    """
-    Unit tests for the Database configuration class.
-
-    This class provides asynchronous test cases to verify the behavior,
-    validation, and integrity of the `Database` configuration class,
-    including default values, attribute validation, dictionary conversion,
-    custom values, hashability, and keyword-only initialization enforcement.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Test that a Database instance initializes with correct default values.
-
-        Ensures that the `default` attribute is set to 'sqlite' and the
-        `connections` attribute is an instance of Connections.
-
-        Returns
-        -------
-        None
-        """
-        db = Database()
-        self.assertEqual(db.default, 'sqlite')
-        self.assertIsInstance(db.connections, Connections)
-
-    async def testDefaultConnectionValidation(self):
-        """
-        Validate the `default` connection attribute for allowed values.
-
-        Checks that only valid connection types are accepted for the `default`
-        attribute. Verifies that invalid, empty, or non-string values raise
-        OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        # Test valid connection types
-        valid_connections = ['sqlite', 'mysql', 'pgsql', 'oracle']
-        for conn in valid_connections:
-            try:
-                Database(default=conn)
-            except OrionisIntegrityException:
-                self.fail(f"Valid connection type '{conn}' should not raise exception")
-
-        # Test invalid connection type
-        with self.assertRaises(OrionisIntegrityException):
-            Database(default='invalid_connection')
-
-        # Test empty default
-        with self.assertRaises(OrionisIntegrityException):
-            Database(default='')
-
-        # Test non-string default
-        with self.assertRaises(OrionisIntegrityException):
-            Database(default=123)
-
-    async def testConnectionsValidation(self):
-        """
-        Validate the `connections` attribute for correct type.
-
-        Ensures that only instances of Connections are accepted for the
-        `connections` attribute. Invalid types or None should raise
-        OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        # Test invalid connections type
-        with self.assertRaises(OrionisIntegrityException):
-            Database(connections="not_a_connections_instance")
-
-        # Test None connections
-        with self.assertRaises(OrionisIntegrityException):
-            Database(connections=None)
-
-        # Test valid connections
-        try:
-            Database(connections=Connections())
-        except OrionisIntegrityException:
-            self.fail("Valid Connections instance should not raise exception")
-
-    async def testToDictMethod(self):
-        """
-        Test the `toDict` method for dictionary representation.
-
-        Ensures that the `toDict` method returns a dictionary containing
-        all attributes of the Database instance, including `default` and
-        `connections`.
-
-        Returns
-        -------
-        None
-        """
-        db = Database()
-        db_dict = db.toDict()
-        self.assertIsInstance(db_dict, dict)
-        self.assertEqual(db_dict['default'], 'sqlite')
-        self.assertIsInstance(db_dict['connections'], dict)
-
-    async def testCustomValues(self):
-        """
-        Test handling and validation of custom attribute values.
-
-        Ensures that custom values for `default` and `connections` are
-        correctly stored and validated in the Database instance.
-
-        Returns
-        -------
-        None
-        """
-        custom_connections = Connections()
-        custom_db = Database(
-            default='mysql',
-            connections=custom_connections
-        )
-        self.assertEqual(custom_db.default, 'mysql')
-        self.assertIs(custom_db.connections, custom_connections)
-
-    async def testHashability(self):
-        """
-        Test that Database instances are hashable.
-
-        Verifies that Database instances can be used in sets and as dictionary
-        keys, and that identical instances are considered equal.
-
-        Returns
-        -------
-        None
-        """
-        db1 = Database()
-        db2 = Database()
-        db_set = {db1, db2}
-        self.assertEqual(len(db_set), 1)
-
-        custom_db = Database(default='pgsql')
-        db_set.add(custom_db)
-        self.assertEqual(len(db_set), 2)
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test enforcement of keyword-only initialization.
-
-        Ensures that Database raises TypeError when positional arguments are
-        used instead of keyword arguments during initialization.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(TypeError):
-            Database('sqlite', Connections())