orionis 0.546.0__py3-none-any.whl → 0.548.0__py3-none-any.whl

tests/metadata/test_metadata_framework.py

@@ -1,140 +0,0 @@
-from orionis.metadata.framework import *
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestMetadataFramework(AsyncTestCase):
-    """
-    Test cases for the metadata constants and utility functions in orionis.metadata.framework.
-    """
-
-    async def testConstantsExistAndAreStr(self):
-        """
-        Test that all required metadata constants exist and are of type `str`.
-
-        This method iterates over a predefined list of metadata constants and checks
-        that each is an instance of `str`. This ensures that the metadata values
-        required by the framework are properly defined and typed.
-
-        Returns
-        -------
-        None
-            This is a test method and does not return any value. Assertions are used
-            to validate the conditions.
-        """
-
-        # List of metadata constants to check
-        for const in [
-            NAME, VERSION, AUTHOR, AUTHOR_EMAIL, DESCRIPTION,
-            SKELETON, FRAMEWORK, DOCS, API, PYTHON_REQUIRES
-        ]:
-            # Assert that each constant is a string
-            self.assertIsInstance(const, str)
-
-    async def testClassifiersStructure(self):
-        """
-        Validate the structure and type of the `CLASSIFIERS` metadata constant.
-
-        This test ensures that the `CLASSIFIERS` constant is a list of strings,
-        and that each string contains at least one '::' separator, which is
-        typical for Python package classifiers.
-
-        Parameters
-        ----------
-        self : TestMetadataFramework
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to
-            validate the structure and contents of `CLASSIFIERS`.
-        """
-
-        # Assert that CLASSIFIERS is a list
-        self.assertIsInstance(CLASSIFIERS, list)
-        for item in CLASSIFIERS:
-
-            # Assert that each item in CLASSIFIERS is a string
-            self.assertIsInstance(item, str)
-
-            # Assert that each classifier string contains at least one '::' separator
-            self.assertTrue("::" in item or len(item.split("::")) > 1)
-
-    async def testKeywords(self):
-        """
-        Validate the structure and contents of the `KEYWORDS` metadata constant.
-
-        This test checks that the `KEYWORDS` constant is a list of strings, ensuring
-        that each keyword is properly typed. Additionally, it verifies that the list
-        contains the essential keywords "orionis" and "framework", which are required
-        for accurate metadata representation.
-
-        Parameters
-        ----------
-        self : TestMetadataFramework
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate
-            the structure and contents of `KEYWORDS`.
-        """
-
-        # Assert that KEYWORDS is a list
-        self.assertIsInstance(KEYWORDS, list)
-
-        # Check that each keyword in KEYWORDS is a string
-        for kw in KEYWORDS:
-            self.assertIsInstance(kw, str)
-
-        # Ensure essential keywords are present in the list
-        self.assertIn("orionis", KEYWORDS)
-        self.assertIn("framework", KEYWORDS)
-
-    async def testRequiresStructure(self):
-        """
-        Validate the structure and contents of the `REQUIRES` metadata constant.
-
-        This test checks that the `REQUIRES` constant is a list of strings, where each string
-        represents a package requirement and contains the '>=' version specifier. This ensures
-        that all requirements are properly typed and formatted for dependency management.
-
-        Parameters
-        ----------
-        self : TestMetadataFramework
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate
-            the structure and contents of `REQUIRES`.
-        """
-
-        # Assert that REQUIRES is a list
-        self.assertIsInstance(REQUIRES, list)
-
-        # Check that each requirement in REQUIRES is a string and contains '>='
-        for req in REQUIRES:
-            self.assertIsInstance(req, str)  # Each requirement should be a string
-            self.assertIn(">=", req)         # Each requirement should specify a minimum version
-
-    async def testIconFunction(self):
-        """
-        Test the behavior and return type of the `icon()` utility function.
-
-        This test verifies that the `icon()` function returns either a string containing
-        SVG data or `None` if the icon file is not found. It ensures that the function's
-        output is correctly typed and handles missing resources gracefully.
-
-        Returns
-        -------
-        None
-            This method does not return any value. Assertions are used to validate
-            the type and behavior of the `icon()` function.
-        """
-        # Call the icon() function and store the result
-        result = icon()
-
-        # Assert that the result is either a string (SVG data) or None (file not found)
-        self.assertTrue(isinstance(result, str) or result is None)

tests/metadata/test_metadata_package.py

@@ -1,139 +0,0 @@
-from orionis.test.cases.asynchronous import AsyncTestCase
-from unittest.mock import patch
-
-class TestPypiOrionisPackage(AsyncTestCase):
-
-    @patch("orionis.metadata.package.PypiOrionisPackage")
-    async def testGetName(self, MockPypiOrionisPackage):
-        """
-        Tests the `getName` method of the `PypiOrionisPackage` class.
-
-        This test verifies that the mocked `getName` method returns the expected package name.
-
-        Parameters
-        ----------
-        MockPypiOrionisPackage : MagicMock
-            Mocked `PypiOrionisPackage` class.
-
-        Returns
-        -------
-        None
-            This method does not return anything. It asserts the expected behavior.
-        """
-
-        # Get the mocked API instance
-        api = MockPypiOrionisPackage.return_value
-
-        # Set the return value for getName
-        api.getName.return_value = "orionis"
-
-        # Assert that getName returns the expected value
-        self.assertEqual(api.getName(), "orionis")
-
-    @patch("orionis.metadata.package.PypiOrionisPackage")
-    async def testGetAuthor(self, MockPypiOrionisPackage):
-        """
-        Tests the `getAuthor` method of the `PypiOrionisPackage` class.
-
-        This test checks that the mocked `getAuthor` method returns the correct author name.
-
-        Parameters
-        ----------
-        MockPypiOrionisPackage : MagicMock
-            Mocked `PypiOrionisPackage` class.
-
-        Returns
-        -------
-        None
-            This method does not return anything. It asserts the expected behavior.
-        """
-
-        # Get the mocked API instance
-        api = MockPypiOrionisPackage.return_value
-
-        # Set the return value for getAuthor
-        api.getAuthor.return_value = "Raul Mauricio Uñate Castro"
-
-        # Assert that getAuthor returns the expected value
-        self.assertEqual(api.getAuthor(), "Raul Mauricio Uñate Castro")
-
-    @patch("orionis.metadata.package.PypiOrionisPackage")
-    async def testGetAuthorEmail(self, MockPypiOrionisPackage):
-        """
-        Tests the `getAuthorEmail` method of the `PypiOrionisPackage` class.
-
-        This test ensures that the mocked `getAuthorEmail` method returns the correct author email address.
-
-        Parameters
-        ----------
-        MockPypiOrionisPackage : MagicMock
-            Mocked `PypiOrionisPackage` class.
-
-        Returns
-        -------
-        None
-            This method does not return anything. It asserts the expected behavior.
-        """
-
-        # Get the mocked API instance
-        api = MockPypiOrionisPackage.return_value
-
-        # Set the return value for getAuthorEmail
-        api.getAuthorEmail.return_value = "raulmauriciounate@gmail.com"
-
-        # Assert that getAuthorEmail returns the expected value
-        self.assertEqual(api.getAuthorEmail(), "raulmauriciounate@gmail.com")
-
-    @patch("orionis.metadata.package.PypiOrionisPackage")
-    async def testGetDescription(self, MockPypiOrionisPackage):
-        """
-        Tests the `getDescription` method of the `PypiOrionisPackage` class.
-
-        This test verifies that the mocked `getDescription` method returns the expected package description.
-
-        Parameters
-        ----------
-        MockPypiOrionisPackage : MagicMock
-            Mocked `PypiOrionisPackage` class.
-
-        Returns
-        -------
-        None
-            This method does not return anything. It asserts the expected behavior.
-        """
-
-        # Get the mocked API instance
-        api = MockPypiOrionisPackage.return_value
-
-        # Set the return value for getDescription
-        api.getDescription.return_value = "Orionis Framework – Elegant, Fast, and Powerful."
-
-        # Assert that getDescription returns the expected value
-        self.assertEqual(api.getDescription(), "Orionis Framework – Elegant, Fast, and Powerful.")
-
-    @patch("orionis.metadata.package.PypiOrionisPackage")
-    async def testGetPythonVersion(self, MockPypiOrionisPackage):
-        """
-        Tests the `getPythonVersion` method of the `PypiOrionisPackage` class.
-
-        This test checks that the mocked `getPythonVersion` method returns the correct Python version requirement.
-
-        Parameters
-        ----------
-        MockPypiOrionisPackage : MagicMock
-            Mocked `PypiOrionisPackage` class.
-
-        Returns
-        -------
-        None
-            This method does not return anything. It asserts the expected behavior.
-        """
-
-        # Get the mocked API instance
-        api = MockPypiOrionisPackage.return_value
-
-        # Set the return value for getPythonVersion
-        api.getPythonVersion.return_value = ">=3.12"
-
-        # Assert that getPythonVersion returns the expected value
-        self.assertEqual(api.getPythonVersion(), ">=3.12")

tests/services/asynchrony/test_services_asynchrony_coroutine.py

@@ -1,85 +0,0 @@
-
-import asyncio
-from orionis.services.asynchrony.coroutines import Coroutine
-from orionis.services.asynchrony.exceptions import OrionisCoroutineException
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestServicesAsynchronyCoroutine(AsyncTestCase):
-
-    async def testExecuteWithActiveEventLoop(self):
-        """
-        Tests coroutine execution within an active event loop.
-
-        This method verifies that a coroutine can be executed successfully when an event loop is already running,
-        such as in asynchronous environments (e.g., Jupyter notebooks or ASGI applications). It ensures that the
-        Coroutine wrapper correctly awaits and returns the result of the coroutine.
-
-        Returns
-        -------
-        None
-            This is a test method and does not return a value. It asserts that the coroutine result matches the expected output.
-        """
-
-        # Simple coroutine that returns a string
-        async def sample_coroutine():
-            asyncio.sleep(0.1)
-            return "Hello, World!"
-
-        # Await the result of running the coroutine using the Coroutine wrapper
-        result = await Coroutine(sample_coroutine()).run()
-
-        # Assert that the result matches the expected output
-        self.assertEqual(result, "Hello, World!")
-
-    def testExecuteWithoutActiveEventLoop(self):
-        """
-        Tests coroutine execution without an active event loop.
-
-        This method simulates the scenario where a coroutine is executed in a synchronous context,
-        such as a standard Python script, where no event loop is running. It verifies that the
-        Coroutine wrapper can correctly create and manage an event loop internally, execute the
-        coroutine, and return the expected result.
-
-        Returns
-        -------
-        None
-            This test method does not return a value. It asserts that the coroutine result matches the expected output.
-        """
-
-        # Define a simple coroutine that returns a string
-        async def sample_coroutine():
-            asyncio.sleep(0.1)
-            return "Hello, World!"
-
-        # Run the coroutine using the Coroutine wrapper, which should handle event loop creation
-        result = Coroutine(sample_coroutine()).run()
-
-        # Assert that the result matches the expected output
-        self.assertEqual(result, "Hello, World!")
-
-    def testExecuteWithNonCoroutine(self):
-        """
-        Tests execution of a non-coroutine object.
-
-        This method verifies that passing a non-coroutine object to the Coroutine wrapper
-        raises an OrionisCoroutineException. It ensures that the Coroutine class enforces
-        the requirement for coroutine objects and does not accept regular functions or other types.
-
-        Parameters
-        ----------
-        self : TestServicesAsynchronyCoroutine
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This test method does not return a value. It asserts that the appropriate exception is raised.
-        """
-
-        # Define a regular function (not a coroutine)
-        def sample_no_coroutine():
-            return "Hello, World!"
-
-        # Assert that passing a non-coroutine raises OrionisCoroutineException
-        with self.assertRaises(OrionisCoroutineException):
-            Coroutine(sample_no_coroutine()).run()

tests/services/environment/test_services_environment.py

@@ -1,226 +0,0 @@
-from orionis.services.environment.core.dot_env import DotEnv
-from orionis.services.environment.env import Env
-from orionis.services.environment.enums.value_type import EnvironmentValueType
-from orionis.services.environment.key.key_generator import SecureKeyGenerator
-from orionis.test.cases.asynchronous import AsyncTestCase
-
-class TestServicesEnvironment(AsyncTestCase):
-
-    async def testSetAndGetConstants(self):
-        """
-        Stores and retrieves framework metadata constants using Env.set and Env.get.
-
-        This test imports several metadata constants from the `orionis.metadata.framework` module,
-        sets each constant in the Env storage using `Env.set`, and verifies that the operation succeeds.
-        It then retrieves each constant using `Env.get` and asserts that the retrieved value matches
-        the original constant.
-
-        Parameters
-        ----------
-        self : TestServicesEnvironment
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return a value. Assertions are used to validate behavior.
-
-        Notes
-        -----
-        - Ensures that `Env.set` returns True for each constant.
-        - Ensures that `Env.get` returns the correct value for each constant.
-        """
-        from orionis.metadata.framework import (
-            NAME, VERSION, AUTHOR, AUTHOR_EMAIL, DESCRIPTION,
-            SKELETON, FRAMEWORK, DOCS, API, PYTHON_REQUIRES
-        )
-
-        # Prepare a dictionary of constant names and their values
-        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 each constant in the environment and assert the operation succeeds
-        for key, value in constants.items():
-            result = Env.set(key, value)
-            self.assertTrue(result)
-
-        # Retrieve each constant and assert the value matches the original
-        for key, value in constants.items():
-            retrieved = Env.get(key)
-            self.assertEqual(retrieved, value)
-
-    async def testGetNonExistentKey(self):
-        """
-        Test the behavior of `Env.get` when retrieving a non-existent environment key.
-
-        This test verifies that attempting to retrieve a value for a key that has not been set
-        in the environment returns `None`. This ensures that the environment behaves as expected
-        when queried for missing keys.
-
-        Parameters
-        ----------
-        self : TestServicesEnvironment
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return a value. Assertions are used to validate that `Env.get`
-            returns `None` for a non-existent key.
-
-        Notes
-        -----
-        - Ensures that `Env.get` returns `None` when the specified key does not exist in the environment.
-        """
-
-        # Attempt to retrieve a value for a key that has not been set.
-        self.assertIsNone(Env.get("NON_EXISTENT_KEY"))
-
-    async def testDotEnvSetAndGetWithType(self):
-        """
-        Test DotEnv.set and DotEnv.get with explicit EnvironmentValueType for various data types.
-
-        This test verifies that the `DotEnv` class correctly stores and retrieves environment variables
-        when an explicit `EnvironmentValueType` is provided. For each supported data type, the test sets
-        a value using `DotEnv.set` with the corresponding `EnvironmentValueType`, then retrieves it using
-        `DotEnv.get` and asserts that the returned value is correctly prefixed or formatted according to
-        the specified type.
-
-        Parameters
-        ----------
-        self : TestServicesEnvironment
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return a value. Assertions are used to validate the correct behavior
-            of `DotEnv.set` and `DotEnv.get` with explicit type information.
-
-        Notes
-        -----
-        - Ensures that values are stored and retrieved with the correct type prefixes or formatting.
-        - Covers all supported types: PATH, STR, INT, FLOAT, BOOL, LIST, DICT, TUPLE, SET, BASE64.
-        """
-
-        env = DotEnv()
-
-        # Set and assert a PATH value with explicit type
-        env.set("CAST_EXAMPLE_PATH", '/tests', EnvironmentValueType.PATH)
-        self.assertTrue(env.get("CAST_EXAMPLE_PATH").endswith('/tests'))
-
-        # Set and assert a string value with explicit type
-        env.set("CAST_EXAMPLE_STR", 'hello', EnvironmentValueType.STR)
-        self.assertEqual(env.get("CAST_EXAMPLE_STR"), "hello")
-
-        # Set and assert an integer value with explicit type
-        env.set("CAST_EXAMPLE_INT", 123, EnvironmentValueType.INT)
-        self.assertEqual(env.get("CAST_EXAMPLE_INT"), 123)
-
-        # Set and assert a float value with explicit type
-        env.set("CAST_EXAMPLE_FLOAT", 3.14, EnvironmentValueType.FLOAT)
-        self.assertEqual(env.get("CAST_EXAMPLE_FLOAT"), 3.14)
-
-        # Set and assert a boolean value with explicit type
-        env.set("CAST_EXAMPLE_BOOL", True, EnvironmentValueType.BOOL)
-        self.assertEqual(env.get("CAST_EXAMPLE_BOOL"), True)
-
-        # Set and assert a list value with explicit type
-        env.set("CAST_EXAMPLE_LIST", [1, 2, 3], EnvironmentValueType.LIST)
-        self.assertEqual(env.get("CAST_EXAMPLE_LIST"), [1, 2, 3])
-
-        # Set and assert a dictionary value with explicit type
-        env.set("CAST_EXAMPLE_DICT", {"a": 1, "b": 2}, EnvironmentValueType.DICT)
-        self.assertEqual(env.get("CAST_EXAMPLE_DICT"), {"a": 1, "b": 2})
-
-        # Set and assert a tuple value with explicit type
-        env.set("CAST_EXAMPLE_TUPLE", (1, 2), EnvironmentValueType.TUPLE)
-        self.assertEqual(env.get("CAST_EXAMPLE_TUPLE"), (1, 2))
-
-        # Set and assert a set value with explicit type
-        env.set("CAST_EXAMPLE_SET", {1, 2, 3}, EnvironmentValueType.SET)
-        self.assertEqual(env.get("CAST_EXAMPLE_SET"), {1, 2, 3})
-
-        # Set and assert a base64 value with explicit type
-        ramdon_text = SecureKeyGenerator.generate()
-        env.set("CAST_EXAMPLE_BASE64", ramdon_text, EnvironmentValueType.BASE64)
-        self.assertEqual(env.get("CAST_EXAMPLE_BASE64"), ramdon_text)
-
-    async def testDotEnvSetAndGetWithoutType(self):
-        """
-        Test DotEnv.set and DotEnv.get without explicit EnvironmentValueType for various data types.
-
-        This test verifies that the `DotEnv` class can store and retrieve environment variables of different
-        Python data types without specifying an explicit `EnvironmentValueType`. It checks that the values
-        are stored and retrieved as their string representations, and asserts the correctness of the returned
-        values for each data type.
-
-        Parameters
-        ----------
-        self : TestServicesEnvironment
-            The test case instance.
-
-        Returns
-        -------
-        None
-            This method does not return a value. Assertions are used to validate that the returned values
-            from `DotEnv.get` match the expected string representations for each data type.
-
-        Notes
-        -----
-        - Ensures that values are stored and retrieved as strings when no explicit type is provided.
-        - Covers various data types: path, str, int, float, bool, list, dict, tuple, set, and base64.
-        """
-
-        env = DotEnv()
-
-        # Set and get a path value without explicit type
-        env.set("EXAMPLE_PATH", '/tests')
-        self.assertEqual(env.get("EXAMPLE_PATH"), '/tests')
-
-        # Set and get a string value without explicit type
-        env.set("EXAMPLE_STR", 'hello')
-        self.assertEqual(env.get("EXAMPLE_STR"), 'hello')
-
-        # Set and get an integer value without explicit type
-        env.set("EXAMPLE_INT", 123)
-        self.assertEqual(env.get("EXAMPLE_INT"), 123)
-
-        # Set and get a float value without explicit type
-        env.set("EXAMPLE_FLOAT", 3.14)
-        self.assertEqual(env.get("EXAMPLE_FLOAT"), 3.14)
-
-        # Set and get a boolean value without explicit type
-        env.set("EXAMPLE_BOOL", True)
-        self.assertEqual(env.get("EXAMPLE_BOOL"), True)
-
-        # Set and get a list value without explicit type
-        env.set("EXAMPLE_LIST", [1, 2, 3])
-        self.assertEqual(env.get("EXAMPLE_LIST"), [1, 2, 3])
-
-        # Set and get a dictionary value without explicit type
-        env.set("EXAMPLE_DICT", {"a": 1, "b": 2})
-        self.assertEqual(env.get("EXAMPLE_DICT"), {"a": 1, "b": 2})
-
-        # Set and get a tuple value without explicit type
-        env.set("EXAMPLE_TUPLE", (1, 2))
-        self.assertEqual(env.get("EXAMPLE_TUPLE"), (1, 2))
-
-        # Set and get a set value without explicit type
-        env.set("EXAMPLE_SET", {1, 2, 3})
-        self.assertEqual(env.get("EXAMPLE_SET"), {1, 2, 3})
-
-        # Set and get a base64 value without explicit type
-        ramdon_text = SecureKeyGenerator.generate()
-        env.set("EXAMPLE_BASE64", ramdon_text)
-        self.assertEqual(env.get("EXAMPLE_BASE64"), ramdon_text)

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

@@ -1,30 +0,0 @@
-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/introspection/dependencies/mocks/mock_user_controller.py

@@ -1,27 +0,0 @@
-from tests.services.introspection.dependencies.mocks.mock_user import FakeUser
-from tests.services.introspection.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