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

tests/foundation/config/session/test_foundation_config_session.py

@@ -1,213 +0,0 @@
-from orionis.foundation.config.session.entities.session import Session
-from orionis.foundation.config.session.enums.same_site_policy import SameSitePolicy
-from orionis.foundation.exceptions import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigSession(AsyncTestCase):
-
-    async def testDefaultInitialization(self):
-        """
-        Test default initialization of the Session instance.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Checks that all attributes of the Session instance are set to their correct default values,
-        including the generation of the secret_key.
-        """
-        session = Session()
-        self.assertIsInstance(session.secret_key, str)
-        self.assertEqual(session.session_cookie, "orionis_session")
-        self.assertEqual(session.max_age, 1800)
-        self.assertEqual(session.same_site, SameSitePolicy.LAX.value)
-        self.assertEqual(session.path, "/")
-        self.assertFalse(session.https_only)
-        self.assertIsNone(session.domain)
-
-    async def testSecretKeyValidation(self):
-        """
-        Test validation of the secret_key attribute.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Ensures that providing an invalid secret_key raises an OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Session(secret_key="")  # Empty string
-        with self.assertRaises(OrionisIntegrityException):
-            Session(secret_key=123)  # Non-string value
-
-    async def testSessionCookieValidation(self):
-        """
-        Test validation of the session_cookie attribute.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Ensures that invalid session_cookie values raise an OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Session(session_cookie="")  # Empty string
-        with self.assertRaises(OrionisIntegrityException):
-            Session(session_cookie="my session")  # Contains space
-        with self.assertRaises(OrionisIntegrityException):
-            Session(session_cookie="session;")  # Contains semicolon
-
-    async def testMaxAgeValidation(self):
-        """
-        Test validation of the max_age attribute.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Ensures that invalid max_age values raise an OrionisIntegrityException.
-        Also verifies that None is accepted as a valid value.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Session(max_age="3600")  # String instead of int
-        with self.assertRaises(OrionisIntegrityException):
-            Session(max_age=-1)  # Negative value
-        # Test None is acceptable
-        session = Session(max_age=None)
-        self.assertIsNone(session.max_age)
-
-    async def testSameSiteValidation(self):
-        """
-        Test validation and normalization of the same_site attribute.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Ensures that both string and enum inputs for same_site are handled correctly.
-        Also checks that invalid values raise an OrionisIntegrityException.
-        """
-        # Test string inputs (case-insensitive)
-        session1 = Session(same_site="strict")
-        self.assertEqual(session1.same_site, SameSitePolicy.STRICT.value)
-        session2 = Session(same_site="NONE")
-        self.assertEqual(session2.same_site, SameSitePolicy.NONE.value)
-
-        # Test enum inputs
-        session3 = Session(same_site=SameSitePolicy.LAX)
-        self.assertEqual(session3.same_site, SameSitePolicy.LAX.value)
-
-        # Test invalid inputs
-        with self.assertRaises(OrionisIntegrityException):
-            Session(same_site="invalid")
-        with self.assertRaises(OrionisIntegrityException):
-            Session(same_site=123)
-
-    async def testPathValidation(self):
-        """
-        Test validation of the path attribute.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Ensures that invalid path values raise an OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Session(path="")  # Empty string
-        with self.assertRaises(OrionisIntegrityException):
-            Session(path="api")  # Doesn't start with /
-        with self.assertRaises(OrionisIntegrityException):
-            Session(path=123)  # Non-string value
-
-    async def testHttpsOnlyValidation(self):
-        """
-        Test validation of the https_only attribute.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Ensures that non-boolean values for https_only raise an OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Session(https_only="true")  # String instead of bool
-        with self.assertRaises(OrionisIntegrityException):
-            Session(https_only=1)  # Integer instead of bool
-
-    async def testDomainValidation(self):
-        """
-        Test validation of the domain attribute.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Ensures that invalid domain values raise an OrionisIntegrityException.
-        Also verifies that None is accepted as a valid value.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Session(domain=".example.com")  # Starts with dot
-        with self.assertRaises(OrionisIntegrityException):
-            Session(domain="example.com.")  # Ends with dot
-        with self.assertRaises(OrionisIntegrityException):
-            Session(domain="example..com")  # Contains consecutive dots
-
-        # Test None is acceptable
-        session = Session(domain=None)
-        self.assertIsNone(session.domain)
-
-    async def testToDictMethod(self):
-        """
-        Test the toDict method of the Session instance.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Ensures that the toDict method returns a dictionary containing all fields with correct values.
-        """
-        session = Session()
-        result = session.toDict()
-        self.assertIsInstance(result, dict)
-        self.assertIn("secret_key", result)
-        self.assertEqual(result["session_cookie"], "orionis_session")
-        self.assertEqual(result["max_age"], 1800)
-        self.assertEqual(result["same_site"], SameSitePolicy.LAX.value)
-        self.assertEqual(result["path"], "/")
-        self.assertFalse(result["https_only"])
-        self.assertIsNone(result["domain"])
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test enforcement of keyword-only initialization for Session.
-
-        Returns
-        -------
-        None
-
-        Notes
-        -----
-        Ensures that the Session class enforces keyword-only arguments during initialization
-        by raising a TypeError when positional arguments are provided.
-        """
-        with self.assertRaises(TypeError):
-            Session("key", "session")

tests/foundation/config/startup/test_foundation_config_startup.py

@@ -1,202 +0,0 @@
-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
-
-class TestFoundationConfigStartup(AsyncTestCase):
-    """
-    Test suite for the `Configuration` dataclass, validating its structure, initialization,
-    type enforcement, mutability, equality, and dictionary conversion.
-
-    Methods
-    -------
-    testConfigurationIsDataclass
-        Verify that `Configuration` is a dataclass.
-    testDefaultInitialization
-        Ensure all fields of `Configuration` are initialized with their default factories and correct types.
-    testAllSectionsHaveDefaultFactories
-        Check that every field in `Configuration` has a callable default factory.
-    testTypeValidationInPostInit
-        Confirm that type validation and dictionary conversion occur in `__post_init__`,
-        and that invalid types raise `OrionisIntegrityException`.
-    testToDictReturnsCompleteDictionary
-        Assert that `toDict()` returns a dictionary containing all configuration sections.
-    testToDictReturnsNestedStructures
-        Ensure that nested configuration sections are represented as dictionaries in `toDict()` output.
-    testMetadataIsAccessible
-        Validate that field metadata is accessible and contains required keys and types.
-    testConfigurationIsMutable
-        Check that attributes of `Configuration` can be modified after initialization.
-    testConfigurationEquality
-        Test equality comparison between `Configuration` instances, especially with differing keys.
-    """
-
-    def testConfigurationIsDataclass(self):
-        """
-        Verify that `Configuration` is implemented as a dataclass.
-
-        Returns
-        -------
-        None
-        """
-        self.assertTrue(is_dataclass(Configuration))
-
-    def testDefaultInitialization(self):
-        """
-        Ensure all fields of `Configuration` are initialized with their default factories
-        and are instances of their respective entity classes.
-
-        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):
-        """
-        Check that every field in `Configuration` has a callable default factory.
-
-        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):
-        """
-        Confirm that type validation and dictionary conversion occur in `__post_init__`.
-        Validates that dictionaries are converted to entity instances and invalid types
-        raise `OrionisIntegrityException`.
-
-        Returns
-        -------
-        None
-        """
-        # Valid dict conversion
-        config = Configuration(app={"name": "TestApp"})
-        self.assertIsInstance(config.app, App)
-
-        # Invalid types for each section should raise an exception
-        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):
-        """
-        Assert that `toDict()` returns a dictionary containing 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):
-        """
-        Ensure that nested configuration sections are represented as dictionaries
-        in the output of `toDict()`.
-
-        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):
-        """
-        Validate that field metadata is accessible and contains the 'description' key
-        as a string and the 'default' key.
-
-        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):
-        """
-        Check that attributes of `Configuration` can be modified after initialization.
-
-        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 comparison between `Configuration` instances, ensuring that
-        instances with differing keys are not considered equal.
-
-        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/foundation/config/testing/test_foundation_config_testing.py

@@ -1,235 +0,0 @@
-from orionis.foundation.config.testing.entities.testing import Testing
-from orionis.foundation.config.testing.enums.mode import ExecutionMode
-from orionis.foundation.exceptions import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigTesting(AsyncTestCase):
-    """
-    Test suite for the Testing configuration entity.
-
-    This class contains asynchronous test cases to validate the default values,
-    custom values, and integrity constraints of the Testing configuration.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Test the default values of the Testing configuration.
-
-        Notes
-        -----
-        Ensures that all default attributes of the Testing configuration are set
-        as expected.
-        """
-        t = Testing()
-        self.assertEqual(t.verbosity, 2)
-        self.assertEqual(t.execution_mode, ExecutionMode.SEQUENTIAL.value)
-        self.assertTrue(isinstance(t.max_workers, int) and t.max_workers >= 1)
-        self.assertFalse(t.fail_fast)
-        self.assertTrue(t.print_result)
-        self.assertFalse(t.throw_exception)
-        self.assertEqual(t.base_path, "tests")
-        self.assertEqual(t.folder_path, "*")
-        self.assertEqual(t.pattern, "test_*.py")
-        self.assertIsNone(t.test_name_pattern)
-        self.assertEqual(t.tags, [])
-
-    async def testValidCustomValues(self):
-        """
-        Test custom valid values for all fields.
-
-        Notes
-        -----
-        Verifies that the Testing configuration accepts and correctly sets
-        custom valid values for all its fields.
-        """
-        t = Testing(
-            verbosity=1,
-            execution_mode=ExecutionMode.PARALLEL,
-            max_workers=4,
-            fail_fast=True,
-            print_result=False,
-            throw_exception=True,
-            base_path="my_tests",
-            folder_path=["unit", "integration"],
-            pattern="*_spec.py",
-            test_name_pattern="test_login*",
-            tags=["fast", "critical"]
-        )
-        self.assertEqual(t.verbosity, 1)
-        self.assertEqual(t.execution_mode, ExecutionMode.PARALLEL.value)
-        self.assertEqual(t.max_workers, 4)
-        self.assertTrue(t.fail_fast)
-        self.assertFalse(t.print_result)
-        self.assertTrue(t.throw_exception)
-        self.assertEqual(t.base_path, "my_tests")
-        self.assertEqual(t.folder_path, ["unit", "integration"])
-        self.assertEqual(t.pattern, "*_spec.py")
-        self.assertEqual(t.test_name_pattern, "test_login*")
-        self.assertEqual(t.tags, ["fast", "critical"])
-
-    async def testFolderPathStringAndList(self):
-        """
-        Test folder_path accepts both string and list of strings.
-
-        Notes
-        -----
-        Checks that the folder_path attribute can be set as a string or a list of strings.
-        """
-        t1 = Testing(folder_path="integration")
-        self.assertEqual(t1.folder_path, "integration")
-        t2 = Testing(folder_path=["integration", "unit"])
-        self.assertEqual(t2.folder_path, ["integration", "unit"])
-
-    async def testTagsNoneOrList(self):
-        """
-        Test tags accepts None or list of strings.
-
-        Notes
-        -----
-        Ensures that the tags attribute can be set to None or a list of strings.
-        """
-        t1 = Testing(tags=None)
-        self.assertIsNone(t1.tags)
-        t2 = Testing(tags=["a", "b"])
-        self.assertEqual(t2.tags, ["a", "b"])
-
-    async def testInvalidVerbosity(self):
-        """
-        Test invalid verbosity values.
-
-        Notes
-        -----
-        Verifies that invalid verbosity values raise OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(verbosity=-1)
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(verbosity=3)
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(verbosity="high")
-
-    async def testInvalidExecutionMode(self):
-        """
-        Test execution_mode cannot be None.
-
-        Notes
-        -----
-        Ensures that setting execution_mode to None raises OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(execution_mode=None)
-
-    async def testInvalidMaxWorkers(self):
-        """
-        Test invalid max_workers values.
-
-        Notes
-        -----
-        Checks that invalid values for max_workers raise OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(max_workers=0)
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(max_workers=-5)
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(max_workers="many")
-
-    async def testInvalidFailFast(self):
-        """
-        Test fail_fast must be boolean.
-
-        Notes
-        -----
-        Ensures that non-boolean values for fail_fast raise OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(fail_fast="yes")
-
-    async def testInvalidPrintResult(self):
-        """
-        Test print_result must be boolean.
-
-        Notes
-        -----
-        Ensures that non-boolean values for print_result raise OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(print_result=1)
-
-    async def testInvalidThrowException(self):
-        """
-        Test throw_exception must be boolean.
-
-        Notes
-        -----
-        Ensures that non-boolean values for throw_exception raise OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(throw_exception="no")
-
-    async def testInvalidBasePath(self):
-        """
-        Test base_path must be string.
-
-        Notes
-        -----
-        Ensures that non-string values for base_path raise OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(base_path=123)
-
-    async def testInvalidFolderPath(self):
-        """
-        Test folder_path must be string or list of strings.
-
-        Notes
-        -----
-        Ensures that invalid types for folder_path raise OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(folder_path=123)
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(folder_path=[1, 2])
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(folder_path=["ok", 2])
-
-    async def testInvalidPattern(self):
-        """
-        Test pattern must be string.
-
-        Notes
-        -----
-        Ensures that non-string values for pattern raise OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(pattern=[])
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(pattern=123)
-
-    async def testInvalidTestNamePattern(self):
-        """
-        Test test_name_pattern must be string or None.
-
-        Notes
-        -----
-        Ensures that invalid types for test_name_pattern raise OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(test_name_pattern=[])
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(test_name_pattern=123)
-
-    async def testInvalidTags(self):
-        """
-        Test tags must be None or list of strings.
-
-        Notes
-        -----
-        Ensures that invalid types for tags raise OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(tags="fast")
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(tags=[1, 2])
-        with self.assertRaises(OrionisIntegrityException):
-            Testing(tags=["ok", 2])