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

tests/foundation/config/cache/test_foundation_config_cache_stores.py

@@ -0,0 +1,148 @@
+from orionis.foundation.config.cache.entities.stores import Stores
+from orionis.foundation.config.cache.entities.file import File
+from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestFoundationConfigCacheStores(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 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)
+        self.assertEqual(stores.file.path, 'storage/framework/cache/data')
+
+    async def testCustomFileStore(self):
+        """
+        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)
+        self.assertIsInstance(stores.file, File)
+        self.assertEqual(stores.file.path, 'custom/cache/path')
+
+    async def testFileTypeValidation(self):
+        """
+        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")
+
+        with self.assertRaises(OrionisIntegrityException):
+            Stores(file=123)
+
+        with self.assertRaises(OrionisIntegrityException):
+            Stores(file=None)
+
+    async def testToDictMethodWithDefaults(self):
+        """
+        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()
+
+        self.assertIsInstance(stores_dict, dict)
+        self.assertIsInstance(stores_dict['file'], dict)
+        self.assertEqual(stores_dict['file']['path'], 'storage/framework/cache/data')
+
+    async def testToDictMethodWithCustomFile(self):
+        """
+        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)
+        stores_dict = stores.toDict()
+
+        self.assertEqual(stores_dict['file']['path'], 'alternate/cache/location')
+
+    async def testHashability(self):
+        """
+        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()
+        store_set = {store1, store2}
+
+        self.assertEqual(len(store_set), 1)
+
+        custom_store = Stores(file=File(path='custom/path'))
+        store_set.add(custom_store)
+        self.assertEqual(len(store_set), 2)
+
+    async def testKwOnlyInitialization(self):
+        """
+        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_foundation_config_cors.py

@@ -0,0 +1,190 @@
+from orionis.foundation.config.cors.entities.cors import Cors
+from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestFoundationConfigCors(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.
+
+        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, ["*"])
+        self.assertIsNone(cors.allow_origin_regex)
+        self.assertEqual(cors.allow_methods, ["*"])
+        self.assertEqual(cors.allow_headers, ["*"])
+        self.assertEqual(cors.expose_headers, [])
+        self.assertFalse(cors.allow_credentials)
+        self.assertEqual(cors.max_age, 600)
+
+    async def testCustomValues(self):
+        """
+        Test custom value assignment for all Cors configuration parameters.
+
+        Ensures that the Cors object accurately reflects the provided 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"],
+            allow_origin_regex="^https://.*\\.example\\.com$",
+            allow_methods=["GET", "POST"],
+            allow_headers=["Authorization", "Content-Type"],
+            expose_headers=["X-Custom-Header"],
+            allow_credentials=True,
+            max_age=3600
+        )
+        self.assertEqual(cors.allow_origins, ["https://example.com"])
+        self.assertEqual(cors.allow_origin_regex, "^https://.*\\.example\\.com$")
+        self.assertEqual(cors.allow_methods, ["GET", "POST"])
+        self.assertEqual(cors.allow_headers, ["Authorization", "Content-Type"])
+        self.assertEqual(cors.expose_headers, ["X-Custom-Header"])
+        self.assertTrue(cors.allow_credentials)
+        self.assertEqual(cors.max_age, 3600)
+
+    async def testInvalidAllowOriginsType(self):
+        """
+        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 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 type validation for 'allow_methods' parameter.
+
+        Ensures that passing a string instead of a list to the `allow_methods` parameter
+        raises an OrionisIntegrityException.
+
+        Raises
+        ------
+        OrionisIntegrityException
+            If `allow_methods` is not a list.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Cors(allow_methods="GET")
+
+    async def testInvalidAllowHeadersType(self):
+        """
+        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 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 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 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 → test_foundation_config_database.py}

@@ -3,15 +3,25 @@ from orionis.foundation.config.database.entities.connections import Connections
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestConfigDatabase(TestCase):
+class TestFoundationConfigDatabase(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 → test_foundation_config_database_connections.py}

@@ -6,15 +6,24 @@ from orionis.foundation.config.database.entities.sqlite import SQLite
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.unittesting import TestCase
 
-class TestConfigConnections(TestCase):
+class TestFoundationConfigDatabaseConnections(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())