orionis 0.418.0__py3-none-any.whl → 0.420.0__py3-none-any.whl

{foundation → tests/foundation}/config/database/test_foundation_config_database_pgsql.py

@@ -26,9 +26,9 @@ class TestFoundationConfigDatabasePgsql(AsyncTestCase):
         pgsql = PGSQL()
         self.assertEqual(pgsql.driver, 'pgsql')
         self.assertEqual(pgsql.host, '127.0.0.1')
-        self.assertEqual(pgsql.port, '5432')
+        self.assertEqual(pgsql.port, 5432)
         self.assertEqual(pgsql.database, 'orionis')
-        self.assertEqual(pgsql.username, 'root')
+        self.assertEqual(pgsql.username, 'postgres')
         self.assertEqual(pgsql.password, '')
         self.assertEqual(pgsql.charset, PGSQLCharset.UTF8.value)
         self.assertEqual(pgsql.prefix, '')
@@ -79,7 +79,7 @@ class TestFoundationConfigDatabasePgsql(AsyncTestCase):
         with self.assertRaises(OrionisIntegrityException):
             PGSQL(port='abc')
         with self.assertRaises(OrionisIntegrityException):
-            PGSQL(port=5432)  # Should be string
+            PGSQL(port='string')
 
     async def testDatabaseValidation(self):
         """
@@ -213,9 +213,9 @@ class TestFoundationConfigDatabasePgsql(AsyncTestCase):
         pgsql_dict = pgsql.toDict()
         self.assertEqual(pgsql_dict['driver'], 'pgsql')
         self.assertEqual(pgsql_dict['host'], '127.0.0.1')
-        self.assertEqual(pgsql_dict['port'], '5432')
+        self.assertEqual(pgsql_dict['port'], 5432)
         self.assertEqual(pgsql_dict['database'], 'orionis')
-        self.assertEqual(pgsql_dict['username'], 'root')
+        self.assertEqual(pgsql_dict['username'], 'postgres')
         self.assertEqual(pgsql_dict['password'], '')
         self.assertEqual(pgsql_dict['charset'], PGSQLCharset.UTF8.value)
         self.assertEqual(pgsql_dict['prefix'], '')

{foundation → tests/foundation}/config/queue/test_foundation_config_queue.py

@@ -44,26 +44,6 @@ class TestFoundationConfigQueue(AsyncTestCase):
             with self.assertRaises(OrionisIntegrityException):
                 Queue(default=option)
 
-    async def testBrokersValidation(self):
-        """
-        Test validation of the `brokers` attribute.
-
-        Ensures that non-Brokers values for the `brokers` attribute raise an OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If a non-Brokers value is provided for brokers.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Queue(brokers="invalid_brokers")
-        with self.assertRaises(OrionisIntegrityException):
-            Queue(brokers={})
-
     async def testValidCustomInitialization(self):
         """
         Test custom initialization with valid parameters.

{foundation → tests/foundation}/config/queue/test_foundation_config_queue_brokers.py

@@ -29,19 +29,6 @@ class TestFoundationConfigQueueBrokers(AsyncTestCase):
         with self.assertRaises(OrionisIntegrityException):
             Brokers(sync=1)
 
-    async def testDatabaseValidation(self):
-        """
-        Test validation for the `database` attribute.
-
-        Notes
-        -----
-        Verifies that non-`Database` values for `database` raise `OrionisIntegrityException`.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Brokers(database="invalid_database")
-        with self.assertRaises(OrionisIntegrityException):
-            Brokers(database={})
-
     async def testCustomInitialization(self):
         """
         Test custom initialization with valid parameters.

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)

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="")