orionis 0.253.0__py3-none-any.whl → 0.266.0__py3-none-any.whl

tests/foundation/config/filesystems/test_filesystems_disks.py

@@ -0,0 +1,114 @@
+from orionis.luminate.foundation.config.filesystems.entitites.aws import S3
+from orionis.luminate.foundation.config.filesystems.entitites.disks import Disks
+from orionis.luminate.foundation.config.filesystems.entitites.local import Local
+from orionis.luminate.foundation.config.filesystems.entitites.public import Public
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigDisks(TestCase):
+    """
+    Test cases for the Disks filesystem configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that Disks instance is created with correct default values.
+        Verifies all default disk configurations are properly initialized.
+        """
+        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.
+        Verifies that only Local instances are accepted for local attribute.
+        """
+        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.
+        Verifies that only Public instances are accepted for public attribute.
+        """
+        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.
+        Verifies that only S3 instances are accepted for aws attribute.
+        """
+        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.
+        Verifies custom disk configurations are correctly handled.
+        """
+        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.
+        Verifies all disk configurations are correctly included in dictionary.
+        """
+        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.
+        Verifies that Disks instances can be used in sets and as dictionary keys.
+        """
+        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.
+        Verifies that positional arguments are not allowed for initialization.
+        """
+        with self.assertRaises(TypeError):
+            Disks(Local(), Public(), S3())

tests/foundation/config/filesystems/test_filesystems_local.py

@@ -0,0 +1,95 @@
+from orionis.luminate.foundation.config.filesystems.entitites.local import Local
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigLocal(TestCase):
+    """
+    Test cases for the Local storage configuration class.
+    """
+
+    async def testDefaultPath(self):
+        """
+        Test that Local instance is created with correct default path.
+        Verifies the default path matches the expected value from class definition.
+        """
+        local = Local()
+        self.assertEqual(local.path, "storage/app/private")
+
+    async def testCustomPath(self):
+        """
+        Test that custom path can be set during initialization.
+        Verifies the path attribute accepts and stores valid custom paths.
+        """
+        custom_path = "custom/storage/path"
+        local = Local(path=custom_path)
+        self.assertEqual(local.path, custom_path)
+
+    async def testEmptyPathValidation(self):
+        """
+        Test that empty paths are rejected.
+        Verifies that an empty path raises OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Local(path="")
+
+    async def testPathTypeValidation(self):
+        """
+        Test that non-string paths are rejected.
+        Verifies that non-string path values raise OrionisIntegrityException.
+        """
+        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 that toDict returns proper dictionary representation.
+        Verifies the returned dictionary contains the expected path value.
+        """
+        local = Local()
+        config_dict = local.toDict()
+        self.assertIsInstance(config_dict, dict)
+        self.assertEqual(config_dict['path'], "storage/app/private")
+
+    async def testCustomPathToDict(self):
+        """
+        Test that custom paths are properly included in dictionary representation.
+        Verifies toDict() includes custom path values when specified.
+        """
+        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 that paths with whitespace are accepted but not automatically trimmed.
+        Verifies the validation allows paths containing whitespace characters.
+        """
+        spaced_path = "  storage/with/space  "
+        local = Local(path=spaced_path)
+        self.assertEqual(local.path, spaced_path)
+
+    async def testHashability(self):
+        """
+        Test that Local maintains hashability due to unsafe_hash=True.
+        Verifies that Local instances can be used in sets and as dictionary keys.
+        """
+        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 that Local enforces keyword-only initialization.
+        Verifies that positional arguments are not allowed for initialization.
+        """
+        with self.assertRaises(TypeError):
+            Local("storage/path")

tests/foundation/config/filesystems/test_filesystems_public.py

@@ -0,0 +1,120 @@
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.luminate.foundation.config.filesystems.entitites.public import Public
+from orionis.unittesting import TestCase
+
+class TestConfigPublic(TestCase):
+    """
+    Test cases for the Public storage configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that Public instance is created with correct default values.
+        Verifies both default path and url match expected values from class definition.
+        """
+        public = Public()
+        self.assertEqual(public.path, "storage/app/public")
+        self.assertEqual(public.url, "static")
+
+    async def testCustomValues(self):
+        """
+        Test that custom path and url can be set during initialization.
+        Verifies both attributes accept and store valid custom values.
+        """
+        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 that empty paths are rejected.
+        Verifies that an empty path raises OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Public(path="")
+
+    async def testEmptyUrlValidation(self):
+        """
+        Test that empty URLs are rejected.
+        Verifies that an empty url raises OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Public(url="")
+
+    async def testTypeValidation(self):
+        """
+        Test that non-string values are rejected for both attributes.
+        Verifies that non-string values raise OrionisIntegrityException.
+        """
+        # 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 that toDict returns proper dictionary representation.
+        Verifies the returned dictionary contains both default values.
+        """
+        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 that custom values are properly included in dictionary representation.
+        Verifies toDict() includes custom values when specified.
+        """
+        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 that values with whitespace are accepted but not automatically trimmed.
+        Verifies the validation allows values containing whitespace characters.
+        """
+        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 that Public maintains hashability due to unsafe_hash=True.
+        Verifies that Public instances can be used in sets and as dictionary keys.
+        """
+        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 that Public enforces keyword-only initialization.
+        Verifies that positional arguments are not allowed for initialization.
+        """
+        with self.assertRaises(TypeError):
+            Public("storage/path", "static")

tests/foundation/config/logging/test_logging.py

@@ -0,0 +1,48 @@
+from orionis.luminate.foundation.config.logging.entities.logging import Logging
+from orionis.luminate.foundation.config.logging.entities.channels import Channels
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestLogging(TestCase):
+
+    async def testDefaultValues(self):
+        """
+        Test that the Logging instance is initialized with correct default values.
+        Verifies that a new Logging object has 'stack' as default channel
+        and an instance of Channels as channels attribute.
+        """
+        logging = Logging()
+        self.assertEqual(logging.default, "stack")
+        self.assertIsInstance(logging.channels, Channels)
+
+    async def testToDictMethod(self):
+        """
+        Test the toDict method returns a proper dictionary representation.
+        Checks that the toDict method converts the Logging instance
+        into a dictionary with all expected fields.
+        """
+        logging = Logging()
+        result = logging.toDict()
+        self.assertIsInstance(result, dict)
+        self.assertIn("default", result)
+        self.assertIn("channels", result)
+
+    async def testPostInitValidation(self):
+        """
+        Test the __post_init__ validation works correctly.
+        Verifies that invalid default channel or channels type
+        raises OrionisIntegrityException.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Logging(default="invalid_channel")
+
+        with self.assertRaises(OrionisIntegrityException):
+            Logging(channels="invalid_channels")
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that Logging requires keyword arguments for initialization.
+        Verifies that the class enforces kw_only=True in its dataclass decorator.
+        """
+        with self.assertRaises(TypeError):
+            Logging("stack", Channels())

tests/foundation/config/logging/test_logging_channels.py

@@ -0,0 +1,157 @@
+from orionis.luminate.foundation.config.logging.entities.channels import Channels
+from orionis.luminate.foundation.config.logging.entities.stack import Stack
+from orionis.luminate.foundation.config.logging.entities.hourly import Hourly
+from orionis.luminate.foundation.config.logging.entities.daily import Daily
+from orionis.luminate.foundation.config.logging.entities.weekly import Weekly
+from orionis.luminate.foundation.config.logging.entities.monthly import Monthly
+from orionis.luminate.foundation.config.logging.entities.chunked import Chunked
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigChannels(TestCase):
+    """
+    Test cases for the Channels logging configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that Channels instance is created with correct default values.
+        Verifies all channel configurations are properly initialized with their default values.
+        """
+        channels = Channels()
+        self.assertIsInstance(channels.stack, Stack)
+        self.assertIsInstance(channels.hourly, Hourly)
+        self.assertIsInstance(channels.daily, Daily)
+        self.assertIsInstance(channels.weekly, Weekly)
+        self.assertIsInstance(channels.monthly, Monthly)
+        self.assertIsInstance(channels.chunked, Chunked)
+
+    async def testStackValidation(self):
+        """
+        Test stack attribute type validation.
+        Verifies that only Stack instances are accepted for stack attribute.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Channels(stack="not_a_stack_instance")
+        with self.assertRaises(OrionisIntegrityException):
+            Channels(stack=123)
+        try:
+            Channels(stack=Stack())
+        except OrionisIntegrityException:
+            self.fail("Valid Stack instance should not raise exception")
+
+    async def testHourlyValidation(self):
+        """
+        Test hourly attribute type validation.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Channels(hourly="not_an_hourly_instance")
+        try:
+            Channels(hourly=Hourly())
+        except OrionisIntegrityException:
+            self.fail("Valid Hourly instance should not raise exception")
+
+    async def testDailyValidation(self):
+        """
+        Test daily attribute type validation.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Channels(daily="not_a_daily_instance")
+        try:
+            Channels(daily=Daily())
+        except OrionisIntegrityException:
+            self.fail("Valid Daily instance should not raise exception")
+
+    async def testWeeklyValidation(self):
+        """
+        Test weekly attribute type validation.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Channels(weekly="not_a_weekly_instance")
+        try:
+            Channels(weekly=Weekly())
+        except OrionisIntegrityException:
+            self.fail("Valid Weekly instance should not raise exception")
+
+    async def testMonthlyValidation(self):
+        """
+        Test monthly attribute type validation.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Channels(monthly="not_a_monthly_instance")
+        try:
+            Channels(monthly=Monthly())
+        except OrionisIntegrityException:
+            self.fail("Valid Monthly instance should not raise exception")
+
+    async def testChunkedValidation(self):
+        """
+        Test chunked attribute type validation.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Channels(chunked="not_a_chunked_instance")
+        try:
+            Channels(chunked=Chunked())
+        except OrionisIntegrityException:
+            self.fail("Valid Chunked instance should not raise exception")
+
+    async def testCustomConfigurations(self):
+        """
+        Test that custom channel configurations are properly stored and validated.
+        """
+        custom_stack = Stack(path="custom/stack.log")
+        custom_hourly = Hourly(path="custom/hourly.log")
+        custom_daily = Daily(path="custom/daily.log")
+        custom_weekly = Weekly(path="custom/weekly.log")
+        custom_monthly = Monthly(path="custom/monthly.log")
+        custom_chunked = Chunked(path="custom/chunked.log")
+
+        channels = Channels(
+            stack=custom_stack,
+            hourly=custom_hourly,
+            daily=custom_daily,
+            weekly=custom_weekly,
+            monthly=custom_monthly,
+            chunked=custom_chunked
+        )
+        self.assertEqual(channels.stack.path, "custom/stack.log")
+        self.assertEqual(channels.hourly.path, "custom/hourly.log")
+        self.assertEqual(channels.daily.path, "custom/daily.log")
+        self.assertEqual(channels.weekly.path, "custom/weekly.log")
+        self.assertEqual(channels.monthly.path, "custom/monthly.log")
+        self.assertEqual(channels.chunked.path, "custom/chunked.log")
+
+    async def testToDictMethod(self):
+        """
+        Test that toDict returns proper dictionary representation.
+        """
+        channels = Channels()
+        channels_dict = channels.toDict()
+        self.assertIsInstance(channels_dict, dict)
+        self.assertIsInstance(channels_dict['stack'], dict)
+        self.assertIsInstance(channels_dict['hourly'], dict)
+        self.assertIsInstance(channels_dict['daily'], dict)
+        self.assertIsInstance(channels_dict['weekly'], dict)
+        self.assertIsInstance(channels_dict['monthly'], dict)
+        self.assertIsInstance(channels_dict['chunked'], dict)
+
+    async def testHashability(self):
+        """
+        Test that Channels maintains hashability due to unsafe_hash=True.
+        """
+        channels1 = Channels()
+        channels2 = Channels()
+        channels_set = {channels1, channels2}
+
+        self.assertEqual(len(channels_set), 1)
+
+        custom_channels = Channels(stack=Stack(path="custom.log"))
+        channels_set.add(custom_channels)
+        self.assertEqual(len(channels_set), 2)
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that Channels enforces keyword-only initialization.
+        """
+        with self.assertRaises(TypeError):
+            Channels(Stack(), Hourly(), Daily(), Weekly(), Monthly(), Chunked())