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

tests/support/inspection/test_reflection_concrete.py

@@ -1,142 +0,0 @@
-from orionis.support.introspection.reflection import Reflection
-from orionis.support.introspection.reflexion_concrete import ReflexionConcrete
-from orionis.test import TestCase
-from tests.support.inspection.fakes.fake_reflection_concrete import BaseExample, FakeExample
-
-class TestReflectionConcrete(TestCase):
-    """
-    Unit tests for the Reflection class.
-    """
-
-    async def testReflectionConcreteExceptionValueError(self):
-        """Ensure Reflection.instance raises ValueError for invalid types."""
-        with self.assertRaises(ValueError):
-            Reflection.concrete(str)
-
-    async def testReflectionConcrete(self):
-        """Verify Reflection.instance returns an instance of ReflexionInstance."""
-        self.assertIsInstance(Reflection.concrete(FakeExample), ReflexionConcrete)
-
-    async def testReflectionConcreteGetClassName(self):
-        """Test getClassName method."""
-        reflection = Reflection.concrete(FakeExample)
-        self.assertEqual(reflection.getClassName(), "FakeExample")
-
-    async def testReflectionConcreteGetClass(self):
-        """Test getClass method."""
-        reflection = Reflection.concrete(FakeExample)
-        self.assertEqual(reflection.getClass(), FakeExample)
-
-    async def testReflectionConcreteGetModuleName(self):
-        """Test getModuleName method."""
-        reflection = Reflection.concrete(FakeExample)
-        self.assertEqual(reflection.getModuleName(), "tests.support.inspection.fakes.fake_reflection_concrete")
-
-    async def testReflectionConcreteGetAttributes(self):
-        """Test getAttributes method."""
-        reflection = Reflection.concrete(FakeExample)
-        self.assertEqual(reflection.getAttributes(), {'class_attr': 42, 'another_attr': 'hello'})
-
-    async def testReflectionConcreteGetMethods(self):
-        """Test getMethods method."""
-        reflection = Reflection.concrete(FakeExample)
-        expected_methods = [
-            'baseMethod',
-            'method_one',
-            'method_two',
-            'static_method',
-        ]
-        self.assertEqual(reflection.getMethods(), expected_methods)
-
-    async def testReflectionConcreteGetStaticMethods(self):
-        """Test getStaticMethods method."""
-        reflection = Reflection.concrete(FakeExample)
-        expected_static_methods = [
-            'static_method'
-        ]
-        self.assertEqual(reflection.getStaticMethods(), expected_static_methods)
-
-    async def testReflectionConcreteGetPropertyNames(self):
-        """Test getPropertyNames method."""
-        reflection = Reflection.concrete(FakeExample)
-        expected_properties = [
-            'prop',
-            'prop_with_getter',
-        ]
-        self.assertEqual(reflection.getPropertyNames(), expected_properties)
-
-    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')
-
-    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')
-
-    async def testReflectionConcreteGetDocstring(self):
-        """Test getDocstring method."""
-        reflection = Reflection.concrete(FakeExample)
-        self.assertIn('This is a fake example class for testing reflection', reflection.getDocstring())
-
-    async def testReflectionConcreteGetBaseClasses(self):
-        """Test getBaseClasses method."""
-        reflection = Reflection.concrete(FakeExample)
-        self.assertEqual(reflection.getBaseClasses(), (BaseExample,))
-
-    async def testReflectionConcreteIsSubclassOf(self):
-        """Test isSubclassOf method."""
-        reflection = Reflection.concrete(FakeExample)
-        self.assertTrue(reflection.isSubclassOf(BaseExample))
-        self.assertFalse(reflection.isSubclassOf(str))
-
-    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)
-
-    async def testReflectionConcreteGetFileLocation(self):
-        """Test getFileLocation method."""
-        reflection = Reflection.concrete(FakeExample)
-        file_location = reflection.getFileLocation()
-        self.assertIn('tests', file_location)
-        self.assertIn('support', file_location)
-        self.assertIn('inspection', file_location)
-        self.assertIn('fakes', file_location)
-        self.assertIn('fake_reflection_concrete.py', file_location)
-
-    async def testReflectionConcreteGetAnnotations(self):
-        """Test getAnnotations method."""
-        reflection = Reflection.concrete(FakeExample)
-        self.assertEqual(reflection.getAnnotations(), {'class_attr': int})
-
-    async def testReflectionConcreteHasAttribute(self):
-        """Test hasAttribute method."""
-        reflection = Reflection.concrete(FakeExample)
-        self.assertTrue(reflection.hasAttribute('class_attr'))
-        self.assertFalse(reflection.hasAttribute('non_existent_attr'))
-
-    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')
-
-    async def testReflectionConcreteGetCallableMembers(self):
-        """Test getCallableMembers method."""
-        reflection = Reflection.concrete(FakeExample)
-        callable_members = reflection.getCallableMembers()
-        self.assertIn('_private_method', callable_members)
-        self.assertIn('_private_static', callable_members)
-        self.assertIn('baseMethod', callable_members)
-        self.assertIn('class_method', callable_members)
-        self.assertIn('method_one', callable_members)
-        self.assertIn('method_two', callable_members)
-        self.assertIn('static_method', callable_members)

tests/support/inspection/test_reflection_concrete_with_abstract.py

@@ -1,87 +0,0 @@
-from orionis.support.introspection.reflexion_concrete_with_abstract import ReflexionConcreteWithAbstract
-from orionis.test import TestCase
-from tests.support.inspection.fakes.fake_reflection_concrete_with_abstract import AbstractService, PartiallyImplementedService
-
-class TestReflexionConcreteWithAbstract(TestCase):
-
-    async def testReflexionInstanceWithAbstractGetImplementationAnalysis(self):
-        """Test reflexion con AbstractService y PartiallyImplementedService."""
-        inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
-
-        # Get Implementation analysis
-        analysis = inspector.getImplementationAnalysis()
-
-        # Verifying implemented methods
-        self.assertFalse(analysis['configure']['implemented'])
-        self.assertIsNone(analysis['configure']['abstract_signature'])
-        self.assertIsNone(analysis['configure']['concrete_signature'])
-        self.assertFalse(analysis['configure']['signature_match'])
-        self.assertEqual(analysis['configure']['type'], 'method')
-
-        self.assertTrue(analysis['get_logs']['implemented'])
-        self.assertEqual(str(analysis['get_logs']['abstract_signature']), "(self, limit: int = 10) -> List[str]")
-        self.assertEqual(str(analysis['get_logs']['concrete_signature']), "(self, limit: int = 10) -> List[str]")
-        self.assertTrue(analysis['get_logs']['signature_match'])
-        self.assertEqual(analysis['get_logs']['type'], 'method')
-
-        self.assertFalse(analysis['reset']['implemented'])
-        self.assertIsNone(analysis['reset']['abstract_signature'])
-        self.assertIsNone(analysis['reset']['concrete_signature'])
-        self.assertFalse(analysis['reset']['signature_match'])
-        self.assertEqual(analysis['reset']['type'], 'method')
-
-        self.assertTrue(analysis['process']['implemented'])
-        self.assertEqual(str(analysis['process']['abstract_signature']), "(self, data: str) -> bool")
-        self.assertEqual(str(analysis['process']['concrete_signature']), "(self, data: str) -> bool")
-        self.assertTrue(analysis['process']['signature_match'])
-        self.assertEqual(analysis['process']['type'], 'method')
-
-        self.assertFalse(analysis['status']['implemented'])
-        self.assertIsNone(analysis['status']['abstract_signature'])
-        self.assertIsNone(analysis['status']['concrete_signature'])
-        self.assertFalse(analysis['status']['signature_match'])
-        self.assertEqual(analysis['status']['type'], 'property')
-
-    async def testReflexionConcreteWithAbstractGetNonInheritedImplementation(self):
-        """Test reflexion con AbstractService y PartiallyImplementedService."""
-        inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
-
-        # Get Non-Inherited implementation analysis
-        analysis = inspector.getNonInheritedImplementation()
-
-        self.assertIn('extra', analysis['methods'])
-        self.assertListEqual(analysis['properties'], [])
-        self.assertIn('__annotations__', analysis['attributes'])
-
-    async def testReflexionConcreteWithAbstractValidateImplementation(self):
-        """Test reflexion con AbstractService y PartiallyImplementedService."""
-        inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
-
-        # Get Implementation analysis
-        is_valid, issues = inspector.validateImplementation()
-
-        # Verifying implemented methods
-        self.assertFalse(is_valid)
-        self.assertIn('reset', issues['missing'])
-
-    async def testReflexionConcreteWithAbstractGetHierarchyAnalysis(self):
-        """Test reflexion con AbstractService y PartiallyImplementedService."""
-        inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
-
-        # Get Hierarchy analysis
-        analysis = inspector.getHierarchyAnalysis()
-
-        # Verifying implemented methods
-        self.assertEqual(analysis['common_ancestors'], [])
-        self.assertIn('AbstractService', analysis['abstract_hierarchy'])
-        self.assertIn('PartiallyImplementedService', analysis['concrete_hierarchy'])
-
-    async def testReflexionConcreteWithAbstractGetImplementationCoverage(self):
-        """Test reflexion con AbstractService y PartiallyImplementedService."""
-        inspector = ReflexionConcreteWithAbstract(PartiallyImplementedService, AbstractService)
-
-        # Get Implementation coverage
-        coverage = inspector.getImplementationCoverage()
-
-        # Verifying implemented methods
-        self.assertTrue(coverage >= 0.4)

tests/support/inspection/test_reflection_instance_with_abstract.py

@@ -1,79 +0,0 @@
-from orionis.support.introspection.reflexion_instance_with_abstract import ReflexionInstanceWithAbstract
-from orionis.test import TestCase
-from tests.support.inspection.fakes.fake_reflection_instance_with_abstract import FakeDataProcessor, IDataProcessor
-
-class TestReflexionInstanceWithAbstract(TestCase):
-
-    async def testReflexionInstanceWithAbstractGetImplementationAnalysis(self):
-        """Test reflexion con IDataProcessor y FakeDataProcessor."""
-        processor = FakeDataProcessor()
-        inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)
-
-        # Get Implementation analysis
-        analysis = inspector.getImplementationAnalysis()
-
-        # Verifying implemented methods
-        self.assertTrue(analysis['validate_input']['implemented'])
-        self.assertEqual(str(analysis['validate_input']['abstract_signature']), "(self, raw_data: str) -> bool")
-        self.assertEqual(str(analysis['validate_input']['concrete_signature']), "(source: str) -> bool")
-        self.assertFalse(analysis['validate_input']['signature_match'])
-        self.assertEqual(analysis['validate_input']['type'], 'method')
-
-        self.assertTrue(analysis['process']['implemented'])
-        self.assertEqual(str(analysis['process']['abstract_signature']), "(self, data: List[float]) -> Dict[str, float]")
-        self.assertEqual(str(analysis['process']['concrete_signature']), "(values: List[float]) -> Dict[str, float]")
-        self.assertFalse(analysis['process']['signature_match'])
-        self.assertEqual(analysis['process']['type'], 'method')
-
-        self.assertTrue(analysis['config']['implemented'])
-        self.assertEqual(str(analysis['config']['abstract_signature']), "(self) -> Dict[str, str]")
-        self.assertEqual(str(analysis['config']['concrete_signature']), "(self) -> Dict[str, str]")
-        self.assertTrue(analysis['config']['signature_match'])
-        self.assertEqual(analysis['config']['type'], 'property')
-
-    async def testReflexionInstanceWithAbstractGetNonInheritedImplementation(self):
-        """Test reflexion con IDataProcessor y FakeDataProcessor."""
-        processor = FakeDataProcessor()
-        inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)
-
-        # Get Non-Inherited implementation analysis
-        analysis = inspector.getNonInheritedImplementation()
-
-        # Verifying implemented methods
-        self.assertIn('extra_method', analysis['methods'])
-
-    async def testReflexionInstanceWithAbstractValidateImplementation(self):
-        """Test reflexion con IDataProcessor y FakeDataProcessor."""
-        processor = FakeDataProcessor()
-        inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)
-
-        # Get Implementation analysis
-        is_valid, issues = inspector.validateImplementation()
-
-        # Verifying implemented methods
-        self.assertFalse(is_valid)
-        self.assertIn('process', issues['signature_mismatch'])
-
-    async def testReflexionInstanceWithAbstractGetHierarchyAnalysis(self):
-        """Test reflexion con IDataProcessor y FakeDataProcessor."""
-        processor = FakeDataProcessor()
-        inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)
-
-        # Get Hierarchy analysis
-        analysis = inspector.getHierarchyAnalysis()
-
-        # Verifying implemented methods
-        self.assertEqual(analysis['common_ancestors'], [])
-        self.assertIn('IDataProcessor', analysis['abstract_hierarchy'])
-        self.assertIn('FakeDataProcessor', analysis['concrete_hierarchy'])
-
-    async def testReflexionInstanceWithAbstractGetImplementationCoverage(self):
-        """Test reflexion con IDataProcessor y FakeDataProcessor."""
-        processor = FakeDataProcessor()
-        inspector = ReflexionInstanceWithAbstract(processor, IDataProcessor)
-
-        # Get Implementation coverage
-        coverage = inspector.getImplementationCoverage()
-
-        # Verifying implemented methods
-        self.assertTrue(coverage >= 0.66)