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

tests/foundation/config/cache/test_cache_file.py

@@ -5,20 +5,33 @@ from orionis.unittesting import TestCase
 class TestConfigFile(TestCase):
     """
     Test cases for the File cache configuration entity.
+
+    This class contains unit tests for the `File` cache configuration entity,
+    validating its initialization, path handling, and dictionary representation.
     """
 
     async def testDefaultPath(self):
         """
-        Test that the File instance is created with the correct default path.
-        Verifies that the default path matches the expected value from the class definition.
+        Test default path initialization.
+
+        Ensures that a `File` instance is created with the correct default path.
+
+        Returns
+        -------
+        None
         """
         file_config = File()
         self.assertEqual(file_config.path, 'storage/framework/cache/data')
 
     async def testCustomPath(self):
         """
-        Test that a custom path can be set during initialization.
-        Verifies that the path attribute accepts and stores valid custom paths.
+        Test custom path initialization.
+
+        Ensures that a custom path can be set during initialization and is stored correctly.
+
+        Returns
+        -------
+        None
         """
         custom_path = 'custom/cache/path'
         file_config = File(path=custom_path)
@@ -26,16 +39,36 @@ class TestConfigFile(TestCase):
 
     async def testEmptyPathValidation(self):
         """
-        Test that empty paths are rejected.
-        Verifies that an empty path raises an OrionisIntegrityException.
+        Test validation for empty path.
+
+        Ensures that providing an empty path raises an `OrionisIntegrityException`.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the path is empty.
         """
         with self.assertRaises(OrionisIntegrityException):
             File(path="")
 
     async def testPathTypeValidation(self):
         """
-        Test that non-string paths are rejected.
-        Verifies that non-string path values raise an OrionisIntegrityException.
+        Test validation for path type.
+
+        Ensures that non-string path values raise an `OrionisIntegrityException`.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If the path is not a string.
         """
         with self.assertRaises(OrionisIntegrityException):
             File(path=123)
@@ -48,8 +81,13 @@ class TestConfigFile(TestCase):
 
     async def testToDictMethod(self):
         """
-        Test that the toDict method returns a proper dictionary representation.
-        Verifies that the returned dictionary contains the expected path value.
+        Test dictionary representation.
+
+        Ensures that the `toDict` method returns a dictionary with the expected path value.
+
+        Returns
+        -------
+        None
         """
         file_config = File()
         config_dict = file_config.toDict()
@@ -59,8 +97,13 @@ class TestConfigFile(TestCase):
 
     async def testCustomPathToDict(self):
         """
-        Test that custom paths are properly included in the dictionary representation.
-        Verifies that toDict() includes custom path values when specified.
+        Test custom path in dictionary representation.
+
+        Ensures that custom paths are properly included in the dictionary returned by `toDict`.
+
+        Returns
+        -------
+        None
         """
         custom_path = 'another/cache/location'
         file_config = File(path=custom_path)
@@ -70,8 +113,13 @@ class TestConfigFile(TestCase):
 
     async def testWhitespacePathHandling(self):
         """
-        Test that paths with whitespace are accepted but not automatically trimmed.
-        Verifies that the validation allows paths containing whitespace characters.
+        Test handling of paths with whitespace.
+
+        Ensures that paths containing whitespace are accepted and not automatically trimmed.
+
+        Returns
+        -------
+        None
         """
         spaced_path = '  storage/cache/with/space  '
         file_config = File(path=spaced_path)

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())