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

tests/foundation/config/mail/test_foundation_config_mail_smtp.py

@@ -1,146 +0,0 @@
-from orionis.foundation.config.mail.entities.smtp import Smtp
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigMailSmtp(AsyncTestCase):
-    """
-    Unit tests for the Smtp configuration entity.
-
-    This test suite validates the default initialization, type validation,
-    attribute-specific validation, custom initialization, dictionary conversion,
-    and keyword-only enforcement for the Smtp class.
-    """
-
-    async def testDefaultInitialization(self):
-        """
-        Test default initialization of Smtp.
-
-        Ensures that an Smtp instance is initialized with the correct default values.
-
-        Returns
-        -------
-        None
-        """
-        smtp = Smtp()
-        self.assertEqual(smtp.url, "smtp.mailtrap.io")
-        self.assertEqual(smtp.host, "smtp.mailtrap.io")
-        self.assertEqual(smtp.port, 587)
-        self.assertEqual(smtp.encryption, "TLS")
-        self.assertEqual(smtp.username, "")
-        self.assertEqual(smtp.password, "")
-        self.assertIsNone(smtp.timeout)
-
-    async def testTypeValidation(self):
-        """
-        Test type validation for Smtp attributes.
-
-        Ensures that providing invalid types for Smtp attributes raises
-        OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Smtp(url=123)
-        with self.assertRaises(OrionisIntegrityException):
-            Smtp(host=456)
-        with self.assertRaises(OrionisIntegrityException):
-            Smtp(port="invalid")
-        with self.assertRaises(OrionisIntegrityException):
-            Smtp(encryption=123)
-        with self.assertRaises(OrionisIntegrityException):
-            Smtp(username=123)
-        with self.assertRaises(OrionisIntegrityException):
-            Smtp(password=123)
-        with self.assertRaises(OrionisIntegrityException):
-            Smtp(timeout="invalid")
-
-    async def testPortValidation(self):
-        """
-        Test validation for the port attribute.
-
-        Ensures that negative port numbers raise OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Smtp(port=-1)
-
-    async def testTimeoutValidation(self):
-        """
-        Test validation for the timeout attribute.
-
-        Ensures that negative timeout values raise OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Smtp(timeout=-1)
-
-    async def testValidCustomInitialization(self):
-        """
-        Test custom initialization with valid parameters.
-
-        Ensures that valid custom values are accepted and stored correctly.
-
-        Returns
-        -------
-        None
-        """
-        custom_config = Smtp(
-            url="smtp.example.com",
-            host="mail.example.com",
-            port=465,
-            encryption="SSL",
-            username="user",
-            password="pass",
-            timeout=30
-        )
-        self.assertEqual(custom_config.url, "smtp.example.com")
-        self.assertEqual(custom_config.host, "mail.example.com")
-        self.assertEqual(custom_config.port, 465)
-        self.assertEqual(custom_config.encryption, "SSL")
-        self.assertEqual(custom_config.username, "user")
-        self.assertEqual(custom_config.password, "pass")
-        self.assertEqual(custom_config.timeout, 30)
-
-    async def testToDictMethod(self):
-        """
-        Test the toDict method of Smtp.
-
-        Ensures that the toDict method returns a dictionary containing all fields
-        with correct values.
-
-        Returns
-        -------
-        None
-        """
-        smtp = Smtp()
-        result = smtp.toDict()
-        self.assertIsInstance(result, dict)
-        self.assertEqual(result["url"], "smtp.mailtrap.io")
-        self.assertEqual(result["host"], "smtp.mailtrap.io")
-        self.assertEqual(result["port"], 587)
-        self.assertEqual(result["encryption"], "TLS")
-        self.assertEqual(result["username"], "")
-        self.assertEqual(result["password"], "")
-        self.assertIsNone(result["timeout"])
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test keyword-only initialization enforcement.
-
-        Ensures that Smtp requires keyword arguments for initialization and
-        enforces kw_only=True in its dataclass decorator.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(TypeError):
-            Smtp("smtp.mailtrap.io", "smtp.mailtrap.io", 587, "TLS", "", "", None)

tests/foundation/config/queue/test_foundation_config_queue.py

@@ -1,88 +0,0 @@
-from orionis.foundation.config.queue.entities.queue import Queue
-from orionis.foundation.config.queue.entities.brokers import Brokers
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigQueue(AsyncTestCase):
-
-    async def testDefaultInitialization(self):
-        """
-        Test default initialization of Queue.
-
-        Ensures that a Queue instance is initialized with the correct default values.
-
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        AssertionError
-            If the default value or brokers instance is incorrect.
-        """
-        queue = Queue()
-        self.assertEqual(queue.default, "sync")
-        self.assertIsInstance(queue.brokers, Brokers)
-
-    async def testDefaultValidation(self):
-        """
-        Test validation of the `default` attribute.
-
-        Checks that invalid values for the `default` attribute raise an OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If an invalid default value is provided.
-        """
-        invalid_options = ["invalid", "", 123, None]
-        for option in invalid_options:
-            with self.assertRaises(OrionisIntegrityException):
-                Queue(default=option)
-
-    async def testValidCustomInitialization(self):
-        """
-        Test custom initialization with valid parameters.
-
-        Verifies that a Queue instance can be initialized with a valid default value and a Brokers instance.
-
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        AssertionError
-            If the custom initialization does not set the attributes correctly.
-        """
-        custom_brokers = Brokers(sync=False)
-        queue = Queue(default="sync", brokers=custom_brokers)
-        self.assertEqual(queue.default, "sync")
-        self.assertIs(queue.brokers, custom_brokers)
-        self.assertFalse(queue.brokers.sync)
-
-    async def testToDictMethod(self):
-        """
-        Test the `toDict` method.
-
-        Ensures that the `toDict` method returns a dictionary representation of the Queue instance with all fields and correct values.
-
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        AssertionError
-            If the dictionary representation is incorrect.
-        """
-        queue = Queue()
-        result = queue.toDict()
-        self.assertIsInstance(result, dict)
-        self.assertEqual(result["default"], "sync")
-        self.assertIsInstance(result["brokers"], dict)
-        self.assertTrue(result["brokers"]["sync"])

tests/foundation/config/queue/test_foundation_config_queue_brokers.py

@@ -1,72 +0,0 @@
-from orionis.foundation.config.queue.entities.brokers import Brokers
-from orionis.foundation.config.queue.entities.database import Database
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigQueueBrokers(AsyncTestCase):
-
-    async def testDefaultInitialization(self):
-        """
-        Test that Brokers instance is initialized with correct default values.
-
-        Notes
-        -----
-        Verifies that `sync` is `True` by default and `database` is a `Database` instance.
-        """
-        brokers = Brokers()
-        self.assertTrue(brokers.sync)
-        self.assertIsInstance(brokers.database, Database)
-
-    async def testSyncValidation(self):
-        """
-        Test validation for the `sync` attribute.
-
-        Notes
-        -----
-        Verifies that non-boolean values for `sync` raise `OrionisIntegrityException`.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Brokers(sync="true")
-        with self.assertRaises(OrionisIntegrityException):
-            Brokers(sync=1)
-
-    async def testCustomInitialization(self):
-        """
-        Test custom initialization with valid parameters.
-
-        Notes
-        -----
-        Verifies that valid boolean and `Database` instances are accepted for initialization.
-        """
-        custom_db = Database(table="custom_queue")
-        brokers = Brokers(sync=False, database=custom_db)
-        self.assertFalse(brokers.sync)
-        self.assertIs(brokers.database, custom_db)
-        self.assertEqual(brokers.database.table, "custom_queue")
-
-    async def testToDictMethod(self):
-        """
-        Test the `toDict` method returns proper dictionary representation.
-
-        Notes
-        -----
-        Verifies all fields are included with correct values in the returned dictionary.
-        """
-        brokers = Brokers()
-        result = brokers.toDict()
-        self.assertIsInstance(result, dict)
-        self.assertIn("sync", result)
-        self.assertIn("database", result)
-        self.assertTrue(result["sync"])
-        self.assertIsInstance(result["database"], dict)
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test that Brokers requires keyword arguments for initialization.
-
-        Notes
-        -----
-        Verifies the class enforces `kw_only=True` in its dataclass decorator.
-        """
-        with self.assertRaises(TypeError):
-            Brokers(True, Database())

tests/foundation/config/queue/test_foundation_config_queue_database.py

@@ -1,134 +0,0 @@
-from orionis.foundation.config.queue.entities.database import Database
-from orionis.foundation.config.queue.enums.strategy import Strategy
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigQueueDatabase(AsyncTestCase):
-
-    async def testDefaultInitialization(self):
-        """
-        Test default initialization of Database.
-
-        Ensures that a Database instance is initialized with the correct default values for
-        table name, queue name, retry_after, and strategy.
-
-        Returns
-        -------
-        None
-        """
-        db_queue = Database()
-        self.assertEqual(db_queue.table, "jobs")
-        self.assertEqual(db_queue.queue, "default")
-        self.assertEqual(db_queue.retry_after, 90)
-        self.assertEqual(db_queue.strategy, Strategy.FIFO.value)
-
-    async def testTableNameValidation(self):
-        """
-        Test validation of the table name attribute.
-
-        Checks that invalid table names raise an OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Database(table="1jobs")  # Starts with number
-        with self.assertRaises(OrionisIntegrityException):
-            Database(table="Jobs")  # Uppercase letter
-        with self.assertRaises(OrionisIntegrityException):
-            Database(table="jobs-table")  # Invalid character
-        with self.assertRaises(OrionisIntegrityException):
-            Database(table=123)  # Non-string value
-
-    async def testQueueNameValidation(self):
-        """
-        Test validation of the queue name attribute.
-
-        Checks that non-ASCII queue names and non-string values raise an OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Database(queue="café")  # Non-ASCII character
-        with self.assertRaises(OrionisIntegrityException):
-            Database(queue=123)  # Non-string value
-
-    async def testRetryAfterValidation(self):
-        """
-        Test validation of the retry_after attribute.
-
-        Ensures that non-positive integers and non-integer values raise an OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Database(retry_after=0)
-        with self.assertRaises(OrionisIntegrityException):
-            Database(retry_after=-1)
-        with self.assertRaises(OrionisIntegrityException):
-            Database(retry_after="90")  # String instead of int
-
-    async def testStrategyValidation(self):
-        """
-        Test validation and normalization of the strategy attribute.
-
-        Verifies that both string and Strategy enum inputs are handled properly, and that
-        invalid inputs raise an OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        # Test string inputs (case-insensitive)
-        db1 = Database(strategy="fifo")
-        self.assertEqual(db1.strategy, Strategy.FIFO.value)
-        db2 = Database(strategy="LIFO")
-        self.assertEqual(db2.strategy, Strategy.LIFO.value)
-
-        # Test enum inputs
-        db3 = Database(strategy=Strategy.PRIORITY)
-        self.assertEqual(db3.strategy, Strategy.PRIORITY.value)
-
-        # Test invalid inputs
-        with self.assertRaises(OrionisIntegrityException):
-            Database(strategy="invalid_strategy")
-        with self.assertRaises(OrionisIntegrityException):
-            Database(strategy=123)
-
-    async def testToDictMethod(self):
-        """
-        Test the toDict method.
-
-        Ensures that the toDict method returns a dictionary representation of the Database
-        instance with all fields included and correct values.
-
-        Returns
-        -------
-        None
-        """
-        db_queue = Database()
-        result = db_queue.toDict()
-        self.assertIsInstance(result, dict)
-        self.assertEqual(result["table"], "jobs")
-        self.assertEqual(result["queue"], "default")
-        self.assertEqual(result["retry_after"], 90)
-        self.assertEqual(result["strategy"], Strategy.FIFO.value)
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test keyword-only initialization enforcement.
-
-        Ensures that the Database class requires keyword arguments for initialization,
-        enforcing kw_only=True in its dataclass decorator.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(TypeError):
-            Database("jobs", "default", 90, Strategy.FIFO)

tests/foundation/config/root/test_foundation_config_root_paths.py

@@ -1,112 +0,0 @@
-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 contains asynchronous unit tests to verify the integrity, default values,
-    type constraints, immutability, and metadata accessibility of the `Paths` dataclass.
-    """
-
-    def testDefaultPathsInstantiation(self):
-        """
-        Test instantiation of `Paths` with default values.
-
-        Ensures that a `Paths` instance can be created using default arguments and
-        that the resulting object is an instance of `Paths`.
-
-        Returns
-        -------
-        None
-        """
-        paths = Paths()
-        self.assertIsInstance(paths, Paths)
-
-    def testAllPathsAreStrings(self):
-        """
-        Verify that all attributes of `Paths` are strings.
-
-        Iterates through all fields of the `Paths` dataclass and asserts that each
-        attribute is a non-empty string.
-
-        Returns
-        -------
-        None
-        """
-        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):
-        """
-        Ensure non-string path values raise `OrionisIntegrityException`.
-
-        Attempts to instantiate `Paths` with a non-string value for a path field
-        and asserts that an `OrionisIntegrityException` is raised.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Paths(console=123)
-
-    def testToDictReturnsCompleteDictionary(self):
-        """
-        Test that `toDict()` returns a complete dictionary of all path fields.
-
-        Asserts that the dictionary returned by `toDict()` contains all fields
-        defined in the `Paths` dataclass and that the dictionary has the correct length.
-
-        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):
-        """
-        Verify that the `Paths` dataclass is immutable (frozen).
-
-        Attempts to modify an attribute of a `Paths` instance after creation and
-        asserts that an exception is raised due to immutability.
-
-        Returns
-        -------
-        None
-        """
-        paths = Paths()
-        with self.assertRaises(Exception):
-            paths.console_scheduler = 'new/path'  # type: ignore
-
-    def testPathMetadataIsAccessible(self):
-        """
-        Check accessibility and structure of path field metadata.
-
-        Iterates through all fields of the `Paths` dataclass and asserts that each
-        field's metadata contains both 'description' and 'default' keys, and that
-        their values are of the expected types.
-
-        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)
-            default_value = metadata['default']
-            if callable(default_value):
-                default_value = default_value()
-            self.assertIsInstance(default_value, str)