orionis 0.546.0__py3-none-any.whl → 0.548.0__py3-none-any.whl

tests/foundation/config/filesystems/test_foundation_config_filesystems_disks.py

@@ -1,184 +0,0 @@
-from orionis.foundation.config.filesystems.entitites.aws import S3
-from orionis.foundation.config.filesystems.entitites.disks import Disks
-from orionis.foundation.config.filesystems.entitites.local import Local
-from orionis.foundation.config.filesystems.entitites.public import Public
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigFilesystemsDisks(AsyncTestCase):
-    """
-    Test cases for the Disks filesystem configuration class.
-
-    This class contains unit tests to validate the behavior and integrity of the
-    `Disks` configuration class, ensuring correct type validation, default values,
-    custom configuration handling, dictionary conversion, hashability, and
-    keyword-only initialization.
-
-    Methods
-    -------
-    testDefaultValues()
-        Test that Disks instance is created with correct default values.
-    testLocalTypeValidation()
-        Test local attribute type validation.
-    testPublicTypeValidation()
-        Test public attribute type validation.
-    testAwsTypeValidation()
-        Test aws attribute type validation.
-    testCustomDiskConfigurations()
-        Test that custom disk configurations are properly stored and validated.
-    testToDictMethod()
-        Test that toDict returns proper dictionary representation.
-    testHashability()
-        Test that Disks maintains hashability due to unsafe_hash=True.
-    testKwOnlyInitialization()
-        Test that Disks enforces keyword-only initialization.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Test that Disks instance is created with correct default values.
-
-        Ensures that all default disk configurations are properly initialized.
-
-        Returns
-        -------
-        None
-        """
-        disks = Disks()
-        self.assertIsInstance(disks.local, Local)
-        self.assertIsInstance(disks.public, Public)
-        self.assertIsInstance(disks.aws, S3)
-
-    async def testLocalTypeValidation(self):
-        """
-        Test local attribute type validation.
-
-        Ensures that only `Local` instances are accepted for the `local` attribute.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the `local` attribute is not a `Local` instance.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Disks(local="not_a_local_instance")
-        with self.assertRaises(OrionisIntegrityException):
-            Disks(local=123)
-        with self.assertRaises(OrionisIntegrityException):
-            Disks(local=None)
-
-    async def testPublicTypeValidation(self):
-        """
-        Test public attribute type validation.
-
-        Ensures that only `Public` instances are accepted for the `public` attribute.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the `public` attribute is not a `Public` instance.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Disks(public="not_a_public_instance")
-        with self.assertRaises(OrionisIntegrityException):
-            Disks(public=123)
-        with self.assertRaises(OrionisIntegrityException):
-            Disks(public=None)
-
-    async def testAwsTypeValidation(self):
-        """
-        Test aws attribute type validation.
-
-        Ensures that only `S3` instances are accepted for the `aws` attribute.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the `aws` attribute is not an `S3` instance.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Disks(aws="not_an_s3_instance")
-        with self.assertRaises(OrionisIntegrityException):
-            Disks(aws=123)
-        with self.assertRaises(OrionisIntegrityException):
-            Disks(aws=None)
-
-    async def testCustomDiskConfigurations(self):
-        """
-        Test that custom disk configurations are properly stored and validated.
-
-        Ensures that custom disk configurations are correctly handled and their
-        attributes are properly set.
-
-        Returns
-        -------
-        None
-        """
-        custom_local = Local(path="custom/local/path")
-        custom_public = Public(path="custom/public/path", url="assets")
-        custom_aws = S3(bucket="custom-bucket", region="eu-west-1")
-
-        disks = Disks(
-            local=custom_local,
-            public=custom_public,
-            aws=custom_aws
-        )
-
-        self.assertEqual(disks.local.path, "custom/local/path")
-        self.assertEqual(disks.public.path, "custom/public/path")
-        self.assertEqual(disks.public.url, "assets")
-        self.assertEqual(disks.aws.bucket, "custom-bucket")
-        self.assertEqual(disks.aws.region, "eu-west-1")
-
-    async def testToDictMethod(self):
-        """
-        Test that toDict returns proper dictionary representation.
-
-        Ensures that all disk configurations are correctly included in the
-        dictionary representation.
-
-        Returns
-        -------
-        None
-        """
-        disks = Disks()
-        disks_dict = disks.toDict()
-
-        self.assertIsInstance(disks_dict, dict)
-        self.assertIsInstance(disks_dict['local'], dict)
-        self.assertIsInstance(disks_dict['public'], dict)
-        self.assertIsInstance(disks_dict['aws'], dict)
-
-    async def testHashability(self):
-        """
-        Test that Disks maintains hashability due to unsafe_hash=True.
-
-        Ensures that `Disks` instances can be used in sets and as dictionary keys.
-
-        Returns
-        -------
-        None
-        """
-        disks1 = Disks()
-        disks2 = Disks()
-        disks_set = {disks1, disks2}
-
-        self.assertEqual(len(disks_set), 1)
-
-        custom_disks = Disks(local=Local(path="custom/path"))
-        disks_set.add(custom_disks)
-        self.assertEqual(len(disks_set), 2)
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test that Disks enforces keyword-only initialization.
-
-        Ensures that positional arguments are not allowed for initialization.
-
-        Raises
-        ------
-        TypeError
-            If positional arguments are used for initialization.
-        """
-        with self.assertRaises(TypeError):
-            Disks(Local(), Public(), S3())

tests/foundation/config/filesystems/test_foundation_config_filesystems_local.py

@@ -1,143 +0,0 @@
-from orionis.foundation.config.filesystems.entitites.local import Local
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigFilesystemsLocal(AsyncTestCase):
-    """
-    Test cases for the Local storage configuration class.
-
-    This class contains asynchronous unit tests for the `Local` storage configuration,
-    validating path handling, dictionary conversion, hashability, and initialization constraints.
-    """
-
-    async def testDefaultPath(self):
-        """
-        Test Local instance creation with default path.
-
-        Ensures that the default path of a Local instance matches the expected value.
-
-        Returns
-        -------
-        None
-        """
-        local = Local()
-        self.assertEqual(local.path, "storage/app/private")
-
-    async def testCustomPath(self):
-        """
-        Test setting a custom path during initialization.
-
-        Ensures that the path attribute accepts and stores valid custom paths.
-
-        Returns
-        -------
-        None
-        """
-        custom_path = "custom/storage/path"
-        local = Local(path=custom_path)
-        self.assertEqual(local.path, custom_path)
-
-    async def testEmptyPathValidation(self):
-        """
-        Test rejection of empty paths.
-
-        Ensures that initializing Local with an empty path raises OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Local(path="")
-
-    async def testPathTypeValidation(self):
-        """
-        Test rejection of non-string paths.
-
-        Ensures that non-string path values raise OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Local(path=123)
-        with self.assertRaises(OrionisIntegrityException):
-            Local(path=None)
-        with self.assertRaises(OrionisIntegrityException):
-            Local(path=[])
-
-    async def testToDictMethod(self):
-        """
-        Test dictionary representation of Local.
-
-        Ensures that toDict returns a dictionary containing the expected path value.
-
-        Returns
-        -------
-        None
-        """
-        local = Local()
-        config_dict = local.toDict()
-        self.assertIsInstance(config_dict, dict)
-        self.assertEqual(config_dict['path'], "storage/app/private")
-
-    async def testCustomPathToDict(self):
-        """
-        Test dictionary representation with custom path.
-
-        Ensures that toDict includes custom path values when specified.
-
-        Returns
-        -------
-        None
-        """
-        custom_path = "another/storage/location"
-        local = Local(path=custom_path)
-        config_dict = local.toDict()
-        self.assertEqual(config_dict['path'], custom_path)
-
-    async def testWhitespacePathHandling(self):
-        """
-        Test handling of paths with whitespace.
-
-        Ensures that paths containing whitespace are accepted and not automatically trimmed.
-
-        Returns
-        -------
-        None
-        """
-        spaced_path = "  storage/with/space  "
-        local = Local(path=spaced_path)
-        self.assertEqual(local.path, spaced_path)
-
-    async def testHashability(self):
-        """
-        Test hashability of Local instances.
-
-        Ensures that Local instances can be used in sets and as dictionary keys.
-
-        Returns
-        -------
-        None
-        """
-        local1 = Local()
-        local2 = Local()
-        local_set = {local1, local2}
-        self.assertEqual(len(local_set), 1)
-        custom_local = Local(path="custom/path")
-        local_set.add(custom_local)
-        self.assertEqual(len(local_set), 2)
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test enforcement of keyword-only initialization.
-
-        Ensures that positional arguments are not allowed for Local initialization.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(TypeError):
-            Local("storage/path")

tests/foundation/config/filesystems/test_foundation_config_filesystems_public.py

@@ -1,184 +0,0 @@
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.foundation.config.filesystems.entitites.public import Public
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigFilesystemsPublic(AsyncTestCase):
-    """
-    Asynchronous unit tests for the `Public` storage configuration class.
-
-    This class validates the behavior of the `Public` storage configuration, including
-    default and custom value assignment, input validation, dictionary conversion,
-    whitespace handling, hashability, and enforcement of keyword-only initialization.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Test creation of a Public instance with default values.
-
-        Ensures that the default `path` and `url` attributes are set as defined
-        in the class.
-
-        Returns
-        -------
-        None
-        """
-        public = Public()
-        self.assertEqual(public.path, "storage/app/public")
-        self.assertEqual(public.url, "static")
-
-    async def testCustomValues(self):
-        """
-        Test assignment of custom values to path and url.
-
-        Checks that custom `path` and `url` values are accepted and stored
-        correctly during initialization.
-
-        Returns
-        -------
-        None
-        """
-        custom_path = "custom/public/path"
-        custom_url = "assets"
-        public = Public(path=custom_path, url=custom_url)
-        self.assertEqual(public.path, custom_path)
-        self.assertEqual(public.url, custom_url)
-
-    async def testEmptyPathValidation(self):
-        """
-        Test validation for empty path values.
-
-        Verifies that providing an empty string for `path` raises
-        OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Public(path="")
-
-    async def testEmptyUrlValidation(self):
-        """
-        Test validation for empty url values.
-
-        Verifies that providing an empty string for `url` raises
-        OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Public(url="")
-
-    async def testTypeValidation(self):
-        """
-        Test type validation for path and url attributes.
-
-        Ensures that non-string values for `path` and `url` raise
-        OrionisIntegrityException.
-
-        Returns
-        -------
-        None
-        """
-        # Test path validation
-        with self.assertRaises(OrionisIntegrityException):
-            Public(path=123)
-        with self.assertRaises(OrionisIntegrityException):
-            Public(path=None)
-
-        # Test url validation
-        with self.assertRaises(OrionisIntegrityException):
-            Public(url=123)
-        with self.assertRaises(OrionisIntegrityException):
-            Public(url=None)
-
-    async def testToDictMethod(self):
-        """
-        Test the toDict method for correct dictionary output.
-
-        Ensures that the dictionary representation contains the correct
-        default values for `path` and `url`.
-
-        Returns
-        -------
-        None
-        """
-        public = Public()
-        config_dict = public.toDict()
-
-        self.assertIsInstance(config_dict, dict)
-        self.assertEqual(config_dict['path'], "storage/app/public")
-        self.assertEqual(config_dict['url'], "static")
-
-    async def testCustomValuesToDict(self):
-        """
-        Test dictionary output with custom values.
-
-        Ensures that the dictionary representation includes custom
-        `path` and `url` values when specified.
-
-        Returns
-        -------
-        None
-        """
-        custom_path = "public/assets"
-        custom_url = "cdn"
-        public = Public(path=custom_path, url=custom_url)
-        config_dict = public.toDict()
-
-        self.assertEqual(config_dict['path'], custom_path)
-        self.assertEqual(config_dict['url'], custom_url)
-
-    async def testWhitespaceHandling(self):
-        """
-        Test handling of whitespace in attribute values.
-
-        Verifies that values containing whitespace are accepted and
-        not automatically trimmed.
-
-        Returns
-        -------
-        None
-        """
-        spaced_path = "  public/storage  "
-        spaced_url = "  static/files  "
-        public = Public(path=spaced_path, url=spaced_url)
-        self.assertEqual(public.path, spaced_path)
-        self.assertEqual(public.url, spaced_url)
-
-    async def testHashability(self):
-        """
-        Test hashability of Public instances.
-
-        Ensures that Public instances are hashable and can be used in sets
-        and as dictionary keys due to `unsafe_hash=True`.
-
-        Returns
-        -------
-        None
-        """
-        public1 = Public()
-        public2 = Public()
-        public_set = {public1, public2}
-
-        self.assertEqual(len(public_set), 1)
-
-        custom_public = Public(path="custom/public", url="custom-url")
-        public_set.add(custom_public)
-        self.assertEqual(len(public_set), 2)
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test enforcement of keyword-only initialization.
-
-        Verifies that positional arguments are not allowed when initializing
-        a Public instance.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(TypeError):
-            Public("storage/path", "static")

tests/foundation/config/logging/test_foundation_config_logging.py

@@ -1,112 +0,0 @@
-from orionis.foundation.config.logging.entities.logging import Logging
-from orionis.foundation.config.logging.entities.channels import Channels
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigLogging(AsyncTestCase):
-    """
-    Unit tests for the Logging class.
-
-    This test suite verifies the correct initialization, dictionary conversion,
-    post-initialization validation, and keyword-only argument enforcement of the
-    Logging class.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Test default values of Logging.
-
-        Ensures that a new Logging instance is initialized with the correct default values.
-
-        Parameters
-        ----------
-        self : TestLogging
-            The test case instance.
-
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        AssertionError
-            If the default values are not as expected.
-        """
-        logging = Logging()
-        self.assertEqual(logging.default, "stack")
-        self.assertIsInstance(logging.channels, Channels)
-
-    async def testToDictMethod(self):
-        """
-        Test the toDict method of Logging.
-
-        Checks that the toDict method returns a dictionary representation with all expected fields.
-
-        Parameters
-        ----------
-        self : TestLogging
-            The test case instance.
-
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        AssertionError
-            If the dictionary representation is not as expected.
-        """
-        logging = Logging()
-        result = logging.toDict()
-        self.assertIsInstance(result, dict)
-        self.assertIn("default", result)
-        self.assertIn("channels", result)
-
-    async def testPostInitValidation(self):
-        """
-        Test post-initialization validation of Logging.
-
-        Verifies that providing an invalid default channel or channels type raises an exception.
-
-        Parameters
-        ----------
-        self : TestLogging
-            The test case instance.
-
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        AssertionError
-            If the expected exception is not raised.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Logging(default="invalid_channel")
-
-        with self.assertRaises(OrionisIntegrityException):
-            Logging(channels="invalid_channels")
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test keyword-only initialization enforcement.
-
-        Ensures that Logging requires keyword arguments for initialization.
-
-        Parameters
-        ----------
-        self : TestLogging
-            The test case instance.
-
-        Returns
-        -------
-        None
-
-        Raises
-        ------
-        AssertionError
-            If TypeError is not raised when using positional arguments.
-        """
-        with self.assertRaises(TypeError):
-            Logging("stack", Channels())