orionis 0.217.0__py3-none-any.whl → 0.219.0__py3-none-any.whl

tests/support/inspection/test_reflection_abstract.py

@@ -10,7 +10,7 @@ class TestReflexionAbstract(TestCase):
     using FakeAbstractClass as the test subject.
     """
 
-    def testReflectionAbstractExceptionValueError(self):
+    async def testReflectionAbstractExceptionValueError(self):
         """Class setup method.
 
         Initializes the ReflexionAbstract instance with FakeAbstractClass
@@ -19,7 +19,7 @@ class TestReflexionAbstract(TestCase):
         with self.assertRaises(ValueError):
             Reflection.abstract(str)
 
-    def testReflectionAbstractGetClassName(self):
+    async def testReflectionAbstractGetClassName(self):
         """Test getClassName() method.
 
         Verifies that:
@@ -30,7 +30,7 @@ class TestReflexionAbstract(TestCase):
         self.assertEqual(class_name, "FakeAbstractClass")
         self.assertIsInstance(class_name, str)
 
-    def testReflectionAbstractGetModuleName(self):
+    async def testReflectionAbstractGetModuleName(self):
         """Test getModuleName() method.
 
         Verifies that:
@@ -41,7 +41,7 @@ class TestReflexionAbstract(TestCase):
         self.assertTrue(module_name == 'tests.support.inspection.fakes.fake_reflection_abstract')
         self.assertIsInstance(module_name, str)
 
-    def testReflectionAbstractGetAbstractMethods(self):
+    async def testReflectionAbstractGetAbstractMethods(self):
         """Test getAbstractMethods() method.
 
         Verifies that:
@@ -54,7 +54,7 @@ class TestReflexionAbstract(TestCase):
         self.assertEqual(methods, expected)
         self.assertIsInstance(methods, set)
 
-    def testReflectionAbstractGetConcreteMethods(self):
+    async def testReflectionAbstractGetConcreteMethods(self):
         """Test getConcreteMethods() method.
 
         Verifies that:
@@ -70,7 +70,7 @@ class TestReflexionAbstract(TestCase):
         self.assertNotIn('_protected_method', methods)
         self.assertNotIn('__private_method', methods)
 
-    def testReflectionAbstractGetStaticMethods(self):
+    async def testReflectionAbstractGetStaticMethods(self):
         """Test getStaticMethods() method.
 
         Verifies that:
@@ -83,7 +83,7 @@ class TestReflexionAbstract(TestCase):
         self.assertEqual(len(static_methods), 1)
         self.assertNotIn('create_instance', static_methods)
 
-    def testReflectionAbstractGetClassMethods(self):
+    async def testReflectionAbstractGetClassMethods(self):
         """Test getClassMethods() method.
 
         Verifies that:
@@ -96,7 +96,7 @@ class TestReflexionAbstract(TestCase):
         self.assertEqual(len(class_methods), 1)
         self.assertNotIn('static_helper', class_methods)
 
-    def testReflectionAbstractGetProperties(self):
+    async def testReflectionAbstractGetProperties(self):
         """Test getProperties() method.
 
         Verifies that:
@@ -108,7 +108,7 @@ class TestReflexionAbstract(TestCase):
         self.assertIn('computed_property', props)
         self.assertEqual(len(props), 1)
 
-    def testReflectionAbstractGetMethodSignature(self):
+    async def testReflectionAbstractGetMethodSignature(self):
         """Test getMethodSignature() method.
 
         Verifies that:
@@ -121,7 +121,7 @@ class TestReflexionAbstract(TestCase):
         self.assertEqual(params, ['self', 'x', 'y'])
         self.assertEqual(sig.return_annotation, int)
 
-    def testReflectionAbstractGetDocstring(self):
+    async def testReflectionAbstractGetDocstring(self):
         """Test getDocstring() method.
 
         Verifies that:
@@ -132,7 +132,7 @@ class TestReflexionAbstract(TestCase):
         self.assertTrue(doc.startswith("A fake abstract class"))
         self.assertIsInstance(doc, str)
 
-    def testReflectionAbstractGetBaseAbstractClasses(self):
+    async def testReflectionAbstractGetBaseAbstractClasses(self):
         """Test getBaseAbstractClasses() method.
 
         Verifies that:
@@ -142,7 +142,7 @@ class TestReflexionAbstract(TestCase):
         bases = Reflection.abstract(FakeAbstractClass).getBaseAbstractClasses()
         self.assertEqual(bases, (ABC,))
 
-    def testReflectionAbstractGetInterfaceMethods(self):
+    async def testReflectionAbstractGetInterfaceMethods(self):
         """Test getInterfaceMethods() method.
 
         Verifies that:
@@ -156,7 +156,7 @@ class TestReflexionAbstract(TestCase):
         sig = interface['abstract_method']
         self.assertEqual(list(sig.parameters.keys()), ['self', 'x', 'y'])
 
-    def testReflectionAbstractIsSubclassOf(self):
+    async def testReflectionAbstractIsSubclassOf(self):
         """Test isSubclassOf() method.
 
         Verifies that:
@@ -166,7 +166,7 @@ class TestReflexionAbstract(TestCase):
         self.assertTrue(Reflection.abstract(FakeAbstractClass).isSubclassOf(ABC))
         self.assertTrue(Reflection.abstract(FakeAbstractClass).isSubclassOf(object))
 
-    def testReflectionAbstractGetSourceCode(self):
+    async def testReflectionAbstractGetSourceCode(self):
         """Test getSourceCode() method.
 
         Verifies that:
@@ -177,7 +177,7 @@ class TestReflexionAbstract(TestCase):
         self.assertIsNotNone(source)
         self.assertIn("class FakeAbstractClass(ABC):", source)
 
-    def testReflectionAbstractGetFileLocation(self):
+    async def testReflectionAbstractGetFileLocation(self):
         """Test getFileLocation() method.
 
         Verifies that:
@@ -188,7 +188,7 @@ class TestReflexionAbstract(TestCase):
         self.assertIsNotNone(location)
         self.assertTrue('fake_reflection_abstract.py' in location)
 
-    def testReflectionAbstractGetAnnotations(self):
+    async def testReflectionAbstractGetAnnotations(self):
         """Test getAnnotations() method.
 
         Verifies that:
@@ -199,7 +199,7 @@ class TestReflexionAbstract(TestCase):
         self.assertIn('class_attr', annotations)
         self.assertEqual(annotations['class_attr'], str)
 
-    def testReflectionAbstractGetDecorators(self):
+    async def testReflectionAbstractGetDecorators(self):
         """Test getDecorators() method.
 
         Verifies that:
@@ -211,7 +211,7 @@ class TestReflexionAbstract(TestCase):
         for decorator in decorators:
             self.assertTrue(decorator in ['decorator_example', 'another_decorator'])
 
-    def testReflectionAbstractIsProtocol(self):
+    async def testReflectionAbstractIsProtocol(self):
         """Test isProtocol() method.
 
         Verifies that:
@@ -219,7 +219,7 @@ class TestReflexionAbstract(TestCase):
         """
         self.assertFalse(Reflection.abstract(FakeAbstractClass).isProtocol())
 
-    def testReflectionAbstractGetRequiredAttributes(self):
+    async def testReflectionAbstractGetRequiredAttributes(self):
         """Test getRequiredAttributes() method.
 
         Verifies that:
@@ -227,11 +227,11 @@ class TestReflexionAbstract(TestCase):
         """
         self.assertEqual(Reflection.abstract(FakeAbstractClass).getRequiredAttributes(), set())
 
-    def testReflectionAbstractGetAbstractProperties(self):
+    async def testReflectionAbstractGetAbstractProperties(self):
         """Test getRequiredMethods() method."""
         self.assertEqual(Reflection.abstract(FakeAbstractClass).getAbstractProperties(), set())
 
-    def testReflectionAbstractGetPropertySignature(self):
+    async def testReflectionAbstractGetPropertySignature(self):
         """Test getPropertySignature() method."""
         signature = Reflection.abstract(FakeAbstractClass).getPropertySignature('computed_property')
         self.assertEqual(str(signature), '(self) -> float')

tests/support/inspection/test_reflection_concrete.py

@@ -8,36 +8,36 @@ class TestReflectionConcrete(TestCase):
     Unit tests for the Reflection class.
     """
 
-    def testReflectionConcreteExceptionValueError(self):
+    async def testReflectionConcreteExceptionValueError(self):
         """Ensure Reflection.instance raises ValueError for invalid types."""
         with self.assertRaises(ValueError):
             Reflection.concrete(str)
 
-    def testReflectionConcrete(self):
+    async def testReflectionConcrete(self):
         """Verify Reflection.instance returns an instance of ReflexionInstance."""
         self.assertIsInstance(Reflection.concrete(FakeExample), ReflexionConcrete)
 
-    def testReflectionConcreteGetClassName(self):
+    async def testReflectionConcreteGetClassName(self):
         """Test getClassName method."""
         reflection = Reflection.concrete(FakeExample)
         self.assertEqual(reflection.getClassName(), "FakeExample")
 
-    def testReflectionConcreteGetClass(self):
+    async def testReflectionConcreteGetClass(self):
         """Test getClass method."""
         reflection = Reflection.concrete(FakeExample)
         self.assertEqual(reflection.getClass(), FakeExample)
 
-    def testReflectionConcreteGetModuleName(self):
+    async def testReflectionConcreteGetModuleName(self):
         """Test getModuleName method."""
         reflection = Reflection.concrete(FakeExample)
         self.assertEqual(reflection.getModuleName(), "tests.support.inspection.fakes.fake_reflection_concrete")
 
-    def testReflectionConcreteGetAttributes(self):
+    async def testReflectionConcreteGetAttributes(self):
         """Test getAttributes method."""
         reflection = Reflection.concrete(FakeExample)
         self.assertEqual(reflection.getAttributes(), {'class_attr': 42, 'another_attr': 'hello'})
 
-    def testReflectionConcreteGetMethods(self):
+    async def testReflectionConcreteGetMethods(self):
         """Test getMethods method."""
         reflection = Reflection.concrete(FakeExample)
         expected_methods = [
@@ -48,7 +48,7 @@ class TestReflectionConcrete(TestCase):
         ]
         self.assertEqual(reflection.getMethods(), expected_methods)
 
-    def testReflectionConcreteGetStaticMethods(self):
+    async def testReflectionConcreteGetStaticMethods(self):
         """Test getStaticMethods method."""
         reflection = Reflection.concrete(FakeExample)
         expected_static_methods = [
@@ -56,7 +56,7 @@ class TestReflectionConcrete(TestCase):
         ]
         self.assertEqual(reflection.getStaticMethods(), expected_static_methods)
 
-    def testReflectionConcreteGetPropertyNames(self):
+    async def testReflectionConcreteGetPropertyNames(self):
         """Test getPropertyNames method."""
         reflection = Reflection.concrete(FakeExample)
         expected_properties = [
@@ -65,43 +65,43 @@ class TestReflectionConcrete(TestCase):
         ]
         self.assertEqual(reflection.getPropertyNames(), expected_properties)
 
-    def testReflectionConcreteGetMethodSignature(self):
+    async def testReflectionConcreteGetMethodSignature(self):
         """Test getMethodSignature method."""
         reflection = Reflection.concrete(FakeExample)
         self.assertEqual(str(reflection.getMethodSignature('method_one')), '(self, x: int) -> int')
         self.assertEqual(str(reflection.getMethodSignature('method_two')), '(self, a: str, b: str = \'default\') -> str')
         self.assertEqual(str(reflection.getMethodSignature('__init__')), '(self, value: int = 10) -> None')
 
-    def testReflectionConcreteGetPropertySignature(self):
+    async def testReflectionConcreteGetPropertySignature(self):
         """Test getPropertySignature method."""
         reflection = Reflection.concrete(FakeExample)
         self.assertEqual(str(reflection.getPropertySignature('prop')), '(self) -> int')
         self.assertEqual(str(reflection.getPropertySignature('prop_with_getter')), '(self) -> str')
 
-    def testReflectionConcreteGetDocstring(self):
+    async def testReflectionConcreteGetDocstring(self):
         """Test getDocstring method."""
         reflection = Reflection.concrete(FakeExample)
         self.assertIn('This is a fake example class for testing reflection', reflection.getDocstring())
 
-    def testReflectionConcreteGetBaseClasses(self):
+    async def testReflectionConcreteGetBaseClasses(self):
         """Test getBaseClasses method."""
         reflection = Reflection.concrete(FakeExample)
         self.assertEqual(reflection.getBaseClasses(), (BaseExample,))
 
-    def testReflectionConcreteIsSubclassOf(self):
+    async def testReflectionConcreteIsSubclassOf(self):
         """Test isSubclassOf method."""
         reflection = Reflection.concrete(FakeExample)
         self.assertTrue(reflection.isSubclassOf(BaseExample))
         self.assertFalse(reflection.isSubclassOf(str))
 
-    def testReflectionConcreteGetSourceCode(self):
+    async def testReflectionConcreteGetSourceCode(self):
         """Test getSourceCode method."""
         reflection = Reflection.concrete(FakeExample)
         source_code = reflection.getSourceCode()
         self.assertIn('class FakeExample(BaseExample):', source_code)
         self.assertIn('def method_one(self, x: int) -> int:', source_code)
 
-    def testReflectionConcreteGetFileLocation(self):
+    async def testReflectionConcreteGetFileLocation(self):
         """Test getFileLocation method."""
         reflection = Reflection.concrete(FakeExample)
         file_location = reflection.getFileLocation()
@@ -111,25 +111,25 @@ class TestReflectionConcrete(TestCase):
         self.assertIn('fakes', file_location)
         self.assertIn('fake_reflection_concrete.py', file_location)
 
-    def testReflectionConcreteGetAnnotations(self):
+    async def testReflectionConcreteGetAnnotations(self):
         """Test getAnnotations method."""
         reflection = Reflection.concrete(FakeExample)
         self.assertEqual(reflection.getAnnotations(), {'class_attr': int})
 
-    def testReflectionConcreteHasAttribute(self):
+    async def testReflectionConcreteHasAttribute(self):
         """Test hasAttribute method."""
         reflection = Reflection.concrete(FakeExample)
         self.assertTrue(reflection.hasAttribute('class_attr'))
         self.assertFalse(reflection.hasAttribute('non_existent_attr'))
 
-    def testReflectionConcreteGetAttribute(self):
+    async def testReflectionConcreteGetAttribute(self):
         """Test getAttribute method."""
         reflection = Reflection.concrete(FakeExample)
         self.assertEqual(reflection.getAttribute('class_attr'), 42)
         with self.assertRaises(AttributeError):
             reflection.getAttribute('non_existent_attr')
 
-    def testReflectionConcreteGetCallableMembers(self):
+    async def testReflectionConcreteGetCallableMembers(self):
         """Test getCallableMembers method."""
         reflection = Reflection.concrete(FakeExample)
         callable_members = reflection.getCallableMembers()

tests/support/inspection/test_reflection_concrete_with_abstract.py

@@ -4,7 +4,7 @@ from tests.support.inspection.fakes.fake_reflection_concrete_with_abstract impor
 
 class TestReflexionConcreteWithAbstract(TestCase):
 
-    def testReflexionInstanceWithAbstractGetImplementationAnalysis(self):
+    async def testReflexionInstanceWithAbstractGetImplementationAnalysis(self):
         """Test reflexion con AbstractService y PartiallyImplementedService."""
         inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
 
@@ -42,7 +42,7 @@ class TestReflexionConcreteWithAbstract(TestCase):
         self.assertFalse(analysis['status']['signature_match'])
         self.assertEqual(analysis['status']['type'], 'property')
 
-    def testReflexionConcreteWithAbstractGetNonInheritedImplementation(self):
+    async def testReflexionConcreteWithAbstractGetNonInheritedImplementation(self):
         """Test reflexion con AbstractService y PartiallyImplementedService."""
         inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
 
@@ -53,7 +53,7 @@ class TestReflexionConcreteWithAbstract(TestCase):
         self.assertListEqual(analysis['properties'], [])
         self.assertIn('__annotations__', analysis['attributes'])
 
-    def testReflexionConcreteWithAbstractValidateImplementation(self):
+    async def testReflexionConcreteWithAbstractValidateImplementation(self):
         """Test reflexion con AbstractService y PartiallyImplementedService."""
         inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
 
@@ -64,7 +64,7 @@ class TestReflexionConcreteWithAbstract(TestCase):
         self.assertFalse(is_valid)
         self.assertIn('reset', issues['missing'])
 
-    def testReflexionConcreteWithAbstractGetHierarchyAnalysis(self):
+    async def testReflexionConcreteWithAbstractGetHierarchyAnalysis(self):
         """Test reflexion con AbstractService y PartiallyImplementedService."""
         inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
 
@@ -76,7 +76,7 @@ class TestReflexionConcreteWithAbstract(TestCase):
         self.assertIn('AbstractService', analysis['abstract_hierarchy'])
         self.assertIn('PartiallyImplementedService', analysis['concrete_hierarchy'])
 
-    def testReflexionConcreteWithAbstractGetImplementationCoverage(self):
+    async def testReflexionConcreteWithAbstractGetImplementationCoverage(self):
         """Test reflexion con AbstractService y PartiallyImplementedService."""
         inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
 

tests/support/inspection/test_reflection_instance.py

@@ -2,37 +2,38 @@ from orionis.luminate.support.inspection.reflection import Reflection
 from orionis.luminate.support.inspection.reflexion_instance import ReflexionInstance
 from orionis.luminate.test.test_case import TestCase
 from tests.support.inspection.fakes.fake_reflection_instance import BaseFakeClass, FakeClass
+import asyncio
 
 class TestReflectionInstance(TestCase):
     """
     Unit tests for the Reflection class.
     """
 
-    def testReflectionInstanceExceptionValueError(self):
+    async def testReflectionInstanceExceptionValueError(self):
         """Ensure Reflection.instance raises ValueError for invalid types."""
         with self.assertRaises(ValueError):
             Reflection.instance(str)
 
-    def testReflectionInstance(self):
+    async def testReflectionInstance(self):
         """Verify Reflection.instance returns an instance of ReflexionInstance."""
         self.assertIsInstance(Reflection.instance(FakeClass()), ReflexionInstance)
 
-    def testReflectionInstanceGetClassName(self):
+    async def testReflectionInstanceGetClassName(self):
         """Check that getClassName returns the correct class name."""
         reflex = Reflection.instance(FakeClass())
         self.assertEqual(reflex.getClassName(), "FakeClass")
 
-    def testReflectionInstanceGetClass(self):
+    async def testReflectionInstanceGetClass(self):
         """Ensure getClass returns the correct class."""
         reflex = Reflection.instance(FakeClass())
         self.assertEqual(reflex.getClass(), FakeClass)
 
-    def testReflectionInstanceGetModuleName(self):
+    async def testReflectionInstanceGetModuleName(self):
         """Verify getModuleName returns the correct module name."""
         reflex = Reflection.instance(FakeClass())
         self.assertEqual(reflex.getModuleName(), "tests.support.inspection.fakes.fake_reflection_instance")
 
-    def testReflectionInstanceGetAttributes(self):
+    async def testReflectionInstanceGetAttributes(self):
         """Check that getAttributes returns all attributes of the class."""
         reflex = Reflection.instance(FakeClass())
         attributes = reflex.getAttributes()
@@ -40,85 +41,85 @@ class TestReflectionInstance(TestCase):
         self.assertTrue("_private_attr" in attributes)
         self.assertTrue("dynamic_attr" in attributes)
 
-    def testReflectionInstanceGetMethods(self):
+    async def testReflectionInstanceGetMethods(self):
         """Ensure getMethods returns all methods of the class."""
         reflex = Reflection.instance(FakeClass())
         methods = reflex.getMethods()
         self.assertTrue("instance_method" in methods)
         self.assertTrue("class_method" in methods)
 
-    def testReflectionInstanceGetStaticMethods(self):
+    async def testReflectionInstanceGetStaticMethods(self):
         """Verify getStaticMethods returns all static methods of the class."""
         reflex = Reflection.instance(FakeClass())
         methods = reflex.getStaticMethods()
         self.assertTrue("static_method" in methods)
 
-    def testReflectionInstanceGetPropertyNames(self):
+    async def testReflectionInstanceGetPropertyNames(self):
         """Check that getPropertyNames returns all property names."""
         reflex = Reflection.instance(FakeClass())
         properties = reflex.getPropertyNames()
         self.assertTrue("computed_property" in properties)
 
-    def testReflectionInstanceCallMethod(self):
+    async def testReflectionInstanceCallMethod(self):
         """Ensure callMethod correctly invokes a method with arguments."""
         reflex = Reflection.instance(FakeClass())
         result = reflex.callMethod("instance_method", 1, 2)
         self.assertEqual(result, 3)
 
-    def testReflectionInstanceGetMethodSignature(self):
+    async def testReflectionInstanceGetMethodSignature(self):
         """Verify getMethodSignature returns the correct method signature."""
         reflex = Reflection.instance(FakeClass())
         signature = reflex.getMethodSignature("instance_method")
         self.assertEqual(str(signature), "(x: int, y: int) -> int")
 
-    def testReflectionInstanceGetDocstring(self):
+    async def testReflectionInstanceGetDocstring(self):
         """Check that getDocstring returns the correct class docstring."""
         reflex = Reflection.instance(FakeClass())
         docstring = reflex.getDocstring()
         self.assertIn("This is a test class for ReflexionInstance", docstring)
 
-    def testReflectionInstanceGetBaseClasses(self):
+    async def testReflectionInstanceGetBaseClasses(self):
         """Ensure getBaseClasses returns the correct base classes."""
         reflex = Reflection.instance(FakeClass())
         base_classes = reflex.getBaseClasses()
         self.assertIn(BaseFakeClass, base_classes)
 
-    def testReflectionInstanceIsInstanceOf(self):
+    async def testReflectionInstanceIsInstanceOf(self):
         """Verify isInstanceOf checks inheritance correctly."""
         reflex = Reflection.instance(FakeClass())
         self.assertTrue(reflex.isInstanceOf(BaseFakeClass))
 
-    def testReflectionInstanceGetSourceCode(self):
+    async def testReflectionInstanceGetSourceCode(self):
         """Check that getSourceCode returns the class source code."""
         reflex = Reflection.instance(FakeClass())
         source_code = reflex.getSourceCode()
         self.assertIn("class FakeClass(BaseFakeClass):", source_code)
 
-    def testReflectionInstanceGetFileLocation(self):
+    async def testReflectionInstanceGetFileLocation(self):
         """Ensure getFileLocation returns the correct file path."""
         reflex = Reflection.instance(FakeClass())
         file_location = reflex.getFileLocation()
         self.assertIn("fake_reflection_instance.py", file_location)
 
-    def testReflectionInstanceGetAnnotations(self):
+    async def testReflectionInstanceGetAnnotations(self):
         """Verify getAnnotations returns the correct class annotations."""
         reflex = Reflection.instance(FakeClass())
         annotations = reflex.getAnnotations()
         self.assertEqual("{'class_attr': <class 'str'>}", str(annotations))
 
-    def testReflectionInstanceHasAttribute(self):
+    async def testReflectionInstanceHasAttribute(self):
         """Check that hasAttribute correctly identifies attributes."""
         reflex = Reflection.instance(FakeClass())
         self.assertTrue(reflex.hasAttribute("public_attr"))
         self.assertFalse(reflex.hasAttribute("non_existent_attr"))
 
-    def testReflectionInstanceGetAttribute(self):
+    async def testReflectionInstanceGetAttribute(self):
         """Ensure getAttribute retrieves the correct attribute value."""
         reflex = Reflection.instance(FakeClass())
         attr_value = reflex.getAttribute("public_attr")
         self.assertEqual(attr_value, 42)
 
-    def testReflectionInstanceGetCallableMembers(self):
+    async def testReflectionInstanceGetCallableMembers(self):
         """Verify getCallableMembers returns all callable members."""
         reflex = Reflection.instance(FakeClass())
         callable_members = reflex.getCallableMembers()
@@ -126,9 +127,11 @@ class TestReflectionInstance(TestCase):
         self.assertIn("class_method", callable_members)
         self.assertIn("static_method", callable_members)
 
-    def testReflectionInstanceSetAttribute(self):
+    async def testReflectionInstanceSetAttribute(self):
         """Check that setAttribute correctly sets a new attribute."""
-        def myMacro(cls: FakeClass, num):
+        async def myMacro(cls: FakeClass, num):
+            """Simulate an async function with an async sleep."""
+            await asyncio.sleep(0.1)
             return cls.instance_method(10, 12) + num
 
         reflex = Reflection.instance(FakeClass())
@@ -136,7 +139,7 @@ class TestReflectionInstance(TestCase):
 
         self.assertTrue(reflex.hasAttribute("myMacro"))
 
-        result = reflex.callMethod("myMacro", reflex._instance, 3)
+        result = await reflex.callMethod("myMacro", reflex._instance, 3)
         self.assertEqual(result, 25)
 
     def testReflectionInstanceGetPropertySignature(self):

tests/support/inspection/test_reflection_instance_with_abstract.py

@@ -4,7 +4,7 @@ from tests.support.inspection.fakes.fake_reflection_instance_with_abstract impor
 
 class TestReflexionInstanceWithAbstract(TestCase):
 
-    def testReflexionInstanceWithAbstractGetImplementationAnalysis(self):
+    async def testReflexionInstanceWithAbstractGetImplementationAnalysis(self):
         """Test reflexion con IDataProcessor y FakeDataProcessor."""
         processor = FakeDataProcessor()
         inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)
@@ -31,7 +31,7 @@ class TestReflexionInstanceWithAbstract(TestCase):
         self.assertTrue(analysis['config']['signature_match'])
         self.assertEqual(analysis['config']['type'], 'property')
 
-    def testReflexionInstanceWithAbstractGetNonInheritedImplementation(self):
+    async def testReflexionInstanceWithAbstractGetNonInheritedImplementation(self):
         """Test reflexion con IDataProcessor y FakeDataProcessor."""
         processor = FakeDataProcessor()
         inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)
@@ -42,7 +42,7 @@ class TestReflexionInstanceWithAbstract(TestCase):
         # Verifying implemented methods
         self.assertIn('extra_method', analysis['methods'])
 
-    def testReflexionInstanceWithAbstractValidateImplementation(self):
+    async def testReflexionInstanceWithAbstractValidateImplementation(self):
         """Test reflexion con IDataProcessor y FakeDataProcessor."""
         processor = FakeDataProcessor()
         inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)
@@ -54,7 +54,7 @@ class TestReflexionInstanceWithAbstract(TestCase):
         self.assertFalse(is_valid)
         self.assertIn('process', issues['signature_mismatch'])
 
-    def testReflexionInstanceWithAbstractGetHierarchyAnalysis(self):
+    async def testReflexionInstanceWithAbstractGetHierarchyAnalysis(self):
         """Test reflexion con IDataProcessor y FakeDataProcessor."""
         processor = FakeDataProcessor()
         inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)
@@ -67,7 +67,7 @@ class TestReflexionInstanceWithAbstract(TestCase):
         self.assertIn('IDataProcessor', analysis['abstract_hierarchy'])
         self.assertIn('FakeDataProcessor', analysis['concrete_hierarchy'])
 
-    def testReflexionInstanceWithAbstractGetImplementationCoverage(self):
+    async def testReflexionInstanceWithAbstractGetImplementationCoverage(self):
         """Test reflexion con IDataProcessor y FakeDataProcessor."""
         processor = FakeDataProcessor()
         inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)

tests/support/parsers/test_exception_parser.py

@@ -4,7 +4,7 @@ from tests.support.parsers.fakes.fake_custom_error import CustomError
 
 class TestsExceptionParser(TestCase):
 
-    def testBasicExceptionStructure(self):
+    async def testBasicExceptionStructure(self):
         """
         Ensure that the ExceptionParser correctly structures a basic exception.
         """
@@ -27,7 +27,7 @@ class TestsExceptionParser(TestCase):
             self.assertIsInstance(result["stack_trace"], list)
             self.assertGreater(len(result["stack_trace"]), 0)
 
-    def testRawExceptionProperty(self):
+    async def testRawExceptionProperty(self):
         """
         Ensure that the raw_exception property returns the original exception.
         """
@@ -37,7 +37,7 @@ class TestsExceptionParser(TestCase):
             parser = ExceptionParser(e)
             self.assertIs(parser.raw_exception, e)
 
-    def testExceptionWithCode(self):
+    async def testExceptionWithCode(self):
         try:
             raise CustomError("Custom message", code=404)
         except Exception as e:
@@ -45,7 +45,7 @@ class TestsExceptionParser(TestCase):
             self.assertEqual(result["error_code"], 404)
             self.assertEqual(result["error_type"], "CustomError")
 
-    def testNestedExceptionCause(self):
+    async def testNestedExceptionCause(self):
         """
         Ensure that the ExceptionParser correctly handles nested exceptions.
         """