orionis 0.437.0__py3-none-any.whl → 0.439.0__py3-none-any.whl

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."""