orionis 0.216.0__py3-none-any.whl → 0.218.0__py3-none-any.whl

orionis/framework.py

@@ -5,7 +5,7 @@
 NAME = "orionis"
 
 # Current version of the framework
-VERSION = "0.216.0"
+VERSION = "0.218.0"
 
 # Full name of the author or maintainer of the project
 AUTHOR = "Raul Mauricio Uñate Castro"
@@ -26,7 +26,7 @@ SKELETON = "https://github.com/orionis-framework/skeleton"
 FRAMEWORK = "https://github.com/orionis-framework/framework"
 
 # URL to the project's documentation
-DOCS = "https://github.com/orionis-framework/docs"
+DOCS = "https://orionis-framework.com/"
 
 # API URL to the project's JSON data
 API = "https://pypi.org/pypi/orionis/json"

orionis/luminate/test/test_case.py

@@ -1,5 +1,62 @@
 import unittest
 from orionis.luminate.test.test_std_out import TestStdOut
 
-class TestCase(unittest.TestCase, TestStdOut):
+class TestCase(unittest.IsolatedAsyncioTestCase, TestStdOut):
+    """
+    TestCase is a base class for unit tests that provides support for asynchronous
+    testing using `unittest.IsolatedAsyncioTestCase` and additional functionality
+    from `TestStdOut`."""
+    async def asyncSetUp(self):
+        """
+        Asynchronous setup method called before each test.
+        It ensures that the parent class's asyncSetUp method is invoked to initialize
+        any required resources.
+        """
+        await super().asyncSetUp()
+
+    async def asyncTearDown(self):
+        """
+        Asynchronous teardown method called after each test.
+        It ensures that the parent class's asyncTearDown method is invoked to clean up
+        any resources used during the test.
+        """
+        await super().asyncTearDown()
+
+# Another asynchronous test case class
+class TestAsyncCase(unittest.IsolatedAsyncioTestCase, TestStdOut):
+    """
+    TestAsyncCase is a test case class designed for asynchronous unit testing.
+    It inherits from `unittest.IsolatedAsyncioTestCase` to provide support for
+    async test methods and `TestStdOut` for additional functionality.
+    Methods
+    -------
+    asyncSetUp()
+        Asynchronous setup method called before each test. It ensures that the
+        parent class's asyncSetUp method is invoked to initialize any required
+        resources.
+    asyncTearDown()
+        Asynchronous teardown method called after each test. It ensures that the
+        parent class's asyncTearDown method is invoked to clean up any resources
+        used during the test.
+    """
+    async def asyncSetUp(self):
+        """
+        Asynchronous setup method called before each test.
+        It ensures that the parent class's asyncSetUp method is invoked to initialize
+        """
+        await super().asyncSetUp()
+
+    async def asyncTearDown(self):
+        """
+        Asynchronous teardown method called after each test.
+        It ensures that the parent class's asyncTearDown method is invoked to clean up
+        """
+        await super().asyncTearDown()
+
+class TestSyncCase(unittest.TestCase, TestStdOut):
+    """
+    TestSyncCase is a test case class designed for synchronous unit testing.
+    It inherits from `unittest.TestCase` to provide support for standard test methods
+    and `TestStdOut` for additional functionality.
+    """
     pass

orionis/luminate/test/test_std_out.py

@@ -56,7 +56,7 @@ class TestStdOut:
         _line = sys._getframe(1).f_lineno
 
         # Print the contextual information and the provided arguments
-        Console.textMuted(f"[DEBUG] File: {_file}, Line: {_line}, Method: {_method}")
+        Console.textMuted(f"[Printout] File: {_file}, Line: {_line}, Method: {_method}")
         print(*args[1:], end='\n')
         Console.newLine()
 

{orionis-0.216.0.dist-info → orionis-0.218.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: orionis
-Version: 0.216.0
+Version: 0.218.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

{orionis-0.216.0.dist-info → orionis-0.218.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=GQEposKTRMRQV49FKtBLhhmOc6z7-SAsQVK3KpYHHgM,1469
+orionis/framework.py,sha256=RK1Wv5laD8Pqih2kN0_l1D5I2dMrABWjgiXk50-BESk,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
@@ -184,11 +184,11 @@ orionis/luminate/support/standard/std.py,sha256=AlhDc0CXC8_TSfZfkodefl_MwCyauX2E
 orionis/luminate/support/standard/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/support/standard/contracts/std.py,sha256=x9sVir2yg4hve56cCklIdVSr8utruIO_sUdlTNfZ1Ds,3109
 orionis/luminate/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/luminate/test/test_case.py,sha256=jFhNcUZWuDTDFpe_nYJTqXQChA4z5kxu0I2YCONGSVk,134
+orionis/luminate/test/test_case.py,sha256=y3-u3oJtCHLP-DoVW3jan2i96Y78VVdIM1pL7iV0uqU,2508
 orionis/luminate/test/test_exception.py,sha256=21PILTXnMuL5-wT3HGKjIklt8VeIYDcQDN346i-BbJw,1336
 orionis/luminate/test/test_result.py,sha256=Px2_M70r_y7BntRITk_h0IPTbSTW5XhDyklMKHm3JJI,999
 orionis/luminate/test/test_status.py,sha256=vNKRmp1lud_ZGTayf3A8wO_0vEYdFABy_oMw-RcEc1c,673
-orionis/luminate/test/test_std_out.py,sha256=annYLGDkskRpMuLwTAswwrgrYmwsXIyKE02M_ePv-qc,2765
+orionis/luminate/test/test_std_out.py,sha256=evvV3aCIBQaiwCJzM0kFWm6tfpjoTeLUVEXt6x7YOs4,2768
 orionis/luminate/test/test_suite.py,sha256=eg3OwknndYSNCip_f5twpaJSFrBIuKpZQgUwBORblWA,2218
 orionis/luminate/test/test_unit.py,sha256=HtPDWzFXpgFwWYej8z2BArU4k5lItH57K_E-l21MBWo,12070
 orionis/static/ascii/icon.ascii,sha256=IgrlVjcYxcCrr0cJuJkOnEz0aEdAQBTyLzO5ainKsWc,398
@@ -205,11 +205,11 @@ tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/test_example.py,sha256=8EYjl1b-J_479dmJdQoAcKCKr7JUydW7EmPQpeiF13Y,586
 tests/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/support/inspection/test_reflection_abstract.py,sha256=K78avxUlI_dYKofSvVcuaVLAz-CivWSe3RkhrO-IRcA,9185
-tests/support/inspection/test_reflection_concrete.py,sha256=XEDzYP3Ac0CkjoukPIFeBz2FIXYW0SJV9uAw7aC2e7E,6662
-tests/support/inspection/test_reflection_concrete_with_abstract.py,sha256=G29gqevXQd7TBOluaPpK6ER-24a4uK-zaImamig7cEE,4650
-tests/support/inspection/test_reflection_instance.py,sha256=iwwf-QY-O3kR_HTHdATUnu9iXn6Nat7d8Y8Hxhwfpb0,6938
-tests/support/inspection/test_reflection_instance_with_abstract.py,sha256=RQkw2BYY8TLuk6h_9NIa_5JfRL7RG8004ro252t6YF8,4059
+tests/support/inspection/test_reflection_abstract.py,sha256=6w8vm8H_fR4Z-KYjQGm8bq-HcetlpQl0EsDmDy3WzQ8,9311
+tests/support/inspection/test_reflection_concrete.py,sha256=3BWSU7MkFEv2UgAVAwhiaMrzEwAyDBBJCa6edOENKSU,6782
+tests/support/inspection/test_reflection_concrete_with_abstract.py,sha256=85cV9loDvtLG7sUxD6n_Ja0KV3x8FYakE2Z0W2Iruu8,4680
+tests/support/inspection/test_reflection_instance.py,sha256=8XKkEhboESLG2UaJ-STJ8STe7mUO4YDkKy01kiiGvkI,7197
+tests/support/inspection/test_reflection_instance_with_abstract.py,sha256=l6tidHJUJpWhol-E5GfQEpMZ5gIVZFsegwVtMk8tYhs,4089
 tests/support/inspection/fakes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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
@@ -217,14 +217,14 @@ tests/support/inspection/fakes/fake_reflection_concrete_with_abstract.py,sha256=
 tests/support/inspection/fakes/fake_reflection_instance.py,sha256=G16rZdJWC3L8SGEQkmwktvw4n7IAusIIx9Tm-ZFLcg4,1419
 tests/support/inspection/fakes/fake_reflection_instance_with_abstract.py,sha256=SfL8FuFmr650RlzXTrP4tGMfsPVZLhOxVnBXu_g1POg,1471
 tests/support/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/support/parsers/test_exception_parser.py,sha256=vSbSDAGH0TFIP4C6xfCecOgQYP-Aibqrb3K8ewWig0c,2339
+tests/support/parsers/test_exception_parser.py,sha256=s-ZRbxyr9bs5uis2SM0IN-vCc-AJhWqRnEMIVgeEFXE,2363
 tests/support/parsers/fakes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/parsers/fakes/fake_custom_error.py,sha256=BD8tQPhmIYFYVcaeMpEQ6uK1d6pcU4EGbwRkVfCZp7c,802
 tests/support/standard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/support/standard/test_std.py,sha256=PSM-AXDxvzJurAO7TfLdnq-W1oUMX6bWThNCGJCFAm4,1900
-orionis-0.216.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
-orionis-0.216.0.dist-info/METADATA,sha256=7d93eflVGbnXtk6z9hAKh_o5mdFO7aMYW6dFcxV_QmU,3003
-orionis-0.216.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-orionis-0.216.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
-orionis-0.216.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.216.0.dist-info/RECORD,,
+tests/support/standard/test_std.py,sha256=bJ5LV_OKEEZa_Bk3PTk9Kapk6qECLzcKf0hfR_x2QqM,2042
+orionis-0.218.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.218.0.dist-info/METADATA,sha256=SM6DhkD76pXjmZj6q4FSH1xUfHAsYoyl3ClHuNCt1nU,3003
+orionis-0.218.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+orionis-0.218.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
+orionis-0.218.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.218.0.dist-info/RECORD,,

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

tests/support/standard/test_std.py

@@ -3,54 +3,58 @@ from orionis.luminate.test.test_case import TestCase
 
 class TestStdClass(TestCase):
 
-    def testInitializationAndAccess(self):
-        obj = StdClass(name='Raul', age=30)
-        self.assertEqual(obj.name, 'Raul')
-        self.assertEqual(obj.age, 30)
-
-    def testToDictReturnsCorrectData(self):
+    async def testInitializationAndAccess(self):
+        obj = StdClass(
+            first_name='Raul',
+            last_name='Uñate',
+            age=31
+        )
+        self.assertEqual(obj.first_name, 'Raul')
+        self.assertEqual(obj.age, 31)
+
+    async def testToDictReturnsCorrectData(self):
         obj = StdClass(a=1, b=2)
         expected = {'a': 1, 'b': 2}
         self.assertEqual(obj.toDict(), expected)
 
-    def testUpdateAttributes(self):
+    async def testUpdateAttributes(self):
         obj = StdClass()
         obj.update(foo='bar', number=42)
         self.assertEqual(obj.foo, 'bar')
         self.assertEqual(obj.number, 42)
 
-    def testUpdateReservedAttributeRaisesError(self):
+    async def testUpdateReservedAttributeRaisesError(self):
         obj = StdClass()
         with self.assertRaises(ValueError):
             obj.update(__init__='bad')
 
-    def testUpdateConflictingAttributeRaisesError(self):
+    async def testUpdateConflictingAttributeRaisesError(self):
         obj = StdClass()
         with self.assertRaises(ValueError):
             obj.update(toDict='oops')
 
-    def testRemoveExistingAttributes(self):
+    async def testRemoveExistingAttributes(self):
         obj = StdClass(x=1, y=2)
         obj.remove('x')
         self.assertFalse(hasattr(obj, 'x'))
         self.assertTrue(hasattr(obj, 'y'))
 
-    def testRemoveNonExistingAttributeRaisesError(self):
+    async def testRemoveNonExistingAttributeRaisesError(self):
         obj = StdClass()
         with self.assertRaises(AttributeError):
             obj.remove('not_there')
 
-    def testFromDictCreatesEquivalentInstance(self):
+    async def testFromDictCreatesEquivalentInstance(self):
         data = {'a': 10, 'b': 20}
         obj = StdClass.from_dict(data)
         self.assertEqual(obj.toDict(), data)
 
-    def testReprAndStr(self):
+    async def testReprAndStr(self):
         obj = StdClass(x=5)
         self.assertIn("StdClass", repr(obj))
         self.assertIn("'x': 5", str(obj))
 
-    def testEquality(self):
+    async def testEquality(self):
         a = StdClass(x=1, y=2)
         b = StdClass(x=1, y=2)
         c = StdClass(x=3)