feature/capability-based-deps (#53)

Reviewed-on: #53
Co-authored-by: David Gwilliam <dhgwilliam@gmail.com>
Co-committed-by: David Gwilliam <dhgwilliam@gmail.com>

tests/test_adapters.py

@@ -0,0 +1,272 @@
+"""
+Tests for engine/pipeline/adapters.py - Stage adapters for the pipeline.
+
+Tests Stage adapters that bridge existing components to the Stage interface.
+Focuses on behavior testing rather than mock interactions.
+"""
+
+from unittest.mock import MagicMock
+
+from engine.data_sources.sources import SourceItem
+from engine.display.backends.null import NullDisplay
+from engine.effects.plugins import discover_plugins
+from engine.effects.registry import get_registry
+from engine.pipeline.adapters import (
+    DataSourceStage,
+    DisplayStage,
+    EffectPluginStage,
+    PassthroughStage,
+    SourceItemsToBufferStage,
+)
+from engine.pipeline.core import PipelineContext
+
+
+class TestDataSourceStage:
+    """Test DataSourceStage adapter."""
+
+    def test_datasource_stage_properties(self):
+        """DataSourceStage has correct name, category, and capabilities."""
+        mock_source = MagicMock()
+        stage = DataSourceStage(mock_source, name="headlines")
+
+        assert stage.name == "headlines"
+        assert stage.category == "source"
+        assert "source.headlines" in stage.capabilities
+        assert stage.dependencies == set()
+
+    def test_datasource_stage_process_calls_get_items(self):
+        """DataSourceStage.process() calls source.get_items()."""
+        mock_items = [
+            SourceItem(content="Item 1", source="headlines", timestamp="12:00"),
+        ]
+        mock_source = MagicMock()
+        mock_source.get_items.return_value = mock_items
+
+        stage = DataSourceStage(mock_source, name="headlines")
+        ctx = PipelineContext()
+        result = stage.process(None, ctx)
+
+        assert result == mock_items
+        mock_source.get_items.assert_called_once()
+
+    def test_datasource_stage_process_fallback(self):
+        """DataSourceStage.process() returns data if no get_items method."""
+        mock_source = MagicMock(spec=[])  # No get_items method
+        stage = DataSourceStage(mock_source, name="headlines")
+        ctx = PipelineContext()
+        test_data = [{"content": "test"}]
+
+        result = stage.process(test_data, ctx)
+        assert result == test_data
+
+
+class TestDisplayStage:
+    """Test DisplayStage adapter using NullDisplay for real behavior."""
+
+    def test_display_stage_properties(self):
+        """DisplayStage has correct name, category, and capabilities."""
+        display = NullDisplay()
+        stage = DisplayStage(display, name="terminal")
+
+        assert stage.name == "terminal"
+        assert stage.category == "display"
+        assert "display.output" in stage.capabilities
+        assert "render.output" in stage.dependencies
+
+    def test_display_stage_init_and_process(self):
+        """DisplayStage initializes display and processes buffer."""
+        from engine.pipeline.params import PipelineParams
+
+        display = NullDisplay()
+        stage = DisplayStage(display, name="terminal")
+
+        ctx = PipelineContext()
+        ctx.params = PipelineParams()
+        ctx.params.viewport_width = 80
+        ctx.params.viewport_height = 24
+
+        # Initialize
+        result = stage.init(ctx)
+        assert result is True
+
+        # Process buffer
+        buffer = ["Line 1", "Line 2", "Line 3"]
+        output = stage.process(buffer, ctx)
+        assert output == buffer
+
+        # Verify display captured the buffer
+        assert display._last_buffer == buffer
+
+    def test_display_stage_skips_none_data(self):
+        """DisplayStage.process() skips show() if data is None."""
+        display = NullDisplay()
+        stage = DisplayStage(display, name="terminal")
+
+        ctx = PipelineContext()
+        result = stage.process(None, ctx)
+
+        assert result is None
+        assert display._last_buffer is None
+
+
+class TestPassthroughStage:
+    """Test PassthroughStage adapter."""
+
+    def test_passthrough_stage_properties(self):
+        """PassthroughStage has correct properties."""
+        stage = PassthroughStage(name="test")
+
+        assert stage.name == "test"
+        assert stage.category == "render"
+        assert stage.optional is True
+        assert "render.output" in stage.capabilities
+        assert "source" in stage.dependencies
+
+    def test_passthrough_stage_process_unchanged(self):
+        """PassthroughStage.process() returns data unchanged."""
+        stage = PassthroughStage()
+        ctx = PipelineContext()
+
+        test_data = [
+            SourceItem(content="Line 1", source="test", timestamp="12:00"),
+        ]
+        result = stage.process(test_data, ctx)
+
+        assert result == test_data
+        assert result is test_data
+
+
+class TestSourceItemsToBufferStage:
+    """Test SourceItemsToBufferStage adapter."""
+
+    def test_source_items_to_buffer_stage_properties(self):
+        """SourceItemsToBufferStage has correct properties."""
+        stage = SourceItemsToBufferStage(name="custom-name")
+
+        assert stage.name == "custom-name"
+        assert stage.category == "render"
+        assert stage.optional is True
+        assert "render.output" in stage.capabilities
+        assert "source" in stage.dependencies
+
+    def test_source_items_to_buffer_stage_process_single_line(self):
+        """SourceItemsToBufferStage converts single-line SourceItem."""
+        stage = SourceItemsToBufferStage()
+        ctx = PipelineContext()
+
+        items = [
+            SourceItem(content="Single line content", source="test", timestamp="12:00"),
+        ]
+        result = stage.process(items, ctx)
+
+        assert isinstance(result, list)
+        assert len(result) >= 1
+        assert all(isinstance(line, str) for line in result)
+        assert "Single line content" in result[0]
+
+    def test_source_items_to_buffer_stage_process_multiline(self):
+        """SourceItemsToBufferStage splits multiline SourceItem content."""
+        stage = SourceItemsToBufferStage()
+        ctx = PipelineContext()
+
+        content = "Line 1\nLine 2\nLine 3"
+        items = [
+            SourceItem(content=content, source="test", timestamp="12:00"),
+        ]
+        result = stage.process(items, ctx)
+
+        # Should have at least 3 lines
+        assert len(result) >= 3
+        assert all(isinstance(line, str) for line in result)
+
+    def test_source_items_to_buffer_stage_process_multiple_items(self):
+        """SourceItemsToBufferStage handles multiple SourceItems."""
+        stage = SourceItemsToBufferStage()
+        ctx = PipelineContext()
+
+        items = [
+            SourceItem(content="Item 1", source="test", timestamp="12:00"),
+            SourceItem(content="Item 2", source="test", timestamp="12:01"),
+            SourceItem(content="Item 3", source="test", timestamp="12:02"),
+        ]
+        result = stage.process(items, ctx)
+
+        # Should have at least 3 lines (one per item, possibly more)
+        assert len(result) >= 3
+        assert all(isinstance(line, str) for line in result)
+
+
+class TestEffectPluginStage:
+    """Test EffectPluginStage adapter with real effect plugins."""
+
+    def test_effect_plugin_stage_properties(self):
+        """EffectPluginStage has correct properties for real effects."""
+        discover_plugins()
+        registry = get_registry()
+        effect = registry.get("noise")
+
+        stage = EffectPluginStage(effect, name="noise")
+
+        assert stage.name == "noise"
+        assert stage.category == "effect"
+        assert stage.optional is False
+        assert "effect.noise" in stage.capabilities
+
+    def test_effect_plugin_stage_hud_special_handling(self):
+        """EffectPluginStage has special handling for HUD effect."""
+        discover_plugins()
+        registry = get_registry()
+        hud_effect = registry.get("hud")
+
+        stage = EffectPluginStage(hud_effect, name="hud")
+
+        assert stage.stage_type == "overlay"
+        assert stage.is_overlay is True
+        assert stage.render_order == 100
+
+    def test_effect_plugin_stage_process_real_effect(self):
+        """EffectPluginStage.process() calls real effect.process()."""
+        from engine.pipeline.params import PipelineParams
+
+        discover_plugins()
+        registry = get_registry()
+        effect = registry.get("noise")
+
+        stage = EffectPluginStage(effect, name="noise")
+        ctx = PipelineContext()
+        ctx.params = PipelineParams()
+        ctx.params.viewport_width = 80
+        ctx.params.viewport_height = 24
+        ctx.params.frame_number = 0
+
+        test_buffer = ["Line 1", "Line 2", "Line 3"]
+        result = stage.process(test_buffer, ctx)
+
+        # Should return a list (possibly modified buffer)
+        assert isinstance(result, list)
+        # Noise effect should preserve line count
+        assert len(result) == len(test_buffer)
+
+    def test_effect_plugin_stage_process_with_real_figment(self):
+        """EffectPluginStage processes figment effect correctly."""
+        from engine.pipeline.params import PipelineParams
+
+        discover_plugins()
+        registry = get_registry()
+        figment = registry.get("figment")
+
+        stage = EffectPluginStage(figment, name="figment")
+        ctx = PipelineContext()
+        ctx.params = PipelineParams()
+        ctx.params.viewport_width = 80
+        ctx.params.viewport_height = 24
+        ctx.params.frame_number = 0
+
+        test_buffer = ["Line 1", "Line 2", "Line 3"]
+        result = stage.process(test_buffer, ctx)
+
+        # Figment is an overlay effect
+        assert stage.is_overlay is True
+        assert stage.stage_type == "overlay"
+        # Result should be a list
+        assert isinstance(result, list)