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

tests/foundation/config/app/test_app.py

@@ -0,0 +1,140 @@
+from orionis.luminate.foundation.config.app.entities.app import App
+from orionis.luminate.foundation.config.app.enums.ciphers import Cipher
+from orionis.luminate.foundation.config.app.enums.environments import Environments
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigApp(TestCase):
+    """
+    Test cases for the App configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that the App instance is created with the correct default values.
+
+        Verifies that all default values match the expected defaults from the class definition.
+        """
+        app = App()
+        self.assertEqual(app.name, 'Orionis Application')
+        self.assertEqual(app.env, Environments.DEVELOPMENT.value)
+        self.assertTrue(app.debug)
+        self.assertEqual(app.url, 'http://127.0.0.1')
+        self.assertEqual(app.port, 8000)
+        self.assertEqual(app.timezone, 'UTC')
+        self.assertEqual(app.locale, 'en')
+        self.assertEqual(app.fallback_locale, 'en')
+        self.assertEqual(app.cipher, Cipher.AES_256_CBC.value)
+        self.assertIsNone(app.key)
+        self.assertEqual(app.maintenance, '/maintenance')
+
+    async def testEnvironmentValidation(self):
+        """
+        Test that the environment attribute is properly validated and converted.
+
+        Verifies that string environments are converted to enum values and invalid environments raise exceptions.
+        """
+        # Test valid string environment
+        app = App(env="PRODUCTION")
+        self.assertEqual(app.env, Environments.PRODUCTION.value)
+
+        # Test valid enum environment
+        app = App(env=Environments.TESTING)
+        self.assertEqual(app.env, Environments.TESTING.value)
+
+        # Test invalid environment
+        with self.assertRaises(OrionisIntegrityException):
+            App(env="INVALID_ENV")
+
+    async def testCipherValidation(self):
+        """
+        Test that the cipher attribute is properly validated and converted.
+
+        Verifies that string ciphers are converted to enum values and invalid ciphers raise exceptions.
+        """
+        # Test valid string cipher
+        app = App(cipher="AES_128_CBC")
+        self.assertEqual(app.cipher, Cipher.AES_128_CBC.value)
+
+        # Test valid enum cipher
+        app = App(cipher=Cipher.AES_192_CBC)
+        self.assertEqual(app.cipher, Cipher.AES_192_CBC.value)
+
+        # Test invalid cipher
+        with self.assertRaises(OrionisIntegrityException):
+            App(cipher="INVALID_CIPHER")
+
+    async def testTypeValidation(self):
+        """
+        Test that type validation works correctly for all attributes.
+
+        Verifies that invalid types for each attribute raise OrionisIntegrityException.
+        """
+        # Test invalid name type
+        with self.assertRaises(OrionisIntegrityException):
+            App(name=123)
+
+        # Test invalid debug type
+        with self.assertRaises(OrionisIntegrityException):
+            App(debug="true")
+
+        # Test invalid url type
+        with self.assertRaises(OrionisIntegrityException):
+            App(url=123)
+
+        # Test invalid port type
+        with self.assertRaises(OrionisIntegrityException):
+            App(port="8000")
+
+        # Test invalid workers type
+        with self.assertRaises(OrionisIntegrityException):
+            App(workers="4")
+
+        # Test invalid reload type
+        with self.assertRaises(OrionisIntegrityException):
+            App(reload="true")
+
+    async def testToDictMethod(self):
+        """
+        Test that the toDict method returns a proper dictionary representation.
+
+        Verifies that the returned dictionary contains all expected keys and values.
+        """
+        app = App()
+        app_dict = app.toDict()
+
+        self.assertIsInstance(app_dict, dict)
+        self.assertEqual(app_dict['name'], 'Orionis Application')
+        self.assertEqual(app_dict['env'], Environments.DEVELOPMENT.value)
+        self.assertTrue(app_dict['debug'])
+        self.assertEqual(app_dict['url'], 'http://127.0.0.1')
+        self.assertEqual(app_dict['port'], 8000)
+        self.assertEqual(app_dict['timezone'], 'UTC')
+        self.assertEqual(app_dict['locale'], 'en')
+        self.assertEqual(app_dict['fallback_locale'], 'en')
+        self.assertEqual(app_dict['cipher'], Cipher.AES_256_CBC.value)
+        self.assertIsNone(app_dict['key'])
+        self.assertEqual(app_dict['maintenance'], '/maintenance')
+
+    async def testNonEmptyStringValidation(self):
+        """
+        Test that empty strings are rejected for attributes requiring non-empty strings.
+        Verifies that attributes requiring non-empty strings raise exceptions when empty strings are provided.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            App(name="")
+
+        with self.assertRaises(OrionisIntegrityException):
+            App(url="")
+
+        with self.assertRaises(OrionisIntegrityException):
+            App(timezone="")
+
+        with self.assertRaises(OrionisIntegrityException):
+            App(locale="")
+
+        with self.assertRaises(OrionisIntegrityException):
+            App(fallback_locale="")
+
+        with self.assertRaises(OrionisIntegrityException):
+            App(maintenance="")

tests/{config → foundation/config/auth}/test_auth.py

@@ -1,9 +1,12 @@
-from orionis.luminate.test import TestCase
-from orionis.luminate.config.auth import Auth
+
+from orionis.luminate.foundation.config.auth.entities.auth import Auth
+from orionis.unittesting import TestCase
 
 class TestConfigApp(TestCase):
     """
-    Unit tests for App configuration defaults.
+    Test suite for verifying the behavior of the Auth configuration within the application.
+    This class contains asynchronous test cases to ensure that the Auth object
+    correctly handles the assignment and retrieval of new attribute values.
     """
 
     async def testNewValue(self):

tests/foundation/config/cache/test_cache.py

@@ -0,0 +1,98 @@
+from orionis.unittesting import TestCase
+from orionis.luminate.foundation.config.cache.entities.cache import Cache
+from orionis.luminate.foundation.config.cache.enums.drivers import Drivers
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.luminate.foundation.config.cache.entities.stores import Stores
+
+class TestConfigCache(TestCase):
+    """
+    Test cases for the Cache configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that the Cache instance is created with the correct default values.
+        Verifies that default values match the expected defaults from the class definition.
+        """
+        cache = Cache()
+        self.assertEqual(cache.default, Drivers.MEMORY.value)
+        self.assertIsInstance(cache.stores, Stores)
+
+    async def testDriverValidation(self):
+        """
+        Test that the default driver attribute is properly validated and converted.
+        Verifies that string drivers are converted to enum values and invalid drivers raise exceptions.
+        """
+        # Test valid string driver
+        cache = Cache(default="FILE")
+        self.assertEqual(cache.default, Drivers.FILE.value)
+
+
+        # Test invalid driver
+        with self.assertRaises(OrionisIntegrityException):
+            Cache(default="INVALID_DRIVER")
+
+    async def testDriverCaseInsensitivity(self):
+        """
+        Test that driver names are case-insensitive when provided as strings.
+        Verifies that different case variations of driver names are properly normalized.
+        """
+        # Test lowercase
+        cache = Cache(default="file")
+        self.assertEqual(cache.default, Drivers.FILE.value)
+
+        # Test mixed case
+        cache = Cache(default="FiLe")
+        self.assertEqual(cache.default, Drivers.FILE.value)
+
+        # Test uppercase
+        cache = Cache(default="FILE")
+        self.assertEqual(cache.default, Drivers.FILE.value)
+
+    async def testTypeValidation(self):
+        """
+        Test that type validation works correctly for all attributes.
+        Verifies that invalid types for each attribute raise OrionisIntegrityException.
+        """
+        # Test invalid default type
+        with self.assertRaises(OrionisIntegrityException):
+            Cache(default=123)
+
+        # Test invalid stores type
+        with self.assertRaises(OrionisIntegrityException):
+            Cache(stores="invalid_stores")
+
+    async def testToDictMethod(self):
+        """
+        Test that the toDict method returns a proper dictionary representation.
+        Verifies that the returned dictionary contains all expected keys and values.
+        """
+        cache = Cache()
+        cache_dict = cache.toDict()
+
+        self.assertIsInstance(cache_dict, dict)
+        self.assertEqual(cache_dict['default'], Drivers.MEMORY.value)
+        self.assertIsInstance(cache_dict['stores'], dict)
+
+    async def testStoresInstanceValidation(self):
+        """
+        Test that stores attribute must be an instance of Stores class.
+        Verifies that only Stores instances are accepted for the stores attribute.
+        """
+        # Test with proper Stores instance
+        stores = Stores()  # Assuming Stores has a default constructor
+        cache = Cache(stores=stores)
+        self.assertIsInstance(cache.stores, Stores)
+
+        # Test with invalid stores type
+        with self.assertRaises(OrionisIntegrityException):
+            Cache(stores={"file": "some_path"})
+
+    async def testDriverEnumConversion(self):
+        """
+        Test that Drivers enum values are properly converted to their string representations.
+        Verifies that enum members are converted to their value representations.
+        """
+        # Test with enum member
+        cache = Cache(default=Drivers.MEMORY)
+        self.assertEqual(cache.default, Drivers.MEMORY.value)

tests/foundation/config/cache/test_cache_file.py

@@ -0,0 +1,78 @@
+from orionis.luminate.foundation.config.cache.entities.file import File
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigFile(TestCase):
+    """
+    Test cases for the File cache configuration entity.
+    """
+
+    async def testDefaultPath(self):
+        """
+        Test that the File instance is created with the correct default path.
+        Verifies that the default path matches the expected value from the class definition.
+        """
+        file_config = File()
+        self.assertEqual(file_config.path, 'storage/framework/cache/data')
+
+    async def testCustomPath(self):
+        """
+        Test that a custom path can be set during initialization.
+        Verifies that the path attribute accepts and stores valid custom paths.
+        """
+        custom_path = 'custom/cache/path'
+        file_config = File(path=custom_path)
+        self.assertEqual(file_config.path, custom_path)
+
+    async def testEmptyPathValidation(self):
+        """
+        Test that empty paths are rejected.
+        Verifies that an empty path raises an OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            File(path="")
+
+    async def testPathTypeValidation(self):
+        """
+        Test that non-string paths are rejected.
+        Verifies that non-string path values raise an OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            File(path=123)
+
+        with self.assertRaises(OrionisIntegrityException):
+            File(path=None)
+
+        with self.assertRaises(OrionisIntegrityException):
+            File(path=[])
+
+    async def testToDictMethod(self):
+        """
+        Test that the toDict method returns a proper dictionary representation.
+        Verifies that the returned dictionary contains the expected path value.
+        """
+        file_config = File()
+        config_dict = file_config.toDict()
+
+        self.assertIsInstance(config_dict, dict)
+        self.assertEqual(config_dict['path'], 'storage/framework/cache/data')
+
+    async def testCustomPathToDict(self):
+        """
+        Test that custom paths are properly included in the dictionary representation.
+        Verifies that toDict() includes custom path values when specified.
+        """
+        custom_path = 'another/cache/location'
+        file_config = File(path=custom_path)
+        config_dict = file_config.toDict()
+
+        self.assertEqual(config_dict['path'], custom_path)
+
+    async def testWhitespacePathHandling(self):
+        """
+        Test that paths with whitespace are accepted but not automatically trimmed.
+        Verifies that the validation allows paths containing whitespace characters.
+        """
+        spaced_path = '  storage/cache/with/space  '
+        file_config = File(path=spaced_path)
+        self.assertEqual(file_config.path, spaced_path)

tests/foundation/config/cache/test_cache_stores.py

@@ -0,0 +1,88 @@
+from orionis.luminate.foundation.config.cache.entities.stores import Stores
+from orionis.luminate.foundation.config.cache.entities.file import File
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigStores(TestCase):
+    """
+    Test cases for the Stores cache configuration entity.
+    """
+
+    async def testDefaultFileStore(self):
+        """
+        Test that Stores initializes with a default File instance.
+        Verifies that the file attribute is properly initialized with default File configuration.
+        """
+        stores = Stores()
+        self.assertIsInstance(stores.file, File)
+        self.assertEqual(stores.file.path, 'storage/framework/cache/data')
+
+    async def testCustomFileStore(self):
+        """
+        Test that Stores accepts a custom File configuration.
+        Verifies that a custom File instance can be provided during initialization.
+        """
+        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')
+
+    async def testFileTypeValidation(self):
+        """
+        Test that Stores validates the file attribute type.
+        Verifies that non-File instances raise OrionisIntegrityException.
+        """
+        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 that toDict returns proper dictionary with default values.
+        Verifies the dictionary representation contains the correct default file path.
+        """
+        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 that toDict includes custom file configurations.
+        Verifies the dictionary representation reflects custom file paths.
+        """
+        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')
+
+    async def testHashability(self):
+        """
+        Test that Stores maintains hashability due to unsafe_hash=True.
+        Verifies that Stores instances can be used in sets and as dictionary keys.
+        """
+        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 that Stores enforces keyword-only initialization.
+        Verifies that positional arguments are not allowed for initialization.
+        """
+        with self.assertRaises(TypeError):
+            Stores(File())

tests/foundation/config/cors/test_cors.py

@@ -0,0 +1,121 @@
+
+from orionis.luminate.foundation.config.cors.entities.cors import Cors
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestCorsConfig(TestCase):
+    """
+    Unit tests for Cors configuration defaults and validation.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test the default values of the Cors configuration.
+
+        This test verifies that a newly instantiated Cors object has the following default settings:
+        - allow_origins: ["*"]
+        - allow_origin_regex: None
+        - allow_methods: ["*"]
+        - allow_headers: ["*"]
+        - expose_headers: []
+        - allow_credentials: False
+        - max_age: 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 that the Cors configuration correctly sets custom values for all parameters.
+
+        This test verifies that:
+        - `allow_origins` is set to the provided list of origins.
+        - `allow_origin_regex` is set to the provided regex pattern.
+        - `allow_methods` is set to the provided list of HTTP methods.
+        - `allow_headers` is set to the provided list of headers.
+        - `expose_headers` is set to the provided list of exposed headers.
+        - `allow_credentials` is set to True.
+        - `max_age` is set to the provided integer value.
+
+        Ensures that the Cors object accurately reflects the custom configuration values.
+        """
+        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 that passing a string instead of a list to the 'allow_origins' parameter of the Cors class
+        raises an OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Cors(allow_origins="*")
+
+    async def testInvalidAllowOriginRegexType(self):
+        """
+        Test that passing a non-string, non-None value (specifically an integer) to the
+        `allow_origin_regex` parameter of the `Cors` class raises an OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Cors(allow_origin_regex=123)
+
+    async def testInvalidAllowMethodsType(self):
+        """
+        Test that initializing the Cors class with an invalid type for 'allow_methods' raises an OrionisIntegrityException.
+
+        This test verifies that passing a string instead of a list to the 'allow_methods' parameter
+        of the Cors class triggers the expected exception, ensuring type validation is enforced.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Cors(allow_methods="GET")
+
+    async def testInvalidAllowHeadersType(self):
+        """
+        Test that initializing the Cors class with a non-list type for 'allow_headers' (specifically a string)
+        raises an OrionisIntegrityException, ensuring type validation for the 'allow_headers' parameter.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Cors(allow_headers="Authorization")
+
+    async def testInvalidExposeHeadersType(self):
+        """
+        Test that initializing the Cors class with a non-list type for 'expose_headers'
+        raises an OrionisIntegrityException. Ensures type validation for the 'expose_headers' parameter.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Cors(expose_headers="X-Custom-Header")
+
+    async def testInvalidAllowCredentialsType(self):
+        """
+        Test that initializing the Cors class with a non-boolean value for 'allow_credentials'
+        raises an OrionisIntegrityException, ensuring type validation for the parameter.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Cors(allow_credentials="yes")
+
+    async def testInvalidMaxAgeType(self):
+        """
+        Test that passing a non-integer value (specifically a string) to the `max_age` parameter of the `Cors` class
+        raises an `OrionisIntegrityException`. This ensures that `max_age` only accepts integer or None values.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Cors(max_age="3600")

tests/foundation/config/database/test_database.py

@@ -0,0 +1,108 @@
+from orionis.luminate.foundation.config.database.entities.database import Database
+from orionis.luminate.foundation.config.database.entities.connections import Connections
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigDatabase(TestCase):
+    """
+    Test cases for the Database configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that Database instance is created with correct default values.
+        Verifies default connection is 'sqlite' and connections object is properly initialized.
+        """
+        db = Database()
+        self.assertEqual(db.default, 'sqlite')
+        self.assertIsInstance(db.connections, Connections)
+
+    async def testDefaultConnectionValidation(self):
+        """
+        Test default connection attribute validation.
+        Verifies that only valid connection types are accepted as default.
+        """
+        # 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):
+        """
+        Test connections attribute validation.
+        Verifies that only Connections instances are accepted.
+        """
+        # 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 that toDict returns proper dictionary representation.
+        Verifies all attributes are correctly included in dictionary.
+        """
+        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 that custom values are properly stored and validated.
+        Verifies custom configurations are correctly handled.
+        """
+        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 maintains hashability due to unsafe_hash=True.
+        Verifies that Database instances can be used in sets and as dictionary keys.
+        """
+        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 that Database enforces keyword-only initialization.
+        Verifies that positional arguments are not allowed for initialization.
+        """
+        with self.assertRaises(TypeError):
+            Database('sqlite', Connections())