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

tests/foundation/config/mail/test_mail_smtp.py

@@ -3,11 +3,23 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.unittesting import TestCase
 
 class TestSmtp(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_queue.py

@@ -4,11 +4,24 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.unittesting import TestCase
 
 class TestQueue(TestCase):
+    """
+    Test suite for the Queue class.
+    """
 
     async def testDefaultInitialization(self):
         """
-        Test that Queue instance is initialized with correct default values.
-        Verifies that default connection is 'sync' and brokers is a Brokers instance.
+        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")
@@ -16,8 +29,18 @@ class TestQueue(TestCase):
 
     async def testDefaultValidation(self):
         """
-        Test validation for default attribute.
-        Verifies that invalid default values raise OrionisIntegrityException.
+        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:
@@ -26,8 +49,18 @@ class TestQueue(TestCase):
 
     async def testBrokersValidation(self):
         """
-        Test validation for brokers attribute.
-        Verifies that non-Brokers values raise OrionisIntegrityException.
+        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")
@@ -37,7 +70,17 @@ class TestQueue(TestCase):
     async def testValidCustomInitialization(self):
         """
         Test custom initialization with valid parameters.
-        Verifies that valid default and Brokers instances are accepted.
+
+        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)
@@ -47,8 +90,18 @@ class TestQueue(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 Queue instance with all fields and correct values.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        AssertionError
+            If the dictionary representation is incorrect.
         """
         queue = Queue()
         result = queue.toDict()

tests/foundation/config/queue/test_queue_brokers.py

@@ -4,11 +4,13 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.unittesting import TestCase
 
 class TestBrokers(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

@@ -4,11 +4,16 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.unittesting import TestCase
 
 class TestDatabaseQueue(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

@@ -6,14 +6,41 @@ from orionis.unittesting import TestCase
 class TestPaths(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():

tests/foundation/config/session/test_session.py

@@ -4,10 +4,12 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.unittesting import TestCase
 
 class TestSession(TestCase):
-
     async def testDefaultInitialization(self):
         """
         Test that Session instance is initialized with correct default values.
+
+        Notes
+        -----
         Verifies default values for all attributes including secret_key generation.
         """
         session = Session()
@@ -22,6 +24,9 @@ class TestSession(TestCase):
     async def testSecretKeyValidation(self):
         """
         Test validation for secret_key attribute.
+
+        Notes
+        -----
         Verifies that invalid secret keys raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
@@ -32,6 +37,9 @@ class TestSession(TestCase):
     async def testSessionCookieValidation(self):
         """
         Test validation for session_cookie attribute.
+
+        Notes
+        -----
         Verifies invalid cookie names raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
@@ -44,6 +52,9 @@ class TestSession(TestCase):
     async def testMaxAgeValidation(self):
         """
         Test validation for max_age attribute.
+
+        Notes
+        -----
         Verifies invalid max_age values raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
@@ -57,6 +68,9 @@ class TestSession(TestCase):
     async def testSameSiteValidation(self):
         """
         Test validation and normalization for same_site attribute.
+
+        Notes
+        -----
         Verifies both string and enum inputs are properly handled.
         """
         # Test string inputs (case-insensitive)
@@ -78,6 +92,9 @@ class TestSession(TestCase):
     async def testPathValidation(self):
         """
         Test validation for path attribute.
+
+        Notes
+        -----
         Verifies invalid paths raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
@@ -90,6 +107,9 @@ class TestSession(TestCase):
     async def testHttpsOnlyValidation(self):
         """
         Test validation for https_only attribute.
+
+        Notes
+        -----
         Verifies non-boolean values raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
@@ -100,6 +120,9 @@ class TestSession(TestCase):
     async def testDomainValidation(self):
         """
         Test validation for domain attribute.
+
+        Notes
+        -----
         Verifies invalid domains raise OrionisIntegrityException.
         """
         with self.assertRaises(OrionisIntegrityException):
@@ -116,6 +139,9 @@ class TestSession(TestCase):
     async def testToDictMethod(self):
         """
         Test the toDict method returns proper dictionary representation.
+
+        Notes
+        -----
         Verifies all fields are included with correct values.
         """
         session = Session()
@@ -132,6 +158,9 @@ class TestSession(TestCase):
     async def testKwOnlyInitialization(self):
         """
         Test that Session requires keyword arguments for initialization.
+
+        Notes
+        -----
         Verifies the class enforces kw_only=True in its dataclass decorator.
         """
         with self.assertRaises(TypeError):