orionis 0.239.0__py3-none-any.whl → 0.240.0__py3-none-any.whl

{orionis-0.239.0.dist-info → orionis-0.240.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 orionis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console.py,sha256=4gYWxf0fWYgJ4RKwARvnTPh06FL3GJ6SAZ7R2NzOICw,1342
-orionis/framework.py,sha256=a8rdKyqZ5yYihxhZIXy4bN9OGy4mNa0IymqdAvl-Gbc,1458
+orionis/framework.py,sha256=G5qsJtJrP_vwcG9n5yrR18nTjlpsC-Ia85Q1mlqjVKY,1458
 orionis/installer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/installer/manager.py,sha256=Li4TVziRXWfum02xNG4JHwbnLk-u8xzHjdqKz-D894k,2755
 orionis/installer/output.py,sha256=7O9qa2xtXMB_4ZvVi-Klneom9YazwygAd_4uYAoxhbU,8548
@@ -166,19 +166,20 @@ orionis/luminate/support/environment/functions.py,sha256=L6gL4z3c89ZU17IWvOXyQ2_
 orionis/luminate/support/environment/helper.py,sha256=G1670w1xkI1pj-rW_inv6D3XmU4oliwnWnrJO5CBm2E,818
 orionis/luminate/support/environment/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/support/environment/contracts/env.py,sha256=buJfzebBOUuq2CnhQCWlnJuzJAEo06-S0_SPR4N_mOY,1647
-orionis/luminate/support/introspection/__init__.py,sha256=s7ZMEnwkCAKNJtNXID4YbWTKTuab8jhqTmkkcmtlO5s,136
+orionis/luminate/support/introspection/__init__.py,sha256=Mf9u1ZQNvC4-Y_Ycl-qIBQr3SoJ315ZBtOb4-JoykxI,108
 orionis/luminate/support/introspection/container_integrity.py,sha256=6d9FsGk-Rm1AXgqBS3Nww49dR7n1ptXTTNyGUuBHgNY,10111
-orionis/luminate/support/introspection/reflect_abstract.py,sha256=vcPy5r33WeyTzFEXGMmGeI7C23_S4nGS_VXBBODAfng,10851
 orionis/luminate/support/introspection/reflect_decorators.py,sha256=fnxnkEcRSU8TxDGdjCNlvXMNHEKzW7AwO_aPOVCbs9w,11548
-orionis/luminate/support/introspection/reflection.py,sha256=gSWNcnHUkM4TbSzt1u_EC17RZQv9BuN8Drei-mFgc6Y,7833
+orionis/luminate/support/introspection/reflection.py,sha256=BVltcTm_0MbD_q2m2f15hSfmU3s-E4tynEX0R7TtXE0,7843
 orionis/luminate/support/introspection/reflexion_concrete.py,sha256=1ISuy2L6Oser-EhmpuGALmbauh7Z-X8Rx1YYgt5CabQ,7543
-orionis/luminate/support/introspection/reflexion_concrete_with_abstract.py,sha256=9DYldzJZcx1fgdDkZsMj63zLVSTPYlhygphRjAtJY3k,7484
-orionis/luminate/support/introspection/reflexion_instance_with_abstract.py,sha256=Y8TNIzQciR3YCklim9OrxAxZpYOS0HKxEpEf8-kTAvE,9424
+orionis/luminate/support/introspection/reflexion_concrete_with_abstract.py,sha256=kChzEBIoHW3U96UaonGxlDjdgiC-FqBdmqgHmS11FAI,7494
+orionis/luminate/support/introspection/reflexion_instance_with_abstract.py,sha256=E38t6BHgzSkgFTlg64fgaV-U3vtdqbj3nkgrA4S4G4w,9434
 orionis/luminate/support/introspection/reflexion_module.py,sha256=OgBXpqNJHkmq-gX4rqFStv-WVNe9R38RsgUgfHpak8k,405
 orionis/luminate/support/introspection/reflexion_module_with_classname.py,sha256=YZHZI0XUZkSWnq9wrGxrIXtI64nY9yVSZoMe7PZXq8Y,620
+orionis/luminate/support/introspection/abstracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/luminate/support/introspection/abstracts/reflect_abstract.py,sha256=MiLkkX0WIIOoP8vU2hM-4FYS2oNVuqwtGn6Ys0Y9bgE,12761
 orionis/luminate/support/introspection/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/support/introspection/contracts/reflection.py,sha256=zF9OLiEdgWJtJWvfrmWCQhbDjgYmm-QvAkFv9OLb3rE,4959
-orionis/luminate/support/introspection/contracts/reflexion_abstract.py,sha256=u8SiBTvcWltwR9g64akCNCzsTq8YkkZIPPEPwbyroQU,6396
+orionis/luminate/support/introspection/contracts/reflexion_abstract.py,sha256=3m0DTIFpbRyYMcqTPt_qtPdOEpM1Zpx0FbnTAruXPhU,6384
 orionis/luminate/support/introspection/dependencies/__init__.py,sha256=WWSAZWJzc4fhCWVycKMgalFPXzLyUiVc01qhAIm5XBc,149
 orionis/luminate/support/introspection/dependencies/reflect_dependencies.py,sha256=Udg4eUDehJiJNaiZOwGvpomNA2OvEQRwbKQk6OPb1sw,7027
 orionis/luminate/support/introspection/dependencies/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -190,7 +191,9 @@ orionis/luminate/support/introspection/dependencies/entities/resolved_dependenci
 orionis/luminate/support/introspection/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/support/introspection/helpers/functions.py,sha256=JC2_t732LqcJn3zoRZwFAqcm6kT6HvsJmupysjH3aiY,8537
 orionis/luminate/support/introspection/instances/__init__.py,sha256=R6dZ6yPk-4m2IaW74ceM4-Sba52aeAryfmIK4pAVWpc,144
-orionis/luminate/support/introspection/instances/reflection_instance.py,sha256=Ft2rqsPYmhQctCwPjFJIQWwDZ2g4whyYzf_MHsdhL2Q,24248
+orionis/luminate/support/introspection/instances/reflection_instance.py,sha256=Kr9KXI6-XS5do8zldVi039S3iRb9eYHXUiYtLeexXQk,24482
+orionis/luminate/support/introspection/instances/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orionis/luminate/support/introspection/instances/contracts/reflection_instance.py,sha256=m6VEx9ixhTmWHABySuN6cDvs1QVWkIbYfiO6avd0qyQ,16543
 orionis/luminate/support/introspection/instances/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/support/introspection/instances/entities/class_attributes.py,sha256=eQSiqCE_3ai_1FJF7VCJlLVmX3X7lEwD7bsoomd5z80,296
 orionis/luminate/support/introspection/instances/entities/class_method.py,sha256=KHxd5mBCNnbtq6RhNrAk5Wu1VrblJzd629rBXMzBVZ8,473
@@ -247,16 +250,16 @@ tests/support/async_io/test_async_coroutine.py,sha256=rMpjIH3DDjMDIqZkaDGv1q1yGl
 tests/support/environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/environment/test_env.py,sha256=fcMyvGnDnP2qamhG7yDRN9MyUDjeYN-oSmlno2mc7dQ,2652
 tests/support/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/support/inspection/test_reflect_abstract.py,sha256=0qjK1vzDu6jt_F16esoxxMVvYF7s-ThC0oYE_oK7UgA,10590
 tests/support/inspection/test_reflect_dependencies.py,sha256=frROd9NDbzwmEpb7TEOpikshFJKbPN5NvJ62ZWUm11E,3686
-tests/support/inspection/test_reflect_instance.py,sha256=dMSVheTV32y3Faz4kYV803gdN2B4IP944e5wB2RVncs,14065
-tests/support/inspection/test_reflection_abstract.py,sha256=447L7TCQ5-08QKWuzpIlx0EZ9b9LjEOpR5ZMU5N2Kz0,9340
+tests/support/inspection/test_reflect_instance.py,sha256=EJ8hKA1Tkw1f8MHzUGOde71fABvlZ4EtKFBbvRfvQM8,14097
 tests/support/inspection/test_reflection_concrete.py,sha256=OXUG4EDW0Xa8c7TWeUuGdwRc3eQ4hoP67ZGbevg8BdU,6778
 tests/support/inspection/test_reflection_concrete_with_abstract.py,sha256=7QPHwZZOpBaRTlpiXWIQ4DPYQBlnD1-XxNMtjEfMPu4,4673
 tests/support/inspection/test_reflection_instance_with_abstract.py,sha256=GmY2W9S84uFCBIRsEjAAVhWbqWR7ZgOPD-AN8sAmhSM,4082
 tests/support/inspection/fakes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/support/inspection/fakes/fake_reflect_abstract.py,sha256=P1Zp39YNxuCI4G3coNbxqU_lSY9vZnk02UmREJgU5rg,5156
 tests/support/inspection/fakes/fake_reflect_dependencies.py,sha256=TgLnBm31I8CE2qL-BkU_vo2XdBILfF5FvLe9VIr5J_E,797
 tests/support/inspection/fakes/fake_reflect_instance.py,sha256=P5lSFiGPLLAPOIRmw4VE3YWctxlqmXARRiWMSGLrg3E,1382
-tests/support/inspection/fakes/fake_reflection_abstract.py,sha256=7qtz44brfFzE4oNYi9kIsvdWP79nP2FnzSz-0bU__pg,5045
 tests/support/inspection/fakes/fake_reflection_concrete.py,sha256=j6gzsxE3xq5oJ30H_Hm1RsUwEY3jOYBu4sclxtD1ayo,1047
 tests/support/inspection/fakes/fake_reflection_concrete_with_abstract.py,sha256=ibCjrtNM6BMf5Z5VMvat7E6zOAk5g9z--gj4ykKJWY8,2118
 tests/support/inspection/fakes/fake_reflection_instance_with_abstract.py,sha256=SfL8FuFmr650RlzXTrP4tGMfsPVZLhOxVnBXu_g1POg,1471
@@ -270,9 +273,9 @@ tests/support/patterns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 tests/support/patterns/test_singleton.py,sha256=I0Cawq0C5mV5v2I1mLmxJeXw9Vt3B1iq1RgLePsG30I,624
 tests/support/standard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/standard/test_std.py,sha256=g_iU9Pa6W9XDnxwdLB_NAmD60547VAReXe_Vhyrhf4M,2032
-orionis-0.239.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
-orionis-0.239.0.dist-info/METADATA,sha256=rvQpEXgngwz2BFcgvDP1iI37nlDNFh3wz2zsnjDLCtg,3003
-orionis-0.239.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-orionis-0.239.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
-orionis-0.239.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.239.0.dist-info/RECORD,,
+orionis-0.240.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.240.0.dist-info/METADATA,sha256=3-_Vp-syEwf7m3x9fCRqyOw5IkYM1rDR_YsXvEIxAPE,3003
+orionis-0.240.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+orionis-0.240.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
+orionis-0.240.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.240.0.dist-info/RECORD,,

tests/support/inspection/fakes/{fake_reflection_abstract.py → fake_reflect_abstract.py}

@@ -73,6 +73,8 @@ class FakeAbstractClass(ABC):
     """
 
     class_attr: str = "class_value"
+    _portected_class_attr: str = "protected_class_attr"
+    __private_class_attr: str = "private_class_attr"
 
     @abstractmethod
     def abstract_method(self, x: int, y: int) -> int:

tests/support/inspection/test_reflect_abstract.py

@@ -0,0 +1,273 @@
+from abc import ABC
+from orionis.luminate.support.introspection.reflection import Reflection
+from orionis.luminate.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.print(attributes)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    # 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

@@ -37,6 +37,7 @@ class TestReflectInstance(TestCase):
         """Check that getAllAttributes returns all attributes of the class."""
         reflex = Reflection.instance(FakeClass())
         attributes = reflex.getAllAttributes()
+        self.print(attributes)
         self.assertTrue("public_attr" in attributes.public)
         self.assertTrue("__private_attr" in attributes.private)
         self.assertTrue("_protected_attr" in attributes.protected)

tests/support/inspection/test_reflection_abstract.py

@@ -1,255 +0,0 @@
-from abc import ABC
-from orionis.luminate.support.introspection.reflection import Reflection
-from orionis.luminate.test import TestCase
-from tests.support.inspection.fakes.fake_reflection_abstract import FakeAbstractClass
-
-class TestReflexionAbstract(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_reflection_abstract')
-        self.assertIsInstance(module_name, str)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    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')