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

tests/foundation/config/app/test_foundation_config_app.py

@@ -1,262 +0,0 @@
-from orionis.foundation.config.app.entities.app import App
-from orionis.foundation.config.app.enums.ciphers import Cipher
-from orionis.foundation.config.app.enums.environments import Environments
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-from orionis.services.system.workers import Workers
-
-class TestFoundationConfigApp(AsyncTestCase):
-
-    async def testDefaultValues(self):
-        """
-        Tests that the App class initializes with the correct default values for all attributes.
-
-        This method creates an instance of the App class without passing any arguments and
-        verifies that each attribute is set to its expected default value. It also checks that
-        the generated key is a non-empty string.
-
-        Returns
-        -------
-        None
-            This method does not return any value. It performs assertions to validate default values.
-        """
-        app = App()  # Create App instance with default parameters
-
-        # Assert default name
-        self.assertEqual(app.name, 'Orionis Application')
-
-        # Assert default environment
-        self.assertEqual(app.env, Environments.DEVELOPMENT.value)
-
-        # Assert default debug mode is enabled
-        self.assertTrue(app.debug)
-
-        # Assert default URL
-        self.assertEqual(app.url, 'http://127.0.0.1')
-
-        # Assert default port
-        self.assertEqual(app.port, 8000)
-
-        # Assert default timezone
-        self.assertEqual(app.timezone, 'UTC')
-
-        # Assert default locale
-        self.assertEqual(app.locale, 'en')
-
-        # Assert default fallback locale
-        self.assertEqual(app.fallback_locale, 'en')
-
-        # Assert default cipher
-        self.assertEqual(app.cipher, Cipher.AES_256_CBC.value)
-
-        # Assert key is a non-empty string
-        self.assertIsInstance(app.key, str)
-        self.assertTrue(app.key)  # key is never None or empty
-        self.assertEqual(app.maintenance, '/maintenance')
-
-    async def testEnvironmentValidation(self):
-        """
-        Validates that the App class correctly handles environment values.
-
-        This method tests the initialization of the App class with different environment values,
-        ensuring that valid environments are accepted and set correctly, while invalid values
-        raise an OrionisIntegrityException.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
-            This method does not return any value. It performs assertions to validate environment handling.
-        """
-        # Test with a valid environment string
-        app = App(env="PRODUCTION")
-        self.assertEqual(app.env, Environments.PRODUCTION.value)
-
-        # Test with a valid Environments enum
-        app = App(env=Environments.TESTING)
-        self.assertEqual(app.env, Environments.TESTING.value)
-
-        # Test with an invalid environment value, expecting an exception
-        with self.assertRaises(OrionisIntegrityException):
-            App(env="INVALID_ENV")
-
-    async def testCipherValidation(self):
-        """
-        Validates that the App class correctly handles cipher values.
-
-        This method tests the initialization of the App class with different cipher values,
-        ensuring that valid ciphers are accepted and set correctly, while invalid values
-        raise an OrionisIntegrityException.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
-            This method does not return any value. It performs assertions to validate cipher handling.
-        """
-        # Test with a valid cipher string
-        app = App(cipher="AES_128_CBC")
-        self.assertEqual(app.cipher, Cipher.AES_128_CBC.value)
-
-        # Test with a valid Cipher enum
-        app = App(cipher=Cipher.AES_192_CBC)
-        self.assertEqual(app.cipher, Cipher.AES_192_CBC.value)
-
-        # Test with an invalid cipher value, expecting an exception
-        with self.assertRaises(OrionisIntegrityException):
-            App(cipher="INVALID_CIPHER")
-
-    async def testTypeValidation(self):
-        """
-        Validates that the App class enforces correct types for its attributes.
-
-        This method attempts to initialize the App class with incorrect types for various attributes.
-        It asserts that an OrionisIntegrityException is raised for each case, ensuring that type validation
-        is properly enforced for all relevant parameters.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
-            This method does not return any value. It performs assertions to verify type validation.
-        """
-        # Name must be a string, not an integer
-        with self.assertRaises(OrionisIntegrityException):
-            App(name=123)
-
-        # Debug must be a boolean, not a string
-        with self.assertRaises(OrionisIntegrityException):
-            App(debug="true")
-
-        # URL must be a string, not an integer
-        with self.assertRaises(OrionisIntegrityException):
-            App(url=123)
-
-        # Port must be an integer, not a string
-        with self.assertRaises(OrionisIntegrityException):
-            App(port="8000")
-
-        # Workers must be an integer, not a string
-        with self.assertRaises(OrionisIntegrityException):
-            App(workers="4")
-
-        # Reload must be a boolean, not a string
-        with self.assertRaises(OrionisIntegrityException):
-            App(reload="true")
-
-    async def testWorkersRangeValidation(self):
-        """
-        Tests the validation of the workers parameter range for the App class.
-
-        This method verifies that the App class raises an OrionisIntegrityException
-        when initialized with an invalid number of workers. Specifically, it checks
-        for two cases:
-            - When the number of workers is set to 0 (below the minimum allowed).
-            - When the number of workers exceeds the maximum allowed, as calculated
-              by Workers().calculate().
-
-        Comments are provided within the code to clarify the purpose of each assertion.
-
-        Returns
-        -------
-        None
-            This test method does not return any value. It asserts that exceptions
-            are raised for invalid worker counts.
-        """
-        max_workers = Workers().calculate()
-        with self.assertRaises(OrionisIntegrityException):
-            App(workers=0)
-        with self.assertRaises(OrionisIntegrityException):
-            App(workers=max_workers + 1)
-
-    async def testToDictMethod(self):
-        """
-        Tests the `toDict` method of the App class to ensure it returns a dictionary
-        representation of the application's configuration with correct values.
-
-        This method creates an instance of the App class using default parameters,
-        invokes the `toDict` method, and verifies that the returned dictionary contains
-        all expected keys and values matching the default configuration. It also checks
-        that the key attribute is a non-empty string.
-
-        Returns
-        -------
-        None
-            This method does not return any value. It performs assertions to validate
-            the correctness of the dictionary returned by `toDict`.
-        """
-        app = App()  # Create App instance with default parameters
-
-        app_dict = app.toDict()  # Get dictionary representation of the app configuration
-
-        # Assert that the returned value is a dictionary
-        self.assertIsInstance(app_dict, dict)
-
-        # Assert each key in the dictionary matches the expected default value
-        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)
-
-        # Assert that the key is a non-empty string
-        self.assertIsInstance(app_dict['key'], str)
-        self.assertTrue(app_dict['key'])
-
-        self.assertEqual(app_dict['maintenance'], '/maintenance')
-
-    async def testNonEmptyStringValidation(self):
-        """
-        Validates that the App class enforces non-empty string constraints for specific attributes.
-
-        This method attempts to initialize the App class with empty strings for attributes that require
-        non-empty values, such as `name`, `url`, `timezone`, `locale`, `fallback_locale`, and `maintenance`.
-        It asserts that an OrionisIntegrityException is raised for each case, ensuring that the class
-        properly enforces non-empty string validation. Additionally, it checks that the `maintenance`
-        attribute must start with a forward slash (`/`).
-
-        Returns
-        -------
-        None
-            This method does not return any value. It performs assertions to verify non-empty string validation.
-        """
-        # Name must not be an empty string
-        with self.assertRaises(OrionisIntegrityException):
-            App(name="")
-
-        # URL must not be an empty string
-        with self.assertRaises(OrionisIntegrityException):
-            App(url="")
-
-        # Timezone must not be an empty string
-        with self.assertRaises(OrionisIntegrityException):
-            App(timezone="")
-
-        # Locale must not be an empty string
-        with self.assertRaises(OrionisIntegrityException):
-            App(locale="")
-
-        # Fallback locale must not be an empty string
-        with self.assertRaises(OrionisIntegrityException):
-            App(fallback_locale="")
-
-        # Maintenance must not be an empty string
-        with self.assertRaises(OrionisIntegrityException):
-            App(maintenance="")
-
-        # Maintenance must start with a forward slash ('/')
-        with self.assertRaises(OrionisIntegrityException):
-            App(maintenance="maintenance")

tests/foundation/config/auth/test_foundation_config_auth.py

@@ -1,29 +0,0 @@
-from orionis.foundation.config.auth.entities.auth import Auth
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigAuth(AsyncTestCase):
-    """
-    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):
-        """
-        Test assignment and retrieval of new attribute values in Auth.
-
-        This test creates a new Auth object and assigns values to new attributes.
-        It then asserts that these attributes hold the expected values.
-
-        Returns
-        -------
-        None
-            This method does not return a value.
-        """
-        auth = Auth()
-        auth.new_value = 'new_value'
-        auth.new_value2 = 'new_value2'
-
-        self.assertEqual(auth.new_value, 'new_value')
-        self.assertEqual(auth.new_value2, 'new_value2')

tests/foundation/config/cache/test_foundation_config_cache.py

@@ -1,143 +0,0 @@
-from orionis.test.cases.asynchronous import AsyncTestCase
-from orionis.foundation.config.cache.entities.cache import Cache
-from orionis.foundation.config.cache.enums.drivers import Drivers
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.foundation.config.cache.entities.stores import Stores
-
-class TestFoundationConfigCache(AsyncTestCase):
-    """
-    Test suite for the Cache configuration entity.
-
-    This class contains asynchronous unit tests for the Cache entity,
-    validating default values, driver validation, type checking,
-    dictionary conversion, and Stores instance validation.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Test that the Cache instance is created with the correct default values.
-
-        Ensures that the default values of the Cache instance match the expected
-        defaults from the class definition.
-
-        Returns
-        -------
-        None
-        """
-        cache = Cache()
-        self.assertEqual(cache.default, Drivers.MEMORY.value)
-        self.assertIsInstance(cache.stores, Stores)
-
-    async def testDriverValidation(self):
-        """
-        Test validation and conversion of the default driver attribute.
-
-        Verifies that string drivers are converted to enum values and that
-        invalid drivers raise exceptions.
-
-        Returns
-        -------
-        None
-        """
-        # 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 case insensitivity of driver names provided as strings.
-
-        Ensures that different case variations of driver names are properly
-        normalized to the correct enum value.
-
-        Returns
-        -------
-        None
-        """
-        # 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 type validation for all attributes.
-
-        Ensures that invalid types for each attribute raise
-        OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        # 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 the toDict method for dictionary representation.
-
-        Ensures that the toDict method returns a dictionary containing all
-        expected keys and values.
-
-        Returns
-        -------
-        None
-        """
-        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 the stores attribute must be an instance of Stores.
-
-        Ensures that only Stores instances are accepted for the stores
-        attribute and invalid types raise exceptions.
-
-        Returns
-        -------
-        None
-        """
-        # 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 conversion of Drivers enum values to string representations.
-
-        Ensures that enum members are converted to their value representations
-        when used as the default driver.
-
-        Returns
-        -------
-        None
-        """
-        # Test with enum member
-        cache = Cache(default=Drivers.MEMORY)
-        self.assertEqual(cache.default, Drivers.MEMORY.value)

tests/foundation/config/cache/test_foundation_config_cache_file.py

@@ -1,126 +0,0 @@
-from orionis.foundation.config.cache.entities.file import File
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigCacheFile(AsyncTestCase):
-    """
-    Unit tests for the File cache configuration dataclass.
-
-    These tests validate the initialization, attribute validation, and dictionary representation
-    of the File cache configuration entity.
-    """
-
-    async def testDefaultPath(self):
-        """
-        Test default path initialization.
-
-        Ensures that a File instance is created with the correct default path.
-
-        Returns
-        -------
-        None
-        """
-        file_config = File()
-        self.assertEqual(file_config.path, 'storage/framework/cache/data')
-
-    async def testCustomPath(self):
-        """
-        Test custom path initialization.
-
-        Ensures that a custom path can be set during initialization and is stored correctly.
-
-        Returns
-        -------
-        None
-        """
-        custom_path = 'custom/cache/path'
-        file_config = File(path=custom_path)
-        self.assertEqual(file_config.path, custom_path)
-
-    async def testEmptyPathValidation(self):
-        """
-        Test validation for empty path.
-
-        Ensures that providing an empty path raises an OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the path is empty.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            File(path="")
-
-    async def testPathTypeValidation(self):
-        """
-        Test validation for path type.
-
-        Ensures that non-string path values raise an OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the path is not a string.
-        """
-        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 dictionary representation.
-
-        Ensures that the toDict method returns a dictionary with the expected path value.
-
-        Returns
-        -------
-        None
-        """
-        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 custom path in dictionary representation.
-
-        Ensures that custom paths are properly included in the dictionary returned by toDict.
-
-        Returns
-        -------
-        None
-        """
-        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 handling of paths with whitespace.
-
-        Ensures that paths containing whitespace are accepted and not automatically trimmed.
-
-        Returns
-        -------
-        None
-        """
-        spaced_path = '  storage/cache/with/space  '
-        file_config = File(path=spaced_path)
-        self.assertEqual(file_config.path, spaced_path)