orionis 0.305.0__py3-none-any.whl → 0.306.0__py3-none-any.whl

tests/support/inspection/test_reflect_abstract.py

@@ -1,334 +0,0 @@
-from abc import ABC
-import json
-from orionis.support.introspection.reflection import Reflection
-from orionis.test import TestCase
-from tests.support.inspection.fakes.fake_reflect_abstract import FakeAbstractClass
-
-class TestReflectAbstract(TestCase):
-    """Test cases for ReflexionAbstract using FakeAbstractClass.
-
-    This test suite verifies all functionality of the ReflexionAbstract class
-    using FakeAbstractClass as the test subject.
-    """
-
-    async def testReflectionAbstractExceptionValueError(self):
-        """Class setup method.
-
-        Initializes the ReflexionAbstract instance with FakeAbstractClass
-        before any tests run.
-        """
-        with self.assertRaises(ValueError):
-            Reflection.abstract(str)
-
-    async def testReflectionAbstractGetClassName(self):
-        """Test getClassName() method.
-
-        Verifies that:
-        - The returned class name matches exactly
-        - The return type is str
-        """
-        class_name = Reflection.abstract(FakeAbstractClass).getClassName()
-        self.assertEqual(class_name, "FakeAbstractClass")
-        self.assertIsInstance(class_name, str)
-
-    async def testReflectionAbstractGetModuleName(self):
-        """Test getModuleName() method.
-
-        Verifies that:
-        - The module name is returned
-        - The name is a string
-        """
-        module_name = Reflection.abstract(FakeAbstractClass).getModuleName()
-        self.assertTrue(module_name == 'tests.support.inspection.fakes.fake_reflect_abstract')
-        self.assertIsInstance(module_name, str)
-
-    async def testReflectionAbstractGetClass(self):
-        """
-        Test the `getClass()` method of the `Reflection.abstract` function.
-        This test verifies the following:
-        - The method raises a `RuntimeError` when attempting to retrieve a class
-          from an abstract class.
-        - Ensures that the behavior aligns with the expected handling of abstract
-          classes in the reflection mechanism.
-        """
-        with self.assertRaises(RuntimeError):
-            Reflection.abstract(FakeAbstractClass).getClass()
-
-    async def testReflectionAbstractGetAllAttributes(self):
-        """Test getAllAttributes() method.
-
-        Verifies that:
-        - All attributes are detected
-        - No private/protected attributes are included
-        - Return type is correct
-        """
-        attributes = Reflection.abstract(FakeAbstractClass).getAllAttributes()
-        self.assertIn('__private_class_attribute', attributes.private)
-        self.assertIn('_protected_class_attribute', attributes.protected)
-        self.assertIn('public_class_attribute', attributes.public)
-
-    async def testReflectionAbstractGetAttribute(self):
-        """Test getAttribute() method.
-
-        Verifies that:
-        - Correct attribute is returned
-        - Attribute type is correct
-        """
-        attr = Reflection.abstract(FakeAbstractClass).getAttributes()
-        self.assertIn('__private_class_attribute', attr)
-        self.assertIn('_protected_class_attribute', attr)
-        self.assertIn('public_class_attribute', attr)
-
-    async def testReflectionAbstractGetPublicAttributes(self):
-        """Test getPublicAttributes() method.
-
-        Verifies that:
-        - Only public attributes are returned
-        - No private/protected attributes are included
-        """
-        public_attributes = Reflection.abstract(FakeAbstractClass).getPublicAttributes()
-        self.assertIn('public_class_attribute', public_attributes)
-        self.assertNotIn('_protected_class_attribute', public_attributes)
-        self.assertNotIn('__private_class_attribute', public_attributes)
-
-    async def testReflectionAbstractGetProtectedAttributes(self):
-        """Test getProtectedAttributes() method.
-
-        Verifies that:
-        - Only protected attributes are returned
-        - No private/public attributes are included
-        """
-        protected_attributes = Reflection.abstract(FakeAbstractClass).getProtectedAttributes()
-        self.assertIn('_protected_class_attribute', protected_attributes)
-        self.assertNotIn('__private_class_attribute', protected_attributes)
-        self.assertNotIn('public_class_attribute', protected_attributes)
-
-    async def testReflectionAbstractGetPrivateAttributes(self):
-        """Test getPrivateAttributes() method.
-
-        Verifies that:
-        - Only private attributes are returned
-        - No protected/public attributes are included
-        """
-        private_attributes = Reflection.abstract(FakeAbstractClass).getPrivateAttributes()
-        self.assertIn('__private_class_attribute', private_attributes)
-        self.assertNotIn('_protected_class_attribute', private_attributes)
-        self.assertNotIn('public_class_attribute', private_attributes)
-
-    async def testReflectionAbstractGetAllMethods(self):
-        """Test getAllMethods() method.
-
-        Verifies that:
-        - All methods are detected
-        - No private/protected methods are included
-        - Return type is correct
-        """
-        methods = Reflection.abstract(FakeAbstractClass).getAllMethods()
-        self.console().info(message="Hola")
-        # self.print(Reflection.abstract(FakeAbstractClass).getAllAttributes())
-        # self.dd(json.dumps(methods, indent=4))
-
-
-
-
-
-
-
-
-
-
-
-    # async def testReflectionAbstractGetAbstractMethods(self):
-    #     """Test getAbstractMethods() method.
-
-    #     Verifies that:
-    #     - All abstract methods are detected
-    #     - No concrete methods are included
-    #     - Return type is correct
-    #     """
-    #     methods = Reflection.abstract(FakeAbstractClass).getAbstractMethods()
-    #     expected = {'abstract_method', 'another_abstract'}
-    #     self.assertEqual(methods, expected)
-    #     self.assertIsInstance(methods, set)
-
-    # async def testReflectionAbstractGetConcreteMethods(self):
-    #     """Test getConcreteMethods() method.
-
-    #     Verifies that:
-    #     - Concrete methods are detected
-    #     - Abstract methods are excluded
-    #     - Protected/private methods are excluded
-    #     """
-    #     methods = Reflection.abstract(FakeAbstractClass).getConcreteMethods()
-    #     self.assertIn('static_helper', methods)
-    #     self.assertIn('concrete_method', methods)
-    #     self.assertIn('decorated_method', methods)
-    #     self.assertNotIn('abstract_method', methods)
-    #     self.assertNotIn('_protected_method', methods)
-    #     self.assertNotIn('__private_method', methods)
-
-    # async def testReflectionAbstractGetStaticMethods(self):
-    #     """Test getStaticMethods() method.
-
-    #     Verifies that:
-    #     - Static methods are detected
-    #     - Only static methods are included
-    #     - Protected/private methods are excluded
-    #     """
-    #     static_methods = Reflection.abstract(FakeAbstractClass).getStaticMethods()
-    #     self.assertIn('static_helper', static_methods)
-    #     self.assertEqual(len(static_methods), 1)
-    #     self.assertNotIn('create_instance', static_methods)
-
-    # async def testReflectionAbstractGetClassMethods(self):
-    #     """Test getClassMethods() method.
-
-    #     Verifies that:
-    #     - Class methods are detected
-    #     - Only class methods are included
-    #     - Protected/private methods are excluded
-    #     """
-    #     class_methods = Reflection.abstract(FakeAbstractClass).getClassMethods()
-    #     self.assertIn('create_instance', class_methods)
-    #     self.assertEqual(len(class_methods), 1)
-    #     self.assertNotIn('static_helper', class_methods)
-
-    # async def testReflectionAbstractGetProperties(self):
-    #     """Test getProperties() method.
-
-    #     Verifies that:
-    #     - Properties are detected
-    #     - Only properties are included
-    #     - Protected/private properties are excluded
-    #     """
-    #     props = Reflection.abstract(FakeAbstractClass).getProperties()
-    #     self.assertIn('computed_property', props)
-    #     self.assertEqual(len(props), 1)
-
-    # async def testReflectionAbstractGetMethodSignature(self):
-    #     """Test getMethodSignature() method.
-
-    #     Verifies that:
-    #     - Correct signature is returned
-    #     - Parameters are properly detected
-    #     - Return type is properly detected
-    #     """
-    #     sig = Reflection.abstract(FakeAbstractClass).getMethodSignature('abstract_method')
-    #     params = list(sig.parameters.keys())
-    #     self.assertEqual(params, ['self', 'x', 'y'])
-    #     self.assertEqual(sig.return_annotation, int)
-
-    # async def testReflectionAbstractGetDocstring(self):
-    #     """Test getDocstring() method.
-
-    #     Verifies that:
-    #     - Docstring is returned
-    #     - Docstring contains expected content
-    #     """
-    #     doc = Reflection.abstract(FakeAbstractClass).getDocstring()
-    #     self.assertTrue(doc.startswith("A fake abstract class"))
-    #     self.assertIsInstance(doc, str)
-
-    # async def testReflectionAbstractGetBaseAbstractClasses(self):
-    #     """Test getBaseAbstractClasses() method.
-
-    #     Verifies that:
-    #     - Base abstract classes are detected
-    #     - Only abstract bases are included
-    #     """
-    #     bases = Reflection.abstract(FakeAbstractClass).getBaseAbstractClasses()
-    #     self.assertEqual(bases, (ABC,))
-
-    # async def testReflectionAbstractGetInterfaceMethods(self):
-    #     """Test getInterfaceMethods() method.
-
-    #     Verifies that:
-    #     - Interface methods are detected
-    #     - Signatures are correct
-    #     - Only abstract methods are included
-    #     """
-    #     interface = Reflection.abstract(FakeAbstractClass).getInterfaceMethods()
-    #     self.assertEqual(len(interface), 2)
-    #     self.assertIn('abstract_method', interface)
-    #     sig = interface['abstract_method']
-    #     self.assertEqual(list(sig.parameters.keys()), ['self', 'x', 'y'])
-
-    # async def testReflectionAbstractIsSubclassOf(self):
-    #     """Test isSubclassOf() method.
-
-    #     Verifies that:
-    #     - Correctly identifies abstract base classes
-    #     - Returns False for non-parent classes
-    #     """
-    #     self.assertTrue(Reflection.abstract(FakeAbstractClass).isSubclassOf(ABC))
-    #     self.assertTrue(Reflection.abstract(FakeAbstractClass).isSubclassOf(object))
-
-    # async def testReflectionAbstractGetSourceCode(self):
-    #     """Test getSourceCode() method.
-
-    #     Verifies that:
-    #     - Source code is returned
-    #     - Contains class definition
-    #     """
-    #     source = Reflection.abstract(FakeAbstractClass).getSourceCode()
-    #     self.assertIsNotNone(source)
-    #     self.assertIn("class FakeAbstractClass(ABC):", source)
-
-    # async def testReflectionAbstractGetFileLocation(self):
-    #     """Test getFileLocation() method.
-
-    #     Verifies that:
-    #     - File location is returned
-    #     - Path ends with .py extension
-    #     """
-    #     location = Reflection.abstract(FakeAbstractClass).getFileLocation()
-    #     self.assertIsNotNone(location)
-    #     self.assertTrue('fake_reflection_abstract.py' in location)
-
-    # async def testReflectionAbstractGetAnnotations(self):
-    #     """Test getAnnotations() method.
-
-    #     Verifies that:
-    #     - Annotations are detected
-    #     - Class attributes are included
-    #     """
-    #     annotations = Reflection.abstract(FakeAbstractClass).getAnnotations()
-    #     self.assertIn('class_attr', annotations)
-    #     self.assertEqual(annotations['class_attr'], str)
-
-    # async def testReflectionAbstractGetDecorators(self):
-    #     """Test getDecorators() method.
-
-    #     Verifies that:
-    #     - Decorators are detected
-    #     - Correct number of decorators is returned
-    #     - Decorator order is preserved
-    #     """
-    #     decorators = Reflection.abstract(FakeAbstractClass).getDecorators('decorated_method')
-    #     for decorator in decorators:
-    #         self.assertTrue(decorator in ['decorator_example', 'another_decorator'])
-
-    # async def testReflectionAbstractIsProtocol(self):
-    #     """Test isProtocol() method.
-
-    #     Verifies that:
-    #     - Correctly identifies non-Protocol classes
-    #     """
-    #     self.assertFalse(Reflection.abstract(FakeAbstractClass).isProtocol())
-
-    # async def testReflectionAbstractGetRequiredAttributes(self):
-    #     """Test getRequiredAttributes() method.
-
-    #     Verifies that:
-    #     - Returns empty set for non-Protocol classes
-    #     """
-    #     self.assertEqual(Reflection.abstract(FakeAbstractClass).getRequiredAttributes(), set())
-
-    # async def testReflectionAbstractGetAbstractProperties(self):
-    #     """Test getRequiredMethods() method."""
-    #     self.assertEqual(Reflection.abstract(FakeAbstractClass).getAbstractProperties(), set())
-
-    # async def testReflectionAbstractGetPropertySignature(self):
-    #     """Test getPropertySignature() method."""
-    #     signature = Reflection.abstract(FakeAbstractClass).getPropertySignature('computed_property')
-    #     self.assertEqual(str(signature), '(self) -> float')

tests/support/inspection/test_reflect_instance.py

@@ -1,288 +0,0 @@
-import asyncio
-from orionis.support.introspection import Reflection
-from orionis.support.introspection.instances import ReflectionInstance
-from orionis.test import TestCase
-from tests.support.inspection.fakes.fake_reflect_instance import BaseFakeClass, FakeClass
-
-class TestReflectInstance(TestCase):
-    """
-    Unit tests for the Reflection class.
-    """
-
-    async def testReflectionInstanceExceptionValueError(self):
-        """Ensure Reflection.instance raises ValueError for invalid types."""
-        with self.assertRaises(ValueError):
-            Reflection.instance(str)
-
-    async def testReflectionInstance(self):
-        """Verify Reflection.instance returns an instance of ReflectionInstance."""
-        self.assertIsInstance(Reflection.instance(FakeClass()), ReflectionInstance)
-
-    async def testReflectionInstanceGetClassName(self):
-        """Check that getClassName returns the correct class name."""
-        reflex = Reflection.instance(FakeClass())
-        self.assertEqual(reflex.getClassName(), "FakeClass")
-
-    async def testReflectionInstanceGetClass(self):
-        """Ensure getClass returns the correct class."""
-        reflex = Reflection.instance(FakeClass())
-        self.assertEqual(reflex.getClass(), FakeClass)
-
-    async def testReflectionInstanceGetModuleName(self):
-        """Verify getModuleName returns the correct module name."""
-        reflex = Reflection.instance(FakeClass())
-        self.assertEqual(reflex.getModuleName(), "tests.support.inspection.fakes.fake_reflect_instance")
-
-    async def testReflectionInstanceGetAllAttributes(self):
-        """Check that getAllAttributes returns all attributes of the class."""
-        reflex = Reflection.instance(FakeClass())
-        attributes = reflex.getAllAttributes()
-        self.assertTrue("public_attr" in attributes.public)
-        self.assertTrue("__private_attr" in attributes.private)
-        self.assertTrue("_protected_attr" in attributes.protected)
-
-    async def testReflectionInstanceGetAttributes(self):
-        """Check that getAttributes returns all attributes of the class."""
-        reflex = Reflection.instance(FakeClass())
-        attributes = reflex.getAttributes()
-        self.assertTrue("public_attr" in attributes)
-        self.assertTrue("__private_attr" in attributes)
-        self.assertTrue("dynamic_attr" in attributes)
-
-    async def testReflectionInstanceGetPublicAttributes(self):
-        """Ensure getPublicAttributes returns all public attributes."""
-        reflex = Reflection.instance(FakeClass())
-        attributes = reflex.getPublicAttributes()
-        self.assertTrue("public_attr" in attributes)
-        self.assertTrue("dynamic_attr" in attributes)
-
-    async def testReflectionInstanceGetProtectedAttributes(self):
-        """Check that getProtectedAttributes returns all protected attributes."""
-        reflex = Reflection.instance(FakeClass())
-        attributes = reflex.getProtectedAttributes()
-        self.assertTrue("_protected_attr" in attributes)
-
-    async def testReflectionInstanceGetPrivateAttributes(self):
-        """Ensure getPrivateAttributes returns all private attributes."""
-        reflex = Reflection.instance(FakeClass())
-        attributes = reflex.getPrivateAttributes()
-        self.assertTrue("__private_attr" in attributes)
-
-    async def testReflectionInstanceGetAllMethods(self):
-        """Check that getAllMethods returns all methods of the class."""
-        reflex = Reflection.instance(FakeClass())
-        methods = reflex.getAllMethods()
-        self.assertTrue("__privateMethod" in methods.private)
-        self.assertTrue("_protectedMethod" in methods.protected)
-        self.assertTrue("asyncMethod" in methods.asynchronous)
-        self.assertTrue("classMethod" in methods.class_methods)
-
-    async def testReflectionInstanceGetMethods(self):
-        """Ensure getMethods returns all methods of the class."""
-        reflex = Reflection.instance(FakeClass())
-        methods = reflex.getMethods()
-        self.assertTrue("__privateMethod" in methods)
-        self.assertTrue("_protectedMethod" in methods)
-        self.assertTrue("asyncMethod" in methods)
-        self.assertTrue("classMethod" in methods)
-        self.assertTrue("instanceMethod" in methods)
-
-    async def testReflectionInstanceGetProtectedMethods(self):
-        """Check that getProtectedMethods returns all protected methods."""
-        reflex = Reflection.instance(FakeClass())
-        methods = reflex.getProtectedMethods()
-        self.assertTrue("_protectedMethod" in methods)
-
-    async def testReflectionInstanceGetPrivateMethods(self):
-        """Ensure getPrivateMethods returns all private methods."""
-        reflex = Reflection.instance(FakeClass())
-        methods = reflex.getPrivateMethods()
-        self.assertTrue("__privateMethod" in methods)
-
-    async def testReflectionInstanceGetAsyncMethods(self):
-        """Check that getAsyncMethods returns all async methods of the class."""
-        reflex = Reflection.instance(FakeClass())
-        methods = reflex.getAsyncMethods()
-        self.assertTrue("asyncMethod" in methods)
-
-    async def testReflectionInstanceGetSyncMethods(self):
-        """Check that getASyncMethods returns all async methods of the class."""
-        reflex = Reflection.instance(FakeClass())
-        methods = reflex.getSyncMethods()
-        self.assertTrue("__privateMethod" in methods)
-        self.assertTrue("_protectedMethod" in methods)
-        self.assertTrue("instanceMethod" in methods)
-
-    async def testReflectionInstanceGetClassMethods(self):
-        """Verify getClassMethods returns all class methods of the class."""
-        reflex = Reflection.instance(FakeClass())
-        methods = reflex.getClassMethods()
-        self.assertTrue("classMethod" in methods)
-
-    async def testReflectionInstanceGetStaticMethods(self):
-        """Verify getStaticMethods returns all static methods of the class."""
-        reflex = Reflection.instance(FakeClass())
-        methods = reflex.getStaticMethods()
-        self.assertTrue("staticAsyncMethod" in methods)
-        self.assertTrue("staticMethod" in methods)
-
-    async def testReflectionInstanceGetAsyncStaticMethods(self):
-        """Ensure getSyncMethods returns all sync methods of the class."""
-        reflex = Reflection.instance(FakeClass())
-        methods = reflex.getAsyncStaticMethods()
-        self.assertTrue("staticAsyncMethod" in methods)
-
-    async def testReflectionInstanceGetSyncStaticMethods(self):
-        """Check that getSyncMethods returns all sync methods of the class."""
-        reflex = Reflection.instance(FakeClass())
-        methods = reflex.getSyncStaticMethods()
-        self.assertTrue("staticMethod" in methods)
-
-    async def testReflectionInstanceGetAllProperties(self):
-        """Check that getAllProperties returns all properties of the class."""
-        reflex = Reflection.instance(FakeClass())
-        properties = reflex.getAllProperties()
-        self.assertTrue("computed_property" in properties.keys())
-
-    async def testReflectionInstanceGetPropertyNames(self):
-        """Check that getPropertyNames returns all property names."""
-        reflex = Reflection.instance(FakeClass())
-        properties = reflex.getPropertyNames()
-        self.assertTrue("computed_property" in properties)
-
-    async def testReflectionInstanceGetProperty(self):
-        """Ensure getProperty retrieves the correct property value."""
-        reflex = Reflection.instance(FakeClass())
-        property_value = reflex.getProperty("computed_property")
-        self.assertEqual(property_value, "Value: 42")
-
-    async def testReflectionInstanceGetPropertyDoc(self):
-        """Check that getPropertyDoc returns the correct property docstring."""
-        reflex = Reflection.instance(FakeClass())
-        doc = reflex.getPropertyDoc("computed_property")
-        self.assertIn("A computed property", doc)
-
-    async def testReflectionInstanceGetPropertySignature(self):
-        """Ensure getPropertySignature returns the correct property signature."""
-        reflex = Reflection.instance(FakeClass())
-        signature = reflex.getPropertySignature("computed_property")
-        self.assertEqual(str(signature), "(self) -> str")
-
-    async def testReflectionInstanceCallMethod(self):
-        """Ensure callMethod correctly invokes a method with arguments."""
-        reflex = Reflection.instance(FakeClass())
-        result = reflex.callMethod("instanceMethod", 1, 2)
-        self.assertEqual(result, 3)
-        result = await reflex.callMethod("asyncMethod")
-        self.assertEqual(result, "This is async")
-
-    async def testReflectionInstanceGetMethodSignature(self):
-        """Verify getMethodSignature returns the correct method signature."""
-        reflex = Reflection.instance(FakeClass())
-        signature = reflex.getMethodSignature("instanceMethod")
-        self.assertEqual(str(signature), "(x: int, y: int) -> int")
-        signature = reflex.getMethodSignature("__privateMethod")
-        self.assertEqual(str(signature), "() -> str")
-
-    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", docstring)
-
-    async def testReflectionInstanceGetBaseClasses(self):
-        """Ensure getBaseClasses returns the correct base classes."""
-        reflex = Reflection.instance(FakeClass())
-        base_classes = reflex.getBaseClasses()
-        self.assertIn(BaseFakeClass, base_classes)
-
-    async def testReflectionInstanceIsInstanceOf(self):
-        """Verify isInstanceOf checks inheritance correctly."""
-        reflex = Reflection.instance(FakeClass())
-        result = reflex.isInstanceOf(BaseFakeClass)
-        self.assertTrue(result)
-
-    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)
-
-    async def testReflectionInstanceGetFileLocation(self):
-        """Ensure getFileLocation returns the correct file path."""
-        reflex = Reflection.instance(FakeClass())
-        file_location = reflex.getFileLocation()
-        self.assertIn("fake_reflect_instance.py", file_location)
-
-    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))
-
-    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"))
-
-    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)
-        attr_value = reflex.getAttribute("__private_attr")
-        self.assertEqual(attr_value, "private")
-
-    async def testReflectionInstanceSetAttribute(self):
-        """Check that setAttribute correctly sets a new attribute."""
-        reflex = Reflection.instance(FakeClass())
-        reflex.setAttribute("new_attr", 'Orionis')
-        attr_value = reflex.getAttribute("new_attr")
-        self.assertEqual(attr_value, 'Orionis')
-        reflex.setAttribute("__new_private_attr", 'Hidden')
-        attr_value = reflex.getAttribute("__new_private_attr")
-        self.assertEqual(attr_value, 'Hidden')
-
-    async def testReflectionInstanceRemoveAttribute(self):
-        """Ensure removeAttribute correctly removes an attribute."""
-        reflex = Reflection.instance(FakeClass())
-        reflex.setAttribute("temp_attr", 'Temporary')
-        reflex.removeAttribute("temp_attr")
-        self.assertFalse(reflex.hasAttribute("temp_attr"))
-
-    async def testReflectionInstanceSetMacro(self):
-        """Check that setMacro correctly."""
-        async def asyncMacro(cls: FakeClass, num):
-            await asyncio.sleep(0.1)
-            return cls.instanceMethod(10, 12) + num
-        def syncMacro(cls: FakeClass, num):
-            return cls.instanceMethod(10, 12) + num
-        def __privateMacro(cls: FakeClass, num):
-            return cls.instanceMethod(10, 12) + num
-
-        reflex = Reflection.instance(FakeClass())
-
-        reflex.setMacro("asyncMacro", asyncMacro)
-        result = await reflex.callMethod("asyncMacro", reflex._instance, 3)
-        self.assertEqual(result, 25)
-
-        reflex.setMacro("syncMacro", syncMacro)
-        result = reflex.callMethod("syncMacro", reflex._instance, 3)
-        self.assertEqual(result, 25)
-
-        reflex.setMacro("__privateMacro", __privateMacro)
-        result = reflex.callMethod("__privateMacro", reflex._instance, 3)
-        self.assertEqual(result, 25)
-
-    async def testReflectionInstanceRemoveMacro(self):
-        """Ensure removeMacro correctly removes a macro."""
-        async def asyncMacro(cls: FakeClass, num):
-            await asyncio.sleep(0.1)
-            return cls.instanceMethod(10, 12) + num
-
-        reflex = Reflection.instance(FakeClass())
-        reflex.setMacro("asyncMacro", asyncMacro)
-        reflex.removeMacro("asyncMacro")
-        with self.assertRaises(Exception):
-            await reflex.callMethod("asyncMacro", reflex._instance, 3)