pygeai-orchestration 0.1.0b2__py3-none-any.whl

pygeai_orchestration/tests/test_config.py

@@ -0,0 +1,301 @@
+"""Tests for configuration system."""
+
+import json
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+from pygeai_orchestration.core.config import (
+    CacheConfig,
+    ConfigManager,
+    ConfigProfile,
+    ExecutionConfig,
+    LogLevel,
+    MetricsConfig,
+    OrchestrationConfig,
+)
+
+
+class TestCacheConfig(unittest.TestCase):
+    def test_default_config(self):
+        config = CacheConfig()
+        self.assertTrue(config.enabled)
+        self.assertEqual(config.max_size, 1000)
+        self.assertEqual(config.ttl, 3600)
+        self.assertEqual(config.backend, "memory")
+
+    def test_custom_config(self):
+        config = CacheConfig(
+            enabled=False,
+            max_size=500,
+            ttl=1800,
+            backend="redis"
+        )
+        self.assertFalse(config.enabled)
+        self.assertEqual(config.max_size, 500)
+        self.assertEqual(config.ttl, 1800)
+        self.assertEqual(config.backend, "redis")
+
+    def test_invalid_max_size(self):
+        with self.assertRaises(ValueError):
+            CacheConfig(max_size=0)
+
+        with self.assertRaises(ValueError):
+            CacheConfig(max_size=-1)
+
+    def test_invalid_ttl(self):
+        with self.assertRaises(ValueError):
+            CacheConfig(ttl=-1)
+
+
+class TestMetricsConfig(unittest.TestCase):
+    def test_default_config(self):
+        config = MetricsConfig()
+        self.assertTrue(config.enabled)
+        self.assertEqual(config.export_interval, 60)
+        self.assertEqual(config.export_format, "json")
+        self.assertTrue(config.include_labels)
+
+    def test_custom_config(self):
+        config = MetricsConfig(
+            enabled=False,
+            export_interval=30,
+            export_format="prometheus",
+            include_labels=False
+        )
+        self.assertFalse(config.enabled)
+        self.assertEqual(config.export_interval, 30)
+        self.assertEqual(config.export_format, "prometheus")
+        self.assertFalse(config.include_labels)
+
+    def test_invalid_export_interval(self):
+        with self.assertRaises(ValueError):
+            MetricsConfig(export_interval=0)
+
+
+class TestExecutionConfig(unittest.TestCase):
+    def test_default_config(self):
+        config = ExecutionConfig()
+        self.assertEqual(config.max_iterations, 10)
+        self.assertEqual(config.timeout, 300)
+        self.assertEqual(config.retry_attempts, 3)
+        self.assertEqual(config.retry_delay, 1.0)
+        self.assertEqual(config.parallel_workers, 4)
+
+    def test_custom_config(self):
+        config = ExecutionConfig(
+            max_iterations=20,
+            timeout=600,
+            retry_attempts=5,
+            retry_delay=2.0,
+            parallel_workers=8
+        )
+        self.assertEqual(config.max_iterations, 20)
+        self.assertEqual(config.timeout, 600)
+        self.assertEqual(config.retry_attempts, 5)
+        self.assertEqual(config.retry_delay, 2.0)
+        self.assertEqual(config.parallel_workers, 8)
+
+    def test_invalid_values(self):
+        with self.assertRaises(ValueError):
+            ExecutionConfig(max_iterations=0)
+
+        with self.assertRaises(ValueError):
+            ExecutionConfig(timeout=-1)
+
+        with self.assertRaises(ValueError):
+            ExecutionConfig(retry_attempts=0)
+
+
+class TestOrchestrationConfig(unittest.TestCase):
+    def test_default_config(self):
+        config = OrchestrationConfig()
+        self.assertEqual(config.profile, ConfigProfile.DEVELOPMENT)
+        self.assertEqual(config.log_level, LogLevel.INFO)
+        self.assertFalse(config.debug)
+        self.assertIsInstance(config.cache, CacheConfig)
+        self.assertIsInstance(config.metrics, MetricsConfig)
+        self.assertIsInstance(config.execution, ExecutionConfig)
+
+    def test_custom_config(self):
+        config = OrchestrationConfig(
+            profile=ConfigProfile.PRODUCTION,
+            log_level=LogLevel.ERROR,
+            debug=True,
+            cache=CacheConfig(enabled=False),
+            custom={"key": "value"}
+        )
+        self.assertEqual(config.profile, ConfigProfile.PRODUCTION)
+        self.assertEqual(config.log_level, LogLevel.ERROR)
+        self.assertTrue(config.debug)
+        self.assertFalse(config.cache.enabled)
+        self.assertEqual(config.custom["key"], "value")
+
+    def test_from_env(self):
+        os.environ["PYGEAI_PROFILE"] = "production"
+        os.environ["PYGEAI_LOG_LEVEL"] = "ERROR"
+        os.environ["PYGEAI_DEBUG"] = "true"
+        os.environ["PYGEAI_CACHE_ENABLED"] = "false"
+        os.environ["PYGEAI_CACHE_MAX_SIZE"] = "2000"
+        os.environ["PYGEAI_MAX_ITERATIONS"] = "15"
+
+        try:
+            config = OrchestrationConfig.from_env()
+            self.assertEqual(config.profile, ConfigProfile.PRODUCTION)
+            self.assertEqual(config.log_level, LogLevel.ERROR)
+            self.assertTrue(config.debug)
+            self.assertFalse(config.cache.enabled)
+            self.assertEqual(config.cache.max_size, 2000)
+            self.assertEqual(config.execution.max_iterations, 15)
+        finally:
+            del os.environ["PYGEAI_PROFILE"]
+            del os.environ["PYGEAI_LOG_LEVEL"]
+            del os.environ["PYGEAI_DEBUG"]
+            del os.environ["PYGEAI_CACHE_ENABLED"]
+            del os.environ["PYGEAI_CACHE_MAX_SIZE"]
+            del os.environ["PYGEAI_MAX_ITERATIONS"]
+
+    def test_from_file(self):
+        config_data = {
+            "profile": "production",
+            "log_level": "WARNING",
+            "debug": False,
+            "cache": {"enabled": True, "max_size": 500},
+            "metrics": {"enabled": False},
+            "execution": {"max_iterations": 25}
+        }
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            json.dump(config_data, f)
+            temp_path = f.name
+
+        try:
+            config = OrchestrationConfig.from_file(temp_path)
+            self.assertEqual(config.profile, ConfigProfile.PRODUCTION)
+            self.assertEqual(config.log_level, LogLevel.WARNING)
+            self.assertFalse(config.debug)
+            self.assertEqual(config.cache.max_size, 500)
+            self.assertFalse(config.metrics.enabled)
+            self.assertEqual(config.execution.max_iterations, 25)
+        finally:
+            os.unlink(temp_path)
+
+    def test_from_file_not_found(self):
+        with self.assertRaises(FileNotFoundError):
+            OrchestrationConfig.from_file("nonexistent.json")
+
+    def test_to_file(self):
+        config = OrchestrationConfig(
+            profile=ConfigProfile.TEST,
+            log_level=LogLevel.DEBUG
+        )
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "config.json"
+            config.to_file(path)
+
+            self.assertTrue(path.exists())
+
+            loaded = OrchestrationConfig.from_file(path)
+            self.assertEqual(loaded.profile, ConfigProfile.TEST)
+            self.assertEqual(loaded.log_level, LogLevel.DEBUG)
+
+    def test_merge(self):
+        base = OrchestrationConfig(
+            profile=ConfigProfile.DEVELOPMENT,
+            cache=CacheConfig(max_size=500)
+        )
+
+        override = OrchestrationConfig(
+            log_level=LogLevel.ERROR,
+            cache=CacheConfig(enabled=False)
+        )
+
+        merged = base.merge(override)
+
+        self.assertEqual(merged.profile, ConfigProfile.DEVELOPMENT)
+        self.assertEqual(merged.log_level, LogLevel.ERROR)
+        self.assertFalse(merged.cache.enabled)
+
+    def test_production_profile(self):
+        config = OrchestrationConfig(profile=ConfigProfile.PRODUCTION)
+        profile_config = config.get_profile_config()
+
+        self.assertEqual(profile_config.log_level, LogLevel.WARNING)
+        self.assertFalse(profile_config.debug)
+        self.assertEqual(profile_config.execution.max_iterations, 20)
+
+    def test_test_profile(self):
+        config = OrchestrationConfig(profile=ConfigProfile.TEST)
+        profile_config = config.get_profile_config()
+
+        self.assertEqual(profile_config.log_level, LogLevel.DEBUG)
+        self.assertTrue(profile_config.debug)
+        self.assertFalse(profile_config.cache.enabled)
+        self.assertFalse(profile_config.metrics.enabled)
+        self.assertEqual(profile_config.execution.max_iterations, 5)
+
+
+class TestConfigManager(unittest.TestCase):
+    def tearDown(self):
+        ConfigManager.reset()
+
+    def test_singleton(self):
+        manager1 = ConfigManager()
+        manager2 = ConfigManager()
+        self.assertIs(manager1, manager2)
+
+    def test_initialize_default(self):
+        manager = ConfigManager.initialize(from_env=False)
+        config = manager.get_config()
+
+        self.assertIsInstance(config, OrchestrationConfig)
+        self.assertEqual(config.profile, ConfigProfile.DEVELOPMENT)
+
+    def test_initialize_with_config(self):
+        custom_config = OrchestrationConfig(
+            profile=ConfigProfile.PRODUCTION,
+            log_level=LogLevel.ERROR
+        )
+
+        manager = ConfigManager.initialize(config=custom_config)
+        config = manager.get_config()
+
+        self.assertEqual(config.log_level, LogLevel.ERROR)
+
+    def test_initialize_from_file(self):
+        config_data = {"profile": "test", "log_level": "DEBUG"}
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            json.dump(config_data, f)
+            temp_path = f.name
+
+        try:
+            manager = ConfigManager.initialize(config_file=temp_path)
+            config = manager.get_config()
+
+            self.assertEqual(config.profile, ConfigProfile.TEST)
+            self.assertEqual(config.log_level, LogLevel.DEBUG)
+        finally:
+            os.unlink(temp_path)
+
+    def test_set_config(self):
+        manager = ConfigManager.initialize(from_env=False)
+
+        new_config = OrchestrationConfig(log_level=LogLevel.CRITICAL)
+        manager.set_config(new_config)
+
+        config = manager.get_config()
+        self.assertEqual(config.log_level, LogLevel.CRITICAL)
+
+    def test_reset(self):
+        manager = ConfigManager.initialize(from_env=False)
+        manager.reset()
+
+        config = manager.get_config()
+        self.assertIsInstance(config, OrchestrationConfig)
+
+
+if __name__ == "__main__":
+    unittest.main()

pygeai_orchestration/tests/test_dev_utils.py

@@ -0,0 +1,337 @@
+"""Tests for development utilities."""
+
+import tempfile
+import unittest
+from pathlib import Path
+
+from pygeai_orchestration.core.base import BasePattern, PatternResult, PatternType
+from pygeai_orchestration.dev.debug import DebugTracer, PatternInspector
+from pygeai_orchestration.dev.templates import PatternTemplate, TemplateGenerator
+from pygeai_orchestration.dev.testing import (
+    AsyncMockHelper,
+    MockAgent,
+    MockPattern,
+    PatternTestCase,
+    TestDataBuilder,
+)
+
+
+class TestTemplateGenerator(unittest.TestCase):
+    def test_generate_reflection_pattern(self):
+        code = TemplateGenerator.generate_reflection_pattern(
+            "MyReflection",
+            "Test reflection"
+        )
+        self.assertIn("MyReflection", code)
+        self.assertIn("ReflectionPattern", code)
+        self.assertIn("reflect", code)
+        self.assertIn("improve", code)
+
+    def test_generate_react_pattern(self):
+        code = TemplateGenerator.generate_react_pattern(
+            "MyReAct",
+            "Test ReAct"
+        )
+        self.assertIn("MyReAct", code)
+        self.assertIn("ReActPattern", code)
+        self.assertIn("think", code)
+        self.assertIn("act", code)
+
+    def test_generate_custom_pattern(self):
+        code = TemplateGenerator.generate_custom_pattern(
+            "MyCustom",
+            "Test custom"
+        )
+        self.assertIn("MyCustom", code)
+        self.assertIn("OrchestrationPattern", code)
+        self.assertIn("_execute_impl", code)
+
+    def test_generate_test_file(self):
+        code = TemplateGenerator.generate_test_file(
+            "MyPattern",
+            PatternTemplate.REFLECTION
+        )
+        self.assertIn("TestMyPattern", code)
+        self.assertIn("PatternTestCase", code)
+        self.assertIn("test_basic_execution", code)
+
+    def test_save_template(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            output_path = Path(tmpdir) / "test_pattern.py"
+            code = "# Test code"
+
+            TemplateGenerator.save_template(code, output_path)
+
+            self.assertTrue(output_path.exists())
+            self.assertEqual(output_path.read_text(), code)
+
+    def test_save_template_no_overwrite(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            output_path = Path(tmpdir) / "test_pattern.py"
+            output_path.write_text("existing")
+
+            with self.assertRaises(FileExistsError):
+                TemplateGenerator.save_template("new", output_path)
+
+    def test_save_template_overwrite(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            output_path = Path(tmpdir) / "test_pattern.py"
+            output_path.write_text("existing")
+
+            TemplateGenerator.save_template("new", output_path, overwrite=True)
+
+            self.assertEqual(output_path.read_text(), "new")
+
+    def test_create_pattern(self):
+        files = TemplateGenerator.create_pattern(
+            PatternTemplate.REFLECTION,
+            "TestPattern",
+            "Test description",
+            include_tests=True
+        )
+
+        self.assertEqual(len(files), 2)
+        self.assertIn("testpattern.py", files)
+        self.assertIn("test_testpattern.py", files)
+
+    def test_create_pattern_no_tests(self):
+        files = TemplateGenerator.create_pattern(
+            PatternTemplate.CUSTOM,
+            "NoTests",
+            "No tests",
+            include_tests=False
+        )
+
+        self.assertEqual(len(files), 1)
+        self.assertIn("notests.py", files)
+
+
+class TestDebugTracer(unittest.TestCase):
+    def setUp(self):
+        self.tracer = DebugTracer()
+
+    def test_trace_event(self):
+        self.tracer.trace("test_event", "TestPattern", {"key": "value"})
+
+        traces = self.tracer.get_traces()
+        self.assertEqual(len(traces), 1)
+        self.assertEqual(traces[0]["event"], "test_event")
+        self.assertEqual(traces[0]["pattern"], "TestPattern")
+
+    def test_disabled_tracer(self):
+        tracer = DebugTracer(enabled=False)
+        tracer.trace("event")
+
+        self.assertEqual(len(tracer.get_traces()), 0)
+
+    def test_get_traces_filtered(self):
+        self.tracer.trace("event1", "Pattern1")
+        self.tracer.trace("event2", "Pattern2")
+        self.tracer.trace("event3", "Pattern1")
+
+        pattern1_traces = self.tracer.get_traces("Pattern1")
+        self.assertEqual(len(pattern1_traces), 2)
+
+    def test_clear_traces(self):
+        self.tracer.trace("event")
+        self.assertEqual(len(self.tracer.get_traces()), 1)
+
+        self.tracer.clear()
+        self.assertEqual(len(self.tracer.get_traces()), 0)
+
+    def test_format_traces(self):
+        self.tracer.trace("event1", "Pattern1", {"data": "value"})
+
+        formatted = self.tracer.format_traces()
+        self.assertIn("Debug Traces", formatted)
+        self.assertIn("event1", formatted)
+        self.assertIn("Pattern1", formatted)
+
+    def test_trace_execution_success(self):
+        with self.tracer.trace_execution("TestPattern", "test task"):
+            pass
+
+        traces = self.tracer.get_traces()
+        self.assertEqual(len(traces), 2)
+        self.assertEqual(traces[0]["event"], "execution_start")
+        self.assertEqual(traces[1]["event"], "execution_end")
+
+    def test_trace_execution_error(self):
+        with self.assertRaises(ValueError):
+            with self.tracer.trace_execution("TestPattern", "test"):
+                raise ValueError("Test error")
+
+        traces = self.tracer.get_traces()
+        self.assertGreaterEqual(len(traces), 2)
+        error_trace = [t for t in traces if t["event"] == "execution_error"]
+        self.assertEqual(len(error_trace), 1)
+
+
+class TestPatternInspector(unittest.TestCase):
+    async def test_inspect_pattern(self):
+        pattern = MockPattern()
+
+        inspection = PatternInspector.inspect_pattern(pattern)
+
+        self.assertEqual(inspection["class_name"], "MockPattern")
+        self.assertIn("methods", inspection)
+        self.assertIn("config", inspection)
+
+    async def test_format_inspection(self):
+        pattern = MockPattern()
+        inspection = PatternInspector.inspect_pattern(pattern)
+
+        formatted = PatternInspector.format_inspection(inspection)
+
+        self.assertIn("MockPattern", formatted)
+        self.assertIn("Methods:", formatted)
+
+    async def test_compare_results(self):
+        result1 = PatternResult(
+            success=True,
+            result="result1",
+            iterations=1,
+            metadata={"key1": "value1"}
+        )
+
+        result2 = PatternResult(
+            success=True,
+            result="result2",
+            iterations=2,
+            metadata={"key2": "value2"}
+        )
+
+        comparison = PatternInspector.compare_results(result1, result2)
+
+        self.assertTrue(comparison["success_match"])
+        self.assertFalse(comparison["result_match"])
+        self.assertEqual(comparison["iterations_diff"], -1)
+
+
+class TestMockAgent(unittest.IsolatedAsyncioTestCase):
+    async def test_generate(self):
+        agent = MockAgent(["response1", "response2"])
+
+        result1 = await agent.generate("prompt1")
+        result2 = await agent.generate("prompt2")
+
+        self.assertEqual(result1, "response1")
+        self.assertEqual(result2, "response2")
+        self.assertEqual(agent.call_count, 2)
+
+    async def test_generate_default_response(self):
+        agent = MockAgent()
+        result = await agent.generate("prompt")
+
+        self.assertEqual(result, "Mock response")
+
+    async def test_chat(self):
+        agent = MockAgent(["chat response"])
+        messages = [{"role": "user", "content": "test"}]
+
+        result = await agent.chat(messages)
+
+        self.assertEqual(result, "chat response")
+
+    async def test_reset(self):
+        agent = MockAgent()
+        await agent.generate("test")
+
+        agent.reset()
+
+        self.assertEqual(agent.call_count, 0)
+        self.assertEqual(len(agent.calls), 0)
+
+
+class TestMockPattern(unittest.IsolatedAsyncioTestCase):
+    async def test_mock_pattern_execution(self):
+        pattern = MockPattern(result="test result", success=True)
+
+        result = await pattern.execute("test task")
+
+        self.assertTrue(result.success)
+        self.assertEqual(result.result, "test result")
+        self.assertEqual(pattern.execution_count, 1)
+
+    async def test_mock_pattern_failure(self):
+        pattern = MockPattern(success=False)
+
+        result = await pattern.execute("test task")
+
+        self.assertFalse(result.success)
+
+
+class TestPatternTestCase(PatternTestCase):
+    async def test_create_mock_agent(self):
+        agent = self.create_mock_agent(["response"])
+
+        result = await agent.generate("prompt")
+
+        self.assertEqual(result, "response")
+
+    async def test_assert_pattern_result(self):
+        result = PatternResult(
+            success=True,
+            result="output",
+            iterations=1
+        )
+
+        self.assert_pattern_result(result, success=True)
+
+    async def test_assert_agent_called(self):
+        agent = MockAgent()
+        await agent.generate("test prompt")
+
+        self.assert_agent_called(agent, min_calls=1, contains="test")
+
+
+class TestCreateTestPattern(unittest.TestCase):
+    def test_create_test_pattern_direct(self):
+        pattern = MockPattern(result="test")
+
+        self.assertIsInstance(pattern, MockPattern)
+        self.assertIsInstance(pattern, BasePattern)
+
+
+class TestAsyncMockHelper(unittest.IsolatedAsyncioTestCase):
+    async def test_create_async_mock(self):
+        mock = AsyncMockHelper.create_async_mock("return value")
+
+        result = await mock()
+
+        self.assertEqual(result, "return value")
+
+    async def test_create_agent_mock(self):
+        agent = AsyncMockHelper.create_agent_mock(["resp1", "resp2"])
+
+        result1 = await agent.generate("prompt1")
+        result2 = await agent.generate("prompt2")
+
+        self.assertEqual(result1, "resp1")
+        self.assertEqual(result2, "resp2")
+
+
+class TestTestDataBuilder(unittest.TestCase):
+    def test_build_pattern_result(self):
+        result = TestDataBuilder.build_pattern_result(
+            success=True,
+            result="output",
+            custom_key="custom_value"
+        )
+
+        self.assertTrue(result.success)
+        self.assertEqual(result.result, "output")
+        self.assertEqual(result.metadata["custom_key"], "custom_value")
+
+    def test_build_pattern_config(self):
+        config = TestDataBuilder.build_pattern_config(
+            name="TestPattern",
+            pattern_type=PatternType.REACT
+        )
+
+        self.assertEqual(config.name, "TestPattern")
+        self.assertEqual(config.pattern_type, PatternType.REACT)
+
+
+if __name__ == "__main__":
+    unittest.main()