orionis 0.545.0__py3-none-any.whl → 0.547.0__py3-none-any.whl

tests/foundation/config/logging/test_foundation_config_logging_channels.py

@@ -1,246 +0,0 @@
-from orionis.foundation.config.logging.entities.channels import Channels
-from orionis.foundation.config.logging.entities.stack import Stack
-from orionis.foundation.config.logging.entities.hourly import Hourly
-from orionis.foundation.config.logging.entities.daily import Daily
-from orionis.foundation.config.logging.entities.weekly import Weekly
-from orionis.foundation.config.logging.entities.monthly import Monthly
-from orionis.foundation.config.logging.entities.chunked import Chunked
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigLoggingChannels(AsyncTestCase):
-    """
-    Unit tests for the `Channels` logging configuration class.
-
-    This test class validates the correct initialization, type enforcement,
-    custom configuration, dictionary conversion, hashability, and keyword-only
-    initialization of the `Channels` class.
-
-    Methods
-    -------
-    testDefaultValues()
-        Verify that a Channels instance is initialized with the correct default values.
-    testStackValidation()
-        Ensure that only Stack instances are accepted for the stack attribute.
-    testHourlyValidation()
-        Ensure that only Hourly instances are accepted for the hourly attribute.
-    testDailyValidation()
-        Ensure that only Daily instances are accepted for the daily attribute.
-    testWeeklyValidation()
-        Ensure that only Weekly instances are accepted for the weekly attribute.
-    testMonthlyValidation()
-        Ensure that only Monthly instances are accepted for the monthly attribute.
-    testChunkedValidation()
-        Ensure that only Chunked instances are accepted for the chunked attribute.
-    testCustomConfigurations()
-        Validate that custom channel configurations are correctly assigned and validated.
-    testToDictMethod()
-        Check that the toDict method returns the correct dictionary representation.
-    testHashability()
-        Confirm that Channels instances are hashable due to unsafe_hash=True.
-    testKwOnlyInitialization()
-        Ensure that Channels enforces keyword-only initialization.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Verify that a Channels instance is initialized with the correct default values.
-
-        Ensures that all channel configuration attributes are instances of their
-        respective classes upon default initialization.
-
-        Returns
-        -------
-        None
-        """
-        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):
-        """
-        Ensure that only Stack instances are accepted for the stack attribute.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the stack attribute is not a Stack instance.
-        """
-        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):
-        """
-        Ensure that only Hourly instances are accepted for the hourly attribute.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the hourly attribute is not an Hourly instance.
-        """
-        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):
-        """
-        Ensure that only Daily instances are accepted for the daily attribute.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the daily attribute is not a Daily instance.
-        """
-        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):
-        """
-        Ensure that only Weekly instances are accepted for the weekly attribute.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the weekly attribute is not a Weekly instance.
-        """
-        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):
-        """
-        Ensure that only Monthly instances are accepted for the monthly attribute.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the monthly attribute is not a Monthly instance.
-        """
-        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):
-        """
-        Ensure that only Chunked instances are accepted for the chunked attribute.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the chunked attribute is not a Chunked instance.
-        """
-        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):
-        """
-        Validate that custom channel configurations are correctly assigned and validated.
-
-        Ensures that custom channel instances are properly set and their properties
-        are accurately assigned.
-
-        Returns
-        -------
-        None
-        """
-        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):
-        """
-        Check that the toDict method returns the correct dictionary representation.
-
-        Ensures that the `toDict` method produces a dictionary with the expected
-        structure and types for each channel.
-
-        Returns
-        -------
-        None
-        """
-        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):
-        """
-        Confirm that Channels instances are hashable due to unsafe_hash=True.
-
-        Ensures that Channels objects can be used in sets and as dictionary keys.
-
-        Returns
-        -------
-        None
-        """
-        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):
-        """
-        Ensure that Channels enforces keyword-only initialization.
-
-        Raises
-        ------
-        TypeError
-            If positional arguments are used instead of keyword arguments.
-        """
-        with self.assertRaises(TypeError):
-            Channels(Stack(), Hourly(), Daily(), Weekly(), Monthly(), Chunked())

tests/foundation/config/logging/test_foundation_config_logging_chunked.py

@@ -1,217 +0,0 @@
-from orionis.foundation.config.logging.entities.chunked import Chunked
-from orionis.foundation.config.logging.enums.levels import Level
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigLoggingChunked(AsyncTestCase):
-    """
-    Test cases for the Chunked logging configuration class.
-
-    Notes
-    -----
-    These tests validate the integrity, default values, and behavior of the
-    `Chunked` logging configuration entity, including its attributes and methods.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Test default values of Chunked instance.
-
-        Ensures that a `Chunked` instance is created with the correct default values
-        for `path`, `level`, `mb_size`, and `files`.
-
-        Returns
-        -------
-        None
-        """
-        chunked = Chunked()
-        self.assertEqual(chunked.path, "storage/log/chunked.log")
-        self.assertEqual(chunked.level, Level.INFO.value)
-        self.assertEqual(chunked.mb_size, 10)
-        self.assertEqual(chunked.files, 5)
-
-    async def testPathValidation(self):
-        """
-        Test validation of the `path` attribute.
-
-        Verifies that empty or non-string paths raise `OrionisIntegrityException`.
-        Also checks that a valid path does not raise an exception.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Chunked(path="")
-        with self.assertRaises(OrionisIntegrityException):
-            Chunked(path=123)
-        try:
-            Chunked(path="custom/log/path.log")
-        except OrionisIntegrityException:
-            self.fail("Valid path should not raise exception")
-
-    async def testLevelValidation(self):
-        """
-        Test validation of the `level` attribute.
-
-        Checks that the `level` can be set using a string, integer, or enum,
-        and that invalid values raise `OrionisIntegrityException`.
-
-        Returns
-        -------
-        None
-        """
-        # Test string level
-        chunked = Chunked(level="debug")
-        self.assertEqual(chunked.level, Level.DEBUG.value)
-
-        # Test int level
-        chunked = Chunked(level=Level.WARNING.value)
-        self.assertEqual(chunked.level, Level.WARNING.value)
-
-        # Test enum level
-        chunked = Chunked(level=Level.ERROR)
-        self.assertEqual(chunked.level, Level.ERROR.value)
-
-        # Test invalid cases
-        with self.assertRaises(OrionisIntegrityException):
-            Chunked(level="invalid")
-        with self.assertRaises(OrionisIntegrityException):
-            Chunked(level=999)
-        with self.assertRaises(OrionisIntegrityException):
-            Chunked(level=[])
-
-    async def testMbSizeValidation(self):
-        """
-        Test validation of the `mb_size` attribute.
-
-        Returns
-        -------
-        None
-        """
-        chunked = Chunked(mb_size=10)
-        self.assertEqual(chunked.mb_size, 10)
-
-        chunked = Chunked(mb_size=1000)
-        self.assertEqual(chunked.mb_size, 1000)
-
-        with self.assertRaises(OrionisIntegrityException):
-            chunked = Chunked(mb_size=2048)
-            self.assertEqual(chunked.mb_size, 2048)
-
-    async def testFilesValidation(self):
-        """
-        Test validation of the `files` attribute.
-
-        Ensures that valid integer values are accepted, and invalid values raise
-        `OrionisIntegrityException`.
-
-        Returns
-        -------
-        None
-        """
-        # Test valid values
-        try:
-            Chunked(files=1)
-            Chunked(files=10)
-        except OrionisIntegrityException:
-            self.fail("Valid files count should not raise exception")
-
-        # Test invalid values
-        with self.assertRaises(OrionisIntegrityException):
-            Chunked(files=0)
-        with self.assertRaises(OrionisIntegrityException):
-            Chunked(files=-1)
-        with self.assertRaises(OrionisIntegrityException):
-            Chunked(files="5")
-
-    async def testWhitespaceHandling(self):
-        """
-        Test handling of whitespace in `path` and `level` attributes.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            chunked = Chunked(path="  logs/app.log  ", level="  debug  ")
-            self.assertEqual(chunked.path, "  logs/app.log  ")
-            self.assertEqual(chunked.level, Level.DEBUG.value)
-
-    async def testToDictMethod(self):
-        """
-        Test the `toDict` method.
-
-        Ensures that `toDict` returns a dictionary representation of the instance
-        with correct values.
-
-        Returns
-        -------
-        None
-        """
-        chunked = Chunked()
-        chunked_dict = chunked.toDict()
-
-        self.assertIsInstance(chunked_dict, dict)
-        self.assertEqual(chunked_dict['path'], "storage/log/chunked.log")
-        self.assertEqual(chunked_dict['level'], Level.INFO.value)
-        self.assertEqual(chunked_dict['mb_size'], 10)
-        self.assertEqual(chunked_dict['files'], 5)
-
-    async def testCustomValuesToDict(self):
-        """
-        Test `toDict` with custom values.
-
-        Ensures that custom values provided to the constructor are correctly
-        reflected in the dictionary representation.
-
-        Returns
-        -------
-        None
-        """
-        custom_chunked = Chunked(
-            path="custom/logs/app.log",
-            level="warning",
-            mb_size=20,
-            files=10
-        )
-        chunked_dict = custom_chunked.toDict()
-        self.assertEqual(chunked_dict['path'], "custom/logs/app.log")
-        self.assertEqual(chunked_dict['level'], 30)
-        self.assertEqual(chunked_dict['mb_size'], 20)
-        self.assertEqual(chunked_dict['files'], 10)
-
-    async def testHashability(self):
-        """
-        Test hashability of Chunked instances.
-
-        Ensures that `Chunked` instances are hashable and can be used in sets,
-        due to `unsafe_hash=True`.
-
-        Returns
-        -------
-        None
-        """
-        chunked1 = Chunked()
-        chunked2 = Chunked()
-        chunked_set = {chunked1, chunked2}
-
-        self.assertEqual(len(chunked_set), 1)
-
-        custom_chunked = Chunked(path="custom.log")
-        chunked_set.add(custom_chunked)
-        self.assertEqual(len(chunked_set), 2)
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test enforcement of keyword-only initialization.
-
-        Ensures that `Chunked` cannot be initialized with positional arguments,
-        and raises a `TypeError` if attempted.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(TypeError):
-            Chunked("path.log", "info", 10, 5)

tests/foundation/config/logging/test_foundation_config_logging_daily.py

@@ -1,220 +0,0 @@
-from datetime import time
-from orionis.foundation.config.logging.entities.daily import Daily
-from orionis.foundation.config.logging.enums.levels import Level
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigLoggingDaily(AsyncTestCase):
-    """
-    Test cases for the Daily logging configuration class.
-
-    This class contains unit tests for the `Daily` logging configuration entity,
-    validating its default values, attribute validation, dictionary conversion,
-    hashability, and keyword-only initialization.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Test creation of Daily instance with default values.
-
-        Ensures that the default path, level, retention_days, and at time
-        are set as expected.
-
-        Returns
-        -------
-        None
-        """
-        daily = Daily()
-        self.assertEqual(daily.path, "storage/log/daily.log")
-        self.assertEqual(daily.level, Level.INFO.value)
-        self.assertEqual(daily.retention_days, 7)
-        self.assertEqual(daily.at, "00:00")
-
-    async def testPathValidation(self):
-        """
-        Test validation of the path attribute.
-
-        Verifies that empty or non-string paths raise exceptions, and that
-        valid paths are accepted.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Daily(path="")
-        with self.assertRaises(OrionisIntegrityException):
-            Daily(path=123)
-        try:
-            Daily(path="custom/log/path.log")
-        except OrionisIntegrityException:
-            self.fail("Valid path should not raise exception")
-
-    async def testLevelValidation(self):
-        """
-        Test validation of the level attribute.
-
-        Checks that string, integer, and enum values are accepted for level,
-        and that invalid values raise exceptions.
-
-        Returns
-        -------
-        None
-        """
-        # Test string level
-        daily = Daily(level="debug")
-        self.assertEqual(daily.level, Level.DEBUG.value)
-
-        # Test int level
-        daily = Daily(level=Level.WARNING.value)
-        self.assertEqual(daily.level, Level.WARNING.value)
-
-        # Test enum level
-        daily = Daily(level=Level.ERROR)
-        self.assertEqual(daily.level, Level.ERROR.value)
-
-        # Test invalid cases
-        with self.assertRaises(OrionisIntegrityException):
-            Daily(level="invalid")
-        with self.assertRaises(OrionisIntegrityException):
-            Daily(level=999)
-        with self.assertRaises(OrionisIntegrityException):
-            Daily(level=[])
-
-    async def testRetentionDaysValidation(self):
-        """
-        Test validation of the retention_days attribute.
-
-        Ensures that valid values are accepted and invalid values raise exceptions.
-
-        Returns
-        -------
-        None
-        """
-        # Test valid values
-        try:
-            Daily(retention_days=1)
-            Daily(retention_days=90)
-            Daily(retention_days=30)
-        except OrionisIntegrityException:
-            self.fail("Valid retention_days should not raise exception")
-
-        # Test invalid values
-        with self.assertRaises(OrionisIntegrityException):
-            Daily(retention_days=0)
-        with self.assertRaises(OrionisIntegrityException):
-            Daily(retention_days=91)
-        with self.assertRaises(OrionisIntegrityException):
-            Daily(retention_days=-1)
-        with self.assertRaises(OrionisIntegrityException):
-            Daily(retention_days="7")
-
-    async def testAtTimeValidation(self):
-        """
-        Test validation and conversion of the at attribute.
-
-        Checks that a `datetime.time` object is properly converted and that
-        invalid types raise exceptions.
-
-        Returns
-        -------
-        None
-        """
-        # Test time object
-        daily = Daily(at=time(12, 30))
-        self.assertEqual(daily.at, "12:30")
-
-        # Test invalid type
-        with self.assertRaises(OrionisIntegrityException):
-            Daily(at="12:00:00")
-        with self.assertRaises(OrionisIntegrityException):
-            Daily(at=1200)
-
-    async def testWhitespaceHandling(self):
-        """
-        Test handling of whitespace in path and level attributes.
-
-        Returns
-        -------
-        None
-        """
-
-        with self.assertRaises(OrionisIntegrityException):
-            daily = Daily(path="  logs/app.log  ", level="  debug  ")
-            self.assertEqual(daily.path, "  logs/app.log  ")
-            self.assertEqual(daily.level, Level.DEBUG.value)
-
-    async def testToDictMethod(self):
-        """
-        Test the toDict method for correct dictionary representation.
-
-        Ensures that the dictionary returned by toDict contains the correct
-        default values.
-
-        Returns
-        -------
-        None
-        """
-        daily = Daily()
-        daily_dict = daily.toDict()
-
-        self.assertIsInstance(daily_dict, dict)
-        self.assertEqual(daily_dict['path'], "storage/log/daily.log")
-        self.assertEqual(daily_dict['level'], Level.INFO.value)
-        self.assertEqual(daily_dict['retention_days'], 7)
-        self.assertEqual(daily_dict['at'], "00:00")
-
-    async def testCustomValuesToDict(self):
-        """
-        Test toDict method with custom values.
-
-        Ensures that custom values are correctly represented in the dictionary.
-
-        Returns
-        -------
-        None
-        """
-        custom_daily = Daily(
-            path="custom/logs/app.log",
-            level="warning",
-            retention_days=14,
-            at=time(23, 59)
-        )
-        daily_dict = custom_daily.toDict()
-        self.assertEqual(daily_dict['path'], "custom/logs/app.log")
-        self.assertEqual(daily_dict['level'], Level.WARNING.value)
-        self.assertEqual(daily_dict['retention_days'], 14)
-        self.assertEqual(daily_dict['at'], "23:59")
-
-    async def testHashability(self):
-        """
-        Test hashability of Daily instances.
-
-        Ensures that Daily instances are hashable and can be used in sets.
-
-        Returns
-        -------
-        None
-        """
-        daily1 = Daily()
-        daily2 = Daily()
-        daily_set = {daily1, daily2}
-
-        self.assertEqual(len(daily_set), 1)
-
-        custom_daily = Daily(path="custom.log")
-        daily_set.add(custom_daily)
-        self.assertEqual(len(daily_set), 2)
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test enforcement of keyword-only initialization.
-
-        Ensures that positional arguments raise a TypeError.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(TypeError):
-            Daily("path.log", "info", 7, time(0, 0))