Spaces:
Configuration error
Configuration error
| import unittest | |
| from unittest.mock import patch, MagicMock | |
| from datetime import datetime | |
| import json | |
| from introspective_parser_module.parser import ASLMetaParser, IntrospectiveLogger | |
| from introspective_parser_module.models import ( | |
| ASLCognitiveTag, ASLTagModel, MentalStateEnum, | |
| EmotionToneEnum, TemporalContextEnum, AetheroIntrospectiveEntity | |
| ) | |
| from introspective_parser_module.metrics import CognitiveMetricsAnalyzer | |
| from introspective_parser_module.reflection_agent import AetheroReflectionAgent, ReflectionAgent | |
| class TestASLCognitiveTag(unittest.TestCase): | |
| def test_create_valid_tag(self): | |
| tag = ASLCognitiveTag( | |
| thought_stream="Analyzing introspection", | |
| mental_state=MentalStateEnum.REFLECTIVE, | |
| emotion_tone=EmotionToneEnum.NEUTRAL, | |
| temporal_context=TemporalContextEnum.PRESENT, | |
| cognitive_load=5, | |
| certainty_level=0.9, | |
| aeth_mem_link="session_123", | |
| constitutional_law="transparency_principle" | |
| ) | |
| self.assertEqual(tag.mental_state, MentalStateEnum.REFLECTIVE) | |
| self.assertEqual(tag.temporal_context, TemporalContextEnum.PRESENT) | |
| def test_invalid_tag(self): | |
| with self.assertRaises(ValueError): | |
| ASLCognitiveTag( | |
| thought_stream="Invalid introspection", | |
| mental_state="INVALID_STATE", | |
| emotion_tone=EmotionToneEnum.NEUTRAL, | |
| temporal_context=TemporalContextEnum.PRESENT, | |
| cognitive_load=5, | |
| certainty_level=0.9, | |
| aeth_mem_link="session_123", | |
| constitutional_law="transparency_principle" | |
| ) | |
| class TestIntrospectiveLogger(unittest.TestCase): | |
| def setUp(self): | |
| self.logger = IntrospectiveLogger("TestLogger") | |
| def test_log_cognitive_state(self): | |
| with self.assertLogs(self.logger.logger, level="INFO") as log: | |
| self.logger.log_cognitive_state("TEST_OPERATION", {"key": "value"}) | |
| self.assertIn("COGNITIVE_OP: TEST_OPERATION", log.output[0]) | |
| def test_log_introspective_reflection(self): | |
| with self.assertLogs(self.logger.logger, level="INFO") as log: | |
| self.logger.log_introspective_reflection("Test reflection", 0.8) | |
| self.assertIn("REFLECTION: Test reflection", log.output[0]) | |
| class TestParser(unittest.TestCase): | |
| def setUp(self): | |
| self.parser = ASLMetaParser() | |
| def test_parse_line_with_valid_asl(self): | |
| line = "# [ASL] mental_state: reflective, emotion_tone: neutral" | |
| result = self.parser.parse_line(line) | |
| self.assertIn("mental_state", result) | |
| self.assertEqual(result["mental_state"], MentalStateEnum.REFLECTIVE.value) | |
| def test_parse_line_with_invalid_asl(self): | |
| line = "# [ASL] invalid_key: value" | |
| result = self.parser.parse_line(line) | |
| self.assertNotIn("invalid_key", result) | |
| def test_validate_asl_block(self): | |
| asl_components = { | |
| "thought_stream": "Analyzing introspection", | |
| "mental_state": MentalStateEnum.REFLECTIVE.value, | |
| "emotion_tone": EmotionToneEnum.NEUTRAL.value, | |
| "temporal_context": TemporalContextEnum.PRESENT.value, | |
| "cognitive_load": 5, | |
| "certainty_level": 0.9, | |
| "aeth_mem_link": "session_123", | |
| "constitutional_law": "transparency_principle" | |
| } | |
| is_valid, validated_model = self.parser.validate_asl_block(asl_components) | |
| self.assertTrue(is_valid) | |
| self.assertIsNotNone(validated_model) | |
| class TestIntrospectiveLogger(unittest.TestCase): | |
| """Testy pre introspektívny logovací systém""" | |
| def setUp(self): | |
| self.logger = IntrospectiveLogger("TestModule") | |
| def test_cognitive_state_logging(self): | |
| """Test logovania kognitívneho stavu""" | |
| test_context = {"operation": "test", "certainty": 0.8} | |
| # Should not raise exception | |
| self.logger.log_cognitive_state("TEST_OPERATION", test_context) | |
| # Verify logger instance exists | |
| self.assertIsNotNone(self.logger.logger) | |
| self.assertEqual(self.logger.module_name, "TestModule") | |
| def test_introspective_reflection_logging(self): | |
| """Test logovania introspektívnych reflexií""" | |
| self.logger.log_introspective_reflection("Test reflection", 0.9) | |
| # Should complete without error | |
| self.assertTrue(True) | |
| class TestASLCognitiveTagModel(unittest.TestCase): | |
| """Komplexné testy pre ASL kognitívny tag model""" | |
| def setUp(self): | |
| self.valid_tag_data = { | |
| "thought_stream": "Analyzing current system capabilities", | |
| "mental_state": MentalStateEnum.FOCUSED, | |
| "emotion_tone": EmotionToneEnum.ANALYTICAL, | |
| "cognitive_load": 7, | |
| "temporal_context": TemporalContextEnum.PRESENT, | |
| "certainty_level": 0.85, | |
| "aeth_mem_link": "test_memory_link_001", | |
| "constitutional_law": "transparency_principle" | |
| } | |
| def test_valid_cognitive_tag_creation(self): | |
| """Test vytvárania validného kognitívneho tagu""" | |
| tag = ASLCognitiveTag(**self.valid_tag_data) | |
| self.assertEqual(tag.thought_stream, "Analyzing current system capabilities") | |
| self.assertEqual(tag.mental_state, MentalStateEnum.FOCUSED) | |
| self.assertEqual(tag.emotion_tone, EmotionToneEnum.ANALYTICAL) | |
| self.assertEqual(tag.cognitive_load, 7) | |
| self.assertEqual(tag.certainty_level, 0.85) | |
| def test_cognitive_coherence_validation(self): | |
| """Test validácie kognitívnej koherencie""" | |
| # Test nekompatibilného stavu - pokojný stav s vysokou záťažou | |
| invalid_data = self.valid_tag_data.copy() | |
| invalid_data["mental_state"] = MentalStateEnum.CALM | |
| invalid_data["cognitive_load"] = 9 | |
| with self.assertRaises(ValueError): | |
| ASLCognitiveTag(**invalid_data) | |
| def test_certainty_coherence_validation(self): | |
| """Test validácie súladu istoty s mentálnym stavom""" | |
| # Test nekonzistentnosti - neistý stav s vysokou istotou | |
| invalid_data = self.valid_tag_data.copy() | |
| invalid_data["mental_state"] = MentalStateEnum.UNCERTAIN | |
| invalid_data["certainty_level"] = 0.9 | |
| with self.assertRaises(ValueError): | |
| ASLCognitiveTag(**invalid_data) | |
| def test_consciousness_enhancement(self): | |
| """Test zvyšovania úrovne vedomia""" | |
| tag = ASLCognitiveTag(**self.valid_tag_data) | |
| initial_consciousness = tag.consciousness_level | |
| initial_depth = tag.introspective_depth | |
| tag.enhance_consciousness(0.2) | |
| self.assertGreater(tag.consciousness_level, initial_consciousness) | |
| self.assertGreater(tag.introspective_depth, initial_depth) | |
| def test_memory_resonance(self): | |
| """Test rezonancie s pamäťovými štruktúrami""" | |
| tag = ASLCognitiveTag(**self.valid_tag_data) | |
| memory_data = {"context": "test", "relevance": 0.8} | |
| tag.resonate_with_memory(memory_data) | |
| self.assertIn("context", tag.consciousness_resonance) | |
| self.assertEqual(tag.consciousness_resonance["relevance"], 0.8) | |
| def test_alias_compatibility(self): | |
| """Test spätnej kompatibility cez ASLTagModel alias""" | |
| tag = ASLTagModel(**self.valid_tag_data) | |
| self.assertIsInstance(tag, ASLCognitiveTag) | |
| class TestASLMetaParser(unittest.TestCase): | |
| """Komplexné testy pre ASL Meta Parser""" | |
| def setUp(self): | |
| self.parser = ASLMetaParser() | |
| def test_parse_line_valid_asl(self): | |
| """Test parsovania validného ASL riadku""" | |
| line = "# [ASL] thought_stream: Deep analytical processing" | |
| result = self.parser.parse_line(line) | |
| self.assertIn("thought_stream", result) | |
| self.assertEqual(result["thought_stream"], "Deep analytical processing") | |
| def test_parse_line_invalid_format(self): | |
| """Test parsovania nevalidného formátu""" | |
| line = "Invalid line without ASL format" | |
| result = self.parser.parse_line(line) | |
| self.assertEqual(result, {}) | |
| def test_cognitive_value_processing(self): | |
| """Test spracovania kognitívnych hodnôt""" | |
| # Test cognitive_load processing | |
| load_value = self.parser._process_cognitive_value("cognitive_load", "7") | |
| self.assertEqual(load_value, 7) | |
| self.assertIsInstance(load_value, int) | |
| # Test certainty_level processing | |
| certainty_value = self.parser._process_cognitive_value("certainty_level", "0.85") | |
| self.assertEqual(certainty_value, 0.85) | |
| self.assertIsInstance(certainty_value, float) | |
| # Test mental_state enum processing | |
| state_value = self.parser._process_cognitive_value("mental_state", "focused") | |
| self.assertEqual(state_value, MentalStateEnum.FOCUSED.value) | |
| def test_enum_validation_with_fallback(self): | |
| """Test validácie enum hodnôt s fallback""" | |
| # Test neznámeho mental_state | |
| unknown_state = self.parser._process_cognitive_value("mental_state", "unknown_state") | |
| self.assertEqual(unknown_state, MentalStateEnum.REFLECTIVE.value) | |
| # Test neznámeho emotion_tone | |
| unknown_emotion = self.parser._process_cognitive_value("emotion_tone", "unknown_emotion") | |
| self.assertEqual(unknown_emotion, EmotionToneEnum.NEUTRAL.value) | |
| def test_legacy_field_mapping(self): | |
| """Test mapovania legacy polí""" | |
| legacy_components = { | |
| "statement": "Test statement", | |
| "law": "test_law", | |
| "mental_state": "focused" | |
| } | |
| mapped_components = self.parser._map_legacy_fields(legacy_components) | |
| self.assertIn("thought_stream", mapped_components) | |
| self.assertIn("constitutional_law", mapped_components) | |
| self.assertEqual(mapped_components["thought_stream"], "Test statement") | |
| self.assertEqual(mapped_components["constitutional_law"], "test_law") | |
| def test_complete_parsing_and_validation(self): | |
| """Test komplexného parsovania a validácie dokumentu""" | |
| document = """ | |
| # [ASL] thought_stream: Analyzing system state mental_state: focused emotion_tone: analytical | |
| # [ASL] cognitive_load: 6 temporal_context: present certainty_level: 0.8 | |
| # [ASL] aeth_mem_link: test_link constitutional_law: transparency_principle | |
| """ | |
| result = self.parser.parse_and_validate(document) | |
| self.assertIn("validated_blocks", result) | |
| self.assertIn("parsing_results", result) | |
| self.assertIn("introspective_reflection", result) | |
| self.assertGreater(len(result["parsing_results"]), 0) | |
| def test_parse_valid_input(self): | |
| valid_input = """ | |
| # [ASL] thought_stream: Analyzing introspection mental_state: reflective | |
| # [ASL] emotion_tone: neutral cognitive_load: 5 temporal_context: present | |
| """ | |
| result = self.parser.parse_and_validate(valid_input) | |
| self.assertIn("validated_blocks", result) | |
| self.assertGreater(len(result["validated_blocks"]), 0) | |
| def test_parse_invalid_input(self): | |
| invalid_input = "# [InvalidTag]" | |
| result = self.parser.parse_and_validate(invalid_input) | |
| self.assertEqual(len(result["validated_blocks"]), 0) | |
| class TestCognitiveMetricsAnalyzer(unittest.TestCase): | |
| """Testy pre analyzátor kognitívnych metrík""" | |
| def setUp(self): | |
| self.analyzer = CognitiveMetricsAnalyzer() | |
| self.sample_tags = [ | |
| ASLCognitiveTag( | |
| thought_stream="First analysis", | |
| mental_state=MentalStateEnum.FOCUSED, | |
| emotion_tone=EmotionToneEnum.ANALYTICAL, | |
| cognitive_load=7, | |
| temporal_context=TemporalContextEnum.PRESENT, | |
| certainty_level=0.85, | |
| aeth_mem_link="link1", | |
| constitutional_law="law1" | |
| ), | |
| ASLCognitiveTag( | |
| thought_stream="Second analysis", | |
| mental_state=MentalStateEnum.CONTEMPLATIVE, | |
| emotion_tone=EmotionToneEnum.NEUTRAL, | |
| cognitive_load=5, | |
| temporal_context=TemporalContextEnum.PRESENT, | |
| certainty_level=0.7, | |
| aeth_mem_link="link2", | |
| constitutional_law="law2" | |
| ) | |
| ] | |
| def test_consciousness_coherence_calculation(self): | |
| """Test výpočtu koherencie vedomia""" | |
| coherence_rate = self.analyzer.calculate_consciousness_coherence_rate(self.sample_tags) | |
| self.assertIsInstance(coherence_rate, float) | |
| self.assertGreaterEqual(coherence_rate, 0.0) | |
| self.assertLessEqual(coherence_rate, 1.0) | |
| def test_mental_emotion_coherence_assessment(self): | |
| """Test hodnotenia koherencie mental_state a emotion_tone""" | |
| coherence = self.analyzer._assess_mental_emotion_coherence( | |
| MentalStateEnum.FOCUSED, EmotionToneEnum.ANALYTICAL | |
| ) | |
| self.assertEqual(coherence, 1.0) # Perfect match | |
| # Test weak coherence | |
| weak_coherence = self.analyzer._assess_mental_emotion_coherence( | |
| MentalStateEnum.CALM, EmotionToneEnum.CRITICAL | |
| ) | |
| self.assertLess(weak_coherence, 0.8) | |
| def test_cognitive_evolution_analysis(self): | |
| """Test analýzy kognitívnej evolúcie""" | |
| evolution = self.analyzer.analyze_cognitive_evolution(self.sample_tags) | |
| self.assertIn("cognitive_load_trend", evolution) | |
| self.assertIn("certainty_trend", evolution) | |
| self.assertIn("mental_state_stability", evolution) | |
| self.assertIn("overall_cognitive_evolution", evolution) | |
| def test_introspective_report_generation(self): | |
| """Test generovania introspektívneho reportu""" | |
| report = self.analyzer.generate_introspective_report(self.sample_tags) | |
| self.assertIn("consciousness_coherence_rate", report) | |
| self.assertIn("cognitive_evolution_analysis", report) | |
| self.assertIn("introspective_insights", report) | |
| self.assertIn("aethero_constitutional_compliance", report) | |
| # Verify insights are generated | |
| self.assertIsInstance(report["introspective_insights"], list) | |
| def test_constitutional_compliance_assessment(self): | |
| """Test hodnotenia ústavného súladu""" | |
| compliance = self.analyzer._assess_constitutional_compliance(self.sample_tags) | |
| self.assertIn("overall_compliance_score", compliance) | |
| self.assertIn("compliance_factors", compliance) | |
| self.assertIn("constitutional_status", compliance) | |
| self.assertIsInstance(compliance["overall_compliance_score"], float) | |
| def test_analyze_metrics(self): | |
| metrics = {"focus": 0.8, "clarity": 0.9} | |
| result = self.analyzer.analyze(metrics) | |
| self.assertIn("focus", result) | |
| class TestAetheroReflectionAgent(unittest.TestCase): | |
| """Testy pre pokročilý reflexívny agent""" | |
| def setUp(self): | |
| self.agent = AetheroReflectionAgent() | |
| def test_agent_initialization(self): | |
| """Test inicializácie agenta""" | |
| self.assertIsNotNone(self.agent.parser) | |
| self.assertIsNotNone(self.agent.metrics_analyzer) | |
| self.assertIsNotNone(self.agent.agent_id) | |
| self.assertEqual(self.agent.reflection_session_count, 0) | |
| def test_reflection_on_simple_document(self): | |
| """Test reflexie na jednoduchom dokumente""" | |
| document = """ | |
| # [ASL] thought_stream: Testing reflection capabilities | |
| # [ASL] mental_state: focused emotion_tone: analytical cognitive_load: 6 | |
| # [ASL] temporal_context: present certainty_level: 0.8 | |
| # [ASL] aeth_mem_link: test_reflection constitutional_law: transparency_principle | |
| """ | |
| reflection = self.agent.reflect_on_input(document) | |
| self.assertIn("reflection_agent_id", reflection) | |
| self.assertIn("deep_cognitive_reflections", reflection) | |
| self.assertIn("actionable_insights", reflection) | |
| self.assertIn("consciousness_evolution_assessment", reflection) | |
| self.assertEqual(self.agent.reflection_session_count, 1) | |
| def test_multiple_reflection_sessions(self): | |
| """Test viacerých reflexívnych sessions""" | |
| document = "# [ASL] thought_stream: Multi-session test mental_state: focused" | |
| # First session | |
| self.agent.reflect_on_input(document) | |
| # Second session | |
| self.agent.reflect_on_input(document) | |
| self.assertEqual(self.agent.reflection_session_count, 2) | |
| self.assertEqual(len(self.agent.reflection_memory), 2) | |
| def test_consciousness_evolution_tracking(self): | |
| """Test sledovania evolúcie vedomia""" | |
| # Create documents with different consciousness levels | |
| doc1 = """# [ASL] thought_stream: Low consciousness test mental_state: confused cognitive_load: 3""" | |
| doc2 = """# [ASL] thought_stream: High consciousness test mental_state: focused cognitive_load: 8""" | |
| self.agent.reflect_on_input(doc1) | |
| self.agent.reflect_on_input(doc2) | |
| self.assertGreater(len(self.agent.consciousness_evolution_track), 0) | |
| def test_actionable_insights_generation(self): | |
| """Test generovania actionable insights""" | |
| # Create document that should trigger insights | |
| poor_coherence_doc = """ | |
| # [ASL] thought_stream: Incoherent test mental_state: calm cognitive_load: 9 | |
| # [ASL] emotion_tone: critical certainty_level: 0.2 | |
| """ | |
| reflection = self.agent.reflect_on_input(poor_coherence_doc) | |
| insights = reflection.get("actionable_insights", []) | |
| self.assertIsInstance(insights, list) | |
| self.assertGreater(len(insights), 0) | |
| def test_agent_performance_tracking(self): | |
| """Test sledovania výkonnosti agenta""" | |
| document = "# [ASL] thought_stream: Performance test" | |
| self.agent.reflect_on_input(document) | |
| performance = self.agent._generate_agent_performance_summary() | |
| self.assertIn("total_reflection_sessions", performance) | |
| self.assertIn("average_reflection_depth", performance) | |
| self.assertIn("introspective_capability_level", performance) | |
| def test_reflect(self): | |
| tags = [ASLCognitiveTag(temporal_context=TemporalContextEnum.PRESENT)] | |
| result = self.agent.reflect(tags) | |
| self.assertIn("temporal_consciousness_insights", result) | |
| class TestLegacyCompatibility(unittest.TestCase): | |
| """Testy pre spätná kompatibilitu""" | |
| def test_legacy_reflection_agent(self): | |
| """Test legacy ReflectionAgent wrappera""" | |
| agent = ReflectionAgent() | |
| document = "# [ASL] thought_stream: Legacy test mental_state: focused" | |
| result = agent.reflect_on_input(document) | |
| # Should have legacy structure | |
| self.assertIn("parsed_data", result) | |
| self.assertIn("introspection", result) | |
| def test_asl_tag_model_aliasu(self): | |
| """Test ASLTagModel aliasu""" | |
| tag_data = { | |
| "thought_stream": "Alias test", | |
| "mental_state": MentalStateEnum.FOCUSED, | |
| "emotion_tone": EmotionToneEnum.NEUTRAL, | |
| "cognitive_load": 5, | |
| "temporal_context": TemporalContextEnum.PRESENT, | |
| "certainty_level": 0.7, | |
| "aeth_mem_link": "test", | |
| "constitutional_law": "test" | |
| } | |
| tag = ASLTagModel(**tag_data) | |
| self.assertIsInstance(tag, ASLCognitiveTag) | |
| class TestIntegrationScenarios(unittest.TestCase): | |
| """Integračné testy pre komplexné scenáre""" | |
| def setUp(self): | |
| self.parser = ASLMetaParser() | |
| self.analyzer = CognitiveMetricsAnalyzer() | |
| self.agent = AetheroReflectionAgent() | |
| def test_complete_introspective_workflow(self): | |
| """Test kompletného introspektívneho workflow""" | |
| complex_document = """ | |
| # [ASL] thought_stream: Beginning complex analysis mental_state: focused | |
| # [ASL] emotion_tone: analytical cognitive_load: 8 certainty_level: 0.9 | |
| # [ASL] temporal_context: present aeth_mem_link: complex_analysis_001 | |
| # [ASL] constitutional_law: comprehensive_analysis_principle | |
| # [ASL] thought_stream: Deepening understanding mental_state: contemplative | |
| # [ASL] emotion_tone: neutral cognitive_load: 6 certainty_level: 0.7 | |
| # [ASL] temporal_context: present aeth_mem_link: complex_analysis_002 | |
| # [ASL] constitutional_law: depth_principle | |
| # [ASL] thought_stream: Reaching conclusions mental_state: decisive | |
| # [ASL] emotion_tone: positive cognitive_load: 7 certainty_level: 0.95 | |
| # [ASL] temporal_context: present aeth_mem_link: complex_analysis_003 | |
| # [ASL] constitutional_law: conclusion_principle | |
| """ | |
| # Full workflow test | |
| reflection = self.agent.reflect_on_input(complex_document) | |
| # Verify all components worked | |
| self.assertGreater(len(reflection["validated_cognitive_tags"]), 0) | |
| self.assertIn("introspective_metrics_report", reflection) | |
| self.assertIn("deep_cognitive_reflections", reflection) | |
| self.assertIn("consciousness_evolution_assessment", reflection) | |
| # Verify cognitive evolution was detected | |
| evolution = reflection["consciousness_evolution_assessment"] | |
| self.assertIn("consciousness_trend", evolution) | |
| self.assertIn("introspective_depth_trend", evolution) | |
| def test_error_handling_and_recovery(self): | |
| """Test spracovania chýb a recovery""" | |
| malformed_document = """ | |
| # [ASL] invalid_format_here | |
| # [ASL] mental_state: invalid_state cognitive_load: not_a_number | |
| # Normal text without ASL tags | |
| # [ASL] thought_stream: Valid tag after errors mental_state: focused | |
| """ | |
| # Should not crash and should process valid parts | |
| reflection = self.agent.reflect_on_input(malformed_document) | |
| self.assertIn("parsing_analysis", reflection) | |
| self.assertIn("failed_validations", reflection["parsing_analysis"]) | |
| # Should still have some successful processing | |
| self.assertIsInstance(reflection, dict) | |
| if __name__ == "__main__": | |
| # Spustenie všetkých testov s detailným outputom | |
| unittest.main(verbosity=2) | |