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

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)

foundation/config/startup/test_foundation_config_startup.py

@@ -1,205 +0,0 @@
-from dataclasses import is_dataclass
-from orionis.foundation.exceptions import OrionisIntegrityException
-from orionis.foundation.config.startup import Configuration
-from orionis.test.cases.asynchronous import AsyncTestCase
-from unittest.mock import Mock
-
-class TestFoundationConfigStartup(AsyncTestCase):
-    """
-    Test suite for the Configuration dataclass.
-
-    This class contains unit tests to verify the correct behavior of the
-    Configuration dataclass, including initialization, type validation,
-    dictionary conversion, metadata accessibility, mutability, and equality.
-
-    Attributes
-    ----------
-    None
-
-    Methods
-    -------
-    testConfigurationIsDataclass()
-        Test that Configuration is properly defined as a dataclass.
-    testDefaultInitialization()
-        Test that Configuration can be initialized with default values.
-    testAllSectionsHaveDefaultFactories()
-        Test that all configuration sections have default factories.
-    testTypeValidationInPostInit()
-        Test that __post_init__ validates types correctly.
-    testToDictReturnsCompleteDictionary()
-        Test that toDict() returns a complete dictionary representation.
-    testToDictReturnsNestedStructures()
-        Test that toDict() properly converts nested dataclasses.
-    testMetadataIsAccessible()
-        Test that field metadata is properly defined and accessible.
-    testConfigurationIsMutable()
-        Test that Configuration is mutable (not frozen).
-    testConfigurationEquality()
-        Test that Configuration instances with same values are equal.
-    """
-
-    def testConfigurationIsDataclass(self):
-        """
-        Test that Configuration is properly defined as a dataclass.
-
-        Ensures that the @dataclass decorator was applied correctly.
-
-        Returns
-        -------
-        None
-        """
-        self.assertTrue(is_dataclass(Configuration))
-
-    def testDefaultInitialization(self):
-        """
-        Test that Configuration can be initialized with default values.
-
-        Verifies that all default factories work correctly and the instance
-        is properly constructed.
-
-        Returns
-        -------
-        None
-        """
-        config = Configuration()
-        self.assertIsInstance(config, Configuration)
-
-    def testAllSectionsHaveDefaultFactories(self):
-        """
-        Test that all configuration sections have default factories.
-
-        Verifies that each field in the Configuration class has a
-        default_factory specified.
-
-        Returns
-        -------
-        None
-        """
-        config = Configuration()
-        for field in config.__dataclass_fields__.values():
-            self.assertTrue(hasattr(field, 'default_factory'),
-                            f"Field {field.name} is missing default_factory")
-
-    def testTypeValidationInPostInit(self):
-        """
-        Test that __post_init__ validates types correctly.
-
-        Verifies that the type checking for each configuration section
-        works as expected.
-
-        Returns
-        -------
-        None
-        """
-        # Test with all correct types (should not raise)
-        try:
-            Configuration()
-        except OrionisIntegrityException:
-            self.fail("__post_init__ raised exception with valid types")
-
-        # Test each section with wrong type
-        sections = [
-            ('paths', Mock()),
-            ('app', Mock()),
-            ('auth', Mock()),
-            ('cache', Mock()),
-            ('cors', Mock()),
-            ('database', Mock()),
-            ('filesystems', Mock()),
-            ('logging', Mock()),
-            ('mail', Mock()),
-            ('queue', Mock()),
-            ('session', Mock()),
-            ('testing', Mock())
-        ]
-
-        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 a complete dictionary representation.
-
-        Verifies that the returned dictionary contains all configuration
-        sections with their current values.
-
-        Returns
-        -------
-        None
-        """
-        config = Configuration()
-        config_dict = config.toDict()
-        self.assertIsInstance(config_dict, dict)
-        self.assertEqual(len(config_dict), len(config.__dataclass_fields__))
-        for field in config.__dataclass_fields__:
-            self.assertIn(field, config_dict)
-
-    def testToDictReturnsNestedStructures(self):
-        """
-        Test that toDict() properly converts nested dataclasses.
-
-        Verifies that the dictionary conversion works recursively for
-        all nested configuration sections.
-
-        Returns
-        -------
-        None
-        """
-        config = Configuration()
-        config_dict = config.toDict()
-        self.assertIsInstance(config_dict['paths'], dict)
-        self.assertIsInstance(config_dict['app'], dict)
-        self.assertIsInstance(config_dict['database'], dict)
-
-    def testMetadataIsAccessible(self):
-        """
-        Test that field metadata is properly defined and accessible.
-
-        Verifies that each configuration section field has the expected
-        metadata structure with description.
-
-        Returns
-        -------
-        None
-        """
-        config = Configuration()
-        for field in config.__dataclass_fields__.values():
-            metadata = field.metadata
-            self.assertIn('description', metadata)
-            self.assertIsInstance(metadata['description'], str)
-
-    def testConfigurationIsMutable(self):
-        """
-        Test that Configuration is mutable (not frozen).
-
-        Verifies that attributes can be modified after creation since
-        the dataclass isn't marked as frozen.
-
-        Returns
-        -------
-        None
-        """
-        config = Configuration()
-        new_paths = config.paths.__class__()
-
-        try:
-            config.paths = new_paths
-        except Exception as e:
-            self.fail(f"Should be able to modify attributes, but got {type(e).__name__}")
-
-    def testConfigurationEquality(self):
-        """
-        Test that Configuration instances with same values are equal.
-
-        Verifies that dataclass equality comparison works as expected.
-
-        Returns
-        -------
-        None
-        """
-        config1 = Configuration()
-        config2 = Configuration()
-        self.assertNotEqual(config1, config2)

foundation/exceptions/test_foundation_config_exceptions.py

@@ -1,117 +0,0 @@
-from orionis.foundation.exceptions import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigExceptions(AsyncTestCase):
-    """
-    Test cases for the OrionisIntegrityException class.
-
-    Notes
-    -----
-    These tests verify the initialization, inheritance, string representation,
-    handling of different message types, raising and catching, and exception
-    chaining behavior of the OrionisIntegrityException.
-    """
-
-    async def testExceptionInitialization(self):
-        """
-        Test initialization of OrionisIntegrityException with a message.
-
-        Verifies
-        --------
-        - The exception stores and returns the provided message correctly.
-        """
-        test_msg = "Test integrity violation message"
-        exception = OrionisIntegrityException(test_msg)
-        self.assertEqual(str(exception), test_msg)
-        self.assertEqual(exception.args[0], test_msg)
-
-    async def testExceptionInheritance(self):
-        """
-        Test inheritance of OrionisIntegrityException.
-
-        Verifies
-        --------
-        - OrionisIntegrityException properly inherits from Exception.
-        - The exception hierarchy is correctly implemented.
-        """
-        exception = OrionisIntegrityException("Test")
-        self.assertIsInstance(exception, Exception)
-        self.assertTrue(issubclass(OrionisIntegrityException, Exception))
-
-    async def testExceptionStringRepresentation(self):
-        """
-        Test string representation of OrionisIntegrityException.
-
-        Verifies
-        --------
-        - The __str__ method returns the expected format.
-        """
-        test_msg = "Configuration validation failed"
-        exception = OrionisIntegrityException(test_msg)
-        self.assertEqual(str(exception), test_msg)
-
-    async def testExceptionWithEmptyMessage(self):
-        """
-        Test OrionisIntegrityException with an empty message.
-
-        Verifies
-        --------
-        - The exception handles empty messages correctly.
-        """
-        exception = OrionisIntegrityException("")
-        self.assertEqual(str(exception), "")
-
-    async def testExceptionWithNonStringMessage(self):
-        """
-        Test OrionisIntegrityException with non-string message types.
-
-        Verifies
-        --------
-        - The exception converts non-string messages to strings.
-
-        Tests
-        -----
-        - Integer message
-        - List message
-        """
-        # Test with integer
-        exception = OrionisIntegrityException(123)
-        self.assertEqual(str(exception), "123")
-
-        # Test with list
-        exception = OrionisIntegrityException(["error1", "error2"])
-        self.assertEqual(str(exception), "['error1', 'error2']")
-
-    async def testExceptionRaiseAndCatch(self):
-        """
-        Test raising and catching OrionisIntegrityException.
-
-        Verifies
-        --------
-        - The exception can be properly raised and caught.
-        """
-        test_msg = "Test exception handling"
-        try:
-            raise OrionisIntegrityException(test_msg)
-        except OrionisIntegrityException as e:
-            self.assertEqual(str(e), test_msg)
-        except Exception:
-            self.fail("OrionisIntegrityException should be caught by its specific handler")
-
-    async def testExceptionChaining(self):
-        """
-        Test exception chaining with OrionisIntegrityException.
-
-        Verifies
-        --------
-        - The exception works correctly in chained exception scenarios.
-        - The __cause__ attribute is set as expected.
-        """
-        try:
-            try:
-                raise ValueError("Original error")
-            except ValueError as ve:
-                raise OrionisIntegrityException("Wrapper error") from ve
-        except OrionisIntegrityException as oe:
-            self.assertIsInstance(oe.__cause__, ValueError)
-            self.assertEqual(str(oe.__cause__), "Original error")

orionis/_contracts/application.py

@@ -1,41 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import List, Type
-from orionis._contracts.container.container import IContainer
-from orionis._contracts.providers.service_provider import IServiceProvider
-
-class IApplication(ABC):
-    """
-    Abstract base class for the Application.
-    """
-
-    @abstractmethod
-    def withProviders(self, providers: List[Type["IServiceProvider"]]) -> None:
-        """
-        Sets custom service providers.
-
-        Parameters
-        ----------
-        providers : List[Type[ServiceProvider]]
-            List of service providers.
-        """
-        pass
-
-    @abstractmethod
-    def container(self) -> "IContainer":
-        """
-        Returns the service container instance.
-
-        Returns
-        -------
-        IContainer
-            The service container.
-        """
-        pass
-
-    @abstractmethod
-    def create(self) -> None:
-        """
-        Initializes and boots the application, including loading commands
-        and service providers.
-        """
-        pass

orionis/_contracts/config/config.py

@@ -1,27 +0,0 @@
-from abc import ABC
-from dataclasses import dataclass
-
-@dataclass
-class EmptyData:
-    """
-    A placeholder dataclass that can be used as a default or empty configuration.
-    This class doesn't have any fields or data, but serves as a default value
-    for the 'config' attribute in classes implementing IConfig.
-    """
-    pass
-
-class IConfig(ABC):
-    """
-    An abstract base class that defines an interface for classes that must have
-    a `config` attribute.
-
-    The subclass is required to implement the `config` attribute, which should be
-    a dataclass instance representing the configuration data.
-
-    Attributes
-    ----------
-    config : object
-        A dataclass instance representing the configuration.
-    """
-
-    config = EmptyData()