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

tests/foundation/config/mail/test_mail_mailers.py

@@ -1,58 +0,0 @@
-from orionis.foundation.config.mail.entities.mailers import Mailers
-from orionis.foundation.config.mail.entities.smtp import Smtp
-from orionis.foundation.config.mail.entities.file import File
-from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
-from orionis.unittesting import TestCase
-
-class TestMailers(TestCase):
-
-    async def testDefaultInitialization(self):
-        """
-        Test that Mailers instance is initialized with correct default factories.
-        Verifies that smtp and file attributes are properly initialized with their respective types.
-        """
-        mailers = Mailers()
-        self.assertIsInstance(mailers.smtp, Smtp)
-        self.assertIsInstance(mailers.file, File)
-
-    async def testTypeValidation(self):
-        """
-        Test type validation for smtp and file attributes.
-        Verifies that invalid types raise OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Mailers(smtp="invalid_smtp")
-        with self.assertRaises(OrionisIntegrityException):
-            Mailers(file="invalid_file")
-
-    async def testCustomInitialization(self):
-        """
-        Test custom initialization with valid parameters.
-        Verifies that valid Smtp and File instances are accepted.
-        """
-        custom_smtp = Smtp()
-        custom_file = File()
-        mailers = Mailers(smtp=custom_smtp, file=custom_file)
-        self.assertIs(mailers.smtp, custom_smtp)
-        self.assertIs(mailers.file, custom_file)
-
-    async def testToDictMethod(self):
-        """
-        Test the toDict method returns proper dictionary representation.
-        Verifies the method returns a dict containing all fields with correct values.
-        """
-        mailers = Mailers()
-        result = mailers.toDict()
-        self.assertIsInstance(result, dict)
-        self.assertIn("smtp", result)
-        self.assertIn("file", result)
-        self.assertIsInstance(result["smtp"], dict)
-        self.assertIsInstance(result["file"], dict)
-
-    async def testKwOnlyInitialization(self):
-        """
-        Test that Mailers requires keyword arguments for initialization.
-        Verifies the class enforces kw_only=True in its dataclass decorator.
-        """
-        with self.assertRaises(TypeError):
-            Mailers(Smtp(), File())

tests/foundation/config/queue/test_queue.py

@@ -1,58 +0,0 @@
-from orionis.foundation.config.queue.entities.queue import Queue
-from orionis.foundation.config.queue.entities.brokers import Brokers
-from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
-from orionis.unittesting import TestCase
-
-class TestQueue(TestCase):
-
-    async def testDefaultInitialization(self):
-        """
-        Test that Queue instance is initialized with correct default values.
-        Verifies that default connection is 'sync' and brokers is a Brokers instance.
-        """
-        queue = Queue()
-        self.assertEqual(queue.default, "sync")
-        self.assertIsInstance(queue.brokers, Brokers)
-
-    async def testDefaultValidation(self):
-        """
-        Test validation for default attribute.
-        Verifies that invalid default values raise OrionisIntegrityException.
-        """
-        invalid_options = ["invalid", "", 123, None]
-        for option in invalid_options:
-            with self.assertRaises(OrionisIntegrityException):
-                Queue(default=option)
-
-    async def testBrokersValidation(self):
-        """
-        Test validation for brokers attribute.
-        Verifies that non-Brokers values raise OrionisIntegrityException.
-        """
-        with self.assertRaises(OrionisIntegrityException):
-            Queue(brokers="invalid_brokers")
-        with self.assertRaises(OrionisIntegrityException):
-            Queue(brokers={})
-
-    async def testValidCustomInitialization(self):
-        """
-        Test custom initialization with valid parameters.
-        Verifies that valid default and Brokers instances are accepted.
-        """
-        custom_brokers = Brokers(sync=False)
-        queue = Queue(default="sync", brokers=custom_brokers)
-        self.assertEqual(queue.default, "sync")
-        self.assertIs(queue.brokers, custom_brokers)
-        self.assertFalse(queue.brokers.sync)
-
-    async def testToDictMethod(self):
-        """
-        Test the toDict method returns proper dictionary representation.
-        Verifies all fields are included with correct values.
-        """
-        queue = Queue()
-        result = queue.toDict()
-        self.assertIsInstance(result, dict)
-        self.assertEqual(result["default"], "sync")
-        self.assertIsInstance(result["brokers"], dict)
-        self.assertTrue(result["brokers"]["sync"])

tests/patterns/singleton/test_singleton.py

@@ -1,18 +0,0 @@
-from orionis.patterns.singleton.meta_class import Singleton
-from orionis.test.cases.test_case import TestCase
-
-class TestsAsyncCoroutine(TestCase):
-
-    async def testSingleton(self):
-        """
-        Test the Singleton metaclass to ensure that only one instance of a class is created.
-        """
-        class SingletonClass(metaclass=Singleton):
-            def __init__(self, value):
-                self.value = value
-
-        instance1 = SingletonClass(1)
-        instance2 = SingletonClass(2)
-
-        self.assertIs(instance1, instance2)
-        self.assertEqual(instance1.value, 1)

tests/services/environment/test_env.py

@@ -1,155 +0,0 @@
-from orionis.services.environment.dot_env import DotEnv
-from orionis.services.environment.env import Env
-from orionis.unittesting import TestCase, unittest_mock_patch
-
-class TestEnv(TestCase):
-    """
-    Test cases for the Env class which provides environment variable management.
-    """
-
-    async def testGetMethod(self):
-        """
-        Test that the get method retrieves values correctly.
-        Verifies that Env.get() properly delegates to DotEnv.get() and returns the expected value.
-        """
-        with unittest_mock_patch.object(DotEnv, 'get', return_value='test_value') as mock_get:
-            result = Env.get('TEST_KEY')
-            mock_get.assert_called_once_with('TEST_KEY', None, False)
-            self.assertEqual(result, 'test_value')
-
-    async def testGetMethodWithDefault(self):
-        """
-        Test that the get method returns default value when key not found.
-        Verifies that the default parameter is properly passed to DotEnv.get().
-        """
-        with unittest_mock_patch.object(DotEnv, 'get', return_value='default_value') as mock_get:
-            result = Env.get('NON_EXISTENT_KEY', 'default_value')
-            mock_get.assert_called_once_with('NON_EXISTENT_KEY', 'default_value', False)
-            self.assertEqual(result, 'default_value')
-
-    async def testSetMethod(self):
-        """
-        Test that the set method updates environment variables.
-        Verifies that Env.set() properly delegates to DotEnv.set() and returns True on success.
-        """
-        with unittest_mock_patch.object(DotEnv, 'set', return_value=True) as mock_set:
-            result = Env.set('TEST_KEY', 'test_value')
-            mock_set.assert_called_once_with('TEST_KEY', 'test_value', False)
-            self.assertTrue(result)
-
-    async def testUnsetMethod(self):
-        """
-        Test that the unset method removes environment variables.
-        Verifies that Env.unset() properly delegates to DotEnv.unset() and returns True on success.
-        """
-        with unittest_mock_patch.object(DotEnv, 'unset', return_value=True) as mock_unset:
-            result = Env.unset('TEST_KEY')
-            mock_unset.assert_called_once_with('TEST_KEY')
-            self.assertTrue(result)
-
-    async def testAllMethod(self):
-        """
-        Test that the all method retrieves all environment variables.
-        Verifies that Env.all() properly delegates to DotEnv.all() and returns the expected dictionary.
-        """
-        mock_env = {'KEY1': 'value1', 'KEY2': 'value2'}
-        with unittest_mock_patch.object(DotEnv, 'all', return_value=mock_env) as mock_all:
-            result = Env.all()
-            mock_all.assert_called_once()
-            self.assertEqual(result, mock_env)
-
-    async def testToJsonMethod(self):
-        """
-        Test that the toJson method serializes environment variables to JSON.
-        Verifies that Env.toJson() properly delegates to DotEnv.toJson() and returns a JSON string.
-        """
-        mock_json = '{"KEY": "value"}'
-        with unittest_mock_patch.object(DotEnv, 'toJson', return_value=mock_json) as mock_to_json:
-            result = Env.toJson()
-            mock_to_json.assert_called_once()
-            self.assertEqual(result, mock_json)
-
-    async def testToBase64Method(self):
-        """
-        Test that the toBase64 method encodes environment variables in Base64.
-        Verifies that Env.toBase64() properly delegates to DotEnv.toBase64() and returns a Base64 string.
-        """
-        mock_b64 = 'base64encodedstring'
-        with unittest_mock_patch.object(DotEnv, 'toBase64', return_value=mock_b64) as mock_to_b64:
-            result = Env.toBase64()
-            mock_to_b64.assert_called_once()
-            self.assertEqual(result, mock_b64)
-
-    async def testDotenvInstanceManagement(self):
-        """
-        Test that the Env._dotenv() method implements singleton behavior by ensuring
-        that multiple calls return the same instance. Also verifies that resetting
-        Env._dotenv_instance allows for a new instance to be created.
-        """
-
-        # Clear any existing instance
-        Env._dotenv_instance = None
-
-        # First call should create instance
-        instance1 = Env._dotenv()
-        instance2 = Env._dotenv()
-
-        # Verify that the same instance is returned
-        self.assertEqual(instance1, instance2)
-
-    async def testHelperFunctionEnv(self):
-        """
-        Test that the env helper function works correctly.
-        Verifies that the env() function properly delegates to DotEnv.get().
-        """
-        with unittest_mock_patch.object(DotEnv, 'get', return_value='test_value') as mock_get:
-            from orionis.services.environment.env import env
-            result = env('TEST_KEY', 'default_value')
-            mock_get.assert_called_once_with('TEST_KEY', 'default_value')
-            self.assertEqual(result, 'test_value')
-
-    async def testOrionisConstants(self):
-        """
-        Test that Orionis framework constants are correctly set and retrieved via Env.
-
-        This test imports a set of well-known constants from the Orionis framework and ensures:
-        - Each constant can be set as an environment variable using Env.set().
-        - Each constant can be retrieved using Env.get() and matches the original value.
-        - The Env.get() method returns None for a non-existent key.
-        - All constants are present in the dictionary returned by Env.all().
-        """
-        from orionis.metadata.framework import (
-            NAME, VERSION, AUTHOR, AUTHOR_EMAIL, DESCRIPTION,
-            SKELETON, FRAMEWORK, DOCS, API, PYTHON_REQUIRES
-        )
-        constants = {
-            "NAME": NAME,
-            "VERSION": VERSION,
-            "AUTHOR": AUTHOR,
-            "AUTHOR_EMAIL": AUTHOR_EMAIL,
-            "DESCRIPTION": DESCRIPTION,
-            "SKELETON": SKELETON,
-            "FRAMEWORK": FRAMEWORK,
-            "DOCS": DOCS,
-            "API": API,
-            "PYTHON_REQUIRES": PYTHON_REQUIRES
-        }
-
-        # Set all constants as environment variables
-        for key, value in constants.items():
-            result = Env.set(key, value)
-            self.assertTrue(result, f"Env.set() should return True for key '{key}'")
-
-        # Retrieve and verify each constant
-        for key, value in constants.items():
-            retrieved = Env.get(key)
-            self.assertEqual(retrieved, value, f"Env.get('{key}') should return '{value}'")
-
-        # Check that a non-existent key returns None
-        self.assertIsNone(Env.get("NON_EXISTENT_ORIONIS_KEY"), "Env.get() should return None for missing keys")
-
-        # Ensure all constants are present in Env.all()
-        env_all = Env.all()
-        for key, value in constants.items():
-            self.assertIn(key, env_all, f"'{key}' should be present in Env.all()")
-            self.assertEqual(env_all[key], value, f"Env.all()['{key}'] should be '{value}'")