orionis 0.417.0__py3-none-any.whl → 0.419.0__py3-none-any.whl

tests/foundation/config/root/test_foundation_config_root_paths.py

@@ -0,0 +1,116 @@
+from orionis.foundation.exceptions import OrionisIntegrityException
+from orionis.foundation.config.roots.paths import Paths
+from orionis.test.cases.asynchronous import AsyncTestCase
+
+class TestFoundationConfigRootPaths(AsyncTestCase):
+    """
+    Test suite for the Paths dataclass which defines the project directory structure.
+
+    This class verifies the integrity of path definitions, default values,
+    and the behavior of accessor methods.
+
+    Methods
+    -------
+    testDefaultPathsInstantiation()
+        Test that a Paths instance can be created with default values.
+    testAllPathsAreStrings()
+        Test that all path attributes are strings.
+    testPathValidationRejectsNonStringValues()
+        Test that non-string path values raise OrionisIntegrityException.
+    testToDictReturnsCompleteDictionary()
+        Test that toDict() returns a complete dictionary of all paths.
+    testFrozenDataclassBehavior()
+        Test that the dataclass is truly frozen (immutable).
+    testPathMetadataIsAccessible()
+        Test that path metadata is properly defined and accessible.
+    """
+
+    def testDefaultPathsInstantiation(self):
+        """
+        Test that a Paths instance can be created with default values.
+
+        Ensures that all default paths are correctly initialized and
+        the instance is properly constructed.
+        """
+        paths = Paths()
+        self.assertIsInstance(paths, Paths)
+
+    def testAllPathsAreStrings(self):
+        """
+        Test that all path attributes are strings.
+
+        Ensures that every field in Paths is a string by default.
+        """
+        paths = Paths()
+        for field_name in paths.__dataclass_fields__:
+            value = getattr(paths, field_name)
+            self.assertIsInstance(value, str)
+            self.assertTrue(len(value) > 0)
+
+    def testPathValidationRejectsNonStringValues(self):
+        """
+        Test that non-string path values raise OrionisIntegrityException.
+
+        Verifies that the __post_init__ validation rejects non-string values
+        for all path fields.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If a non-string value is provided.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Paths(console_scheduler=123)
+
+    def testToDictReturnsCompleteDictionary(self):
+        """
+        Test that toDict() returns a complete dictionary of all paths.
+
+        Verifies that the returned dictionary contains all path fields
+        with their current values.
+
+        Returns
+        -------
+        None
+        """
+        paths = Paths()
+        path_dict = paths.toDict()
+        self.assertIsInstance(path_dict, dict)
+        self.assertEqual(len(path_dict), len(paths.__dataclass_fields__))
+        for field in paths.__dataclass_fields__:
+            self.assertIn(field, path_dict)
+
+    def testFrozenDataclassBehavior(self):
+        """
+        Test that the dataclass is truly frozen (immutable).
+
+        Verifies that attempts to modify attributes after creation
+        raise exceptions.
+
+        Raises
+        ------
+        Exception
+            If an attempt is made to modify a frozen dataclass.
+        """
+        paths = Paths()
+        with self.assertRaises(Exception):
+            paths.console_scheduler = 'new/path'  # type: ignore
+
+    def testPathMetadataIsAccessible(self):
+        """
+        Test that path metadata is properly defined and accessible.
+
+        Verifies that each path field has the expected metadata structure
+        with description and default fields.
+
+        Returns
+        -------
+        None
+        """
+        paths = Paths()
+        for field in paths.__dataclass_fields__.values():
+            metadata = field.metadata
+            self.assertIn('description', metadata)
+            self.assertIn('default', metadata)
+            self.assertIsInstance(metadata['description'], str)
+            self.assertIsInstance(metadata['default'], str)

tests/foundation/config/startup/test_foundation_config_startup.py

@@ -0,0 +1,199 @@
+from dataclasses import is_dataclass
+from orionis.foundation.exceptions.integrity import OrionisIntegrityException
+from orionis.foundation.config.startup import Configuration
+from orionis.foundation.config.app.entities.app import App
+from orionis.foundation.config.auth.entities.auth import Auth
+from orionis.foundation.config.cache.entities.cache import Cache
+from orionis.foundation.config.cors.entities.cors import Cors
+from orionis.foundation.config.database.entities.database import Database
+from orionis.foundation.config.roots.paths import Paths
+from orionis.foundation.config.filesystems.entitites.filesystems import Filesystems
+from orionis.foundation.config.logging.entities.logging import Logging
+from orionis.foundation.config.mail.entities.mail import Mail
+from orionis.foundation.config.queue.entities.queue import Queue
+from orionis.foundation.config.session.entities.session import Session
+from orionis.foundation.config.testing.entities.testing import Testing
+from orionis.test.cases.asynchronous import AsyncTestCase
+from unittest.mock import Mock
+
+class TestFoundationConfigStartup(AsyncTestCase):
+    """
+    Test suite for the Configuration dataclass.
+
+    Methods
+    -------
+    testConfigurationIsDataclass()
+        Test that Configuration is a dataclass.
+    testDefaultInitialization()
+        Test default initialization of Configuration.
+    testAllSectionsHaveDefaultFactories()
+        Test that all fields have default factories.
+    testTypeValidationInPostInit()
+        Test type validation and dict conversion in __post_init__.
+    testToDictReturnsCompleteDictionary()
+        Test that toDict() returns all configuration sections.
+    testToDictReturnsNestedStructures()
+        Test that toDict() returns nested structures as dicts.
+    testMetadataIsAccessible()
+        Test that field metadata is accessible and correct.
+    testConfigurationIsMutable()
+        Test that Configuration is mutable.
+    testConfigurationEquality()
+        Test equality of Configuration instances.
+    """
+
+    def testConfigurationIsDataclass(self):
+        """
+        Test that Configuration is a dataclass.
+
+        Returns
+        -------
+        None
+        """
+        self.assertTrue(is_dataclass(Configuration))
+
+    def testDefaultInitialization(self):
+        """
+        Test default initialization of Configuration.
+
+        Ensures all fields are initialized with their default factories.
+
+        Returns
+        -------
+        None
+        """
+        config = Configuration()
+        self.assertIsInstance(config, Configuration)
+        self.assertIsInstance(config.app, App)
+        self.assertIsInstance(config.auth, Auth)
+        self.assertIsInstance(config.cache, Cache)
+        self.assertIsInstance(config.cors, Cors)
+        self.assertIsInstance(config.database, Database)
+        self.assertIsInstance(config.filesystems, Filesystems)
+        self.assertIsInstance(config.logging, Logging)
+        self.assertIsInstance(config.mail, Mail)
+        self.assertIsInstance(config.path, Paths)
+        self.assertIsInstance(config.queue, Queue)
+        self.assertIsInstance(config.session, Session)
+        self.assertIsInstance(config.testing, Testing)
+
+    def testAllSectionsHaveDefaultFactories(self):
+        """
+        Test that all fields have default factories.
+
+        Returns
+        -------
+        None
+        """
+        config = Configuration()
+        for field in config.__dataclass_fields__.values():
+            self.assertTrue(callable(field.default_factory),
+                            f"Field {field.name} is missing default_factory")
+
+    def testTypeValidationInPostInit(self):
+        """
+        Test type validation and dict conversion in __post_init__.
+
+        Ensures that dicts are converted to entities and wrong types raise OrionisIntegrityException.
+
+        Returns
+        -------
+        None
+        """
+        # Valid dict conversion
+        config = Configuration(app={"name": "TestApp"})
+        self.assertIsInstance(config.app, App)
+
+        # Invalid types
+        sections = [
+            ('app', 123),
+            ('auth', 123),
+            ('cache', 123),
+            ('cors', 123),
+            ('database', 123),
+            ('filesystems', 123),
+            ('logging', 123),
+            ('mail', 123),
+            ('path', 123),
+            ('queue', 123),
+            ('session', 123),
+            ('testing', 123)
+        ]
+        for section_name, wrong_value in sections:
+            with self.subTest(section=section_name):
+                kwargs = {section_name: wrong_value}
+                with self.assertRaises(OrionisIntegrityException):
+                    Configuration(**kwargs)
+
+    def testToDictReturnsCompleteDictionary(self):
+        """
+        Test that toDict() returns all configuration sections.
+
+        Returns
+        -------
+        None
+        """
+        config = Configuration()
+        config_dict = config.toDict()
+        self.assertIsInstance(config_dict, dict)
+        self.assertEqual(set(config_dict.keys()), set(config.__dataclass_fields__.keys()))
+
+    def testToDictReturnsNestedStructures(self):
+        """
+        Test that toDict() returns nested structures as dicts.
+
+        Returns
+        -------
+        None
+        """
+        config = Configuration()
+        config_dict = config.toDict()
+        self.assertIsInstance(config_dict['app'], dict)
+        self.assertIsInstance(config_dict['auth'], dict)
+        self.assertIsInstance(config_dict['database'], dict)
+        self.assertIsInstance(config_dict['path'], dict)
+
+    def testMetadataIsAccessible(self):
+        """
+        Test that field metadata is accessible and correct.
+
+        Returns
+        -------
+        None
+        """
+        config = Configuration()
+        for field in config.__dataclass_fields__.values():
+            metadata = field.metadata
+            self.assertIn('description', metadata)
+            self.assertIsInstance(metadata['description'], str)
+            self.assertIn('default', metadata)
+
+    def testConfigurationIsMutable(self):
+        """
+        Test that Configuration is mutable.
+
+        Returns
+        -------
+        None
+        """
+        config = Configuration()
+        new_app = App()
+        try:
+            config.app = new_app
+        except Exception as e:
+            self.fail(f"Should be able to modify attributes, but got {type(e).__name__}")
+
+    def testConfigurationEquality(self):
+        """
+        Test equality of Configuration instances.
+
+        Returns
+        -------
+        None
+        """
+        # Ensure both configs have identical App objects, but their keys differ
+        app_data = {"name": "TestApp"}
+        config1 = Configuration(app=app_data)
+        config2 = Configuration(app=app_data)
+        # The key (e.g., a generated UUID or secret) will be different for each instance
+        self.assertNotEqual(config1, config2)

tests/testing/view/test_render.py

@@ -0,0 +1,31 @@
+from orionis.test.cases.asynchronous import AsyncTestCase
+from orionis.test.view.render import TestingResultRender
+
+class TestTestingRender(AsyncTestCase):
+
+    async def testMethodsExist(self):
+        """
+        Checks if the required methods exist in the TestingResultRender class.
+
+        This test verifies the presence of specific methods in the TestingResultRender class
+        and asserts that each required method exists. It is important for ensuring that the
+        class interface meets expectations.
+
+        Returns
+        -------
+        None
+            This method does not return any value. It performs assertions to validate method existence.
+        """
+        # List of method names that must exist in TestingResultRender
+        required_methods = [
+            "render"
+        ]
+
+        # Validate that each required method exists in the class
+        for method_name in required_methods:
+
+            # Assert that the method is present in TestingResultRender
+            self.assertTrue(
+                hasattr(TestingResultRender, method_name),
+                f"{method_name} does not exist"
+            )

foundation/config/app/test_foundation_config_app.py

@@ -1,150 +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
-
-class TestFoundationConfigApp(AsyncTestCase):
-
-    async def testDefaultValues(self):
-        """
-        Test that the App instance is created with the correct default values.
-
-        Notes
-        -----
-        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.
-
-        Notes
-        -----
-        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.
-
-        Notes
-        -----
-        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.
-
-        Notes
-        -----
-        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.
-
-        Notes
-        -----
-        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.
-
-        Notes
-        -----
-        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="")

foundation/config/root/test_foundation_config_root_paths.py

@@ -1,201 +0,0 @@
-from pathlib import Path
-from orionis.foundation.exceptions import OrionisIntegrityException
-from orionis.foundation.config.roots.paths import Paths
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigRootPaths(AsyncTestCase):
-    """
-    Test suite for the Paths dataclass which defines the project directory structure.
-
-    This class verifies the integrity of path definitions, default values,
-    and the behavior of accessor methods.
-
-    Attributes
-    ----------
-    None
-
-    Methods
-    -------
-    testDefaultPathsInstantiation()
-        Test that a Paths instance can be created with default values.
-    testRequiredPathsAreSet()
-        Test that all required paths have non-empty default values.
-    testOptionalPathsCanBeEmpty()
-        Test that optional paths can be empty strings.
-    testPathValidationRejectsNonStringValues()
-        Test that non-string path values raise OrionisIntegrityException.
-    testPathValidationRejectsEmptyRequiredPaths()
-        Test that empty required paths raise OrionisIntegrityException.
-    testToDictReturnsCompleteDictionary()
-        Test that toDict() returns a complete dictionary of all paths.
-    testPathAccessorMethodsReturnPathObjects()
-        Test that all path accessor methods return Path objects.
-    testFrozenDataclassBehavior()
-        Test that the dataclass is truly frozen (immutable).
-    testPathMetadataIsAccessible()
-        Test that path metadata is properly defined and accessible.
-    """
-
-    def testDefaultPathsInstantiation(self):
-        """
-        Test that a Paths instance can be created with default values.
-
-        Ensures that all default paths are correctly initialized and
-        the instance is properly constructed.
-        """
-        paths = Paths()
-        self.assertIsInstance(paths, Paths)
-
-    def testRequiredPathsAreSet(self):
-        """
-        Test that all required paths have non-empty default values.
-
-        Checks that paths marked as required in metadata are properly
-        initialized with valid string values.
-        """
-        paths = Paths()
-        required_fields = [
-            'console_scheduler', 'console_commands', 'http_controllers',
-            'http_middleware', 'models', 'providers', 'exceptions',
-            'views', 'routes_web', 'config', 'migrations',
-            'storage_logs', 'storage_framework'
-        ]
-        for field in required_fields:
-            value = getattr(paths, field)
-            self.assertTrue(isinstance(value, str) and len(value) > 0)
-
-    def testOptionalPathsCanBeEmpty(self):
-        """
-        Test that optional paths can be empty strings.
-
-        Verifies that paths not marked as required can be empty strings
-        without raising exceptions.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If required validation fails.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Paths(
-                http_requests='',
-                events='',
-                listeners='',
-                notifications='',
-                jobs='',
-                policies='',
-                services='',
-                lang='',
-                assets='',
-                routes_api='',
-                routes_console='',
-                routes_channels='',
-                seeders='',
-                factories='',
-                storage_sessions='',
-                storage_cache='',
-                storage_views=''
-            )
-
-    def testPathValidationRejectsNonStringValues(self):
-        """
-        Test that non-string path values raise OrionisIntegrityException.
-
-        Verifies that the __post_init__ validation rejects non-string values
-        for all path fields.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If a non-string value is provided.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Paths(console_scheduler=123)
-
-    def testPathValidationRejectsEmptyRequiredPaths(self):
-        """
-        Test that empty required paths raise OrionisIntegrityException.
-
-        Verifies that required paths cannot be empty strings.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If a required path is empty.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Paths(console_scheduler='')
-
-    def testToDictReturnsCompleteDictionary(self):
-        """
-        Test that toDict() returns a complete dictionary of all paths.
-
-        Verifies that the returned dictionary contains all path fields
-        with their current values.
-
-        Returns
-        -------
-        None
-        """
-        paths = Paths()
-        path_dict = paths.toDict()
-        self.assertIsInstance(path_dict, dict)
-        self.assertEqual(len(path_dict), len(paths.__dataclass_fields__))
-        for field in paths.__dataclass_fields__:
-            self.assertIn(field, path_dict)
-
-    def testPathAccessorMethodsReturnPathObjects(self):
-        """
-        Test that all path accessor methods return Path objects.
-
-        Verifies that each get* method returns a proper pathlib.Path instance.
-
-        Returns
-        -------
-        None
-        """
-        paths = Paths()
-        self.assertIsInstance(paths.getConsoleScheduler(), Path)
-        self.assertIsInstance(paths.getHttpControllers(), Path)
-        self.assertIsInstance(paths.getModels(), Path)
-        self.assertIsInstance(paths.getViews(), Path)
-        self.assertIsInstance(paths.getRoutesWeb(), Path)
-        self.assertIsInstance(paths.getConfig(), Path)
-        self.assertIsInstance(paths.getMigrations(), Path)
-        self.assertIsInstance(paths.getStorageLogs(), Path)
-
-    def testFrozenDataclassBehavior(self):
-        """
-        Test that the dataclass is truly frozen (immutable).
-
-        Verifies that attempts to modify attributes after creation
-        raise exceptions.
-
-        Raises
-        ------
-        Exception
-            If an attempt is made to modify a frozen dataclass.
-        """
-        paths = Paths()
-        with self.assertRaises(Exception):
-            paths.console_scheduler = 'new/path'  # type: ignore
-
-    def testPathMetadataIsAccessible(self):
-        """
-        Test that path metadata is properly defined and accessible.
-
-        Verifies that each path field has the expected metadata structure
-        with description, type, and required fields.
-
-        Returns
-        -------
-        None
-        """
-        paths = Paths()
-        for field in paths.__dataclass_fields__.values():
-            metadata = field.metadata
-            self.assertIn('description', metadata)
-            self.assertIn('type', metadata)
-            self.assertIn('required', metadata)
-            self.assertIn(metadata['type'], ['file', 'directory'])
-            self.assertIsInstance(metadata['required'], bool)