pygeai-orchestration 0.1.0b2__py3-none-any.whl

pygeai_orchestration/tests/test_cli_formatters.py

@@ -0,0 +1,232 @@
+"""Tests for CLI formatters."""
+
+import unittest
+from io import StringIO
+from unittest.mock import patch
+
+from pygeai_orchestration.cli.formatters import (
+    Color,
+    OutputFormatter,
+    ProgressBar,
+    Spinner,
+    Symbol,
+    format_error_details,
+)
+
+
+class TestColor(unittest.TestCase):
+    def test_color_values(self):
+        self.assertIsInstance(Color.RED, str)
+        self.assertIsInstance(Color.GREEN, str)
+        self.assertIsInstance(Color.RESET, str)
+
+
+class TestSymbol(unittest.TestCase):
+    def test_symbol_values(self):
+        self.assertIsInstance(Symbol.SUCCESS, str)
+        self.assertIsInstance(Symbol.ERROR, str)
+        self.assertIsInstance(Symbol.WARNING, str)
+
+
+class TestOutputFormatter(unittest.TestCase):
+    def setUp(self):
+        self.formatter_color = OutputFormatter(use_color=True)
+        self.formatter_no_color = OutputFormatter(use_color=False)
+
+    def test_colorize_with_color(self):
+        result = self.formatter_color.colorize("test", Color.RED)
+        self.assertIn("test", result)
+
+    def test_colorize_no_color(self):
+        result = self.formatter_no_color.colorize("test", Color.RED)
+        self.assertEqual(result, "test")
+
+    def test_colorize_bold(self):
+        result = self.formatter_color.colorize("test", Color.RED, bold=True)
+        self.assertIn("test", result)
+
+    def test_success(self):
+        result = self.formatter_no_color.success("Great!")
+        self.assertIn(Symbol.SUCCESS, result)
+        self.assertIn("Great!", result)
+
+    def test_error(self):
+        result = self.formatter_no_color.error("Oops!")
+        self.assertIn(Symbol.ERROR, result)
+        self.assertIn("Oops!", result)
+
+    def test_warning(self):
+        result = self.formatter_no_color.warning("Careful!")
+        self.assertIn(Symbol.WARNING, result)
+        self.assertIn("Careful!", result)
+
+    def test_info(self):
+        result = self.formatter_no_color.info("FYI")
+        self.assertIn(Symbol.INFO, result)
+        self.assertIn("FYI", result)
+
+    def test_heading_level_1(self):
+        result = self.formatter_no_color.heading("Title", level=1)
+        self.assertEqual(result, "Title")
+
+    def test_heading_level_2(self):
+        result = self.formatter_no_color.heading("Subtitle", level=2)
+        self.assertEqual(result, "Subtitle")
+
+    def test_heading_level_3(self):
+        result = self.formatter_no_color.heading("Minor", level=3)
+        self.assertEqual(result, "Minor")
+
+    def test_dim(self):
+        result = self.formatter_no_color.dim("faded")
+        self.assertEqual(result, "faded")
+
+    def test_bold(self):
+        result = self.formatter_no_color.bold("strong")
+        self.assertEqual(result, "strong")
+
+    def test_key_value(self):
+        result = self.formatter_no_color.key_value("name", "value")
+        self.assertIn("name", result)
+        self.assertIn("value", result)
+
+    def test_key_value_indent(self):
+        result = self.formatter_no_color.key_value("name", "value", indent=2)
+        self.assertIn("    ", result)
+        self.assertIn("name", result)
+
+    def test_bullet_list(self):
+        items = ["item1", "item2", "item3"]
+        result = self.formatter_no_color.bullet_list(items)
+        self.assertIn("item1", result)
+        self.assertIn("item2", result)
+        self.assertIn("item3", result)
+        self.assertIn(Symbol.BULLET, result)
+
+    def test_bullet_list_indent(self):
+        items = ["item1"]
+        result = self.formatter_no_color.bullet_list(items, indent=1)
+        self.assertIn("  ", result)
+
+    def test_section(self):
+        result = self.formatter_no_color.section("Section", "content")
+        self.assertIn("Section", result)
+        self.assertIn("content", result)
+
+    def test_table_empty(self):
+        result = self.formatter_no_color.table(["H1", "H2"], [])
+        self.assertEqual(result, "")
+
+    def test_table_with_rows(self):
+        headers = ["Name", "Age"]
+        rows = [["Alice", "30"], ["Bob", "25"]]
+        result = self.formatter_no_color.table(headers, rows)
+        self.assertIn("Name", result)
+        self.assertIn("Age", result)
+        self.assertIn("Alice", result)
+        self.assertIn("Bob", result)
+
+    def test_json_tree_simple(self):
+        data = {"key": "value"}
+        result = self.formatter_no_color.json_tree(data)
+        self.assertIn("key", result)
+        self.assertIn("value", result)
+
+    def test_json_tree_nested(self):
+        data = {"outer": {"inner": "value"}}
+        result = self.formatter_no_color.json_tree(data)
+        self.assertIn("outer", result)
+        self.assertIn("inner", result)
+        self.assertIn("value", result)
+
+    def test_json_tree_list(self):
+        data = {"items": ["a", "b"]}
+        result = self.formatter_no_color.json_tree(data)
+        self.assertIn("items", result)
+        self.assertIn("a", result)
+        self.assertIn("b", result)
+
+
+class TestProgressBar(unittest.TestCase):
+    @patch("sys.stdout", new_callable=StringIO)
+    def test_progress_bar_creation(self, mock_stdout):
+        bar = ProgressBar(total=10, width=20)
+        self.assertEqual(bar.total, 10)
+        self.assertEqual(bar.width, 20)
+        self.assertEqual(bar.current, 0)
+
+    @patch("sys.stdout.isatty", return_value=False)
+    def test_progress_bar_update_no_tty(self, mock_isatty):
+        bar = ProgressBar(total=10)
+        bar.update(5)
+        self.assertEqual(bar.current, 5)
+
+    @patch("sys.stdout.isatty", return_value=False)
+    def test_progress_bar_finish(self, mock_isatty):
+        bar = ProgressBar(total=10)
+        bar.finish()
+        self.assertEqual(bar.current, 10)
+
+
+class TestSpinner(unittest.TestCase):
+    @patch("sys.stdout.isatty", return_value=False)
+    def test_spinner_creation(self, mock_isatty):
+        spinner = Spinner("Loading...")
+        self.assertEqual(spinner.message, "Loading...")
+        self.assertFalse(spinner.running)
+
+    @patch("sys.stdout.isatty", return_value=False)
+    def test_spinner_start(self, mock_isatty):
+        spinner = Spinner("Loading...")
+        spinner.start()
+        self.assertTrue(spinner.running)
+
+    @patch("sys.stdout.isatty", return_value=False)
+    def test_spinner_update(self, mock_isatty):
+        spinner = Spinner("Loading...")
+        spinner.update("New message")
+        self.assertEqual(spinner.message, "New message")
+
+    @patch("sys.stdout.isatty", return_value=False)
+    def test_spinner_stop(self, mock_isatty):
+        spinner = Spinner("Loading...")
+        spinner.start()
+        spinner.stop()
+        self.assertFalse(spinner.running)
+
+    @patch("sys.stdout.isatty", return_value=False)
+    def test_spinner_stop_with_message(self, mock_isatty):
+        spinner = Spinner("Loading...")
+        spinner.start()
+        spinner.stop("Done!")
+        self.assertFalse(spinner.running)
+
+
+class TestFormatErrorDetails(unittest.TestCase):
+    def test_format_simple_error(self):
+        error = ValueError("Something went wrong")
+        result = format_error_details(error)
+        self.assertIn("ValueError", result)
+        self.assertIn("Something went wrong", result)
+
+    def test_format_error_with_attributes(self):
+        class CustomError(Exception):
+            def __init__(self, message: str, code: int):
+                super().__init__(message)
+                self.code = code
+
+        error = CustomError("Error message", 42)
+        result = format_error_details(error)
+        self.assertIn("CustomError", result)
+        self.assertIn("Error message", result)
+
+    def test_format_error_no_color(self):
+        formatter = OutputFormatter(use_color=False)
+        error = RuntimeError("Test error")
+        result = format_error_details(error, formatter=formatter)
+        self.assertIn("RuntimeError", result)
+        self.assertIn("Test error", result)
+
+
+if __name__ == "__main__":
+    unittest.main()

pygeai_orchestration/tests/test_common.py

@@ -0,0 +1,214 @@
+import unittest
+from pygeai_orchestration import (
+    Message,
+    MessageRole,
+    Conversation,
+    Context,
+    ContextManager,
+    State,
+    StateStatus,
+    StateManager,
+    Memory,
+    MemoryStore
+)
+
+
+class TestMessage(unittest.TestCase):
+
+    def test_creation(self):
+        msg = Message(role=MessageRole.USER, content="Hello")
+
+        self.assertEqual(msg.role, MessageRole.USER)
+        self.assertEqual(msg.content, "Hello")
+        self.assertIsNotNone(msg.timestamp)
+
+    def test_with_metadata(self):
+        msg = Message(
+            role=MessageRole.ASSISTANT,
+            content="Response",
+            metadata={"key": "value"}
+        )
+
+        self.assertEqual(msg.metadata["key"], "value")
+
+
+class TestConversation(unittest.TestCase):
+
+    def test_creation(self):
+        conv = Conversation(id="conv-1")
+
+        self.assertEqual(conv.id, "conv-1")
+        self.assertEqual(len(conv.messages), 0)
+
+    def test_add_message(self):
+        conv = Conversation(id="conv-1")
+        msg = Message(role=MessageRole.USER, content="Hello")
+
+        conv.add_message(msg)
+        self.assertEqual(len(conv.messages), 1)
+
+    def test_get_messages_by_role(self):
+        conv = Conversation(id="conv-1")
+        conv.add_message(Message(role=MessageRole.USER, content="Q1"))
+        conv.add_message(Message(role=MessageRole.ASSISTANT, content="A1"))
+        conv.add_message(Message(role=MessageRole.USER, content="Q2"))
+
+        user_msgs = conv.get_messages(MessageRole.USER)
+        self.assertEqual(len(user_msgs), 2)
+
+    def test_to_dict_list(self):
+        conv = Conversation(id="conv-1")
+        conv.add_message(Message(role=MessageRole.USER, content="Hello"))
+
+        dict_list = conv.to_dict_list()
+        self.assertEqual(len(dict_list), 1)
+        self.assertEqual(dict_list[0]["role"], "user")
+
+
+class TestContext(unittest.TestCase):
+
+    def test_creation(self):
+        ctx = Context()
+        self.assertEqual(len(ctx.data), 0)
+
+    def test_set_get(self):
+        ctx = Context()
+        ctx.set("key", "value")
+
+        self.assertTrue(ctx.has("key"))
+        self.assertEqual(ctx.get("key"), "value")
+
+    def test_remove(self):
+        ctx = Context()
+        ctx.set("key", "value")
+        ctx.remove("key")
+
+        self.assertFalse(ctx.has("key"))
+
+    def test_update(self):
+        ctx = Context()
+        ctx.update({"a": 1, "b": 2})
+
+        self.assertEqual(ctx.get("a"), 1)
+        self.assertEqual(ctx.get("b"), 2)
+
+
+class TestContextManager(unittest.TestCase):
+
+    def test_create_context(self):
+        manager = ContextManager()
+        ctx = manager.create_context("ctx-1")
+
+        self.assertIsNotNone(ctx)
+        self.assertIn("ctx-1", manager.list_contexts())
+
+    def test_get_context(self):
+        manager = ContextManager()
+        manager.create_context("ctx-1", {"test": "data"})
+
+        ctx = manager.get_context("ctx-1")
+        self.assertEqual(ctx.get("test"), "data")
+
+    def test_delete_context(self):
+        manager = ContextManager()
+        manager.create_context("ctx-1")
+        manager.delete_context("ctx-1")
+
+        self.assertNotIn("ctx-1", manager.list_contexts())
+
+
+class TestState(unittest.TestCase):
+
+    def test_creation(self):
+        state = State()
+        self.assertEqual(state.status, StateStatus.INITIALIZED)
+
+    def test_update_status(self):
+        state = State()
+        state.update_status(StateStatus.RUNNING)
+
+        self.assertEqual(state.status, StateStatus.RUNNING)
+
+    def test_checkpoint(self):
+        state = State()
+        state.set("key", "value")
+        state.create_checkpoint()
+
+        state.set("key", "new_value")
+        self.assertEqual(state.get("key"), "new_value")
+
+        state.restore_checkpoint()
+        self.assertEqual(state.get("key"), "value")
+
+
+class TestStateManager(unittest.TestCase):
+
+    def test_create_state(self):
+        manager = StateManager()
+        state = manager.create_state("state-1")
+
+        self.assertIsNotNone(state)
+        self.assertIn("state-1", manager.list_states())
+
+    def test_update_state(self):
+        manager = StateManager()
+        manager.create_state("state-1")
+
+        success = manager.update_state("state-1", StateStatus.COMPLETED, {"result": "done"})
+        self.assertTrue(success)
+
+        state = manager.get_state("state-1")
+        self.assertEqual(state.status, StateStatus.COMPLETED)
+
+
+class TestMemory(unittest.TestCase):
+
+    def test_creation(self):
+        mem = Memory()
+        self.assertEqual(mem.size(), 0)
+
+    def test_store_retrieve(self):
+        mem = Memory()
+        mem.store("fact1", "The sky is blue")
+
+        self.assertTrue(mem.has("fact1"))
+        self.assertEqual(mem.retrieve("fact1"), "The sky is blue")
+
+    def test_max_size(self):
+        mem = Memory(max_size=2)
+        mem.store("k1", "v1")
+        mem.store("k2", "v2")
+        mem.store("k3", "v3")
+
+        self.assertEqual(mem.size(), 2)
+        self.assertFalse(mem.has("k1"))
+
+    def test_get_recent(self):
+        mem = Memory()
+        mem.store("k1", "v1")
+        mem.store("k2", "v2")
+        mem.store("k3", "v3")
+
+        recent = mem.get_recent(limit=2)
+        self.assertEqual(len(recent), 2)
+
+
+class TestMemoryStore(unittest.TestCase):
+
+    def test_create_memory(self):
+        store = MemoryStore()
+        mem = store.create_memory("mem-1")
+
+        self.assertIsNotNone(mem)
+        self.assertIn("mem-1", store.list_memories())
+
+    def test_get_memory(self):
+        store = MemoryStore()
+        store.create_memory("mem-1")
+
+        mem = store.get_memory("mem-1")
+        self.assertIsNotNone(mem)
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai_orchestration/tests/test_composition.py

@@ -0,0 +1,265 @@
+import unittest
+
+from pygeai_orchestration.core.base.pattern import BasePattern, PatternConfig, PatternResult, PatternType
+from pygeai_orchestration.core.composition import (
+    CompositionConfig,
+    CompositionMode,
+    PatternComposer,
+    PatternPipeline,
+)
+from pygeai_orchestration.core.exceptions import PatternExecutionError
+
+
+class MockPattern(BasePattern):
+    def __init__(self, name: str, output: str, success: bool = True):
+        config = PatternConfig(name=name, pattern_type=PatternType.REFLECTION)
+        super().__init__(config)
+        self.output = output
+        self.success = success
+        self.executed = False
+
+    async def execute(self, task: str, **kwargs) -> PatternResult:
+        self.executed = True
+        if not self.success:
+            raise Exception(f"Pattern {self.config.name} failed")
+        return PatternResult(
+            success=True,
+            result=f"{self.output}: {task}",
+            metadata={"pattern_name": self.config.name}
+        )
+
+    async def _execute_impl(self, task: str, context=None) -> PatternResult:
+        return await self.execute(task)
+
+    async def step(self, task: str, context=None):
+        return await self.execute(task)
+
+
+class TestCompositionConfig(unittest.TestCase):
+    def test_default_config(self):
+        config = CompositionConfig()
+        self.assertEqual(config.mode, CompositionMode.SEQUENTIAL)
+        self.assertTrue(config.stop_on_error)
+        self.assertTrue(config.pass_output)
+
+    def test_custom_config(self):
+        config = CompositionConfig(
+            mode=CompositionMode.PARALLEL,
+            stop_on_error=False,
+            pass_output=False
+        )
+        self.assertEqual(config.mode, CompositionMode.PARALLEL)
+        self.assertFalse(config.stop_on_error)
+        self.assertFalse(config.pass_output)
+
+
+class TestPatternPipeline(unittest.IsolatedAsyncioTestCase):
+    def setUp(self):
+        self.pattern1 = MockPattern("pattern1", "Result1")
+        self.pattern2 = MockPattern("pattern2", "Result2")
+        self.pattern3 = MockPattern("pattern3", "Result3")
+
+    async def test_pipeline_creation(self):
+        pipeline = PatternPipeline()
+        self.assertEqual(len(pipeline), 0)
+
+    async def test_add_pattern(self):
+        pipeline = PatternPipeline()
+        pipeline.add_pattern(self.pattern1)
+        self.assertEqual(len(pipeline), 1)
+
+    async def test_add_patterns(self):
+        pipeline = PatternPipeline()
+        pipeline.add_patterns(self.pattern1, self.pattern2, self.pattern3)
+        self.assertEqual(len(pipeline), 3)
+
+    async def test_add_invalid_pattern(self):
+        pipeline = PatternPipeline()
+        with self.assertRaises(TypeError):
+            pipeline.add_pattern("not a pattern")
+
+    async def test_fluent_interface(self):
+        pipeline = PatternPipeline()
+        result = pipeline.add_pattern(self.pattern1).add_pattern(self.pattern2)
+        self.assertIs(result, pipeline)
+        self.assertEqual(len(pipeline), 2)
+
+    async def test_sequential_execution(self):
+        pipeline = PatternPipeline()
+        pipeline.add_patterns(self.pattern1, self.pattern2, self.pattern3)
+
+        result = await pipeline.execute("input")
+
+        self.assertTrue(result.success)
+        self.assertTrue(self.pattern1.executed)
+        self.assertTrue(self.pattern2.executed)
+        self.assertTrue(self.pattern3.executed)
+
+    async def test_sequential_output_passing(self):
+        pipeline = PatternPipeline(CompositionConfig(pass_output=True))
+        pipeline.add_patterns(self.pattern1, self.pattern2)
+
+        result = await pipeline.execute("input")
+
+        self.assertIn("Result2", result.result)
+        self.assertIn("Result1: input", result.result)
+
+    async def test_sequential_no_output_passing(self):
+        pipeline = PatternPipeline(CompositionConfig(pass_output=False))
+        pipeline.add_patterns(self.pattern1, self.pattern2)
+
+        result = await pipeline.execute("input")
+
+        self.assertIn("Result2: input", result.result)
+
+    async def test_stop_on_error(self):
+        failing_pattern = MockPattern("failing", "fail", success=False)
+        pipeline = PatternPipeline(CompositionConfig(stop_on_error=True))
+        pipeline.add_patterns(self.pattern1, failing_pattern, self.pattern3)
+
+        with self.assertRaises(PatternExecutionError):
+            await pipeline.execute("input")
+
+        self.assertTrue(self.pattern1.executed)
+        self.assertFalse(self.pattern3.executed)
+
+    async def test_continue_on_error(self):
+        failing_pattern = MockPattern("failing", "fail", success=False)
+        pipeline = PatternPipeline(CompositionConfig(stop_on_error=False))
+        pipeline.add_patterns(self.pattern1, failing_pattern, self.pattern3)
+
+        await pipeline.execute("input")
+
+        self.assertTrue(self.pattern1.executed)
+        self.assertTrue(self.pattern3.executed)
+
+    async def test_empty_pipeline(self):
+        pipeline = PatternPipeline()
+
+        with self.assertRaises(PatternExecutionError) as cm:
+            await pipeline.execute("input")
+
+        self.assertIn("No patterns", str(cm.exception))
+
+    async def test_get_results(self):
+        pipeline = PatternPipeline()
+        pipeline.add_patterns(self.pattern1, self.pattern2)
+
+        await pipeline.execute("input")
+        results = pipeline.get_results()
+
+        self.assertEqual(len(results), 2)
+        self.assertTrue(all(isinstance(r, PatternResult) for r in results))
+
+    async def test_clear_pipeline(self):
+        pipeline = PatternPipeline()
+        pipeline.add_patterns(self.pattern1, self.pattern2)
+        await pipeline.execute("input")
+
+        pipeline.clear()
+
+        self.assertEqual(len(pipeline), 0)
+        self.assertEqual(len(pipeline.get_results()), 0)
+
+    async def test_pipeline_metadata(self):
+        pipeline = PatternPipeline()
+        pipeline.add_patterns(self.pattern1, self.pattern2, self.pattern3)
+
+        result = await pipeline.execute("input")
+
+        self.assertIn("pipeline_results", result.metadata)
+        self.assertEqual(result.metadata["total_patterns"], 3)
+        self.assertEqual(result.metadata["successful_patterns"], 3)
+
+    async def test_parallel_execution(self):
+        pipeline = PatternPipeline(CompositionConfig(mode=CompositionMode.PARALLEL))
+        pipeline.add_patterns(self.pattern1, self.pattern2, self.pattern3)
+
+        result = await pipeline.execute("input")
+
+        self.assertTrue(result.success)
+        self.assertTrue(self.pattern1.executed)
+        self.assertTrue(self.pattern2.executed)
+        self.assertTrue(self.pattern3.executed)
+
+    async def test_parallel_combined_output(self):
+        pipeline = PatternPipeline(CompositionConfig(mode=CompositionMode.PARALLEL))
+        pipeline.add_patterns(self.pattern1, self.pattern2)
+
+        result = await pipeline.execute("input")
+
+        self.assertIn("Result1", result.result)
+        self.assertIn("Result2", result.result)
+
+    async def test_parallel_with_failure(self):
+        failing_pattern = MockPattern("failing", "fail", success=False)
+        pipeline = PatternPipeline(CompositionConfig(mode=CompositionMode.PARALLEL))
+        pipeline.add_patterns(self.pattern1, failing_pattern, self.pattern2)
+
+        result = await pipeline.execute("input")
+
+        self.assertTrue(result.success)
+        self.assertIn("Result1", result.result)
+        self.assertIn("Result2", result.result)
+
+    async def test_parallel_all_fail(self):
+        failing1 = MockPattern("fail1", "fail", success=False)
+        failing2 = MockPattern("fail2", "fail", success=False)
+        pipeline = PatternPipeline(CompositionConfig(mode=CompositionMode.PARALLEL))
+        pipeline.add_patterns(failing1, failing2)
+
+        with self.assertRaises(PatternExecutionError) as cm:
+            await pipeline.execute("input")
+
+        self.assertIn("All patterns failed", str(cm.exception))
+
+
+class TestPatternComposer(unittest.IsolatedAsyncioTestCase):
+    def setUp(self):
+        self.pattern1 = MockPattern("pattern1", "Result1")
+        self.pattern2 = MockPattern("pattern2", "Result2")
+
+    async def test_sequential_composer(self):
+        pipeline = PatternComposer.sequential(self.pattern1, self.pattern2)
+
+        self.assertIsInstance(pipeline, PatternPipeline)
+        self.assertEqual(len(pipeline), 2)
+        self.assertEqual(pipeline.config.mode, CompositionMode.SEQUENTIAL)
+
+    async def test_parallel_composer(self):
+        pipeline = PatternComposer.parallel(self.pattern1, self.pattern2)
+
+        self.assertIsInstance(pipeline, PatternPipeline)
+        self.assertEqual(len(pipeline), 2)
+        self.assertEqual(pipeline.config.mode, CompositionMode.PARALLEL)
+
+    async def test_custom_composer(self):
+        pipeline = PatternComposer.custom(
+            mode=CompositionMode.SEQUENTIAL,
+            stop_on_error=False,
+            pass_output=False
+        )
+
+        self.assertIsInstance(pipeline, PatternPipeline)
+        self.assertFalse(pipeline.config.stop_on_error)
+        self.assertFalse(pipeline.config.pass_output)
+
+    async def test_sequential_execution_via_composer(self):
+        pipeline = PatternComposer.sequential(self.pattern1, self.pattern2)
+        result = await pipeline.execute("input")
+
+        self.assertTrue(result.success)
+        self.assertTrue(self.pattern1.executed)
+        self.assertTrue(self.pattern2.executed)
+
+    async def test_parallel_execution_via_composer(self):
+        pipeline = PatternComposer.parallel(self.pattern1, self.pattern2)
+        result = await pipeline.execute("input")
+
+        self.assertTrue(result.success)
+        self.assertTrue(self.pattern1.executed)
+        self.assertTrue(self.pattern2.executed)
+
+
+if __name__ == "__main__":
+    unittest.main()