orionis 0.286.0__py3-none-any.whl → 0.288.0__py3-none-any.whl

tests/testing/test_testing_unit.py

@@ -1,14 +1,14 @@
 from orionis.test.cases.test_case import TestCase
-from orionis.unittesting import UnitTest, ExecutionMode, UnittestTestLoader, UnittestTestSuite, unittest_mock_patch, UnittestMagicMock, UnittestTestResult
+from orionis.unittesting import UnitTest, ExecutionMode, TestLoader, StandardTestSuite, patch, MagicMock, StandardTestResult
 
-class TestUnitTest(TestCase):
-    """
-    Test cases for the UnitTest class which handles test discovery and execution.
-    """
+class TestTestingUnit(TestCase):
 
-    async def testDefaultConfiguration(self):
+    async def testDefaultConfiguration(self) -> None:
         """
         Test that UnitTest initializes with correct default configuration values.
+
+        Notes
+        -----
         Verifies that all default attributes are set as expected upon initialization.
         """
         unit_test = UnitTest()
@@ -17,13 +17,31 @@ class TestUnitTest(TestCase):
         self.assertEqual(unit_test.max_workers, 4)
         self.assertFalse(unit_test.fail_fast)
         self.assertTrue(unit_test.print_result)
-        self.assertIsInstance(unit_test.loader, UnittestTestLoader)
-        self.assertIsInstance(unit_test.suite, UnittestTestSuite)
-
-    async def testConfigureMethod(self):
-        """
-        Test that configure method properly updates configuration values.
-        Verifies that all configuration parameters can be updated through the configure method.
+        self.assertIsInstance(unit_test.loader, TestLoader)
+        self.assertIsInstance(unit_test.suite, StandardTestSuite)
+
+    async def testConfigureMethod(self) -> None:
+        """
+        Test the `configure` method for correct configuration updates.
+        This test verifies that all configuration parameters of the `UnitTest` class
+        can be updated through the `configure` method and that the changes are
+        reflected in the instance attributes.
+
+        Parameters
+        ----------
+        self : TestCase
+            The test case instance.
+
+        Notes
+        -----
+        The test checks the following configuration parameters:
+        - verbosity
+        - execution_mode
+        - max_workers
+        - fail_fast
+        - print_result
+        - throw_exception
+        It also asserts that the `configure` method returns the instance itself.
         """
         unit_test = UnitTest()
         configured = unit_test.configure(
@@ -43,35 +61,53 @@ class TestUnitTest(TestCase):
         self.assertTrue(unit_test.throw_exception)
         self.assertEqual(configured, unit_test)
 
-    async def testDiscoverTestsInModule(self):
+    async def testDiscoverTestsInModule(self) -> None:
         """
-        Test that discoverTestsInModule correctly loads tests from a module.
+        Test that `discoverTestsInModule` correctly loads tests from a module.
+
         Verifies that tests can be discovered from a module and added to the test suite.
+
+        Notes
+        -----
+        This test mocks the loader's `loadTestsFromName` method to ensure that
+        `discoverTestsInModule` calls it with the correct arguments and that the
+        returned suite is handled as expected.
         """
         unit_test = UnitTest()
-        with unittest_mock_patch.object(unit_test.loader, 'loadTestsFromName') as mock_load:
-            mock_load.return_value = UnittestTestSuite()
+        with patch.object(unit_test.loader, 'loadTestsFromName') as mock_load:
+            mock_load.return_value = StandardTestSuite()
             result = unit_test.discoverTestsInModule('test_module')
 
             mock_load.assert_called_once_with('test_module')
             self.assertEqual(result, unit_test)
             self.assertEqual(len(unit_test.suite._tests), 0)
 
-    async def testFlattenTestSuite(self):
+    async def testFlattenTestSuite(self) -> None:
         """
-        Test that _flattenTestSuite correctly flattens nested test suites.
+        Test the _flattenTestSuite method for correct flattening of nested test suites.
+        This test verifies that the _flattenTestSuite method of the UnitTest class
+        correctly flattens both simple and nested unittest suites into a single list
+        of test cases.
+
+        Parameters
+        ----------
+        self : TestCase
+            The test case instance.
 
-        Verifies that both simple and nested test suites are properly flattened.
+        Notes
+        -----
+        - Ensures that nested suites are recursively flattened.
+        - Asserts that all test cases from nested suites are present in the flattened result.
         """
         unit_test = UnitTest()
-        test_case1 = UnittestMagicMock()
-        test_case2 = UnittestMagicMock()
+        test_case1 = MagicMock()
+        test_case2 = MagicMock()
 
-        nested_suite = UnittestTestSuite()
+        nested_suite = StandardTestSuite()
         nested_suite.addTest(test_case1)
         nested_suite.addTest(test_case2)
 
-        main_suite = UnittestTestSuite()
+        main_suite = StandardTestSuite()
         main_suite.addTest(nested_suite)
 
         flattened = unit_test._flattenTestSuite(main_suite)
@@ -79,15 +115,20 @@ class TestUnitTest(TestCase):
         self.assertIn(test_case1, flattened)
         self.assertIn(test_case2, flattened)
 
-    async def testMergeTestResults(self):
+    async def testMergeTestResults(self) -> None:
         """
-        Test that _mergeTestResults correctly combines test results.
+        Test the _mergeTestResults method for correct merging of test results.
+        Ensures that the method accurately combines the number of tests run,
+        as well as the lists of failures and errors from individual test results.
 
-        Verifies that test counts, failures, and errors are properly merged.
+        Notes
+        -----
+        - Verifies that the total number of tests run is updated correctly.
+        - Checks that failures and errors are merged without loss of information.
         """
         unit_test = UnitTest()
-        combined = UnittestTestResult()
-        individual = UnittestTestResult()
+        combined = StandardTestResult()
+        individual = StandardTestResult()
 
         individual.testsRun = 2
         individual.failures = [('test1', 'failure')]
@@ -98,39 +139,67 @@ class TestUnitTest(TestCase):
         self.assertEqual(len(combined.failures), 1)
         self.assertEqual(len(combined.errors), 1)
 
-    async def testClearTests(self):
+    async def testClearTests(self) -> None:
         """
-        Test that clearTests method resets the test suite.
-        Verifies that the test suite is emptied when clearTests is called.
+        Test the clearTests method to ensure it resets the test suite.
+        This test verifies that after adding a mock test to the suite and calling
+        the clearTests method, the suite is emptied as expected.
+
+        Steps
+        -----
+        1. Create an instance of UnitTest.
+        2. Add a mock test to the test suite.
+        3. Call the clearTests method.
+        4. Assert that the test suite is empty.
+
+        Assertions
+        ----------
+        - The length of the test suite should be zero after calling clearTests.
         """
         unit_test = UnitTest()
-        mock_test = UnittestMagicMock()
+        mock_test = MagicMock()
         unit_test.suite.addTest(mock_test)
 
         unit_test.clearTests()
         self.assertEqual(len(unit_test.suite._tests), 0)
 
-    async def testGetTestNames(self):
+    async def testGetTestNames(self) -> None:
         """
-        Test that getTestNames returns correct test identifiers.
-        Verifies that test names are properly extracted from the test suite.
+        This test verifies that the `getTestNames` method of the `UnitTest` class
+        correctly extracts and returns the identifiers of tests present in the test suite.
+
+        Notes
+        -----
+        - Mocks a test case with a predefined identifier.
+        - Adds the mock test to the test suite.
+        - Asserts that the returned list of test names matches the expected value.
         """
         unit_test = UnitTest()
-        mock_test = UnittestMagicMock()
+        mock_test = MagicMock()
         mock_test.id.return_value = 'test_id'
         unit_test.suite.addTest(mock_test)
 
         names = unit_test.getTestNames()
         self.assertEqual(names, ['test_id'])
 
-    async def testGetTestCount(self):
+    async def testGetTestCount(self) -> None:
         """
-        Test that getTestCount returns the correct number of tests.
+        Test that `getTestCount` returns the correct number of tests.
+
         Verifies that the count matches the number of tests in the suite.
+
+        Notes
+        -----
+        - Adds two mock tests to the suite.
+        - Asserts that `getTestCount` returns 2.
+
+        Returns
+        -------
+        None
         """
         unit_test = UnitTest()
-        mock_test1 = UnittestMagicMock()
-        mock_test2 = UnittestMagicMock()
+        mock_test1 = MagicMock()
+        mock_test2 = MagicMock()
         unit_test.suite.addTest(mock_test1)
         unit_test.suite.addTest(mock_test2)
 

orionis/services/environment/exceptions/value_exception.py

@@ -1,27 +0,0 @@
-class OrionisEnvironmentValueException(Exception):
-    """
-    Exception raised for invalid or unexpected environment values within the Orionis framework.
-    This exception is intended to signal issues encountered when an environment variable,
-    configuration value, or similar parameter does not meet the expected criteria or format.
-    It provides a clear and descriptive error message to facilitate debugging and error handling.
-    Attributes:
-        raise OrionisEnvironmentValueException("Invalid value for ORIONIS_MODE: expected 'production' or 'development'.")
-        msg (str): The error message describing the specific value-related exception.
-    """
-
-    def __init__(self, msg: str):
-        """
-        Initializes the exception with a custom error message.
-        Args:
-            msg (str): The error message describing the exception.
-        """
-        super().__init__(msg)
-
-    def __str__(self) -> str:
-        """
-        Return a string representation of the exception, including the class name and the first argument.
-
-        Returns:
-            str: A formatted string with the exception class name and its first argument.
-        """
-        return f"{self.__class__.__name__}: {self.args[0]}"

tests/foundation/config/cache/test_cache_file.py

@@ -1,78 +0,0 @@
-from orionis.foundation.config.cache.entities.file import File
-from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
-from orionis.unittesting import TestCase
-
-class TestConfigFile(TestCase):
-    """
-    Test cases for the File cache configuration entity.
-    """
-
-    async def testDefaultPath(self):
-        """
-        Test that the File instance is created with the correct default path.
-        Verifies that the default path matches the expected value from the class definition.
-        """
-        file_config = File()
-        self.assertEqual(file_config.path, 'storage/framework/cache/data')
-
-    async def testCustomPath(self):
-        """
-        Test that a custom path can be set during initialization.
-        Verifies that the path attribute accepts and stores valid custom paths.
-        """
-        custom_path = 'custom/cache/path'
-        file_config = File(path=custom_path)
-        self.assertEqual(file_config.path, custom_path)
-
-    async def testEmptyPathValidation(self):
-        """
-        Test that empty paths are rejected.
-        Verifies that an empty path raises an OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            File(path="")
-
-    async def testPathTypeValidation(self):
-        """
-        Test that non-string paths are rejected.
-        Verifies that non-string path values raise an OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            File(path=123)
-
-        with self.assertRaises(OrionisIntegrityException):
-            File(path=None)
-
-        with self.assertRaises(OrionisIntegrityException):
-            File(path=[])
-
-    async def testToDictMethod(self):
-        """
-        Test that the toDict method returns a proper dictionary representation.
-        Verifies that the returned dictionary contains the expected path value.
-        """
-        file_config = File()
-        config_dict = file_config.toDict()
-
-        self.assertIsInstance(config_dict, dict)
-        self.assertEqual(config_dict['path'], 'storage/framework/cache/data')
-
-    async def testCustomPathToDict(self):
-        """
-        Test that custom paths are properly included in the dictionary representation.
-        Verifies that toDict() includes custom path values when specified.
-        """
-        custom_path = 'another/cache/location'
-        file_config = File(path=custom_path)
-        config_dict = file_config.toDict()
-
-        self.assertEqual(config_dict['path'], custom_path)
-
-    async def testWhitespacePathHandling(self):
-        """
-        Test that paths with whitespace are accepted but not automatically trimmed.
-        Verifies that the validation allows paths containing whitespace characters.
-        """
-        spaced_path = '  storage/cache/with/space  '
-        file_config = File(path=spaced_path)
-        self.assertEqual(file_config.path, spaced_path)

tests/foundation/config/cache/test_cache_stores.py

@@ -1,88 +0,0 @@
-from orionis.foundation.config.cache.entities.stores import Stores
-from orionis.foundation.config.cache.entities.file import File
-from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
-from orionis.unittesting import TestCase
-
-class TestConfigStores(TestCase):
-    """
-    Test cases for the Stores cache configuration entity.
-    """
-
-    async def testDefaultFileStore(self):
-        """
-        Test that Stores initializes with a default File instance.
-        Verifies that the file attribute is properly initialized with default File configuration.
-        """
-        stores = Stores()
-        self.assertIsInstance(stores.file, File)
-        self.assertEqual(stores.file.path, 'storage/framework/cache/data')
-
-    async def testCustomFileStore(self):
-        """
-        Test that Stores accepts a custom File configuration.
-        Verifies that a custom File instance can be provided during initialization.
-        """
-        custom_file = File(path='custom/cache/path')
-        stores = Stores(file=custom_file)
-        self.assertIsInstance(stores.file, File)
-        self.assertEqual(stores.file.path, 'custom/cache/path')
-
-    async def testFileTypeValidation(self):
-        """
-        Test that Stores validates the file attribute type.
-        Verifies that non-File instances raise OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Stores(file="not_a_file_instance")
-
-        with self.assertRaises(OrionisIntegrityException):
-            Stores(file=123)
-
-        with self.assertRaises(OrionisIntegrityException):
-            Stores(file=None)
-
-    async def testToDictMethodWithDefaults(self):
-        """
-        Test that toDict returns proper dictionary with default values.
-        Verifies the dictionary representation contains the correct default file path.
-        """
-        stores = Stores()
-        stores_dict = stores.toDict()
-
-        self.assertIsInstance(stores_dict, dict)
-        self.assertIsInstance(stores_dict['file'], dict)
-        self.assertEqual(stores_dict['file']['path'], 'storage/framework/cache/data')
-
-    async def testToDictMethodWithCustomFile(self):
-        """
-        Test that toDict includes custom file configurations.
-        Verifies the dictionary representation reflects custom file paths.
-        """
-        custom_file = File(path='alternate/cache/location')
-        stores = Stores(file=custom_file)
-        stores_dict = stores.toDict()
-
-        self.assertEqual(stores_dict['file']['path'], 'alternate/cache/location')
-
-    async def testHashability(self):
-        """
-        Test that Stores maintains hashability due to unsafe_hash=True.
-        Verifies that Stores instances can be used in sets and as dictionary keys.
-        """
-        store1 = Stores()
-        store2 = Stores()
-        store_set = {store1, store2}
-
-        self.assertEqual(len(store_set), 1)
-
-        custom_store = Stores(file=File(path='custom/path'))
-        store_set.add(custom_store)
-        self.assertEqual(len(store_set), 2)
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test that Stores enforces keyword-only initialization.
-        Verifies that positional arguments are not allowed for initialization.
-        """
-        with self.assertRaises(TypeError):
-            Stores(File())

tests/foundation/config/cors/test_cors.py

@@ -1,121 +0,0 @@
-
-from orionis.foundation.config.cors.entities.cors import Cors
-from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
-from orionis.unittesting import TestCase
-
-class TestCorsConfig(TestCase):
-    """
-    Unit tests for Cors configuration defaults and validation.
-    """
-
-    async def testDefaultValues(self):
-        """
-        Test the default values of the Cors configuration.
-
-        This test verifies that a newly instantiated Cors object has the following default settings:
-        - allow_origins: ["*"]
-        - allow_origin_regex: None
-        - allow_methods: ["*"]
-        - allow_headers: ["*"]
-        - expose_headers: []
-        - allow_credentials: False
-        - max_age: 600
-        """
-        cors = Cors()
-        self.assertEqual(cors.allow_origins, ["*"])
-        self.assertIsNone(cors.allow_origin_regex)
-        self.assertEqual(cors.allow_methods, ["*"])
-        self.assertEqual(cors.allow_headers, ["*"])
-        self.assertEqual(cors.expose_headers, [])
-        self.assertFalse(cors.allow_credentials)
-        self.assertEqual(cors.max_age, 600)
-
-    async def testCustomValues(self):
-        """
-        Test that the Cors configuration correctly sets custom values for all parameters.
-
-        This test verifies that:
-        - `allow_origins` is set to the provided list of origins.
-        - `allow_origin_regex` is set to the provided regex pattern.
-        - `allow_methods` is set to the provided list of HTTP methods.
-        - `allow_headers` is set to the provided list of headers.
-        - `expose_headers` is set to the provided list of exposed headers.
-        - `allow_credentials` is set to True.
-        - `max_age` is set to the provided integer value.
-
-        Ensures that the Cors object accurately reflects the custom configuration values.
-        """
-        cors = Cors(
-            allow_origins=["https://example.com"],
-            allow_origin_regex="^https://.*\\.example\\.com$",
-            allow_methods=["GET", "POST"],
-            allow_headers=["Authorization", "Content-Type"],
-            expose_headers=["X-Custom-Header"],
-            allow_credentials=True,
-            max_age=3600
-        )
-        self.assertEqual(cors.allow_origins, ["https://example.com"])
-        self.assertEqual(cors.allow_origin_regex, "^https://.*\\.example\\.com$")
-        self.assertEqual(cors.allow_methods, ["GET", "POST"])
-        self.assertEqual(cors.allow_headers, ["Authorization", "Content-Type"])
-        self.assertEqual(cors.expose_headers, ["X-Custom-Header"])
-        self.assertTrue(cors.allow_credentials)
-        self.assertEqual(cors.max_age, 3600)
-
-    async def testInvalidAllowOriginsType(self):
-        """
-        Test that passing a string instead of a list to the 'allow_origins' parameter of the Cors class
-        raises an OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Cors(allow_origins="*")
-
-    async def testInvalidAllowOriginRegexType(self):
-        """
-        Test that passing a non-string, non-None value (specifically an integer) to the
-        `allow_origin_regex` parameter of the `Cors` class raises an OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Cors(allow_origin_regex=123)
-
-    async def testInvalidAllowMethodsType(self):
-        """
-        Test that initializing the Cors class with an invalid type for 'allow_methods' raises an OrionisIntegrityException.
-
-        This test verifies that passing a string instead of a list to the 'allow_methods' parameter
-        of the Cors class triggers the expected exception, ensuring type validation is enforced.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Cors(allow_methods="GET")
-
-    async def testInvalidAllowHeadersType(self):
-        """
-        Test that initializing the Cors class with a non-list type for 'allow_headers' (specifically a string)
-        raises an OrionisIntegrityException, ensuring type validation for the 'allow_headers' parameter.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Cors(allow_headers="Authorization")
-
-    async def testInvalidExposeHeadersType(self):
-        """
-        Test that initializing the Cors class with a non-list type for 'expose_headers'
-        raises an OrionisIntegrityException. Ensures type validation for the 'expose_headers' parameter.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Cors(expose_headers="X-Custom-Header")
-
-    async def testInvalidAllowCredentialsType(self):
-        """
-        Test that initializing the Cors class with a non-boolean value for 'allow_credentials'
-        raises an OrionisIntegrityException, ensuring type validation for the parameter.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Cors(allow_credentials="yes")
-
-    async def testInvalidMaxAgeType(self):
-        """
-        Test that passing a non-integer value (specifically a string) to the `max_age` parameter of the `Cors` class
-        raises an `OrionisIntegrityException`. This ensures that `max_age` only accepts integer or None values.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Cors(max_age="3600")

tests/foundation/config/logging/test_logging.py

@@ -1,48 +0,0 @@
-from orionis.foundation.config.logging.entities.logging import Logging
-from orionis.foundation.config.logging.entities.channels import Channels
-from orionis.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/mail/test_mail.py

@@ -1,73 +0,0 @@
-from orionis.foundation.config.mail.entities.mail import Mail
-from orionis.foundation.config.mail.entities.mailers import Mailers
-from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
-from orionis.unittesting import TestCase
-
-class TestMail(TestCase):
-
-    async def testDefaultInitialization(self):
-        """
-        Test that Mail instance is initialized with correct default values.
-        Verifies that default mailer is 'smtp' and mailers is an instance of Mailers.
-        """
-        mail = Mail()
-        self.assertEqual(mail.default, "smtp")
-        self.assertIsInstance(mail.mailers, Mailers)
-
-    async def testDefaultValidation(self):
-        """
-        Test validation of default mailer against available options.
-        Verifies that invalid default mailer raises OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Mail(default="invalid_mailer")
-        with self.assertRaises(OrionisIntegrityException):
-            Mail(default=123)
-
-    async def testMailersTypeValidation(self):
-        """
-        Test validation of mailers attribute type.
-        Verifies that non-Mailers objects raise OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Mail(mailers="invalid_mailers_object")
-
-    async def testToDictMethod(self):
-        """
-        Test the toDict method returns proper dictionary representation.
-        Verifies the method returns a dict containing all fields.
-        """
-        mail = Mail()
-        result = mail.toDict()
-        self.assertIsInstance(result, dict)
-        self.assertIn("default", result)
-        self.assertIn("mailers", result)
-        self.assertEqual(result["default"], "smtp")
-
-    async def testHashability(self):
-        """
-        Test that Mail instances are hashable due to unsafe_hash=True.
-        Verifies instances can be used in sets or as dictionary keys.
-        """
-        mail1 = Mail()
-        mail2 = Mail(default="smtp")
-        test_set = {mail1, mail2}
-        self.assertEqual(len(test_set), 1)
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test that Mail requires keyword arguments for initialization.
-        Verifies the class enforces kw_only=True in its dataclass decorator.
-        """
-        with self.assertRaises(TypeError):
-            Mail("smtp", Mailers())
-
-    async def testValidCustomInitialization(self):
-        """
-        Test valid custom initialization with proper values.
-        Verifies instance can be created with valid non-default values.
-        """
-        # Assuming 'smtp' is a valid mailer option from Mailers
-        mail = Mail(default="smtp", mailers=Mailers())
-        self.assertEqual(mail.default, "smtp")
-        self.assertIsInstance(mail.mailers, Mailers)