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

tests/foundation/config/logging/test_logging_chunked.py

@@ -0,0 +1,166 @@
+from orionis.luminate.foundation.config.logging.entities.chunked import Chunked
+from orionis.luminate.foundation.config.logging.enums.levels import Level
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigChunked(TestCase):
+    """
+    Test cases for the Chunked logging configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that Chunked instance is created with correct default values.
+        Verifies default path, level, mb_size and files match expected values.
+        """
+        chunked = Chunked()
+        self.assertEqual(chunked.path, "storage/log/application.log")
+        self.assertEqual(chunked.level, Level.INFO.value)
+        self.assertEqual(chunked.mb_size, 10)
+        self.assertEqual(chunked.files, 5)
+
+    async def testPathValidation(self):
+        """
+        Test path attribute validation.
+        Verifies that empty or non-string paths raise exceptions.
+        """
+        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 level attribute validation with different input types.
+        """
+        # 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 mb_size attribute validation with different input formats.
+        """
+        # Test valid integer values
+        try:
+            Chunked(mb_size=1)
+            Chunked(mb_size=100)
+        except OrionisIntegrityException:
+            self.fail("Valid mb_size should not raise exception")
+
+        # Test string formats
+        chunked = Chunked(mb_size="10MB")
+        self.assertEqual(chunked.mb_size, 10)
+
+        chunked = Chunked(mb_size="10240KB")
+        self.assertEqual(chunked.mb_size, 10)
+
+        chunked = Chunked(mb_size="10485760B")
+        self.assertEqual(chunked.mb_size, 10)
+
+        # Test invalid cases
+        with self.assertRaises(OrionisIntegrityException):
+            Chunked(mb_size=0)
+        with self.assertRaises(OrionisIntegrityException):
+            Chunked(mb_size=-1)
+        with self.assertRaises(OrionisIntegrityException):
+            Chunked(mb_size="invalid")
+        with self.assertRaises(OrionisIntegrityException):
+            Chunked(mb_size="10GB")
+
+    async def testFilesValidation(self):
+        """
+        Test files attribute validation.
+        """
+        # 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 whitespace handling in path and level attributes.
+        """
+        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 that toDict returns proper dictionary representation.
+        """
+        chunked = Chunked()
+        chunked_dict = chunked.toDict()
+
+        self.assertIsInstance(chunked_dict, dict)
+        self.assertEqual(chunked_dict['path'], "storage/log/application.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 that custom values are properly included in dictionary.
+        """
+        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'], Level.WARNING.value)
+        self.assertEqual(chunked_dict['mb_size'], 20)
+        self.assertEqual(chunked_dict['files'], 10)
+
+    async def testHashability(self):
+        """
+        Test that Chunked maintains hashability due to unsafe_hash=True.
+        """
+        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 that Chunked enforces keyword-only initialization.
+        """
+        with self.assertRaises(TypeError):
+            Chunked("path.log", "info", 10, 5)

tests/foundation/config/logging/test_logging_daily.py

@@ -0,0 +1,153 @@
+from datetime import time
+from orionis.luminate.foundation.config.logging.entities.daily import Daily
+from orionis.luminate.foundation.config.logging.enums.levels import Level
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigDaily(TestCase):
+    """
+    Test cases for the Daily logging configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that Daily instance is created with correct default values.
+        Verifies default path, level, retention_days and at time match expected values.
+        """
+        daily = Daily()
+        self.assertEqual(daily.path, "storage/log/application.log")
+        self.assertEqual(daily.level, Level.INFO.value)
+        self.assertEqual(daily.retention_days, 7)
+        self.assertEqual(daily.at, "00:00:00")
+
+    async def testPathValidation(self):
+        """
+        Test path attribute validation.
+        Verifies that empty or non-string paths raise exceptions.
+        """
+        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 level attribute validation with different input types.
+        """
+        # 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 retention_days attribute validation.
+        """
+        # 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 at time attribute validation and conversion.
+        """
+        # Test time object
+        daily = Daily(at=time(12, 30))
+        self.assertEqual(daily.at, "12:30:00")
+
+        # Test invalid type
+        with self.assertRaises(OrionisIntegrityException):
+            Daily(at="12:00:00")
+        with self.assertRaises(OrionisIntegrityException):
+            Daily(at=1200)
+
+    async def testWhitespaceHandling(self):
+        """
+        Test whitespace handling in path and level attributes.
+        """
+        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 that toDict returns proper dictionary representation.
+        """
+        daily = Daily()
+        daily_dict = daily.toDict()
+
+        self.assertIsInstance(daily_dict, dict)
+        self.assertEqual(daily_dict['path'], "storage/log/application.log")
+        self.assertEqual(daily_dict['level'], Level.INFO.value)
+        self.assertEqual(daily_dict['retention_days'], 7)
+        self.assertEqual(daily_dict['at'], "00:00:00")
+
+    async def testCustomValuesToDict(self):
+        """
+        Test that custom values are properly included in dictionary.
+        """
+        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:00")
+
+    async def testHashability(self):
+        """
+        Test that Daily maintains hashability due to unsafe_hash=True.
+        """
+        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 that Daily enforces keyword-only initialization.
+        """
+        with self.assertRaises(TypeError):
+            Daily("path.log", "info", 7, time(0, 0))

tests/foundation/config/logging/test_logging_hourly.py

@@ -0,0 +1,131 @@
+from orionis.luminate.foundation.config.logging.entities.hourly import Hourly
+from orionis.luminate.foundation.config.logging.enums.levels import Level
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigHourly(TestCase):
+    """
+    Test cases for the Hourly logging configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that Hourly instance is created with correct default values.
+        Verifies default path, level and retention_hours match expected values.
+        """
+        hourly = Hourly()
+        self.assertEqual(hourly.path, "storage/log/application.log")
+        self.assertEqual(hourly.level, Level.INFO.value)
+        self.assertEqual(hourly.retention_hours, 24)
+
+    async def testPathValidation(self):
+        """
+        Test path attribute validation.
+        Verifies that empty or non-string paths raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Hourly(path="")
+        with self.assertRaises(OrionisIntegrityException):
+            Hourly(path=123)
+        try:
+            Hourly(path="custom/log/path.log")
+        except OrionisIntegrityException:
+            self.fail("Valid path should not raise exception")
+
+    async def testLevelValidation(self):
+        """
+        Test level attribute validation with different input types.
+        """
+        # Test string level
+        hourly = Hourly(level="debug")
+        self.assertEqual(hourly.level, Level.DEBUG.value)
+
+        # Test int level
+        hourly = Hourly(level=Level.WARNING.value)
+        self.assertEqual(hourly.level, Level.WARNING.value)
+
+        # Test enum level
+        hourly = Hourly(level=Level.ERROR)
+        self.assertEqual(hourly.level, Level.ERROR.value)
+
+        # Test invalid cases
+        with self.assertRaises(OrionisIntegrityException):
+            Hourly(level="invalid")
+        with self.assertRaises(OrionisIntegrityException):
+            Hourly(level=999)
+        with self.assertRaises(OrionisIntegrityException):
+            Hourly(level=[])
+
+    async def testRetentionHoursValidation(self):
+        """
+        Test retention_hours attribute validation.
+        """
+        # Test valid values
+        try:
+            Hourly(retention_hours=1)
+            Hourly(retention_hours=168)
+            Hourly(retention_hours=72)
+        except OrionisIntegrityException:
+            self.fail("Valid retention_hours should not raise exception")
+
+        # Test invalid values
+        with self.assertRaises(OrionisIntegrityException):
+            Hourly(retention_hours=0)
+        with self.assertRaises(OrionisIntegrityException):
+            Hourly(retention_hours=169)
+        with self.assertRaises(OrionisIntegrityException):
+            Hourly(retention_hours=-1)
+        with self.assertRaises(OrionisIntegrityException):
+            Hourly(retention_hours="24")
+
+    async def testWhitespaceHandling(self):
+        """
+        Test whitespace handling in path and level attributes.
+        """
+        hourly = Hourly(path="  logs/app.log  ", level="  debug  ")
+        self.assertEqual(hourly.path, "  logs/app.log  ")
+        self.assertEqual(hourly.level, Level.DEBUG.value)
+
+    async def testToDictMethod(self):
+        """
+        Test that toDict returns proper dictionary representation.
+        """
+        hourly = Hourly()
+        hourly_dict = hourly.toDict()
+        self.assertIsInstance(hourly_dict, dict)
+        self.assertEqual(hourly_dict['path'], "storage/log/application.log")
+        self.assertEqual(hourly_dict['level'], Level.INFO.value)
+        self.assertEqual(hourly_dict['retention_hours'], 24)
+
+    async def testCustomValuesToDict(self):
+        """
+        Test that custom values are properly included in dictionary.
+        """
+        custom_hourly = Hourly(
+            path="custom/logs/app.log",
+            level="warning",
+            retention_hours=48
+        )
+        hourly_dict = custom_hourly.toDict()
+        self.assertEqual(hourly_dict['path'], "custom/logs/app.log")
+        self.assertEqual(hourly_dict['level'], Level.WARNING.value)
+        self.assertEqual(hourly_dict['retention_hours'], 48)
+
+    async def testHashability(self):
+        """
+        Test that Hourly maintains hashability due to unsafe_hash=True.
+        """
+        hourly1 = Hourly()
+        hourly2 = Hourly()
+        hourly_set = {hourly1, hourly2}
+        self.assertEqual(len(hourly_set), 1)
+        custom_hourly = Hourly(path="custom.log")
+        hourly_set.add(custom_hourly)
+        self.assertEqual(len(hourly_set), 2)
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that Hourly enforces keyword-only initialization.
+        """
+        with self.assertRaises(TypeError):
+            Hourly("path.log", "info", 24)

tests/foundation/config/logging/test_logging_monthly.py

@@ -0,0 +1,133 @@
+from orionis.luminate.foundation.config.logging.entities.monthly import Monthly
+from orionis.luminate.foundation.config.logging.enums.levels import Level
+from orionis.luminate.foundation.config.exceptions.integrity import OrionisIntegrityException
+from orionis.unittesting import TestCase
+
+class TestConfigMonthly(TestCase):
+    """
+    Test cases for the Monthly logging configuration class.
+    """
+
+    async def testDefaultValues(self):
+        """
+        Test that Monthly instance is created with correct default values.
+        Verifies default path, level and retention_months match expected values.
+        """
+        monthly = Monthly()
+        self.assertEqual(monthly.path, "storage/log/application.log")
+        self.assertEqual(monthly.level, Level.INFO.value)
+        self.assertEqual(monthly.retention_months, 4)
+
+    async def testPathValidation(self):
+        """
+        Test path attribute validation.
+        Verifies that empty or non-string paths raise exceptions.
+        """
+        with self.assertRaises(OrionisIntegrityException):
+            Monthly(path="")
+        with self.assertRaises(OrionisIntegrityException):
+            Monthly(path=123)
+        try:
+            Monthly(path="custom/log/path.log")
+        except OrionisIntegrityException:
+            self.fail("Valid path should not raise exception")
+
+    async def testLevelValidation(self):
+        """
+        Test level attribute validation with different input types.
+        """
+        # Test string level
+        monthly = Monthly(level="debug")
+        self.assertEqual(monthly.level, Level.DEBUG.value)
+
+        # Test int level
+        monthly = Monthly(level=Level.WARNING.value)
+        self.assertEqual(monthly.level, Level.WARNING.value)
+
+        # Test enum level
+        monthly = Monthly(level=Level.ERROR)
+        self.assertEqual(monthly.level, Level.ERROR.value)
+
+        # Test invalid cases
+        with self.assertRaises(OrionisIntegrityException):
+            Monthly(level="invalid")
+        with self.assertRaises(OrionisIntegrityException):
+            Monthly(level=999)
+        with self.assertRaises(OrionisIntegrityException):
+            Monthly(level=[])
+
+    async def testRetentionMonthsValidation(self):
+        """
+        Test retention_months attribute validation.
+        """
+        # Test valid values
+        try:
+            Monthly(retention_months=1)
+            Monthly(retention_months=12)
+            Monthly(retention_months=6)
+        except OrionisIntegrityException:
+            self.fail("Valid retention_months should not raise exception")
+
+        # Test invalid values
+        with self.assertRaises(OrionisIntegrityException):
+            Monthly(retention_months=0)
+        with self.assertRaises(OrionisIntegrityException):
+            Monthly(retention_months=13)
+        with self.assertRaises(OrionisIntegrityException):
+            Monthly(retention_months=-1)
+        with self.assertRaises(OrionisIntegrityException):
+            Monthly(retention_months="4")
+
+    async def testWhitespaceHandling(self):
+        """
+        Test whitespace handling in path and level attributes.
+        """
+        monthly = Monthly(path="  logs/app.log  ", level="  debug  ")
+        self.assertEqual(monthly.path, "  logs/app.log  ")
+        self.assertEqual(monthly.level, Level.DEBUG.value)
+
+    async def testToDictMethod(self):
+        """
+        Test that toDict returns proper dictionary representation.
+        """
+        monthly = Monthly()
+        monthly_dict = monthly.toDict()
+        self.assertIsInstance(monthly_dict, dict)
+        self.assertEqual(monthly_dict['path'], "storage/log/application.log")
+        self.assertEqual(monthly_dict['level'], Level.INFO.value)
+        self.assertEqual(monthly_dict['retention_months'], 4)
+
+    async def testCustomValuesToDict(self):
+        """
+        Test that custom values are properly included in dictionary.
+        """
+        custom_monthly = Monthly(
+            path="custom/logs/app.log",
+            level="warning",
+            retention_months=6
+        )
+        monthly_dict = custom_monthly.toDict()
+        self.assertEqual(monthly_dict['path'], "custom/logs/app.log")
+        self.assertEqual(monthly_dict['level'], Level.WARNING.value)
+        self.assertEqual(monthly_dict['retention_months'], 6)
+
+    async def testHashability(self):
+        """
+        Test that Monthly maintains hashability due to unsafe_hash=True.
+        """
+        monthly1 = Monthly()
+        monthly2 = Monthly()
+        monthly_set = {monthly1, monthly2}
+
+        self.assertEqual(len(monthly_set), 1)
+
+        custom_monthly = Monthly(path="custom.log")
+        monthly_set.add(custom_monthly)
+        self.assertEqual(len(monthly_set), 2)
+
+    async def testKwOnlyInitialization(self):
+        """
+        Test that Monthly enforces keyword-only initialization.
+        """
+        with self.assertRaises(TypeError):
+            Monthly("path.log", "info", 4)