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

tests/{support/async_io/test_async_coroutine.py → services/asynchrony/test_async_io.py}

@@ -1,5 +1,6 @@
-from orionis.luminate.support.asynchrony.async_io import AsyncIO
-from orionis.luminate.test import TestCase
+
+from orionis.luminate.services.asynchrony.async_io import run_coroutine
+from orionis.unittesting import TestCase
 
 class TestsAsyncIO(TestCase):
 
@@ -12,7 +13,7 @@ class TestsAsyncIO(TestCase):
         async def sample_coroutine():
             return "Hello, World!"
 
-        result = await AsyncIO.run(sample_coroutine())
+        result = await run_coroutine(sample_coroutine())
         self.assertEqual(result, "Hello, World!")
 
     def testExecuteWithoutActiveEventLoop(self):
@@ -23,7 +24,7 @@ class TestsAsyncIO(TestCase):
         async def sample_coroutine():
             return "Hello, World!"
 
-        result = AsyncIO.run(sample_coroutine())
+        result = run_coroutine(sample_coroutine())
         self.assertEqual(result, "Hello, World!")
 
     def testExecuteWithNonCoroutine(self):
@@ -35,4 +36,4 @@ class TestsAsyncIO(TestCase):
             return "Hello, World!"
 
         with self.assertRaises(TypeError):
-            AsyncIO.run(sample_no_coroutine())
+            run_coroutine(sample_no_coroutine())

tests/services/environment/test_env.py

@@ -1,33 +1,155 @@
-from orionis.luminate.services.environment.env import Env, env
-from orionis.luminate.test import TestCase
-from orionis.framework import *
-
-class TestDotEnv(TestCase):
-
-    async def testDotEnv(self):
-
-        # Test set and get environment variable.
-        Env.set('NAME', NAME)
-        result = Env.get('NAME')
-        self.assertEqual(result, NAME)
-
-        # Test unset environment variable.
-        Env.set('VERSION', VERSION)
-        Env.unset('VERSION')
-        result = Env.get('VERSION')
-        self.assertIsNone(result)
-
-        # Test env helper function retrieves variable.
-        Env.set('DOCS', DOCS)
-        result = env('DOCS')
-        self.assertEqual(result, DOCS)
-
-        # Test retrieving all environment variables.
-        Env.set('SKELETON', SKELETON)
-        Env.set('FRAMEWORK', FRAMEWORK)
-        result = Env.all()
-        self.assertEqual(result.get('SKELETON'), SKELETON)
-        self.assertEqual(result.get('FRAMEWORK'), FRAMEWORK)
-
-        # Destroy the environment
-        Env.destroy()
+from orionis.luminate.services.environment.dot_env import DotEnv
+from orionis.luminate.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)
+            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')
+            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')
+            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.luminate.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.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}'")

tests/services/inspection/dependencies/mocks/mock_user.py

@@ -0,0 +1,30 @@
+class FakeUser:
+    """
+    FakeUser is a mock class intended for testing purposes, simulating a user entity.
+    Methods:
+        __init__():
+            Initializes the FakeUser instance and sets user_data to None.
+        getUser(user_id):
+            Retrieves user information based on the provided user ID.
+    """
+
+    def __init__(self):
+        """
+        Initializes the instance and sets the user_data attribute to None.
+
+        Attributes:
+            user_data (Any): Placeholder for user-specific data, initialized as None.
+        """
+        self.user_data = None
+
+    def getUser(self, user_id):
+        """
+        Retrieve user information based on the provided user ID.
+
+        Args:
+            user_id: The unique identifier of the user.
+
+        Returns:
+            The user data associated with the given user ID.
+        """
+        return self.user_data

tests/services/inspection/dependencies/mocks/mock_user_controller.py

@@ -0,0 +1,27 @@
+from tests.services.inspection.dependencies.mocks.mock_user import FakeUser
+from tests.services.inspection.dependencies.mocks.mock_users_permissions import FakeUserWithPermissions
+
+
+class UserController:
+    """
+    UserController manages user-related operations, utilizing a user repository for data access.
+    Methods:
+        __init__(user_repository: FakeUser)
+            Initializes the controller with a user repository.
+        createUserWithPermissions(user_permissions: FakeUserWithPermissions, permissions: list[str]) -> FakeUserWithPermissions
+            Adds a list of permissions to the given user_permissions object and returns it.
+    """
+
+    def __init__(self, user_repository: FakeUser):
+        """
+        Initializes the class with a user repository.
+
+        Args:
+            user_repository (FakeUser): An instance of FakeUser to be used as the user repository.
+        """
+        self.user_repository = user_repository
+
+    def createUserWithPermissions(self, user_permissions: FakeUserWithPermissions, permissions: list[str]):
+        for permission in permissions:
+            user_permissions.addPermission(permission)
+        return user_permissions

tests/services/inspection/dependencies/mocks/mock_users_permissions.py

@@ -0,0 +1,41 @@
+class FakeUserWithPermissions:
+    """
+    A fake user class for testing permission-based logic.
+    This class simulates a user object with a set of permissions, providing methods to add and check permissions.
+        permissions (set): A set containing the permissions assigned to the user.
+    Methods:
+        addPermission(permission: str):
+            Adds a permission to the user's set of permissions.
+        hasPermission(permission: str) -> bool:
+            Checks if the user has a specific permission.
+    """
+
+    def __init__(self):
+        """
+        Initializes the object with an empty set of permissions.
+
+        Attributes:
+            permissions (set): A set to store permission values.
+        """
+        self.permissions = set()
+
+    def addPermission(self, permission: str):
+        """
+        Adds a permission to the set of permissions.
+
+        Args:
+            permission (str): The permission to add.
+        """
+        self.permissions.add(permission)
+
+    def hasPermission(self, permission: str) -> bool:
+        """
+        Check if the specified permission exists in the user's permissions.
+
+        Args:
+            permission (str): The permission to check for.
+
+        Returns:
+            bool: True if the permission exists, False otherwise.
+        """
+        return permission in self.permissions

tests/services/inspection/dependencies/test_reflect_dependencies.py

@@ -0,0 +1,94 @@
+from orionis.luminate.services.introspection.dependencies.reflect_dependencies import (
+    ReflectDependencies,
+    ClassDependency,
+    MethodDependency,
+    ResolvedDependency
+)
+from orionis.unittesting import TestCase
+from tests.services.inspection.dependencies.mocks.mock_user import FakeUser
+from tests.services.inspection.dependencies.mocks.mock_user_controller import UserController
+from tests.services.inspection.dependencies.mocks.mock_users_permissions import FakeUserWithPermissions
+
+class TestReflectDependencies(TestCase):
+    """
+    Test suite for verifying the functionality of the ReflectDependencies class in resolving and reflecting dependencies for class constructors and methods.
+    This test class covers:
+        - Retrieval and resolution of constructor dependencies for the UserController class.
+        - Validation that constructor dependencies are correctly identified as instances of ClassDependency.
+        - Verification that resolved dependencies (such as 'user_repository') are instances of ResolvedDependency and have the expected module name, class name, full class path, and type.
+        - Reflection and resolution of method dependencies for specific methods (e.g., 'createUserWithPermissions').
+        - Validation that method dependencies are correctly identified as instances of MethodDependency.
+        - Verification that resolved method dependencies (such as 'user_permissions' and 'permissions') are instances of ResolvedDependency and have the expected attributes.
+        - Ensuring that unresolved dependencies lists are empty where appropriate.
+    """
+
+    async def testReflectionDependenciesGetConstructorDependencies(self):
+        """
+        Test that ReflectDependencies correctly retrieves and resolves constructor dependencies for the UserController class.
+        This test verifies:
+            - The returned constructor dependencies are an instance of ClassDependency.
+            - The list of unresolved dependencies is empty.
+            - The 'user_repository' dependency is resolved as an instance of ResolvedDependency.
+            - The resolved dependency for 'user_repository' has the expected module name, class name, full class path, and type (FakeUser).
+        """
+
+        depend = ReflectDependencies(UserController)
+        constructor_dependencies = depend.getConstructorDependencies()
+
+        # Check Instance of ClassDependency
+        self.assertIsInstance(constructor_dependencies, ClassDependency)
+
+        self.assertEqual(constructor_dependencies.unresolved, [])
+
+        # Check Instance of ResolvedDependency
+        dep_user_repository = constructor_dependencies.resolved.get('user_repository')
+        self.assertIsInstance(dep_user_repository, ResolvedDependency)
+
+        # Check resolved dependencies for 'user_repository'
+        dependencies:ResolvedDependency = dep_user_repository
+        self.assertEqual(dependencies.module_name, 'tests.services.inspection.dependencies.mocks.mock_user')
+        self.assertEqual(dependencies.class_name, 'FakeUser')
+        self.assertEqual(dependencies.full_class_path, 'tests.services.inspection.dependencies.mocks.mock_user.FakeUser')
+        self.assertEqual(dependencies.type, FakeUser)
+
+    async def testReflectionDependenciesGetMethodDependencies(self):
+        """
+        Tests the `getMethodDependencies` method of the `ReflectDependencies` class for the 'createUserWithPermissions' method
+        of the `UserController`.
+        This test verifies:
+            - The returned object is an instance of `MethodDependency`.
+            - There are no unresolved dependencies.
+            - The 'user_permissions' dependency is correctly resolved as an instance of `ResolvedDependency` with the expected
+              module name, class name, full class path, and type (`FakeUserWithPermissions`).
+            - The 'permissions' dependency is correctly resolved as an instance of `ResolvedDependency` with the expected
+              module name, class name, full class path, and type (`list[str]`).
+        """
+
+        depend = ReflectDependencies(UserController)
+        method_dependencies = depend.getMethodDependencies('createUserWithPermissions')
+
+        # Check Instance of MethodDependency
+        self.assertIsInstance(method_dependencies, MethodDependency)
+
+        # Check unresolved dependencies
+        self.assertEqual(method_dependencies.unresolved, [])
+
+        # Check Instance of ResolvedDependency for 'user_permissions'
+        dep_user_permissions:ResolvedDependency = method_dependencies.resolved.get('user_permissions')
+        self.assertIsInstance(dep_user_permissions, ResolvedDependency)
+
+        # Check resolved dependencies for 'user_permissions'
+        self.assertEqual(dep_user_permissions.module_name, 'tests.services.inspection.dependencies.mocks.mock_users_permissions')
+        self.assertEqual(dep_user_permissions.class_name, 'FakeUserWithPermissions')
+        self.assertEqual(dep_user_permissions.full_class_path, 'tests.services.inspection.dependencies.mocks.mock_users_permissions.FakeUserWithPermissions')
+        self.assertEqual(dep_user_permissions.type, FakeUserWithPermissions)
+
+        # Check Instance of ResolvedDependency for 'permissions'
+        dep_permissions:ResolvedDependency = method_dependencies.resolved.get('permissions')
+        self.assertIsInstance(dep_permissions, ResolvedDependency)
+
+        # Check resolved dependencies for 'permissions'
+        self.assertEqual(dep_permissions.module_name, 'builtins')
+        self.assertEqual(dep_permissions.class_name, 'list')
+        self.assertEqual(dep_permissions.full_class_path, 'builtins.list')
+        self.assertEqual(dep_permissions.type, list[str])

tests/services/parsers/mocks/mock_custom_error.py

@@ -0,0 +1,15 @@
+class CustomError(Exception):
+    """
+    A custom exception class for handling errors with an optional error code.
+    """
+
+    def __init__(self, message, code=None):
+        """
+        Initialize the custom error with a message and an optional error code.
+
+        Args:
+            message (str): The error message describing the exception.
+            code (Optional[Any]): An optional error code associated with the exception.
+        """
+        super().__init__(message)
+        self.code = code

tests/{support → services}/parsers/test_exception_parser.py

@@ -1,6 +1,6 @@
-from orionis.luminate.support.parsers.exception_parser import ExceptionParser
-from orionis.luminate.test import TestCase
-from tests.support.parsers.fakes.fake_custom_error import CustomError
+from orionis.luminate.services.parsers.serializer import Parser
+from orionis.unittesting import TestCase
+from tests.services.parsers.mocks.mock_custom_error import CustomError
 
 class TestsExceptionParser(TestCase):
 
@@ -11,7 +11,7 @@ class TestsExceptionParser(TestCase):
         try:
             raise ValueError("Something went wrong")
         except Exception as e:
-            result = ExceptionParser(e).toDict()
+            result = Parser.exception(e).toDict()
 
             self.assertIsInstance(result, dict)
             self.assertIn("error_type", result)
@@ -34,20 +34,20 @@ class TestsExceptionParser(TestCase):
         try:
             raise RuntimeError("Test exception")
         except Exception as e:
-            parser = ExceptionParser(e)
+            parser = Parser.exception(e)
             self.assertIs(parser.raw_exception, e)
 
     async def testExceptionWithCode(self):
         try:
             raise CustomError("Custom message", code=404)
         except Exception as e:
-            result = ExceptionParser(e).toDict()
+            result = Parser.exception(e).toDict()
             self.assertEqual(result["error_code"], 404)
             self.assertEqual(result["error_type"], "CustomError")
 
     async def testNestedExceptionCause(self):
         """
-        Ensure that the ExceptionParser correctly handles nested exceptions.
+        Ensure that the Parser.exception correctly handles nested exceptions.
         """
         try:
             try:
@@ -55,5 +55,5 @@ class TestsExceptionParser(TestCase):
             except ValueError as exc:
                 raise TypeError("Outer error")
         except Exception as e:
-            result = ExceptionParser(e).toDict()
+            result = Parser.exception(e).toDict()
             self.assertEqual(result["error_type"], "TypeError")

tests/services/path/test_resolver.py

@@ -0,0 +1,73 @@
+import tempfile
+import os
+from pathlib import Path
+from orionis.luminate.services.paths.resolver import Resolver
+from orionis.unittesting import TestCase
+
+class TestsResolver(TestCase):
+    """
+    Unit tests for the Resolver class, which resolves file and directory paths relative to a base directory.
+    """
+
+    async def test_file_not_found(self):
+        """
+        Test that resolving a non-existent file path raises FileNotFoundError.
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            resolver = Resolver(tmpdir)
+            non_existent = "does_not_exist.txt"
+            with self.assertRaises(FileNotFoundError):
+                resolver.relativePath(non_existent)
+
+    async def test_valid_file_path(self):
+        """
+        Test that resolving a valid file path returns the correct absolute path.
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a temporary file inside the temp directory
+            file_path = Path(tmpdir) / "testfile.txt"
+            file_path.write_text("sample content")
+            resolver = Resolver(tmpdir)
+            resolved = resolver.relativePath("testfile.txt").toString()
+            # The resolved path should end with the file name
+            self.assertTrue(resolved.endswith("testfile.txt"))
+            # The resolved path should be absolute
+            self.assertTrue(os.path.isabs(resolved))
+
+    async def test_valid_directory_path(self):
+        """
+        Test that resolving a valid directory path returns the correct absolute path.
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a subdirectory inside the temp directory
+            subdir = Path(tmpdir) / "subdir"
+            subdir.mkdir()
+            resolver = Resolver(tmpdir)
+            resolved = resolver.relativePath("subdir").toString()
+            self.assertTrue(resolved.endswith("subdir"))
+            self.assertTrue(os.path.isabs(resolved))
+
+    async def test_other_base_path(self):
+        """
+        Test that providing a different base path to Resolver works as expected.
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a file in a subdirectory
+            subdir = Path(tmpdir) / "base"
+            subdir.mkdir()
+            file_path = subdir / "file.txt"
+            file_path.write_text("data")
+            resolver = Resolver(str(subdir))
+            resolved = resolver.relativePath("file.txt").toString()
+            self.assertTrue(resolved.endswith("file.txt"))
+            self.assertTrue(os.path.isabs(resolved))
+
+    async def test_equal_output_string(self):
+        """
+        Test that the string representation of the resolved path matches the output of toString().
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = Path(tmpdir) / "file.txt"
+            file_path.write_text("abc")
+            resolver = Resolver(tmpdir).relativePath("file.txt")
+            self.assertEqual(resolver.toString(), str(resolver))