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

tests/foundation/config/logging/test_foundation_config_logging_hourly.py

@@ -1,196 +0,0 @@
-from orionis.foundation.config.logging.entities.hourly import Hourly
-from orionis.foundation.config.logging.enums.levels import Level
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigLoggingHourly(AsyncTestCase):
-    """
-    Test cases for the Hourly logging configuration class.
-
-    This class contains unit tests for the `Hourly` logging configuration entity,
-    verifying its default values, attribute validation, dictionary representation,
-    hashability, and keyword-only initialization enforcement.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Test that Hourly instance is created with correct default values.
-
-        Verifies that the default `path`, `level`, and `retention_hours` attributes
-        of the Hourly instance match the expected values.
-
-        Returns
-        -------
-        None
-        """
-        hourly = Hourly()
-        self.assertEqual(hourly.path, "storage/log/hourly.log")
-        self.assertEqual(hourly.level, Level.INFO.value)
-        self.assertEqual(hourly.retention_hours, 24)
-
-    async def testPathValidation(self):
-        """
-        Test path attribute validation.
-
-        Ensures that invalid values for the `path` attribute, such as empty strings
-        or non-string types, raise an `OrionisIntegrityException`. Also verifies that
-        valid paths do not raise exceptions.
-
-        Returns
-        -------
-        None
-        """
-        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.
-
-        Checks that the `level` attribute accepts string, integer, and enum values,
-        and that invalid values raise an `OrionisIntegrityException`.
-
-        Returns
-        -------
-        None
-        """
-        # 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.
-
-        Ensures that valid values for `retention_hours` are accepted and invalid
-        values raise an `OrionisIntegrityException`.
-
-        Returns
-        -------
-        None
-        """
-        # 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.
-
-        Returns
-        -------
-        None
-        """
-
-        with self.assertRaises(OrionisIntegrityException):
-            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.
-
-        Ensures that the `toDict` method returns a dictionary with the correct
-        attribute values.
-
-        Returns
-        -------
-        None
-        """
-        hourly = Hourly()
-        hourly_dict = hourly.toDict()
-        self.assertIsInstance(hourly_dict, dict)
-        self.assertEqual(hourly_dict['path'], "storage/log/hourly.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.
-
-        Verifies that custom values provided to the Hourly instance are correctly
-        reflected in the dictionary returned by `toDict`.
-
-        Returns
-        -------
-        None
-        """
-        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.
-
-        Ensures that Hourly instances can be added to a set and that their
-        hashability is preserved.
-
-        Returns
-        -------
-        None
-        """
-        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.
-
-        Verifies that attempting to initialize Hourly with positional arguments
-        raises a TypeError.
-
-        Returns
-        -------
-        None
-        """
-        with self.assertRaises(TypeError):
-            Hourly("path.log", "info", 24)

tests/foundation/config/logging/test_foundation_config_logging_monthly.py

@@ -1,214 +0,0 @@
-from orionis.foundation.config.logging.entities.monthly import Monthly
-from orionis.foundation.config.logging.enums.levels import Level
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigLoggingMonthly(AsyncTestCase):
-    """
-    Test suite for the `Monthly` logging configuration class.
-
-    This class contains asynchronous test cases to validate the behavior of the
-    `Monthly` logging configuration, including default values, attribute validation,
-    dictionary conversion, hashability, and keyword-only initialization.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Test the default attribute values of a Monthly instance.
-
-        Returns
-        -------
-        None
-
-        Asserts
-        -------
-        - The default path is "storage/log/monthly.log".
-        - The default level is `Level.INFO.value`.
-        - The default retention_months is 4.
-        """
-        monthly = Monthly()
-        self.assertEqual(monthly.path, "storage/log/monthly.log")
-        self.assertEqual(monthly.level, Level.INFO.value)
-        self.assertEqual(monthly.retention_months, 4)
-
-    async def testPathValidation(self):
-        """
-        Validate the `path` attribute for correct and incorrect values.
-
-        Returns
-        -------
-        None
-
-        Asserts
-        -------
-        - Raises OrionisIntegrityException for empty or non-string paths.
-        - Does not raise for valid string paths.
-        """
-        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):
-        """
-        Validate the `level` attribute with various input types.
-
-        Returns
-        -------
-        None
-
-        Asserts
-        -------
-        - Accepts string, int, and enum values for level.
-        - Raises OrionisIntegrityException for invalid level values.
-        """
-        # 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):
-        """
-        Validate the `retention_months` attribute for correct and incorrect values.
-
-        Returns
-        -------
-        None
-
-        Asserts
-        -------
-        - Accepts valid integer values for retention_months.
-        - Raises OrionisIntegrityException for invalid values.
-        """
-        # 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 handling of leading and trailing whitespace in `path` and `level` attributes.
-
-        Returns
-        -------
-        None
-
-        Asserts
-        -------
-        - Raises OrionisIntegrityException if whitespace is not properly handled.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            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 the `toDict` method for correct dictionary representation.
-
-        Returns
-        -------
-        None
-
-        Asserts
-        -------
-        - The output is a dictionary with correct keys and values.
-        """
-        monthly = Monthly()
-        monthly_dict = monthly.toDict()
-        self.assertIsInstance(monthly_dict, dict)
-        self.assertEqual(monthly_dict['path'], "storage/log/monthly.log")
-        self.assertEqual(monthly_dict['level'], Level.INFO.value)
-        self.assertEqual(monthly_dict['retention_months'], 4)
-
-    async def testCustomValuesToDict(self):
-        """
-        Test that custom attribute values are reflected in the dictionary output.
-
-        Returns
-        -------
-        None
-
-        Asserts
-        -------
-        - Custom path, level, and retention_months are present in the output 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 instances are hashable and can be used in sets.
-
-        Returns
-        -------
-        None
-
-        Asserts
-        -------
-        - Monthly instances with identical attributes are considered equal in a set.
-        - Monthly instances with different attributes are considered distinct.
-        """
-        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.
-
-        Returns
-        -------
-        None
-
-        Asserts
-        -------
-        - Raises TypeError when positional arguments are used.
-        """
-        with self.assertRaises(TypeError):
-            Monthly("path.log", "info", 4)

tests/foundation/config/logging/test_foundation_config_logging_stack.py

@@ -1,178 +0,0 @@
-from orionis.foundation.config.logging.entities.stack import Stack
-from orionis.foundation.config.logging.enums.levels import Level
-from orionis.foundation.exceptions.integrity import OrionisIntegrityException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestFoundationConfigLoggingStack(AsyncTestCase):
-    """
-    Asynchronous unit tests for the Stack logging configuration class.
-
-    This test class validates the behavior of the Stack class, including default values,
-    attribute validation, dictionary conversion, hashability, and enforcement of keyword-only
-    initialization.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Test that Stack initializes with correct default values.
-
-        Checks that the default path and level attributes of a Stack instance match
-        the expected class defaults.
-
-        Returns
-        -------
-        None
-        """
-        stack = Stack()
-        self.assertEqual(stack.path, "storage/log/stack.log")
-        self.assertEqual(stack.level, Level.INFO.value)
-
-    async def testPathValidation(self):
-        """
-        Validate the path attribute for correct type and non-emptiness.
-
-        Ensures that providing an empty string or a non-string value for the path
-        raises an OrionisIntegrityException, while a valid string path is accepted.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the path is empty or not a string.
-        """
-        # Test empty path
-        with self.assertRaises(OrionisIntegrityException):
-            Stack(path="")
-        # Test non-string path
-        with self.assertRaises(OrionisIntegrityException):
-            Stack(path=123)
-        # Test valid path
-        try:
-            Stack(path="custom/log/path.log")
-        except OrionisIntegrityException:
-            self.fail("Valid path should not raise exception")
-
-    async def testLevelValidation(self):
-        """
-        Validate the level attribute with various input types.
-
-        Verifies that the level attribute accepts string, integer, and enum values
-        corresponding to valid logging levels, and raises exceptions for invalid values.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the level is invalid or of an unsupported type.
-        """
-        # Test string level
-        stack = Stack(level="debug")
-        self.assertEqual(stack.level, Level.DEBUG.value)
-
-        # Test int level
-        stack = Stack(level=Level.WARNING.value)
-        self.assertEqual(stack.level, Level.WARNING.value)
-
-        # Test enum level
-        stack = Stack(level=Level.ERROR)
-        self.assertEqual(stack.level, Level.ERROR.value)
-
-        # Test invalid string level
-        with self.assertRaises(OrionisIntegrityException):
-            Stack(level="invalid")
-
-        # Test invalid int level
-        with self.assertRaises(OrionisIntegrityException):
-            Stack(level=999)
-
-        # Test invalid type
-        with self.assertRaises(OrionisIntegrityException):
-            Stack(level=[])
-
-    async def testWhitespaceHandling(self):
-        """
-        Test handling of whitespace in path and level attributes.
-
-        Ensures that leading or trailing whitespace in the path attribute is not accepted
-        and raises an OrionisIntegrityException.
-
-        Raises
-        ------
-        OrionisIntegrityException
-            If the path contains leading or trailing whitespace.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            spaced_path = "  logs/app.log  "
-            stack = Stack(path=spaced_path)
-            self.assertEqual(stack.path, spaced_path)
-
-    async def testToDictMethod(self):
-        """
-        Test the toDict method for correct dictionary representation.
-
-        Verifies that the dictionary returned by toDict contains the correct path and
-        level values for a Stack instance with default attributes.
-
-        Returns
-        -------
-        None
-        """
-        stack = Stack()
-        stack_dict = stack.toDict()
-
-        self.assertIsInstance(stack_dict, dict)
-        self.assertEqual(stack_dict['path'], "storage/log/stack.log")
-        self.assertEqual(stack_dict['level'], Level.INFO.value)
-
-    async def testCustomValuesToDict(self):
-        """
-        Test dictionary representation with custom attribute values.
-
-        Ensures that custom path and level values are accurately reflected in the
-        dictionary returned by toDict.
-
-        Returns
-        -------
-        None
-        """
-        custom_stack = Stack(
-            path="custom/logs/app.log",
-            level="warning"
-        )
-        stack_dict = custom_stack.toDict()
-        self.assertEqual(stack_dict['path'], "custom/logs/app.log")
-        self.assertEqual(stack_dict['level'], Level.WARNING.value)
-
-    async def testHashability(self):
-        """
-        Test that Stack instances are hashable.
-
-        Verifies that Stack instances can be added to sets and used as dictionary keys,
-        and that instances with identical attributes are considered equal.
-
-        Returns
-        -------
-        None
-        """
-        stack1 = Stack()
-        stack2 = Stack()
-        stack_set = {stack1, stack2}
-
-        self.assertEqual(len(stack_set), 1)
-
-        custom_stack = Stack(path="custom.log")
-        stack_set.add(custom_stack)
-        self.assertEqual(len(stack_set), 2)
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test enforcement of keyword-only initialization for Stack.
-
-        Ensures that attempting to initialize Stack with positional arguments raises
-        a TypeError.
-
-        Raises
-        ------
-        TypeError
-            If positional arguments are used for initialization.
-        """
-        with self.assertRaises(TypeError):
-            Stack("path.log", "info")