orionis 0.312.0__py3-none-any.whl → 0.314.0__py3-none-any.whl

orionis/test/suite/test_unit.py

@@ -140,6 +140,7 @@ class UnitTest(IUnitTest):
 
     def configure(
             self,
+            *,
             verbosity: int = None,
             execution_mode: str | ExecutionMode = None,
             max_workers: int = None,
@@ -210,6 +211,7 @@ class UnitTest(IUnitTest):
 
     def discoverTestsInFolder(
         self,
+        *,
         folder_path: str,
         base_path: str = "tests",
         pattern: str = "test_*.py",
@@ -281,7 +283,7 @@ class UnitTest(IUnitTest):
         except Exception as e:
             raise OrionisTestValueError(f"Unexpected error discovering tests: {str(e)}")
 
-    def discoverTestsInModule(self, module_name: str, test_name_pattern: Optional[str] = None) -> 'UnitTest':
+    def discoverTestsInModule(self, *, module_name: str, test_name_pattern: Optional[str] = None) -> 'UnitTest':
         """
         Discovers and loads tests from a specified module, optionally filtering by a test name pattern, and adds them to the test suite.
 
@@ -1129,15 +1131,22 @@ class UnitTest(IUnitTest):
         and ensuring that each test appears only once in the resulting list.
         """
         tests = []
-        seen = set()
+        seen_ids = set()
 
         def _flatten(item):
             if isinstance(item, unittest.TestSuite):
                 for sub_item in item:
                     _flatten(sub_item)
-            elif item not in seen:
-                seen.add(item)
-                tests.append(item)
+            elif hasattr(item, "id"):
+                test_id = item.id()
+                parts = test_id.split('.')
+                if len(parts) >= 2:
+                    short_id = '.'.join(parts[-2:])
+                else:
+                    short_id = test_id
+                if short_id not in seen_ids:
+                    seen_ids.add(short_id)
+                    tests.append(item)
 
         _flatten(suite)
         return tests
@@ -1404,8 +1413,6 @@ class UnitTest(IUnitTest):
         """
         if self.__output_buffer:
             print(self.__output_buffer)
-        else:
-            print("No output buffer available.")
 
     def getErrorBuffer(self) -> int:
         """
@@ -1424,6 +1431,4 @@ class UnitTest(IUnitTest):
         This method retrieves the error buffer and prints its contents using the rich console.
         """
         if self.__error_buffer:
-            print(self.__error_buffer)
-        else:
-            print("No error buffer available.")
+            print(self.__error_buffer)

{orionis-0.312.0.dist-info → orionis-0.314.0.dist-info}/METADATA

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

{orionis-0.312.0.dist-info → orionis-0.314.0.dist-info}/RECORD

@@ -135,11 +135,11 @@ orionis/console/output/console.py,sha256=TE_Hl720ADd82dbERFSWhkoQRukDQZmETSw4nkw
 orionis/console/output/executor.py,sha256=bdvkzW2-buy0BPpy2r5qUGrRFW2Ay6k-5rSeHb0gQ3o,3352
 orionis/console/output/progress_bar.py,sha256=vFy582z6VJS46LV6tuyrmr9qvdVeTEtw3hyNcEHezeg,3088
 orionis/console/output/styles.py,sha256=6a4oQCOBOKMh2ARdeq5GlIskJ3wjiylYmh66tUKKmpQ,4053
-orionis/container/container.py,sha256=eP2YEf2UdllDFbfPPB4ILcdVQBd5kgHyWZkdttfsp1s,928
+orionis/container/container.py,sha256=bUpUV_4_Zi5vpj7R86glNVB0iLQk67qXJAe1uEfhgKM,19474
 orionis/container/enums/lifetimes.py,sha256=RqQmugMIB1Ev_j_vFLcWorndm-to7xg4stQ7yKFDdDw,190
-orionis/container/exceptions/container_exception.py,sha256=cmoiDR2LvQ4AnxxZL-F3JdeI18ux7CzKmsCki98DAEk,585
-orionis/container/exceptions/type_error_exception.py,sha256=M7I64T5wBtHzLRyvrdP4dEzF2N3UzbOAnQmpyKy9aWo,547
-orionis/container/exceptions/value_exception.py,sha256=FSFsoG_piErEs-OOCtDrdDY02bPIOdNy4-rbJ8qPNHg,565
+orionis/container/exceptions/container_exception.py,sha256=goTDEwC70xTMD2qppN8KV-xyR0Nps218OD4D1LZ2-3s,470
+orionis/container/exceptions/type_error_exception.py,sha256=cYuvoXVOgRYj3tZPfK341aUERkf33-buOiI2eXxcrAw,470
+orionis/container/exceptions/value_exception.py,sha256=hjY0YEusoL3DurME1ornxvIv1wyGaf6tBggLFlGHblo,472
 orionis/foundation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/config/startup.py,sha256=JKAH2ZRhlAZgkD2w11LR1-TVktfjSH9cHo3PsZXOLrg,8275
@@ -231,7 +231,7 @@ orionis/foundation/contracts/config.py,sha256=Rpz6U6t8OXHO9JJKSTnCimytXE-tfCB-1i
 orionis/foundation/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/foundation/exceptions/integrity.py,sha256=mc4pL1UMoYRHEmphnpW2oGk5URhu7DJRREyzHaV-cs8,472
 orionis/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/metadata/framework.py,sha256=OY1y-roZUBYR9Du8KyC-jHXB-GPu8Sjj9j-gB99J0hQ,4960
+orionis/metadata/framework.py,sha256=TeS7Xb6-ikiXXQ64K1gd_KmswDCfsqNDRvkEd0sR0ZQ,4960
 orionis/metadata/package.py,sha256=tqLfBRo-w1j_GN4xvzUNFyweWYFS-qhSgAEc-AmCH1M,5452
 orionis/patterns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/patterns/singleton/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -254,11 +254,11 @@ orionis/services/environment/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5J
 orionis/services/environment/exceptions/environment_value_error.py,sha256=Pe1qNHRrM9T0AzESN284CzA3GQYxzokfXPMOVqOTlyQ,475
 orionis/services/environment/exceptions/environment_value_exception.py,sha256=NnxWmgoSca7LXi7GLDa95HSBPKotFfy8u729d1OAmCc,479
 orionis/services/introspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/introspection/reflection.py,sha256=AI5ZMv9kHCLOQe9lL_G7wAeY3cPLKZ1FMYqIhU0yS-M,2972
+orionis/services/introspection/reflection.py,sha256=6z4VkDICohMIkm9jEd7nmFABwVuU7SBoTFaH3tq4PGk,10897
 orionis/services/introspection/abstract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/introspection/abstract/reflection_abstract.py,sha256=O8fK2a7X82VOK4Pt2Zv6Mt0wsxezLFTyb1JVu9ApCVc,43327
+orionis/services/introspection/abstract/reflection_abstract.py,sha256=SPK2X11VvGORxxPOYloaD6hPAvky--obRU4CO1DE4zM,43865
 orionis/services/introspection/concretes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/introspection/concretes/reflection_concrete.py,sha256=dhZHzMcGNXzxinWOf8gdeD1h2bUgqrLgw00qdAcor2U,49755
+orionis/services/introspection/concretes/reflection_concrete.py,sha256=1GxD-y8LPGL6kI4Y3XbeLcFjR5Y8cOqbVEPCtPnsuYA,50982
 orionis/services/introspection/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/introspection/contracts/reflect_dependencies.py,sha256=5fdImZarC1ixoFM-1JSBx28RvYbY3GGZhDGjar7cvHc,1771
 orionis/services/introspection/contracts/reflection_abstract.py,sha256=-ugpFcAkGTlk0Md5ft8NrvupnlfVji8QZjGYqWBxqeY,22370
@@ -276,7 +276,7 @@ orionis/services/introspection/exceptions/reflection_attribute_error.py,sha256=_
 orionis/services/introspection/exceptions/reflection_type_error.py,sha256=73DB8JoTbxd7LNMnZKXf4jJ8OzLyC0HPXgDo5pffkYY,466
 orionis/services/introspection/exceptions/reflection_value_error.py,sha256=ywO_cwawEmB22uP3i4ofsZytO9QTbvy7axm9NzEfHr4,467
 orionis/services/introspection/instances/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/services/introspection/instances/reflection_instance.py,sha256=89sgsV059H5CeoIuJQBeARujNwl6uXwqxyy5HBfjKV4,51929
+orionis/services/introspection/instances/reflection_instance.py,sha256=DrPrzdm7FbnUj6h6970hJOyFfit-OpWskZ4FnxJMz6k,54053
 orionis/services/introspection/modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/services/introspection/modules/reflection_module.py,sha256=1QB_853_ct5ehDNSxNQaaJDCeY9eXciXJwRYkNHgYd4,15632
 orionis/services/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -335,10 +335,10 @@ orionis/test/logs/history.py,sha256=eAEPWpubs1fFzL-0o8K82hd2lC0S98VOu1AEblCmjYI,
 orionis/test/output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/output/dumper.py,sha256=q1_S5AYMce01ukPkEJ73gQT7gyLBK5XA1NyOeVINQMI,4280
 orionis/test/suite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-orionis/test/suite/test_unit.py,sha256=5UTdCYmD_Yz8asaBF54RHOx0kjwjLjEhkyPDoDIxk-k,57049
+orionis/test/suite/test_unit.py,sha256=wKqbLmkz1t0ilhLU6vz9ThCfURTM5hPQBLFTDC_vcII,57254
 orionis/test/view/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/test/view/render.py,sha256=jXZkbITBknbUwm_mD8bcTiwLDvsFkrO9qrf0ZgPwqxc,4903
-orionis-0.312.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.314.0.dist-info/licenses/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/example/test_example.py,sha256=kvWgiW3ADEZf718dGsMPtDh_rmOSx1ypEInKm7_6ZPQ,601
@@ -407,6 +407,7 @@ tests/services/asynchrony/test_services_asynchrony_coroutine.py,sha256=azlDv29Q9
 tests/services/environment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/environment/test_services_environment.py,sha256=fdkjwbY-aDEA1FT-9vBT5ihwaCdg_-UgAx--kQXFPGA,3745
 tests/services/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/services/inspection/test_reflection.py,sha256=ZApQeaDxYLsrfGN6UqEDPbyNzocMV9CURflQ35YMfqk,13678
 tests/services/inspection/dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/services/inspection/dependencies/test_reflect_dependencies.py,sha256=z0C9KkhV27Y7jKpLSCN9XCmHbjJDCPbBb7NkRFs3oMI,5803
 tests/services/inspection/dependencies/mocks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -436,9 +437,9 @@ tests/support/wrapper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 tests/support/wrapper/test_services_wrapper_docdict.py,sha256=yeVwl-VcwkWSQYyxZu3qfqT7YtP8LIEJgHo2ejzISh0,4984
 tests/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/testing/test_testing_result.py,sha256=MrGK3ZimedL0b5Ydu69Dg8Iul017AzLTm7VPxpXlpfU,4315
-tests/testing/test_testing_unit.py,sha256=A6QkiOkP7GPC1Szh_GqsrV7GxjWjK8cIwFez6YfrzmM,7683
-orionis-0.312.0.dist-info/METADATA,sha256=9Js6d3O7wPFOdIXfLXomApm1mBjD6r556KQQEejCwZM,4772
-orionis-0.312.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-orionis-0.312.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.312.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-orionis-0.312.0.dist-info/RECORD,,
+tests/testing/test_testing_unit.py,sha256=9flen4fNMSFWrZUzGyUq8Sd0wwRlj1BgnrRyJVn_uQs,7695
+orionis-0.314.0.dist-info/METADATA,sha256=00zT_BZNttTEU5W9ufDdJNoXUkL4eCAR32wyIVjRrz0,4772
+orionis-0.314.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+orionis-0.314.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.314.0.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+orionis-0.314.0.dist-info/RECORD,,

tests/services/inspection/test_reflection.py

@@ -0,0 +1,462 @@
+from orionis.services.introspection.reflection import Reflection
+from orionis.unittesting import TestCase
+import sys
+import inspect
+import abc
+
+class TestServiceReflectionAbstract(TestCase):
+
+    async def testIsAbstract(self):
+        """
+        Test Reflection.isAbstract for abstract and concrete classes.
+
+        Parameters
+        ----------
+        None
+
+        Tests
+        -----
+        - DummyAbstract: An abstract class using abc.ABCMeta with an abstract method.
+        - DummyConcrete: A regular concrete class.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Reflection.isAbstract(DummyAbstract) returns True.
+        - Reflection.isAbstract(DummyConcrete) returns False.
+        """
+        class DummyAbstract(metaclass=abc.ABCMeta):
+            @abc.abstractmethod
+            def foo(self):
+                pass
+
+        class DummyConcrete:
+            def bar(self):
+                return 42
+
+        self.assertTrue(Reflection.isAbstract(DummyAbstract))
+        self.assertFalse(Reflection.isAbstract(DummyConcrete))
+
+    async def testIsAsyncGen(self):
+        """
+        Test Reflection.isAsyncGen for correct identification of asynchronous generators.
+
+        Notes
+        -----
+        - The asynchronous generator is defined using `async def` and `yield`.
+        - The regular generator is defined using `def` and `yield`.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Reflection.isAsyncGen(agen) is True.
+        - Reflection.isAsyncGen(dummy_generator()) is False.
+        """
+        async def dummy_asyncgen():
+            yield 1
+
+        def dummy_generator():
+            yield 1
+
+        agen = dummy_asyncgen()
+        self.assertTrue(Reflection.isAsyncGen(agen))
+        self.assertFalse(Reflection.isAsyncGen(dummy_generator()))
+
+    async def testIsAsyncGenFunction(self):
+        """
+        Test Reflection.isAsyncGenFunction for correct identification of async generator functions.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Reflection.isAsyncGenFunction(dummy_asyncgen) returns True.
+        - Reflection.isAsyncGenFunction(dummy_generator) returns False.
+        """
+        async def dummy_asyncgen():
+            yield 1
+
+        def dummy_generator():
+            yield 1
+
+        self.assertTrue(Reflection.isAsyncGenFunction(dummy_asyncgen))
+        self.assertFalse(Reflection.isAsyncGenFunction(dummy_generator))
+
+    async def testIsAwaitable(self):
+        """
+        Test Reflection.isAwaitable to verify correct identification of awaitable objects.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - An async coroutine object is recognized as awaitable.
+        - A non-awaitable object (e.g., an integer) is not recognized as awaitable.
+        """
+        async def dummy_coroutine():
+            pass
+
+        coro = dummy_coroutine()
+        self.assertTrue(Reflection.isAwaitable(coro))
+        self.assertFalse(Reflection.isAwaitable(42))
+
+    async def testIsBuiltin(self):
+        """
+        Test Reflection.isBuiltin to verify correct identification of built-in functions.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - The built-in function `len` is recognized as built-in.
+        - A user-defined function is not recognized as built-in.
+        """
+        def dummy_function():
+            pass
+
+        self.assertTrue(Reflection.isBuiltin(len))
+        self.assertFalse(Reflection.isBuiltin(dummy_function))
+
+    async def testIsClass(self):
+        """
+        Test Reflection.isClass to verify correct identification of classes and non-class objects.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Reflection.isClass returns True for a class.
+        - Reflection.isClass returns False for a function.
+        """
+        class DummyConcrete:
+            def bar(self):
+                return 42
+
+        def dummy_function():
+            pass
+
+        self.assertTrue(Reflection.isClass(DummyConcrete))
+        self.assertFalse(Reflection.isClass(dummy_function))
+
+    async def testIsCode(self):
+        """
+        Test Reflection.isCode to verify correct identification of code objects.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Passing a function's __code__ attribute returns True.
+        - Passing the function itself returns False.
+        """
+        def dummy_function():
+            pass
+
+        self.assertTrue(Reflection.isCode(dummy_function.__code__))
+        self.assertFalse(Reflection.isCode(dummy_function))
+
+    async def testIsCoroutine(self):
+        """
+        Test Reflection.isCoroutine to ensure correct identification of coroutine objects.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Reflection.isCoroutine returns True for a coroutine object.
+        - Reflection.isCoroutine returns False for a regular function.
+        """
+        async def dummy_coroutine():
+            pass
+
+        def dummy_function():
+            pass
+
+        coro = dummy_coroutine()
+        self.assertTrue(Reflection.isCoroutine(coro))
+        self.assertFalse(Reflection.isCoroutine(dummy_function))
+
+    async def testIsCoroutineFunction(self):
+        """
+        Test Reflection.isCoroutineFunction to verify correct identification of coroutine functions.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Reflection.isCoroutineFunction(dummy_coroutine) returns True.
+        - Reflection.isCoroutineFunction(dummy_function) returns False.
+        """
+        async def dummy_coroutine():
+            pass
+
+        def dummy_function():
+            pass
+
+        self.assertTrue(Reflection.isCoroutineFunction(dummy_coroutine))
+        self.assertFalse(Reflection.isCoroutineFunction(dummy_function))
+
+    async def testIsDataDescriptor(self):
+        """
+        Test Reflection.isDataDescriptor to verify correct identification of data descriptors.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - A property object is recognized as a data descriptor.
+        - A non-descriptor object (such as an integer) is not.
+        """
+        class X:
+            @property
+            def foo(self): return 1
+
+        self.assertTrue(Reflection.isDataDescriptor(X.__dict__['foo']))
+        self.assertFalse(Reflection.isDataDescriptor(42))
+
+    async def testIsFrame(self):
+        """
+        Test Reflection.isFrame to verify correct identification of frame objects.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Reflection.isFrame returns True for a valid frame object.
+        - Reflection.isFrame returns False for a non-frame object.
+        """
+        frame = inspect.currentframe()
+        self.assertTrue(Reflection.isFrame(frame))
+        self.assertFalse(Reflection.isFrame(42))
+
+    async def testIsFunction(self):
+        """
+        Test Reflection.isFunction to verify correct identification of functions.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - A standalone function is correctly identified as a function.
+        - An unbound method is not identified as a function.
+        """
+        def dummy_function():
+            pass
+
+        class DummyConcrete:
+            def bar(self):
+                return 42
+
+        self.assertTrue(Reflection.isFunction(dummy_function))
+        # Unbound methods in Python 3 are just functions, so this should be True
+        self.assertTrue(Reflection.isFunction(DummyConcrete.bar))
+
+    async def testIsGenerator(self):
+        """
+        Test Reflection.isGenerator to verify correct identification of generator objects.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Reflection.isGenerator returns True for a generator object.
+        - Reflection.isGenerator returns False for a regular function.
+        """
+        def dummy_generator():
+            yield 1
+
+        def dummy_function():
+            pass
+
+        gen = dummy_generator()
+        self.assertTrue(Reflection.isGenerator(gen))
+        self.assertFalse(Reflection.isGenerator(dummy_function))
+
+    async def testIsGeneratorFunction(self):
+        """
+        Test Reflection.isGeneratorFunction to verify correct identification of generator functions.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Reflection.isGeneratorFunction(dummy_generator) returns True.
+        - Reflection.isGeneratorFunction(dummy_function) returns False.
+        """
+        def dummy_generator():
+            yield 1
+
+        def dummy_function():
+            pass
+
+        self.assertTrue(Reflection.isGeneratorFunction(dummy_generator))
+        self.assertFalse(Reflection.isGeneratorFunction(dummy_function))
+
+    async def testIsGetSetDescriptor(self):
+        """
+        Test Reflection.isGetSetDescriptor to verify correct identification of get-set descriptors.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Reflection.isGetSetDescriptor returns True for a known get-set descriptor.
+        - Reflection.isGetSetDescriptor returns False for a non-descriptor object.
+        """
+        self.assertTrue(Reflection.isGetSetDescriptor(type.__dict__['__dict__']))
+        self.assertFalse(Reflection.isGetSetDescriptor(42))
+
+    async def testIsMemberDescriptor(self):
+        """
+        Test Reflection.isMemberDescriptor to verify correct identification of member descriptors.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - type.__dict__['__weakref__'] is recognized as a member descriptor.
+        - An integer is not recognized as a member descriptor.
+        """
+        # Use an alternative member descriptor: use a slot from a new-style class
+        class Y:
+            __slots__ = ('foo',)
+        self.assertTrue(Reflection.isMemberDescriptor(Y.__dict__['foo']))
+        self.assertFalse(Reflection.isMemberDescriptor(42))
+        self.assertFalse(Reflection.isMemberDescriptor(42))
+
+    async def testIsMethod(self):
+        """
+        Test Reflection.isMethod to verify correct identification of methods.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Reflection.isMethod returns True for a class method.
+        - Reflection.isMethod returns False for a standalone function.
+        """
+        class DummyConcrete:
+            def bar(self):
+                return 42
+
+        obj = DummyConcrete()
+        def dummy_function():
+            pass
+
+        self.assertTrue(Reflection.isMethod(obj.bar))
+        self.assertFalse(Reflection.isMethod(dummy_function))
+
+    async def testIsMethodDescriptor(self):
+        """
+        Test Reflection.isMethodDescriptor to verify correct identification of method descriptors.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Reflection.isMethodDescriptor(str.upper) returns True.
+        - Reflection.isMethodDescriptor(dummy_function) returns False.
+        """
+        def dummy_function():
+            pass
+
+        self.assertTrue(Reflection.isMethodDescriptor(str.upper))
+        self.assertFalse(Reflection.isMethodDescriptor(dummy_function))
+
+    async def testIsModule(self):
+        """
+        Test Reflection.isModule to verify correct identification of module objects.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Reflection.isModule returns True for a module (e.g., sys).
+        - Reflection.isModule returns False for a non-module (e.g., a function).
+        """
+        def dummy_function():
+            pass
+
+        self.assertTrue(Reflection.isModule(sys))
+        self.assertFalse(Reflection.isModule(dummy_function))
+
+    async def testIsRoutine(self):
+        """
+        Test Reflection.isRoutine to verify correct identification of routine objects.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - A user-defined function is recognized as a routine.
+        - A built-in function is recognized as a routine.
+        - A non-routine object is not recognized as a routine.
+        """
+        def dummy_function():
+            pass
+
+        self.assertTrue(Reflection.isRoutine(dummy_function))
+        self.assertTrue(Reflection.isRoutine(len))
+        self.assertFalse(Reflection.isRoutine(42))
+
+    async def testIsTraceback(self):
+        """
+        Test Reflection.isTraceback to verify correct identification of traceback objects.
+
+        Returns
+        -------
+        None
+
+        Asserts
+        -------
+        - Reflection.isTraceback returns True for a traceback object.
+        - Reflection.isTraceback returns False for a non-traceback object.
+        """
+        try:
+            raise Exception("test")
+        except Exception:
+            tb = sys.exc_info()[2]
+        self.assertTrue(Reflection.isTraceback(tb))
+        self.assertFalse(Reflection.isTraceback(42))

tests/testing/test_testing_unit.py

@@ -76,7 +76,7 @@ class TestTestingUnit(TestCase):
         unit_test = UnitTest()
         with patch.object(unit_test.loader, 'loadTestsFromName') as mock_load:
             mock_load.return_value = StandardTestSuite()
-            result = unit_test.discoverTestsInModule('test_module')
+            result = unit_test.discoverTestsInModule(module_name='test_module')
 
             mock_load.assert_called_once_with('test_module')
             self.assertEqual(result, unit_test)