orionis 0.287.0__py3-none-any.whl → 0.289.0__py3-none-any.whl

tests/foundation/config/startup/{test_config_startup.py → test_foundation_config_startup.py}

@@ -1,9 +1,9 @@
 from dataclasses import is_dataclass
 from orionis.foundation.config.exceptions.integrity import OrionisIntegrityException
 from orionis.foundation.config.startup import Configuration
-from orionis.unittesting import TestCase, UnittestMock
+from orionis.unittesting import TestCase, Mock
 
-class TestConfiguration(TestCase):
+class TestFoundationConfigStartup(TestCase):
     """
     Test suite for the Configuration dataclass.
 
@@ -98,18 +98,18 @@ class TestConfiguration(TestCase):
 
         # Test each section with wrong type
         sections = [
-            ('paths', UnittestMock()),
-            ('app', UnittestMock()),
-            ('auth', UnittestMock()),
-            ('cache', UnittestMock()),
-            ('cors', UnittestMock()),
-            ('database', UnittestMock()),
-            ('filesystems', UnittestMock()),
-            ('logging', UnittestMock()),
-            ('mail', UnittestMock()),
-            ('queue', UnittestMock()),
-            ('session', UnittestMock()),
-            ('testing', UnittestMock())
+            ('paths', Mock()),
+            ('app', Mock()),
+            ('auth', Mock()),
+            ('cache', Mock()),
+            ('cors', Mock()),
+            ('database', Mock()),
+            ('filesystems', Mock()),
+            ('logging', Mock()),
+            ('mail', Mock()),
+            ('queue', Mock()),
+            ('session', Mock()),
+            ('testing', Mock())
         ]
 
         for section_name, wrong_value in sections:

tests/foundation/config/testing/{test_testing.py → test_foundation_config_testing.py}

@@ -3,7 +3,7 @@ from orionis.foundation.config.exceptions.integrity import OrionisIntegrityExcep
 from orionis.test.enums.test_mode import ExecutionMode
 from orionis.unittesting import TestCase
 
-class TestTestingConfig(TestCase):
+class TestFoundationConfigTesting(TestCase):
     """
     Test suite for the Testing configuration entity.
 

tests/metadata/test_metadata_framework.py

@@ -0,0 +1,101 @@
+from orionis.metadata.framework import *
+from orionis.test.cases.test_case import TestCase
+
+class TestMetadataFramework(TestCase):
+    """
+    Test cases for the metadata constants and utility functions in orionis.metadata.framework.
+
+    Notes
+    -----
+    This test suite validates the existence, type, and structure of metadata constants and utility
+    functions provided by the `orionis.metadata.framework` module.
+    """
+
+    async def testConstantsExistAndAreStr(self):
+        """
+        Test that all metadata constants exist and are of type `str`.
+
+        Raises
+        ------
+        AssertionError
+            If any constant is not a string.
+        """
+        for const in [
+            NAME, VERSION, AUTHOR, AUTHOR_EMAIL, DESCRIPTION,
+            SKELETON, FRAMEWORK, DOCS, API, PYTHON_REQUIRES
+        ]:
+            assert isinstance(const, str)
+
+    async def testClassifiersStructure(self):
+        """
+        Test that `CLASSIFIERS` is a list of tuples of strings.
+
+        Raises
+        ------
+        AssertionError
+            If `CLASSIFIERS` is not a list of tuples of strings.
+        """
+        assert isinstance(CLASSIFIERS, list)
+        for item in CLASSIFIERS:
+            assert isinstance(item, tuple)
+            assert all(isinstance(part, str) for part in item)
+
+    async def testGetClassifiers(self):
+        """
+        Test that `get_classifiers` returns a list of classifier strings.
+
+        Raises
+        ------
+        AssertionError
+            If the returned value is not a list of strings containing '::'.
+        """
+        classifiers = get_classifiers()
+        assert isinstance(classifiers, list)
+        for c in classifiers:
+            assert isinstance(c, str)
+            assert " :: " in c or len(c.split(" :: ")) > 1
+
+    async def testKeywords(self):
+        """
+        Test that `KEYWORDS` is a list of strings and contains specific keywords.
+
+        Raises
+        ------
+        AssertionError
+            If `KEYWORDS` is not a list of strings or required keywords are missing.
+        """
+        assert isinstance(KEYWORDS, list)
+        for kw in KEYWORDS:
+            assert isinstance(kw, str)
+        assert "orionis" in KEYWORDS
+        assert "framework" in KEYWORDS
+
+    async def testRequiresStructure(self):
+        """
+        Test that `REQUIRES` is a list of 2-element tuples of strings.
+
+        Raises
+        ------
+        AssertionError
+            If `REQUIRES` is not a list of 2-element tuples of strings.
+        """
+        assert isinstance(REQUIRES, list)
+        for req in REQUIRES:
+            assert isinstance(req, tuple)
+            assert len(req) == 2
+            assert all(isinstance(part, str) for part in req)
+
+    async def testGetRequires(self):
+        """
+        Test that `get_requires` returns a list of requirement strings.
+
+        Raises
+        ------
+        AssertionError
+            If the returned value is not a list of strings containing '>='.
+        """
+        requires = get_requires()
+        assert isinstance(requires, list)
+        for req in requires:
+            assert isinstance(req, str)
+            assert ">=" in req

tests/metadata/test_metadata_package.py

@@ -0,0 +1,69 @@
+from orionis.unittesting import TestCase
+from orionis.metadata.package import PypiPackageApi
+
+class TestPypiPackageApi(TestCase):
+
+    async def testGetName(self):
+        """
+        Test getName method.
+
+        Tests that getName returns the correct package name.
+
+        Returns
+        -------
+        None
+        """
+        api = PypiPackageApi()
+        self.assertEqual(api.getName(), "orionis")
+
+    async def testGetAuthor(self):
+        """
+        Test getAuthor method.
+
+        Tests that getAuthor returns the correct author name.
+
+        Returns
+        -------
+        None
+        """
+        api = PypiPackageApi()
+        self.assertEqual(api.getAuthor(), "Raul Mauricio Uñate Castro")
+
+    async def testGetAuthorEmail(self):
+        """
+        Test getAuthorEmail method.
+
+        Tests that getAuthorEmail returns the correct author email.
+
+        Returns
+        -------
+        None
+        """
+        api = PypiPackageApi()
+        self.assertEqual(api.getAuthorEmail(), "raulmauriciounate@gmail.com")
+
+    async def testGetDescription(self):
+        """
+        Test getDescription method.
+
+        Tests that getDescription returns the correct description.
+
+        Returns
+        -------
+        None
+        """
+        api = PypiPackageApi()
+        self.assertEqual(api.getDescription(), "Orionis Framework – Elegant, Fast, and Powerful.")
+
+    async def testGetPythonVersion(self):
+        """
+        Test getPythonVersion method.
+
+        Tests that getPythonVersion returns the correct required Python version.
+
+        Returns
+        -------
+        None
+        """
+        api = PypiPackageApi()
+        self.assertEqual(api.getPythonVersion(), ">=3.12")

tests/patterns/singleton/{test_singleton.py → test_patterns_singleton.py}

@@ -1,7 +1,7 @@
 from orionis.patterns.singleton.meta_class import Singleton
 from orionis.test.cases.test_case import TestCase
 
-class TestsAsyncCoroutine(TestCase):
+class TestPatternsSingleton(TestCase):
     """
     Test cases for the Singleton metaclass.
 

tests/services/asynchrony/{test_async_io.py → test_services_asynchrony_coroutine.py}

@@ -3,7 +3,7 @@ from orionis.services.asynchrony.coroutines import Coroutine
 from orionis.services.asynchrony.exceptions.coroutine_exception import OrionisCoroutineException
 from orionis.unittesting import TestCase
 
-class TestsAsyncIO(TestCase):
+class TestServicesAsynchronyCoroutine(TestCase):
 
     async def testExecuteWithActiveEventLoop(self):
         """

tests/services/environment/test_services_environment.py

@@ -0,0 +1,93 @@
+from orionis.services.environment.env import Env
+from orionis.unittesting import TestCase
+
+class TestServicesEnvironment(TestCase):
+
+    async def testSetAndGetConstants(self):
+        """
+        Test storing and retrieving framework metadata constants using Env.set and Env.get.
+
+        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. Then retrieves each
+        constant using `Env.get` and asserts that the retrieved value matches the original constant.
+
+        Ensures
+        -------
+        - `Env.set` returns True for each constant.
+        - `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
+        )
+        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
+        }
+        for key, value in constants.items():
+            result = Env.set(key, value)
+            self.assertTrue(result)
+        for key, value in constants.items():
+            retrieved = Env.get(key)
+            self.assertEqual(retrieved, value)
+
+    async def testGetNonExistentKey(self):
+        """
+        Test that Env.get returns None for a non-existent environment key.
+
+        Ensures
+        -------
+        - `Env.get` returns None when the key does not exist.
+        """
+        self.assertIsNone(Env.get("NON_EXISTENT_KEY"))
+
+    async def testTypeHints(self):
+        """
+        Test that Env.set and Env.get correctly handle and preserve Python type hints.
+
+        Sets environment variables with various data types (int, float, bool, str, list, dict, tuple, set)
+        using the `Env.set` method, specifying the type as a string. Then retrieves each variable using
+        `Env.get` and asserts that the returned value is of the expected Python type.
+
+        Ensures
+        -------
+        - The returned value from `Env.get` matches the expected Python type for each variable.
+        """
+
+        # Set environment variables with type hints
+        Env.set("TEST_INT", 42, 'int')
+        Env.set("TEST_FLOAT", 3.14, 'float')
+        Env.set("TEST_BOOL", True, 'bool')
+        Env.set("TEST_STR", "Hello, World!", 'str')
+        Env.set("TEST_LIST", [1, 2, 3], 'list')
+        Env.set("TEST_DICT", {"key": "value"}, 'dict')
+        Env.set("TEST_TUPLE", (1,2,3), 'tuple')
+        Env.set("TEST_SET", {1, 2, 3}, 'set')
+
+        # Retrieve and check types
+        self.assertIsInstance(Env.get("TEST_INT"), int)
+        self.assertIsInstance(Env.get("TEST_FLOAT"), float)
+        self.assertIsInstance(Env.get("TEST_BOOL"), bool)
+        self.assertIsInstance(Env.get("TEST_STR"), str)
+        self.assertIsInstance(Env.get("TEST_LIST"), list)
+        self.assertIsInstance(Env.get("TEST_DICT"), dict)
+        self.assertIsInstance(Env.get("TEST_TUPLE"), tuple)
+        self.assertIsInstance(Env.get("TEST_SET"), set)
+
+        # Clean up environment variables after test
+        Env.unset("TEST_INT")
+        Env.unset("TEST_FLOAT")
+        Env.unset("TEST_BOOL")
+        Env.unset("TEST_STR")
+        Env.unset("TEST_LIST")
+        Env.unset("TEST_DICT")
+        Env.unset("TEST_TUPLE")
+        Env.unset("TEST_SET")

tests/services/parsers/mocks/mock_custom_error.py

@@ -1,15 +1,25 @@
 class CustomError(Exception):
     """
-    A custom exception class for handling errors with an optional error code.
+    Custom exception class for handling errors with an optional error code.
+
+    Parameters
+    ----------
+    message : str
+        The error message describing the exception.
+    code : any, optional
+        An optional error code associated with the exception.
     """
 
     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.
+        Parameters
+        ----------
+        message : str
+            The error message describing the exception.
+        code : any, optional
+            An optional error code associated with the exception.
         """
         super().__init__(message)
         self.code = code

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

@@ -2,11 +2,15 @@ from orionis.services.parsers.serializer import Parser
 from orionis.unittesting import TestCase
 from tests.services.parsers.mocks.mock_custom_error import CustomError
 
-class TestsExceptionParser(TestCase):
+class TestServicesParserExceptions(TestCase):
 
     async def testBasicExceptionStructure(self):
         """
         Ensure that the ExceptionParser correctly structures a basic exception.
+
+        Returns
+        -------
+        None
         """
         try:
             raise ValueError("Something went wrong")
@@ -29,7 +33,11 @@ class TestsExceptionParser(TestCase):
 
     async def testRawExceptionProperty(self):
         """
-        Ensure that the raw_exception property returns the original exception.
+        Ensure that the rawException property returns the original exception.
+
+        Returns
+        -------
+        None
         """
         try:
             raise RuntimeError("Test exception")
@@ -38,6 +46,13 @@ class TestsExceptionParser(TestCase):
             self.assertIs(parser.raw_exception, e)
 
     async def testExceptionWithCode(self):
+        """
+        Ensure that exceptions with a custom error code are serialized correctly.
+
+        Returns
+        -------
+        None
+        """
         try:
             raise CustomError("Custom message", code=404)
         except Exception as e:
@@ -48,6 +63,10 @@ class TestsExceptionParser(TestCase):
     async def testNestedExceptionCause(self):
         """
         Ensure that the Parser.exception correctly handles nested exceptions.
+
+        Returns
+        -------
+        None
         """
         try:
             try:

tests/services/path/{test_resolver.py → test_services_resolver.py}

@@ -1,27 +1,42 @@
-import tempfile
 import os
+import tempfile
 from pathlib import Path
+from orionis.services.paths.exceptions.not_found_exceptions import OrionisFileNotFoundException
 from orionis.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.
-    """
+class TestServicesResolver(TestCase):
 
-    async def test_file_not_found(self):
+    async def testFileNotFound(self):
         """
-        Test that resolving a non-existent file path raises FileNotFoundError.
+        Test that resolving a non-existent file path raises OrionisFileNotFoundException.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        OrionisFileNotFoundException
+            If the file does not exist.
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             resolver = Resolver(tmpdir)
             non_existent = "does_not_exist.txt"
-            with self.assertRaises(FileNotFoundError):
+            with self.assertRaises(OrionisFileNotFoundException):
                 resolver.relativePath(non_existent)
 
-    async def test_valid_file_path(self):
+    async def testValidFilePath(self):
         """
         Test that resolving a valid file path returns the correct absolute path.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        The resolved path ends with the file name and is absolute.
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             # Create a temporary file inside the temp directory
@@ -34,9 +49,17 @@ class TestsResolver(TestCase):
             # The resolved path should be absolute
             self.assertTrue(os.path.isabs(resolved))
 
-    async def test_valid_directory_path(self):
+    async def testValidDirectoryPath(self):
         """
         Test that resolving a valid directory path returns the correct absolute path.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        The resolved path ends with the directory name and is absolute.
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             # Create a subdirectory inside the temp directory
@@ -47,9 +70,17 @@ class TestsResolver(TestCase):
             self.assertTrue(resolved.endswith("subdir"))
             self.assertTrue(os.path.isabs(resolved))
 
-    async def test_other_base_path(self):
+    async def testOtherBasePath(self):
         """
         Test that providing a different base path to Resolver works as expected.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        The resolved path ends with the file name and is absolute.
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             # Create a file in a subdirectory
@@ -62,9 +93,17 @@ class TestsResolver(TestCase):
             self.assertTrue(resolved.endswith("file.txt"))
             self.assertTrue(os.path.isabs(resolved))
 
-    async def test_equal_output_string(self):
+    async def testEqualOutputString(self):
         """
         Test that the string representation of the resolved path matches the output of toString().
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        The string representation of the resolved path matches the output of toString().
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             file_path = Path(tmpdir) / "file.txt"

tests/services/standard/{test_std.py → test_services_std.py}

@@ -1,14 +1,16 @@
-
+from orionis.services.standard.exceptions.std_value_exception import OrionisStdValueException
 from orionis.services.standard.std import StdClass
 from orionis.unittesting import TestCase
 
-class TestStdClass(TestCase):
+class TestServicesStd(TestCase):
 
     async def testInitializationAndAccess(self):
         """
         Test the initialization of StdClass and access to its attributes.
 
-        This test verifies that an instance of StdClass can be created with the given
+        Notes
+        -----
+        Verifies that an instance of StdClass can be created with the given
         first name, last name, and age, and that these attributes can be accessed
         correctly after initialization.
         """
@@ -24,7 +26,9 @@ class TestStdClass(TestCase):
         """
         Test that the toDict method of StdClass returns a dictionary with the correct data.
 
-        This test creates an instance of StdClass with specific attributes and verifies
+        Notes
+        -----
+        Creates an instance of StdClass with specific attributes and verifies
         that calling toDict() returns a dictionary containing those attributes and their values.
         """
         obj = StdClass(a=1, b=2)
@@ -35,7 +39,9 @@ class TestStdClass(TestCase):
         """
         Test that the `update` method of `StdClass` correctly sets multiple attributes.
 
-        This test creates an instance of `StdClass`, updates its attributes using the `update` method,
+        Notes
+        -----
+        Creates an instance of `StdClass`, updates its attributes using the `update` method,
         and asserts that the attributes `foo` and `number` are set to the expected values.
         """
         obj = StdClass()
@@ -47,27 +53,36 @@ class TestStdClass(TestCase):
         """
         Test that updating a reserved attribute (such as '__init__') on a StdClass instance
         raises a ValueError exception.
+
+        Notes
+        -----
+        Ensures that updating a reserved attribute raises an OrionisStdValueException.
         """
         obj = StdClass()
-        with self.assertRaises(ValueError):
+        with self.assertRaises(OrionisStdValueException):
             obj.update(__init__='bad')
 
     async def testUpdateConflictingAttributeRaisesError(self):
         """
         Test that updating an object with a conflicting attribute name ('toDict') raises a ValueError.
 
-        This test ensures that attempting to update the StdClass instance with a keyword argument
+        Notes
+        -----
+        Ensures that attempting to update the StdClass instance with a keyword argument
         that conflicts with an existing method or reserved attribute ('toDict') correctly triggers
-        a ValueError, enforcing attribute safety.
+        an OrionisStdValueException, enforcing attribute safety.
         """
         obj = StdClass()
-        with self.assertRaises(ValueError):
+        with self.assertRaises(OrionisStdValueException):
             obj.update(toDict='oops')
 
     async def testRemoveExistingAttributes(self):
         """
-        Tests that the `remove` method of `StdClass` successfully removes an existing attribute ('x') from the object,
-        while leaving other attributes ('y') intact.
+        Test that the `remove` method of `StdClass` successfully removes an existing attribute.
+
+        Notes
+        -----
+        Removes attribute 'x' from the object and checks that 'y' remains.
         """
         obj = StdClass(x=1, y=2)
         obj.remove('x')
@@ -78,7 +93,9 @@ class TestStdClass(TestCase):
         """
         Test that attempting to remove a non-existing attribute from a StdClass instance raises an AttributeError.
 
-        This test verifies that the `remove` method of `StdClass` correctly raises an AttributeError
+        Notes
+        -----
+        Verifies that the `remove` method of `StdClass` raises an AttributeError
         when called with the name of an attribute that does not exist on the object.
         """
         obj = StdClass()
@@ -89,20 +106,23 @@ class TestStdClass(TestCase):
         """
         Test that StdClass.from_dict creates an instance equivalent to the original data.
 
-        This test verifies that when a dictionary is passed to StdClass.from_dict,
+        Notes
+        -----
+        Verifies that when a dictionary is passed to StdClass.from_dict,
         the resulting object's toDict() method returns a dictionary equal to the original input.
         """
         data = {'a': 10, 'b': 20}
-        obj = StdClass.from_dict(data)
+        obj = StdClass.fromDict(data)
         self.assertEqual(obj.toDict(), data)
 
     async def testReprAndStr(self):
         """
         Test that the __repr__ and __str__ methods of StdClass include the class name and the value of 'x' respectively.
 
-        This test verifies:
-        - The string representation produced by repr(obj) contains the class name 'StdClass'.
-        - The string representation produced by str(obj) contains the key-value pair "'x': 5".
+        Notes
+        -----
+        - Checks that repr(obj) contains the class name 'StdClass'.
+        - Checks that str(obj) contains the key-value pair "'x': 5".
         """
         obj = StdClass(x=5)
         self.assertIn("StdClass", repr(obj))
@@ -110,15 +130,18 @@ class TestStdClass(TestCase):
 
     async def testEquality(self):
         """
-        Tests the equality and inequality operations for StdClass instances.
+        Test the equality and inequality operations for StdClass instances.
 
-        This test creates three instances of StdClass:
+        Notes
+        -----
+        Creates three instances of StdClass:
         - 'a' and 'b' with identical attributes (x=1, y=2), which should be considered equal.
         - 'c' with a different attribute (x=3), which should not be equal to 'a'.
 
-        Assertions:
-        - Verifies that 'a' and 'b' are equal.
-        - Verifies that 'a' and 'c' are not equal.
+        Asserts
+        -------
+        - 'a' and 'b' are equal.
+        - 'a' and 'c' are not equal.
         """
         a = StdClass(x=1, y=2)
         b = StdClass(x=1, y=2)