orionis 0.286.0__py3-none-any.whl → 0.288.0__py3-none-any.whl

tests/foundation/config/mail/test_foundation_config_mail_mailers.py

@@ -0,0 +1,106 @@
+from orionis.foundation.config.mail.entities.mailers import Mailers
+from orionis.foundation.config.mail.entities.smtp import Smtp
+from orionis.foundation.config.mail.entities.file import File
+from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestFoundationConfigMailMailers(TestCase):
+    """
+    Unit tests for the Mailers class.
+
+    This test suite verifies the correct initialization, type validation,
+    custom initialization, dictionary conversion, and keyword-only enforcement
+    of the Mailers class.
+    """
+
+    async def testDefaultInitialization(self):
+        """
+        Test default initialization of Mailers.
+
+        Ensures that a Mailers instance is initialized with default factories
+        and that the `smtp` and `file` attributes are instances of their
+        respective types.
+
+        Returns
+        -------
+        None
+        """
+        mailers = Mailers()
+        self.assertIsInstance(mailers.smtp, Smtp)
+        self.assertIsInstance(mailers.file, File)
+
+    async def testTypeValidation(self):
+        """
+        Test type validation for smtp and file attributes.
+
+        Ensures that providing invalid types for `smtp` or `file` raises
+        an OrionisIntegrityException.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If an invalid type is provided for `smtp` or `file`.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Mailers(smtp="invalid_smtp")
+        with self.assertRaises(OrionisIntegrityException):
+            Mailers(file="invalid_file")
+
+    async def testCustomInitialization(self):
+        """
+        Test custom initialization with valid parameters.
+
+        Ensures that valid Smtp and File instances can be provided to the
+        Mailers constructor and are correctly assigned.
+
+        Returns
+        -------
+        None
+        """
+        custom_smtp = Smtp()
+        custom_file = File()
+        mailers = Mailers(smtp=custom_smtp, file=custom_file)
+        self.assertIs(mailers.smtp, custom_smtp)
+        self.assertIs(mailers.file, custom_file)
+
+    async def testToDictMethod(self):
+        """
+        Test the toDict method of Mailers.
+
+        Ensures that the `toDict` method returns a dictionary representation
+        containing all fields with correct values and types.
+
+        Returns
+        -------
+        None
+        """
+        mailers = Mailers()
+        result = mailers.toDict()
+        self.assertIsInstance(result, dict)
+        self.assertIn("smtp", result)
+        self.assertIn("file", result)
+        self.assertIsInstance(result["smtp"], dict)
+        self.assertIsInstance(result["file"], dict)
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test keyword-only initialization enforcement.
+
+        Ensures that the Mailers class enforces keyword-only arguments
+        during initialization (i.e., `kw_only=True` in its dataclass decorator).
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        TypeError
+            If positional arguments are provided to the constructor.
+        """
+        with self.assertRaises(TypeError):
+            Mailers(Smtp(), File())

tests/foundation/config/mail/{test_mail_smtp.py → test_foundation_config_mail_smtp.py}

@@ -2,12 +2,24 @@ from orionis.foundation.config.mail.entities.smtp import Smtp
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestSmtp(TestCase):
+class TestFoundationConfigMailSmtp(TestCase):
+    """
+    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 that Smtp instance is initialized with correct default values.
-        Verifies all default values match the expected configuration.
+        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")
@@ -20,8 +32,14 @@ class TestSmtp(TestCase):
 
     async def testTypeValidation(self):
         """
-        Test type validation for all Smtp attributes.
-        Verifies that invalid types raise OrionisIntegrityException.
+        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)
@@ -40,16 +58,26 @@ class TestSmtp(TestCase):
 
     async def testPortValidation(self):
         """
-        Test specific validation for port attribute.
-        Verifies that negative port numbers raise OrionisIntegrityException.
+        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 specific validation for timeout attribute.
-        Verifies that negative timeout values raise OrionisIntegrityException.
+        Test validation for the timeout attribute.
+
+        Ensures that negative timeout values raise OrionisIntegrityException.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(OrionisIntegrityException):
             Smtp(timeout=-1)
@@ -57,7 +85,12 @@ class TestSmtp(TestCase):
     async def testValidCustomInitialization(self):
         """
         Test custom initialization with valid parameters.
-        Verifies that valid custom values are accepted and stored correctly.
+
+        Ensures that valid custom values are accepted and stored correctly.
+
+        Returns
+        -------
+        None
         """
         custom_config = Smtp(
             url="smtp.example.com",
@@ -78,8 +111,14 @@ class TestSmtp(TestCase):
 
     async def testToDictMethod(self):
         """
-        Test the toDict method returns proper dictionary representation.
-        Verifies the method returns a dict containing all fields with correct values.
+        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()
@@ -92,11 +131,16 @@ class TestSmtp(TestCase):
         self.assertEqual(result["password"], "")
         self.assertIsNone(result["timeout"])
 
-
     async def testKwOnlyInitialization(self):
         """
-        Test that Smtp requires keyword arguments for initialization.
-        Verifies the class enforces kw_only=True in its dataclass decorator.
+        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

@@ -0,0 +1,111 @@
+from orionis.foundation.config.queue.entities.queue import Queue
+from orionis.foundation.config.queue.entities.brokers import Brokers
+from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestFoundationConfigQueue(TestCase):
+    """
+    Test suite for the Queue class.
+    """
+
+    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 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.
+
+        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_queue_brokers.py → test_foundation_config_queue_brokers.py}

@@ -3,12 +3,14 @@ from orionis.foundation.config.queue.entities.database import Database
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestBrokers(TestCase):
-
+class TestFoundationConfigQueueBrokers(TestCase):
     async def testDefaultInitialization(self):
         """
         Test that Brokers instance is initialized with correct default values.
-        Verifies that sync is True by default and database is a Database instance.
+
+        Notes
+        -----
+        Verifies that `sync` is `True` by default and `database` is a `Database` instance.
         """
         brokers = Brokers()
         self.assertTrue(brokers.sync)
@@ -16,8 +18,11 @@ class TestBrokers(TestCase):
 
     async def testSyncValidation(self):
         """
-        Test validation for sync attribute.
-        Verifies that non-boolean values raise OrionisIntegrityException.
+        Test validation for the `sync` attribute.
+
+        Notes
+        -----
+        Verifies that non-boolean values for `sync` raise `OrionisIntegrityException`.
         """
         with self.assertRaises(OrionisIntegrityException):
             Brokers(sync="true")
@@ -26,8 +31,11 @@ class TestBrokers(TestCase):
 
     async def testDatabaseValidation(self):
         """
-        Test validation for database attribute.
-        Verifies that non-Database values raise OrionisIntegrityException.
+        Test validation for the `database` attribute.
+
+        Notes
+        -----
+        Verifies that non-`Database` values for `database` raise `OrionisIntegrityException`.
         """
         with self.assertRaises(OrionisIntegrityException):
             Brokers(database="invalid_database")
@@ -37,7 +45,10 @@ class TestBrokers(TestCase):
     async def testCustomInitialization(self):
         """
         Test custom initialization with valid parameters.
-        Verifies that valid boolean and Database instances are accepted.
+
+        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)
@@ -47,8 +58,11 @@ class TestBrokers(TestCase):
 
     async def testToDictMethod(self):
         """
-        Test the toDict method returns proper dictionary representation.
-        Verifies all fields are included with correct values.
+        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()
@@ -61,7 +75,10 @@ class TestBrokers(TestCase):
     async def testKwOnlyInitialization(self):
         """
         Test that Brokers requires keyword arguments for initialization.
-        Verifies the class enforces kw_only=True in its dataclass decorator.
+
+        Notes
+        -----
+        Verifies the class enforces `kw_only=True` in its dataclass decorator.
         """
         with self.assertRaises(TypeError):
             Brokers(True, Database())

tests/foundation/config/queue/{test_queue_database.py → test_foundation_config_queue_database.py}

@@ -3,12 +3,17 @@ from orionis.foundation.config.queue.enums.strategy import Strategy
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestDatabaseQueue(TestCase):
-
+class TestFoundationConfigQueueDatabase(TestCase):
     async def testDefaultInitialization(self):
         """
-        Test that Database instance is initialized with correct default values.
-        Verifies that default table name, queue name, retry_after, and strategy are set properly.
+        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")
@@ -18,8 +23,13 @@ class TestDatabaseQueue(TestCase):
 
     async def testTableNameValidation(self):
         """
-        Test validation for table name attribute.
-        Verifies that invalid table names raise OrionisIntegrityException.
+        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
@@ -32,8 +42,13 @@ class TestDatabaseQueue(TestCase):
 
     async def testQueueNameValidation(self):
         """
-        Test validation for queue name attribute.
-        Verifies that non-ASCII queue names raise OrionisIntegrityException.
+        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
@@ -42,8 +57,13 @@ class TestDatabaseQueue(TestCase):
 
     async def testRetryAfterValidation(self):
         """
-        Test validation for retry_after attribute.
-        Verifies that non-positive integers raise OrionisIntegrityException.
+        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)
@@ -54,8 +74,14 @@ class TestDatabaseQueue(TestCase):
 
     async def testStrategyValidation(self):
         """
-        Test validation and normalization for strategy attribute.
-        Verifies both string and Strategy enum inputs are properly handled.
+        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")
@@ -75,8 +101,14 @@ class TestDatabaseQueue(TestCase):
 
     async def testToDictMethod(self):
         """
-        Test the toDict method returns proper dictionary representation.
-        Verifies all fields are included with correct values.
+        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()
@@ -88,8 +120,14 @@ class TestDatabaseQueue(TestCase):
 
     async def testKwOnlyInitialization(self):
         """
-        Test that Database requires keyword arguments for initialization.
-        Verifies the class enforces kw_only=True in its dataclass decorator.
+        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_root_paths.py → test_foundation_config_root_paths.py}

@@ -3,17 +3,44 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.foundation.config.roots.paths import Paths
 from orionis.unittesting import TestCase
 
-class TestPaths(TestCase):
+class TestFoundationConfigRootPaths(TestCase):
     """
     Test suite for the Paths dataclass which defines the project directory structure.
-    This test class verifies the integrity of path definitions, default values,
+
+    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.
-        Verifies that all default paths are correctly initialized and
+
+        Ensures that all default paths are correctly initialized and
         the instance is properly constructed.
         """
         paths = Paths()
@@ -22,6 +49,7 @@ class TestPaths(TestCase):
     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.
         """
@@ -39,8 +67,14 @@ class TestPaths(TestCase):
     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(
@@ -66,8 +100,14 @@ class TestPaths(TestCase):
     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)
@@ -75,7 +115,13 @@ class TestPaths(TestCase):
     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='')
@@ -83,8 +129,13 @@ class TestPaths(TestCase):
     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()
@@ -96,7 +147,12 @@ class TestPaths(TestCase):
     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)
@@ -111,8 +167,14 @@ class TestPaths(TestCase):
     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):
@@ -121,8 +183,13 @@ class TestPaths(TestCase):
     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():