test(async): add inspection coverage

Author: zigai

tests/examples.py

@@ -13,7 +13,7 @@ def __init__(self, a: str, b: int) -> None:
         print("ExampleClassA init")
 
     def method_1(self):
-        """test docstring"""
+        """Test docstring"""
         print("method test called")
         print(f"{self.a=}")
         print(f"{self.b=}")
@@ -61,6 +61,25 @@ def property_method(self):
         return "property"
 
 
+class ExampleAsyncClass:
+    def __init__(self, prefix: str = "value") -> None:
+        self.prefix = prefix
+
+    async def async_instance_method(self, value: int) -> str:
+        return f"{self.prefix}:{value}"
+
+    @staticmethod
+    async def async_static_method(value: int) -> int:
+        return value + 1
+
+    @classmethod
+    async def async_class_method(cls, value: str = "x") -> str:
+        return f"{cls.__name__}:{value}"
+
+    def sync_method(self, value: int) -> int:
+        return value * 2
+
+
 def example_function(a, b=None, c=4) -> int:
     """
     example_function dostring
@@ -71,3 +90,7 @@ def example_function(a, b=None, c=4) -> int:
         c (int, optional): Argument c. Defaults to 4.
     """
     return c * 2
+
+
+async def async_example_function(value: int = 1) -> int:
+    return value + 1

tests/test_class.py

@@ -1,5 +1,7 @@
+import asyncio
+
 import pytest
-from examples import ExampleClassA, ExampleClassC
+from examples import ExampleAsyncClass, ExampleClassA, ExampleClassC
 
 from objinspect import Class
 
@@ -78,3 +80,27 @@ def test_instance_classmethod_filter_only_excludes_classmethods():
     method_names = [method.name for method in cls.methods]
     assert "public_method" in method_names
     assert "class_method" not in method_names
+
+
+def test_classmethod_can_be_called_without_initialization():
+    cls = Class(ExampleClassC, classmethod=True)
+    assert cls.call_method("class_method") is None
+
+
+def test_async_method_call_requires_initialization():
+    cls = Class(ExampleAsyncClass, classmethod=True)
+    with pytest.raises(ValueError, match="is not initialized"):
+        asyncio.run(cls.call_method_async("async_instance_method", 3))
+
+
+def test_async_static_and_class_methods_call_without_initialization():
+    cls = Class(ExampleAsyncClass, classmethod=True)
+    assert asyncio.run(cls.call_method_async("async_static_method", 4)) == 5
+    assert asyncio.run(cls.call_method_async("async_class_method", "ok")) == "ExampleAsyncClass:ok"
+
+
+def test_async_call_on_initialized_instance():
+    cls = Class(ExampleAsyncClass)
+    cls.init("pref")
+    assert asyncio.run(cls.call_method_async("async_instance_method", 7)) == "pref:7"
+    assert asyncio.run(cls.call_method_async("sync_method", 7)) == 14

tests/test_function.py

@@ -1,5 +1,7 @@
+import asyncio
+
 import pytest
-from examples import example_function
+from examples import async_example_function, example_function
 
 from objinspect.constants import EMPTY
 from objinspect.function import Function
@@ -60,10 +62,17 @@ def test_call():
 
 
 def test_async():
-    async def async_function():
-        return 1
-
-    async_func = Function(async_function)
+    async_func = Function(async_example_function)
 
     assert not func.is_coroutine
     assert async_func.is_coroutine
+
+
+def test_call_async_with_sync_function():
+    from math import pow as math_pow
+
+    assert asyncio.run(Function(math_pow).call_async(2, 2)) == 4
+
+
+def test_call_async_with_async_function():
+    assert asyncio.run(Function(async_example_function).call_async(3)) == 4

tests/test_inspect.py

@@ -1,11 +1,19 @@
-from examples import ExampleClassA, ExampleClassC, example_function
+from examples import (
+    ExampleAsyncClass,
+    ExampleClassA,
+    ExampleClassC,
+    async_example_function,
+    example_function,
+)
 
 from objinspect import Class, Function, Method, inspect
 
 
 def test_correct_return_types():
     assert isinstance(inspect(ExampleClassA("a", 1).method_1), Method)
     assert isinstance(inspect(example_function), Function)
+    assert isinstance(inspect(async_example_function), Function)
+    assert isinstance(inspect(ExampleAsyncClass.async_instance_method), Method)
     assert isinstance(inspect(ExampleClassA), Class)
     assert isinstance(inspect(lambda x: x), Function)
 
@@ -21,3 +29,9 @@ def test_inspect_classmethod_flag():
 
     enabled_obj = inspect(ExampleClassC, classmethod=True)
     assert "class_method" in [method.name for method in enabled_obj.methods]
+
+
+def test_inspect_async_metadata():
+    assert inspect(async_example_function).is_coroutine
+    assert inspect(ExampleAsyncClass.async_static_method).is_coroutine
+    assert inspect(ExampleAsyncClass.async_class_method).is_coroutine

tests/test_method.py

@@ -1,4 +1,4 @@
-from examples import ExampleClassC
+from examples import ExampleAsyncClass, ExampleClassC
 
 from objinspect import Class
 from objinspect.method import Method, MethodFilter
@@ -67,3 +67,11 @@ def test_extractor():
     assert "inherited_method" not in [
         i.name for i in MethodFilter(inherited=False).extract(ALL_METHODS)
     ]
+
+
+def test_async_methods():
+    assert Method(ExampleAsyncClass.async_instance_method, ExampleAsyncClass).is_coroutine
+    assert Method(ExampleAsyncClass.async_static_method, ExampleAsyncClass).is_coroutine
+    assert Method(ExampleAsyncClass.async_class_method, ExampleAsyncClass).is_coroutine
+    assert Method(ExampleAsyncClass.async_static_method, ExampleAsyncClass).is_static
+    assert Method(ExampleAsyncClass.async_class_method, ExampleAsyncClass).is_classmethod

tests/test_utils.py

@@ -1,6 +1,9 @@
+import asyncio
+
 import pytest
+from examples import ExampleAsyncClass
 
-from objinspect.util import create_function
+from objinspect.util import call_method_async, create_function
 
 
 class TestCreateFunction:
@@ -60,3 +63,13 @@ def test_body_execution(self):
     def test_edge_cases(self):
         nop = create_function(name="nop", args={}, body="pass", globs=globals())
         assert nop() is None
+
+
+def test_call_method_async_with_async_method():
+    obj = ExampleAsyncClass("util")
+    assert asyncio.run(call_method_async(obj, "async_instance_method", args=(2,))) == "util:2"
+
+
+def test_call_method_async_with_sync_method():
+    obj = ExampleAsyncClass()
+    assert asyncio.run(call_method_async(obj, "sync_method", args=(3,))) == 6