orionis 0.438.0__py3-none-any.whl → 0.440.0__py3-none-any.whl

tests/services/introspection/reflection/test_reflection_abstract.py

@@ -4,29 +4,6 @@ from tests.services.introspection.reflection.mock.fake_reflect_instance import A
 from orionis.test.cases.asynchronous import AsyncTestCase
 
 class TestServiceReflectionAbstract(AsyncTestCase):
-    """
-    Test suite for the ReflectionAbstract class functionality.
-
-    This test class provides comprehensive testing for the ReflectionAbstract
-    service, which offers introspection capabilities for Python classes including
-    attribute inspection, method discovery, dependency analysis, and metadata extraction.
-
-    The tests verify that the reflection service correctly handles:
-    - Class metadata retrieval (name, module, docstring, etc.)
-    - Attribute management and visibility filtering
-    - Method discovery and categorization (public/protected/private, sync/async)
-    - Property introspection
-    - Dependency analysis for constructors and methods
-    - Source code and file information access
-
-    Test Target
-    -----------
-    orionis.services.introspection.abstract.reflection.ReflectionAbstract
-
-    Mock Objects
-    ------------
-    AbstractFakeClass : Mock class for testing reflection capabilities
-    """
 
     async def testGetClass(self):
         """
@@ -345,58 +322,6 @@ class TestServiceReflectionAbstract(AsyncTestCase):
         self.assertTrue(reflect.hasMethod('instanceSyncMethod'))
         self.assertFalse(reflect.hasMethod('non_existent_method'))
 
-    async def testCallMethod(self):
-        """
-        Test the callMethod method of ReflectionAbstract.
-
-        This test method is not applicable for ReflectionAbstract as it only
-        provides introspection capabilities without method execution.
-
-        Notes
-        -----
-        ReflectionAbstract is designed for reflection, not execution.
-        """
-        # No aplica para ReflectionAbstract, se omite
-
-    async def testCallAsyncMethod(self):
-        """
-        Test the callAsyncMethod method of ReflectionAbstract.
-
-        This test method is not applicable for ReflectionAbstract as it only
-        provides introspection capabilities without method execution.
-
-        Notes
-        -----
-        ReflectionAbstract is designed for reflection, not execution.
-        """
-        # No aplica para ReflectionAbstract, se omite
-
-    async def testSetMethod(self):
-        """
-        Test the setMethod method of ReflectionAbstract.
-
-        This test method is not applicable for ReflectionAbstract as it only
-        provides introspection capabilities without method modification.
-
-        Notes
-        -----
-        ReflectionAbstract is designed for reflection, not modification.
-        """
-        # No aplica para ReflectionAbstract, se omite
-
-    async def testRemoveMethod(self):
-        """
-        Test the removeMethod method of ReflectionAbstract.
-
-        This test method is not applicable for ReflectionAbstract as it only
-        provides introspection capabilities without method removal.
-
-        Notes
-        -----
-        ReflectionAbstract is designed for reflection, not modification.
-        """
-        # No aplica para ReflectionAbstract, se omite
-
     async def testGetMethodSignature(self):
         """
         Test the getMethodSignature method of ReflectionAbstract.
@@ -617,7 +542,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetPublicClassAsyncMethods(self):
         """
-        Verifies that getPublicClassAsyncMethods returns only public class async methods.
+        Test getPublicClassAsyncMethods for public class async methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only public class asynchronous methods are returned by
+        getPublicClassAsyncMethods. Public methods have no leading underscores.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         public_class_async_methods = reflect.getPublicClassAsyncMethods()
@@ -627,7 +561,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetProtectedClassMethods(self):
         """
-        Verifies that getProtectedClassMethods returns only protected class methods.
+        Test getProtectedClassMethods for protected class methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only protected class methods (single leading underscore)
+        are returned by getProtectedClassMethods.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         protected_class_methods = reflect.getProtectedClassMethods()
@@ -637,7 +580,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetProtectedClassSyncMethods(self):
         """
-        Verifies that getProtectedClassSyncMethods returns only protected class sync methods.
+        Test getProtectedClassSyncMethods for protected class sync methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only protected synchronous class methods (single leading underscore)
+        are returned by getProtectedClassSyncMethods.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         protected_class_sync_methods = reflect.getProtectedClassSyncMethods()
@@ -647,7 +599,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetProtectedClassAsyncMethods(self):
         """
-        Verifies that getProtectedClassAsyncMethods returns only protected class async methods.
+        Test that getProtectedClassAsyncMethods returns only protected class asynchronous methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only protected class async methods (single leading underscore)
+        are included in the result, while public and private class async methods are excluded.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         protected_class_async_methods = reflect.getProtectedClassAsyncMethods()
@@ -657,7 +618,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetPrivateClassMethods(self):
         """
-        Verifies that getPrivateClassMethods returns only private class methods.
+        Test that getPrivateClassMethods returns only private class methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only private class methods (double leading underscore)
+        are included in the result, while public and protected class methods are excluded.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         private_class_methods = reflect.getPrivateClassMethods()
@@ -667,7 +637,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetPrivateClassSyncMethods(self):
         """
-        Verifies that getPrivateClassSyncMethods returns only private class sync methods.
+        Test that getPrivateClassSyncMethods returns only private synchronous class methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only private synchronous class methods (double leading underscore)
+        are included in the result, while public and protected class sync methods are excluded.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         private_class_methods = reflect.getPrivateClassSyncMethods()
@@ -677,7 +656,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetPrivateClassAsyncMethods(self):
         """
-        Verifies that getPrivateClassAsyncMethods returns only private class async methods.
+        Test that getPrivateClassAsyncMethods returns only private class asynchronous methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only private class async methods (double leading underscore)
+        are included in the result, while public and protected class async methods are excluded.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         private_class_async_methods = reflect.getPrivateClassAsyncMethods()
@@ -687,7 +675,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetPublicStaticMethods(self):
         """
-        Verifies that getPublicStaticMethods returns only public static methods.
+        Test that getPublicStaticMethods returns only public static methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only public static methods (no leading underscore) are included in the result.
+        Both synchronous and asynchronous public static methods are considered.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         public_static_methods = reflect.getPublicStaticMethods()
@@ -697,7 +694,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetPublicStaticSyncMethods(self):
         """
-        Verifies that getPublicStaticSyncMethods returns only public static sync methods.
+        Test that getPublicStaticSyncMethods returns only public static synchronous methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only public static synchronous methods (no leading underscore)
+        are included in the result, while async and non-public static methods are excluded.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         public_static_sync_methods = reflect.getPublicStaticSyncMethods()
@@ -707,7 +713,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetPublicStaticAsyncMethods(self):
         """
-        Verifies that getPublicStaticAsyncMethods returns only public static async methods.
+        Test that getPublicStaticAsyncMethods returns only public static asynchronous methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only public static asynchronous methods (no leading underscore)
+        are included in the result, while synchronous and non-public static methods are excluded.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         public_static_async_methods = reflect.getPublicStaticAsyncMethods()
@@ -717,7 +732,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetProtectedStaticMethods(self):
         """
-        Verifies that getProtectedStaticMethods returns only protected static methods.
+        Test that getProtectedStaticMethods returns only protected static methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only protected static methods (single leading underscore)
+        are included in the result, while public and private static methods are excluded.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         protected_static_methods = reflect.getProtectedStaticMethods()
@@ -727,7 +751,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetProtectedStaticSyncMethods(self):
         """
-        Verifies that getProtectedStaticSyncMethods returns only protected static sync methods.
+        Test that getProtectedStaticSyncMethods returns only protected static synchronous methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only protected static synchronous methods (single leading underscore)
+        are included in the result, while async, public, and private static methods are excluded.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         protected_static_sync_methods = reflect.getProtectedStaticSyncMethods()
@@ -737,7 +770,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetProtectedStaticAsyncMethods(self):
         """
-        Verifies that getProtectedStaticAsyncMethods returns only protected static async methods.
+        Test that getProtectedStaticAsyncMethods returns only protected static asynchronous methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only protected static asynchronous methods (single leading underscore)
+        are included in the result, while public and private static methods are excluded.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         protected_static_async_methods = reflect.getProtectedStaticAsyncMethods()
@@ -747,7 +789,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetPrivateStaticMethods(self):
         """
-        Verifies that getPrivateStaticMethods returns only private static methods.
+        Test that getPrivateStaticMethods returns only private static methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only private static methods (double leading underscore)
+        are included in the result, while public and protected static methods are excluded.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         private_static_methods = reflect.getPrivateStaticMethods()
@@ -757,7 +808,16 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetPrivateStaticSyncMethods(self):
         """
-        Verifies that getPrivateStaticSyncMethods returns only private static sync methods.
+        Test that getPrivateStaticSyncMethods returns only private static synchronous methods.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only private static synchronous methods (double leading underscore)
+        are included in the result, while public and protected static sync methods are excluded.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         private_static_sync_methods = reflect.getPrivateStaticSyncMethods()
@@ -767,10 +827,25 @@ class TestServiceReflectionAbstract(AsyncTestCase):
 
     async def testGetPrivateStaticAsyncMethods(self):
         """
-        Verifies that getPrivateStaticAsyncMethods returns only private static async methods.
+        Test that getPrivateStaticAsyncMethods returns only private static asynchronous methods.
+
+        Parameters
+        ----------
+        self : TestServiceReflectionAbstract
+            The test case instance.
+
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Ensures that only private static asynchronous methods (double leading underscore)
+        are included in the result, while public and protected static async methods are excluded.
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         private_static_async_methods = reflect.getPrivateStaticAsyncMethods()
+        # Should include only double underscore (private) static async methods
         self.assertIn('__staticAsyncMethodPrivate', private_static_async_methods)
         self.assertNotIn('staticAsyncMethod', private_static_async_methods)
         self.assertNotIn('_staticAsyncMethodProtected', private_static_async_methods)
@@ -901,7 +976,7 @@ class TestServiceReflectionAbstract(AsyncTestCase):
         """
         reflect = ReflectionAbstract(AbstractFakeClass)
         docstring = reflect.getPropertyDocstring('computed_public_property')
-        self.assertIn('Computes and returns the valu', docstring)
+        self.assertIn('Abstract property for a computed', docstring)
 
     async def testGetConstructorDependencies(self):
         """

tests/services/introspection/reflection/test_reflection_callable.py

@@ -7,8 +7,14 @@ class TestReflectionCallable(AsyncTestCase):
 
     async def testInitValidFunction(self):
         """
-        Tests that a ReflectionCallable object can be correctly initialized with a valid function.
-        Verifies that the callable stored in the ReflectionCallable instance matches the original function.
+        Test initialization of ReflectionCallable with a valid function.
+
+        Validates that a ReflectionCallable instance can be created with a standard function
+        and that the stored callable matches the original function.
+
+        Returns
+        -------
+        None
         """
         def sample_function(a, b=2):
             """Sample docstring."""
@@ -18,18 +24,27 @@ class TestReflectionCallable(AsyncTestCase):
 
     async def testInitInvalid(self):
         """
-        Test that initializing ReflectionCallable with an invalid argument (e.g., an integer)
+        Test initialization of ReflectionCallable with an invalid argument.
+
+        Ensures that passing a non-callable object (e.g., an integer) to ReflectionCallable
         raises a ReflectionTypeError.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(ReflectionTypeError):
             ReflectionCallable(123)
 
     async def testGetName(self):
         """
-        Tests that the ReflectionCallable.getName() method correctly returns the name of the provided function.
+        Test retrieval of the function name from ReflectionCallable.
+
+        Checks that the getName() method returns the correct name of the wrapped function.
 
-        This test defines a sample function, wraps it with ReflectionCallable, and asserts that getName()
-        returns the function's name as a string.
+        Returns
+        -------
+        None
         """
         def sample_function(a, b=2):
             """Sample docstring."""
@@ -39,9 +54,13 @@ class TestReflectionCallable(AsyncTestCase):
 
     async def testGetModuleName(self):
         """
-        Tests that the getModuleName method of ReflectionCallable returns the correct module name
-        for a given function. It verifies that the module name returned matches the __module__ attribute
-        of the sample function.
+        Test retrieval of the module name from ReflectionCallable.
+
+        Verifies that getModuleName() returns the module name where the function is defined.
+
+        Returns
+        -------
+        None
         """
         def sample_function(a, b=2):
             """Sample docstring."""
@@ -51,12 +70,14 @@ class TestReflectionCallable(AsyncTestCase):
 
     async def testGetModuleWithCallableName(self):
         """
-        Tests that the `getModuleWithCallableName` method of the `ReflectionCallable` class
-        correctly returns the fully qualified name of a given callable, including its module
-        and function name.
+        Test retrieval of the fully qualified name from ReflectionCallable.
+
+        Ensures that getModuleWithCallableName() returns the module and function name
+        in the format "<module>.<function_name>".
 
-        The test defines a sample function, wraps it with `ReflectionCallable`, and asserts
-        that the returned string matches the expected format: "<module>.<function_name>".
+        Returns
+        -------
+        None
         """
         def sample_function(a, b=2):
             """Sample docstring."""
@@ -67,7 +88,13 @@ class TestReflectionCallable(AsyncTestCase):
 
     async def testGetDocstring(self):
         """
-        Tests that the getDocstring method of ReflectionCallable correctly retrieves the docstring from a given function.
+        Test retrieval of the docstring from ReflectionCallable.
+
+        Confirms that getDocstring() returns the docstring of the wrapped function.
+
+        Returns
+        -------
+        None
         """
         def sample_function(a, b=2):
             """Sample docstring."""
@@ -77,9 +104,14 @@ class TestReflectionCallable(AsyncTestCase):
 
     async def testGetSourceCode(self):
         """
-        Tests that the getSourceCode method of ReflectionCallable correctly retrieves
-        the source code of a given function. Verifies that the returned code contains
-        the function definition for 'sample_function'.
+        Test retrieval of source code from ReflectionCallable.
+
+        Checks that getSourceCode() returns the source code of the wrapped function,
+        and that the code contains the function definition.
+
+        Returns
+        -------
+        None
         """
         def sample_function(a, b=2):
             """Sample docstring."""
@@ -90,8 +122,14 @@ class TestReflectionCallable(AsyncTestCase):
 
     async def testGetSourceCodeError(self):
         """
-        Test that ReflectionCallable.getSourceCode() raises a ReflectionTypeError
-        when called on a built-in function (e.g., len) that does not have accessible source code.
+        Test error handling when retrieving source code from a built-in function.
+
+        Ensures that getSourceCode() raises a ReflectionTypeError when called on a
+        built-in function (e.g., len) that lacks accessible source code.
+
+        Returns
+        -------
+        None
         """
         with self.assertRaises(ReflectionTypeError):
             rc = ReflectionCallable(len)
@@ -99,9 +137,14 @@ class TestReflectionCallable(AsyncTestCase):
 
     async def testGetFile(self):
         """
-        Tests that the getFile() method of the ReflectionCallable class returns the correct file path
-        for a given callable. Verifies that the returned file path ends with '.py', indicating it is a
-        Python source file.
+        Test retrieval of the file path from ReflectionCallable.
+
+        Verifies that getFile() returns the file path of the wrapped function and that
+        the path ends with '.py', indicating a Python source file.
+
+        Returns
+        -------
+        None
         """
         def sample_function(a, b=2):
             """Sample docstring."""
@@ -112,11 +155,13 @@ class TestReflectionCallable(AsyncTestCase):
 
     async def testCallSync(self):
         """
-        Tests the synchronous call functionality of the ReflectionCallable class.
+        Test synchronous invocation of the wrapped function using ReflectionCallable.
+
+        Validates that calling the wrapped function with arguments returns the expected result.
 
-        This test defines a sample function with one required and one optional argument,
-        wraps it with ReflectionCallable, and asserts that calling it with specific arguments
-        returns the expected result.
+        Returns
+        -------
+        None
         """
         def sample_function(a, b=2):
             """Sample docstring."""
@@ -126,10 +171,13 @@ class TestReflectionCallable(AsyncTestCase):
 
     async def testCallAsync(self):
         """
-        Tests the ReflectionCallable's ability to call an asynchronous function synchronously.
+        Test asynchronous invocation of an async function using ReflectionCallable.
 
-        This test defines an asynchronous function `sample_async_function` that takes two arguments and returns their sum.
-        It then wraps this function with `ReflectionCallable` and asserts that calling it with arguments (1, 2) returns 3.
+        Ensures that an asynchronous function can be called and awaited, returning the correct result.
+
+        Returns
+        -------
+        None
         """
         async def sample_async_function(a, b=2):
             """Async docstring."""
@@ -139,12 +187,14 @@ class TestReflectionCallable(AsyncTestCase):
 
     async def testGetDependencies(self):
         """
-        Tests the getDependencies method of the ReflectionCallable class.
+        Test retrieval of callable dependencies from ReflectionCallable.
+
+        Checks that getDependencies() returns a CallableDependency object with
+        'resolved' and 'unresolved' attributes for the wrapped function.
 
-        This test defines a sample function with one required and one default argument,
-        creates a ReflectionCallable instance for it, and retrieves its dependencies.
-        It then asserts that the returned dependencies object has both 'resolved' and
-        'unresolved' attributes.
+        Returns
+        -------
+        None
         """
         def sample_function(a, b=2):
             """Sample docstring."""