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

tests/foundation/config/cache/test_cache_stores.py

@@ -6,12 +6,26 @@ from orionis.unittesting import TestCase
 class TestConfigStores(TestCase):
     """
     Test cases for the Stores cache configuration entity.
+
+    This class contains asynchronous unit tests for the `Stores` entity,
+    validating its initialization, type enforcement, dictionary conversion,
+    hashability, and keyword-only argument enforcement.
+
+    Attributes
+    ----------
+    None
     """
 
     async def testDefaultFileStore(self):
         """
-        Test that Stores initializes with a default File instance.
-        Verifies that the file attribute is properly initialized with default File configuration.
+        Test initialization with default File instance.
+
+        Ensures that `Stores` initializes with a default `File` instance and
+        that the `file` attribute is properly set with the default configuration.
+
+        Returns
+        -------
+        None
         """
         stores = Stores()
         self.assertIsInstance(stores.file, File)
@@ -19,8 +33,14 @@ class TestConfigStores(TestCase):
 
     async def testCustomFileStore(self):
         """
-        Test that Stores accepts a custom File configuration.
-        Verifies that a custom File instance can be provided during initialization.
+        Test initialization with a custom File configuration.
+
+        Ensures that a custom `File` instance can be provided during
+        initialization and is correctly assigned to the `file` attribute.
+
+        Returns
+        -------
+        None
         """
         custom_file = File(path='custom/cache/path')
         stores = Stores(file=custom_file)
@@ -29,8 +49,19 @@ class TestConfigStores(TestCase):
 
     async def testFileTypeValidation(self):
         """
-        Test that Stores validates the file attribute type.
-        Verifies that non-File instances raise OrionisIntegrityException.
+        Test type validation for the file attribute.
+
+        Ensures that providing a non-`File` instance to the `file` attribute
+        raises an `OrionisIntegrityException`.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the `file` attribute is not a `File` instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Stores(file="not_a_file_instance")
@@ -43,8 +74,14 @@ class TestConfigStores(TestCase):
 
     async def testToDictMethodWithDefaults(self):
         """
-        Test that toDict returns proper dictionary with default values.
-        Verifies the dictionary representation contains the correct default file path.
+        Test dictionary representation with default values.
+
+        Ensures that `toDict` returns a dictionary with the correct default
+        file path.
+
+        Returns
+        -------
+        None
         """
         stores = Stores()
         stores_dict = stores.toDict()
@@ -55,8 +92,14 @@ class TestConfigStores(TestCase):
 
     async def testToDictMethodWithCustomFile(self):
         """
-        Test that toDict includes custom file configurations.
-        Verifies the dictionary representation reflects custom file paths.
+        Test dictionary representation with custom file configuration.
+
+        Ensures that `toDict` reflects custom file paths in its dictionary
+        representation.
+
+        Returns
+        -------
+        None
         """
         custom_file = File(path='alternate/cache/location')
         stores = Stores(file=custom_file)
@@ -66,8 +109,14 @@ class TestConfigStores(TestCase):
 
     async def testHashability(self):
         """
-        Test that Stores maintains hashability due to unsafe_hash=True.
-        Verifies that Stores instances can be used in sets and as dictionary keys.
+        Test hashability of Stores instances.
+
+        Ensures that `Stores` instances are hashable and can be used in sets
+        and as dictionary keys.
+
+        Returns
+        -------
+        None
         """
         store1 = Stores()
         store2 = Stores()
@@ -81,8 +130,19 @@ class TestConfigStores(TestCase):
 
     async def testKwOnlyInitialization(self):
         """
-        Test that Stores enforces keyword-only initialization.
-        Verifies that positional arguments are not allowed for initialization.
+        Test keyword-only initialization enforcement.
+
+        Ensures that `Stores` enforces keyword-only arguments and does not
+        allow positional arguments during initialization.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        TypeError
+            If positional arguments are provided during initialization.
         """
         with self.assertRaises(TypeError):
             Stores(File())

tests/foundation/config/cors/test_cors.py

@@ -1,4 +1,3 @@
-
 from orionis.foundation.config.cors.entities.cors import Cors
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
@@ -6,20 +5,35 @@ from orionis.unittesting import TestCase
 class TestCorsConfig(TestCase):
     """
     Unit tests for Cors configuration defaults and validation.
+
+    Notes
+    -----
+    These tests verify the default values, custom value assignment, and type validation
+    for the `Cors` configuration entity.
     """
 
     async def testDefaultValues(self):
         """
         Test the default values of the Cors configuration.
 
-        This test verifies that a newly instantiated Cors object has the following default settings:
-        - allow_origins: ["*"]
-        - allow_origin_regex: None
-        - allow_methods: ["*"]
-        - allow_headers: ["*"]
-        - expose_headers: []
-        - allow_credentials: False
-        - max_age: 600
+        Verifies that a newly instantiated Cors object has the expected default settings.
+
+        Expected Defaults
+        -----------------
+        allow_origins : list of str
+            ["*"]
+        allow_origin_regex : None or str
+            None
+        allow_methods : list of str
+            ["*"]
+        allow_headers : list of str
+            ["*"]
+        expose_headers : list of str
+            []
+        allow_credentials : bool
+            False
+        max_age : int
+            600
         """
         cors = Cors()
         self.assertEqual(cors.allow_origins, ["*"])
@@ -32,18 +46,26 @@ class TestCorsConfig(TestCase):
 
     async def testCustomValues(self):
         """
-        Test that the Cors configuration correctly sets custom values for all parameters.
+        Test custom value assignment for all Cors configuration parameters.
 
-        This test verifies that:
-        - `allow_origins` is set to the provided list of origins.
-        - `allow_origin_regex` is set to the provided regex pattern.
-        - `allow_methods` is set to the provided list of HTTP methods.
-        - `allow_headers` is set to the provided list of headers.
-        - `expose_headers` is set to the provided list of exposed headers.
-        - `allow_credentials` is set to True.
-        - `max_age` is set to the provided integer value.
+        Ensures that the Cors object accurately reflects the provided custom configuration values.
 
-        Ensures that the Cors object accurately reflects the custom configuration values.
+        Parameters
+        ----------
+        allow_origins : list of str
+            Custom list of allowed origins.
+        allow_origin_regex : str
+            Custom regex pattern for allowed origins.
+        allow_methods : list of str
+            Custom list of allowed HTTP methods.
+        allow_headers : list of str
+            Custom list of allowed headers.
+        expose_headers : list of str
+            Custom list of exposed headers.
+        allow_credentials : bool
+            Whether credentials are allowed.
+        max_age : int
+            Custom max age value.
         """
         cors = Cors(
             allow_origins=["https://example.com"],
@@ -64,58 +86,105 @@ class TestCorsConfig(TestCase):
 
     async def testInvalidAllowOriginsType(self):
         """
-        Test that passing a string instead of a list to the 'allow_origins' parameter of the Cors class
+        Test type validation for 'allow_origins' parameter.
+
+        Ensures that passing a string instead of a list to the `allow_origins` parameter
         raises an OrionisIntegrityException.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If `allow_origins` is not a list.
         """
         with self.assertRaises(OrionisIntegrityException):
             Cors(allow_origins="*")
 
     async def testInvalidAllowOriginRegexType(self):
         """
-        Test that passing a non-string, non-None value (specifically an integer) to the
-        `allow_origin_regex` parameter of the `Cors` class raises an OrionisIntegrityException.
+        Test type validation for 'allow_origin_regex' parameter.
+
+        Ensures that passing a non-string, non-None value (e.g., integer) to the
+        `allow_origin_regex` parameter raises an OrionisIntegrityException.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If `allow_origin_regex` is not a string or None.
         """
         with self.assertRaises(OrionisIntegrityException):
             Cors(allow_origin_regex=123)
 
     async def testInvalidAllowMethodsType(self):
         """
-        Test that initializing the Cors class with an invalid type for 'allow_methods' raises an OrionisIntegrityException.
+        Test type validation for 'allow_methods' parameter.
+
+        Ensures that passing a string instead of a list to the `allow_methods` parameter
+        raises an OrionisIntegrityException.
 
-        This test verifies that passing a string instead of a list to the 'allow_methods' parameter
-        of the Cors class triggers the expected exception, ensuring type validation is enforced.
+        Raises
+        ------
+        OrionisIntegrityException
+            If `allow_methods` is not a list.
         """
         with self.assertRaises(OrionisIntegrityException):
             Cors(allow_methods="GET")
 
     async def testInvalidAllowHeadersType(self):
         """
-        Test that initializing the Cors class with a non-list type for 'allow_headers' (specifically a string)
-        raises an OrionisIntegrityException, ensuring type validation for the 'allow_headers' parameter.
+        Test type validation for 'allow_headers' parameter.
+
+        Ensures that passing a string instead of a list to the `allow_headers` parameter
+        raises an OrionisIntegrityException.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If `allow_headers` is not a list.
         """
         with self.assertRaises(OrionisIntegrityException):
             Cors(allow_headers="Authorization")
 
     async def testInvalidExposeHeadersType(self):
         """
-        Test that initializing the Cors class with a non-list type for 'expose_headers'
-        raises an OrionisIntegrityException. Ensures type validation for the 'expose_headers' parameter.
+        Test type validation for 'expose_headers' parameter.
+
+        Ensures that passing a string instead of a list to the `expose_headers` parameter
+        raises an OrionisIntegrityException.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If `expose_headers` is not a list.
         """
         with self.assertRaises(OrionisIntegrityException):
             Cors(expose_headers="X-Custom-Header")
 
     async def testInvalidAllowCredentialsType(self):
         """
-        Test that initializing the Cors class with a non-boolean value for 'allow_credentials'
-        raises an OrionisIntegrityException, ensuring type validation for the parameter.
+        Test type validation for 'allow_credentials' parameter.
+
+        Ensures that passing a non-boolean value to the `allow_credentials` parameter
+        raises an OrionisIntegrityException.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If `allow_credentials` is not a boolean.
         """
         with self.assertRaises(OrionisIntegrityException):
             Cors(allow_credentials="yes")
 
     async def testInvalidMaxAgeType(self):
         """
-        Test that passing a non-integer value (specifically a string) to the `max_age` parameter of the `Cors` class
-        raises an `OrionisIntegrityException`. This ensures that `max_age` only accepts integer or None values.
+        Test type validation for 'max_age' parameter.
+
+        Ensures that passing a non-integer value (e.g., string) to the `max_age` parameter
+        raises an OrionisIntegrityException.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If `max_age` is not an integer or None.
         """
         with self.assertRaises(OrionisIntegrityException):
             Cors(max_age="3600")

tests/foundation/config/database/test_database.py

@@ -6,12 +6,22 @@ from orionis.unittesting import TestCase
 class TestConfigDatabase(TestCase):
     """
     Test cases for the Database configuration class.
+
+    This class contains unit tests for the `Database` configuration class,
+    ensuring correct default values, validation, dictionary representation,
+    custom values, hashability, and keyword-only initialization.
+
+    Attributes
+    ----------
+    None
     """
 
     async def testDefaultValues(self):
         """
-        Test that Database instance is created with correct default values.
-        Verifies default connection is 'sqlite' and connections object is properly initialized.
+        Test creation of Database instance with default values.
+
+        Ensures that the default connection is set to 'sqlite' and the
+        connections attribute is properly initialized as a Connections instance.
         """
         db = Database()
         self.assertEqual(db.default, 'sqlite')
@@ -19,8 +29,11 @@ class TestConfigDatabase(TestCase):
 
     async def testDefaultConnectionValidation(self):
         """
-        Test default connection attribute validation.
-        Verifies that only valid connection types are accepted as default.
+        Validate the default connection attribute.
+
+        Checks that only valid connection types are accepted as default.
+        Also verifies that invalid, empty, or non-string defaults raise
+        OrionisIntegrityException.
         """
         # Test valid connection types
         valid_connections = ['sqlite', 'mysql', 'pgsql', 'oracle']
@@ -44,8 +57,11 @@ class TestConfigDatabase(TestCase):
 
     async def testConnectionsValidation(self):
         """
-        Test connections attribute validation.
-        Verifies that only Connections instances are accepted.
+        Validate the connections attribute.
+
+        Ensures that only instances of Connections are accepted for the
+        connections attribute. Invalid types or None should raise
+        OrionisIntegrityException.
         """
         # Test invalid connections type
         with self.assertRaises(OrionisIntegrityException):
@@ -63,8 +79,10 @@ class TestConfigDatabase(TestCase):
 
     async def testToDictMethod(self):
         """
-        Test that toDict returns proper dictionary representation.
-        Verifies all attributes are correctly included in dictionary.
+        Test the toDict method of Database.
+
+        Ensures that the toDict method returns a dictionary representation
+        of the Database instance, including all attributes.
         """
         db = Database()
         db_dict = db.toDict()
@@ -74,8 +92,10 @@ class TestConfigDatabase(TestCase):
 
     async def testCustomValues(self):
         """
-        Test that custom values are properly stored and validated.
-        Verifies custom configurations are correctly handled.
+        Test storage and validation of custom values.
+
+        Ensures that custom configurations for default and connections
+        are correctly handled and validated.
         """
         custom_connections = Connections()
         custom_db = Database(
@@ -87,8 +107,10 @@ class TestConfigDatabase(TestCase):
 
     async def testHashability(self):
         """
-        Test that Database maintains hashability due to unsafe_hash=True.
-        Verifies that Database instances can be used in sets and as dictionary keys.
+        Test hashability of Database instances.
+
+        Ensures that Database instances are hashable (due to unsafe_hash=True)
+        and can be used in sets and as dictionary keys.
         """
         db1 = Database()
         db2 = Database()
@@ -101,8 +123,10 @@ class TestConfigDatabase(TestCase):
 
     async def testKwOnlyInitialization(self):
         """
-        Test that Database enforces keyword-only initialization.
-        Verifies that positional arguments are not allowed for initialization.
+        Test keyword-only initialization enforcement.
+
+        Ensures that Database enforces keyword-only initialization and
+        raises TypeError when positional arguments are used.
         """
         with self.assertRaises(TypeError):
             Database('sqlite', Connections())

tests/foundation/config/database/test_database_connections.py

@@ -9,12 +9,21 @@ from orionis.unittesting import TestCase
 class TestConfigConnections(TestCase):
     """
     Test cases for the Connections configuration class.
+
+    This class contains unit tests to validate the behavior and integrity of the
+    Connections class, ensuring correct type validation, default values, dictionary
+    representation, custom connection handling, hashability, and keyword-only initialization.
     """
 
     async def testDefaultValues(self):
         """
         Test that Connections instance is created with correct default values.
+
         Verifies all default connections are properly initialized with their respective types.
+
+        Returns
+        -------
+        None
         """
         connections = Connections()
         self.assertIsInstance(connections.sqlite, SQLite)
@@ -25,7 +34,17 @@ class TestConfigConnections(TestCase):
     async def testSqliteTypeValidation(self):
         """
         Test sqlite attribute type validation.
-        Verifies that only SQLite instances are accepted for sqlite attribute.
+
+        Verifies that only SQLite instances are accepted for the sqlite attribute.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the sqlite attribute is not a valid SQLite instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Connections(sqlite="not_a_sqlite_instance")
@@ -37,7 +56,17 @@ class TestConfigConnections(TestCase):
     async def testMysqlTypeValidation(self):
         """
         Test mysql attribute type validation.
-        Verifies that only MySQL instances are accepted for mysql attribute.
+
+        Verifies that only MySQL instances are accepted for the mysql attribute.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the mysql attribute is not a valid MySQL instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Connections(mysql="not_a_mysql_instance")
@@ -49,7 +78,17 @@ class TestConfigConnections(TestCase):
     async def testPgsqlTypeValidation(self):
         """
         Test pgsql attribute type validation.
-        Verifies that only PGSQL instances are accepted for pgsql attribute.
+
+        Verifies that only PGSQL instances are accepted for the pgsql attribute.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the pgsql attribute is not a valid PGSQL instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Connections(pgsql="not_a_pgsql_instance")
@@ -61,7 +100,17 @@ class TestConfigConnections(TestCase):
     async def testOracleTypeValidation(self):
         """
         Test oracle attribute type validation.
-        Verifies that only Oracle instances are accepted for oracle attribute.
+
+        Verifies that only Oracle instances are accepted for the oracle attribute.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the oracle attribute is not a valid Oracle instance.
         """
         with self.assertRaises(OrionisIntegrityException):
             Connections(oracle="not_an_oracle_instance")
@@ -73,7 +122,12 @@ class TestConfigConnections(TestCase):
     async def testToDictMethod(self):
         """
         Test that toDict returns proper dictionary representation.
-        Verifies all connections are correctly included in dictionary.
+
+        Verifies all connections are correctly included in the dictionary.
+
+        Returns
+        -------
+        None
         """
         connections = Connections()
         connections_dict = connections.toDict()
@@ -86,7 +140,12 @@ class TestConfigConnections(TestCase):
     async def testCustomConnections(self):
         """
         Test that custom connections are properly stored and validated.
+
         Verifies custom connection configurations are correctly handled.
+
+        Returns
+        -------
+        None
         """
         custom_sqlite = SQLite(database='custom.db')
         custom_mysql = MySQL(database='custom_db')
@@ -108,7 +167,12 @@ class TestConfigConnections(TestCase):
     async def testHashability(self):
         """
         Test that Connections maintains hashability due to unsafe_hash=True.
+
         Verifies that Connections instances can be used in sets and as dictionary keys.
+
+        Returns
+        -------
+        None
         """
         conn1 = Connections()
         conn2 = Connections()
@@ -123,7 +187,17 @@ class TestConfigConnections(TestCase):
     async def testKwOnlyInitialization(self):
         """
         Test that Connections enforces keyword-only initialization.
+
         Verifies that positional arguments are not allowed for initialization.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        TypeError
+            If positional arguments are used for initialization.
         """
         with self.assertRaises(TypeError):
             Connections(SQLite(), MySQL(), PGSQL(), Oracle())