pixelweaver 0.1.0

package/server/tests/test_mcp_resources.py

@@ -0,0 +1,648 @@
+"""Tests for MCP resources and subscription tracking."""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from pydantic import AnyUrl
+
+from pixelweaver.mcp_bridge import CollabServerUnreachableError
+from pixelweaver.state import CanvasState, FrameState, ProjectState, ServerState
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture(autouse=True)
+def _reset_subscriptions():
+    """Clear the module-level subscription set before and after each test."""
+    from pixelweaver import mcp_resources
+    mcp_resources._subscribed_uris.clear()
+    yield
+    mcp_resources._subscribed_uris.clear()
+
+
+@pytest.fixture()
+def state_with_project() -> ServerState:
+    """ServerState with a single 4x4 project, one canvas, one layer, one frame."""
+    s = ServerState()
+    s.create_project("test-project", 4, 4)
+    return s
+
+
+@pytest.fixture()
+def state_with_painted_pixel(state_with_project: ServerState) -> ServerState:
+    """State with a red pixel at (0,0) so the palette resource has colors."""
+    canvas = next(iter(state_with_project.get_active_project().canvases.values()))
+    layer_id = canvas.layers[0]["id"]
+    data = bytearray(canvas.current_frame().pixel_data[layer_id])
+    data[0:4] = [255, 0, 0, 255]  # red pixel at (0,0)
+    canvas.current_frame().pixel_data[layer_id] = bytes(data)
+    return state_with_project
+
+
+def _patch_synced_state(state: ServerState):
+    """Return a context manager that patches _synced_state to return the given state."""
+    return patch(
+        "pixelweaver.mcp_resources._synced_state",
+        new_callable=AsyncMock,
+        return_value=state,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Helpers to extract resource handlers from a FastMCP mock
+# ---------------------------------------------------------------------------
+
+def _register_resources_on_mock() -> tuple[MagicMock, dict[str, Any]]:
+    """Create a FastMCP mock, call init_mcp_resources, return (mock, handlers).
+
+    handlers is a dict mapping resource URI templates to (handler_fn, kwargs).
+    """
+    from pixelweaver.mcp_resources import init_mcp_resources
+
+    mcp = MagicMock()
+    registered: dict[str, tuple] = {}
+
+    def fake_resource(uri_template: str, **kwargs):
+        """Capture the decorator registration."""
+        def decorator(fn):
+            registered[uri_template] = (fn, kwargs)
+            return fn
+        return decorator
+
+    mcp.resource = fake_resource
+    init_mcp_resources(mcp)
+    return mcp, registered
+
+
+# ---------------------------------------------------------------------------
+# Tests: init_mcp_resources registration
+# ---------------------------------------------------------------------------
+
+class TestInitMcpResources:
+    def test_registers_all_four_resources(self):
+        """init_mcp_resources registers all four expected resource URIs."""
+        _, registered = _register_resources_on_mock()
+        expected = {
+            "project://state",
+            "project://canvas/{name}",
+            "project://canvas/{name}/frame/{index}",
+            "project://palette",
+        }
+        assert set(registered.keys()) == expected
+
+    def test_resource_names(self):
+        """Each resource has the expected name kwarg."""
+        _, registered = _register_resources_on_mock()
+        assert registered["project://state"][1]["name"] == "project_state"
+        assert registered["project://canvas/{name}"][1]["name"] == "canvas_info"
+        assert registered["project://canvas/{name}/frame/{index}"][1]["name"] == "frame_png"
+        assert registered["project://palette"][1]["name"] == "palette"
+
+    def test_resource_mime_types(self):
+        """Each resource specifies the correct mime_type."""
+        _, registered = _register_resources_on_mock()
+        assert registered["project://state"][1]["mime_type"] == "application/json"
+        assert registered["project://canvas/{name}"][1]["mime_type"] == "application/json"
+        assert registered["project://canvas/{name}/frame/{index}"][1]["mime_type"] == "image/png"
+        assert registered["project://palette"][1]["mime_type"] == "application/json"
+
+
+# ---------------------------------------------------------------------------
+# Tests: project://state resource handler
+# ---------------------------------------------------------------------------
+
+class TestProjectStateResource:
+    async def test_returns_project_overview(self, state_with_project: ServerState):
+        """project://state returns project name, dimensions, and canvas info."""
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://state"][0]
+
+        with _patch_synced_state(state_with_project):
+            result = await handler()
+
+        data = json.loads(result)
+        assert data["name"] == "test-project"
+        assert data["width"] == 4
+        assert data["height"] == 4
+        assert "canvas-0" in data["canvases"]
+
+    async def test_canvas_info_structure(self, state_with_project: ServerState):
+        """Canvas entries contain layers, frame_count, and playback settings."""
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://state"][0]
+
+        with _patch_synced_state(state_with_project):
+            result = await handler()
+
+        canvas = json.loads(result)["canvases"]["canvas-0"]
+        assert canvas["name"] == "canvas-0"
+        assert canvas["width"] == 4
+        assert canvas["height"] == 4
+        assert canvas["layer_count"] == 1
+        assert len(canvas["layers"]) == 1
+        assert canvas["frame_count"] == 1
+        assert canvas["current_frame_index"] == 0
+        assert canvas["global_fps"] == 12.0
+
+    async def test_layer_info_structure(self, state_with_project: ServerState):
+        """Layer entries contain id, name, visible, and opacity."""
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://state"][0]
+
+        with _patch_synced_state(state_with_project):
+            result = await handler()
+
+        layer = json.loads(result)["canvases"]["canvas-0"]["layers"][0]
+        assert "id" in layer
+        assert layer["name"] == "Layer 0"
+        assert layer["visible"] is True
+        assert layer["opacity"] == 1.0
+
+    async def test_no_active_project(self):
+        """Returns error JSON when no active project exists."""
+        empty_state = ServerState()
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://state"][0]
+
+        with _patch_synced_state(empty_state):
+            result = await handler()
+
+        data = json.loads(result)
+        assert "error" in data
+        assert "No active project" in data["error"]
+
+    async def test_collab_server_unreachable(self):
+        """Returns error JSON when the collab server is unreachable."""
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://state"][0]
+
+        with patch(
+            "pixelweaver.mcp_resources._synced_state",
+            new_callable=AsyncMock,
+            side_effect=CollabServerUnreachableError("connection refused"),
+        ):
+            result = await handler()
+
+        data = json.loads(result)
+        assert "error" in data
+        assert "Collab server unreachable" in data["error"]
+
+
+# ---------------------------------------------------------------------------
+# Tests: project://canvas/{name} resource handler
+# ---------------------------------------------------------------------------
+
+class TestCanvasInfoResource:
+    async def test_returns_canvas_metadata(self, state_with_project: ServerState):
+        """canvas_info returns dimensions, layers, frames, and playback."""
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://canvas/{name}"][0]
+
+        with _patch_synced_state(state_with_project):
+            result = await handler("canvas-0")
+
+        data = json.loads(result)
+        assert data["name"] == "canvas-0"
+        assert data["width"] == 4
+        assert data["height"] == 4
+        assert len(data["layers"]) == 1
+        assert data["frame_count"] == 1
+        assert data["current_frame_index"] == 0
+        assert data["global_fps"] == 12.0
+
+    async def test_layer_includes_extra_fields(self, state_with_project: ServerState):
+        """Layer entries in canvas_info include locked and blend_mode."""
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://canvas/{name}"][0]
+
+        with _patch_synced_state(state_with_project):
+            result = await handler("canvas-0")
+
+        layer = json.loads(result)["layers"][0]
+        assert "locked" in layer
+        assert "blend_mode" in layer
+        assert layer["locked"] is False
+        assert layer["blend_mode"] == "normal"
+
+    async def test_canvas_not_found(self, state_with_project: ServerState):
+        """Returns error when canvas name does not exist."""
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://canvas/{name}"][0]
+
+        with _patch_synced_state(state_with_project):
+            result = await handler("nonexistent")
+
+        data = json.loads(result)
+        assert "error" in data
+        assert "not found" in data["error"]
+
+    async def test_no_active_project(self):
+        """Returns error when no active project exists."""
+        empty_state = ServerState()
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://canvas/{name}"][0]
+
+        with _patch_synced_state(empty_state):
+            result = await handler("canvas-0")
+
+        data = json.loads(result)
+        assert "error" in data
+        assert "No active project" in data["error"]
+
+    async def test_collab_server_unreachable(self):
+        """Returns error JSON when the collab server is unreachable."""
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://canvas/{name}"][0]
+
+        with patch(
+            "pixelweaver.mcp_resources._synced_state",
+            new_callable=AsyncMock,
+            side_effect=CollabServerUnreachableError("timeout"),
+        ):
+            result = await handler("canvas-0")
+
+        data = json.loads(result)
+        assert "error" in data
+        assert "Collab server unreachable" in data["error"]
+
+
+# ---------------------------------------------------------------------------
+# Tests: project://palette resource handler
+# ---------------------------------------------------------------------------
+
+class TestPaletteResource:
+    async def test_returns_colors(self, state_with_painted_pixel: ServerState):
+        """palette returns sorted hex colors from canvas pixel data."""
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://palette"][0]
+
+        with _patch_synced_state(state_with_painted_pixel):
+            result = await handler()
+
+        data = json.loads(result)
+        assert "colors" in data
+        assert "#ff0000ff" in data["colors"]
+
+    async def test_empty_canvas_returns_no_colors(self, state_with_project: ServerState):
+        """palette returns empty color list for a fully transparent canvas."""
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://palette"][0]
+
+        with _patch_synced_state(state_with_project):
+            result = await handler()
+
+        data = json.loads(result)
+        assert data["colors"] == []
+
+    async def test_no_active_project(self):
+        """Returns error when no active project."""
+        empty_state = ServerState()
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://palette"][0]
+
+        with _patch_synced_state(empty_state):
+            result = await handler()
+
+        data = json.loads(result)
+        assert "error" in data
+        assert "No active project" in data["error"]
+
+    async def test_no_canvas_in_project(self):
+        """Returns error when the project has no canvases."""
+        state = ServerState()
+        state.create_project("empty-proj", 4, 4)
+        # Remove all canvases
+        state.projects["empty-proj"].canvases.clear()
+
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://palette"][0]
+
+        with _patch_synced_state(state):
+            result = await handler()
+
+        data = json.loads(result)
+        assert "error" in data
+        assert "No canvas" in data["error"]
+
+    async def test_collab_server_unreachable(self):
+        """Returns error JSON when the collab server is unreachable."""
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://palette"][0]
+
+        with patch(
+            "pixelweaver.mcp_resources._synced_state",
+            new_callable=AsyncMock,
+            side_effect=CollabServerUnreachableError("down"),
+        ):
+            result = await handler()
+
+        data = json.loads(result)
+        assert "error" in data
+        assert "Collab server unreachable" in data["error"]
+
+    async def test_max_colors_cap(self, state_with_project: ServerState):
+        """palette caps at 256 colors even when more exist."""
+        canvas = next(iter(state_with_project.get_active_project().canvases.values()))
+        layer_id = canvas.layers[0]["id"]
+
+        # Create a canvas large enough to hold >256 unique colors.
+        # We need at least 257 unique RGBA values with a > 0.
+        # Resize canvas to 18x18 = 324 pixels (enough for 257+ unique colors).
+        canvas.width = 18
+        canvas.height = 18
+        big_data = bytearray(18 * 18 * 4)
+        for i in range(18 * 18):
+            # Generate unique color per pixel (vary R and G, keep A=255)
+            r = i % 256
+            g = (i // 256) % 256
+            big_data[i * 4] = r
+            big_data[i * 4 + 1] = g
+            big_data[i * 4 + 2] = 0
+            big_data[i * 4 + 3] = 255
+        canvas.current_frame().pixel_data[layer_id] = bytes(big_data)
+
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://palette"][0]
+
+        with _patch_synced_state(state_with_project):
+            result = await handler()
+
+        data = json.loads(result)
+        assert len(data["colors"]) == 256
+
+
+# ---------------------------------------------------------------------------
+# Tests: project://canvas/{name}/frame/{index} resource handler
+# ---------------------------------------------------------------------------
+
+class TestFramePngResource:
+    async def test_returns_png_bytes(self, state_with_project: ServerState):
+        """frame_png returns bytes that look like a PNG."""
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://canvas/{name}/frame/{index}"][0]
+
+        with _patch_synced_state(state_with_project), patch(
+            "pixelweaver.storage.export_frame_png",
+            return_value=b"\x89PNG\r\n\x1a\nfake",
+        ) as mock_export:
+            result = await handler("canvas-0", "0")
+
+        assert isinstance(result, bytes)
+        assert result.startswith(b"\x89PNG")
+        mock_export.assert_called_once_with(
+            state_with_project.get_active_project(), "canvas-0", 0,
+        )
+
+    async def test_invalid_frame_index_raises(self, state_with_project: ServerState):
+        """frame_png raises RuntimeError for non-integer index."""
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://canvas/{name}/frame/{index}"][0]
+
+        with _patch_synced_state(state_with_project), pytest.raises(
+            RuntimeError, match="Invalid frame index",
+        ):
+            await handler("canvas-0", "not-a-number")
+
+    async def test_no_active_project_raises(self):
+        """frame_png raises RuntimeError when no active project."""
+        empty_state = ServerState()
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://canvas/{name}/frame/{index}"][0]
+
+        with _patch_synced_state(empty_state), pytest.raises(
+            RuntimeError, match="No active project",
+        ):
+            await handler("canvas-0", "0")
+
+    async def test_collab_server_unreachable_raises(self):
+        """frame_png raises RuntimeError when collab server is unreachable."""
+        _, registered = _register_resources_on_mock()
+        handler = registered["project://canvas/{name}/frame/{index}"][0]
+
+        with patch(
+            "pixelweaver.mcp_resources._synced_state",
+            new_callable=AsyncMock,
+            side_effect=CollabServerUnreachableError("refused"),
+        ), pytest.raises(RuntimeError, match="Collab server unreachable"):
+            await handler("canvas-0", "0")
+
+
+# ---------------------------------------------------------------------------
+# Tests: Subscription tracking
+# ---------------------------------------------------------------------------
+
+class TestSubscriptionTracking:
+    async def test_subscribe_adds_uri(self):
+        """Subscribing adds the URI string to the tracked set."""
+        from pixelweaver.mcp_resources import _subscribed_uris, init_mcp_subscriptions
+
+        mcp = MagicMock()
+        low_level = MagicMock()
+        mcp._mcp_server = low_level
+
+        # Capture the subscribe handler
+        subscribe_handler = None
+
+        def capture_subscribe():
+            def decorator(fn):
+                nonlocal subscribe_handler
+                subscribe_handler = fn
+                return fn
+            return decorator
+
+        low_level.subscribe_resource = capture_subscribe
+        low_level.unsubscribe_resource = lambda: lambda fn: fn
+        low_level.get_capabilities = MagicMock(return_value=MagicMock(resources=MagicMock(subscribe=False)))
+
+        init_mcp_subscriptions(mcp)
+        assert subscribe_handler is not None
+
+        uri = AnyUrl("project://state")
+        await subscribe_handler(uri)
+        assert str(uri) in _subscribed_uris
+
+    async def test_unsubscribe_removes_uri(self):
+        """Unsubscribing removes the URI from the tracked set."""
+        from pixelweaver.mcp_resources import _subscribed_uris, init_mcp_subscriptions
+
+        mcp = MagicMock()
+        low_level = MagicMock()
+        mcp._mcp_server = low_level
+
+        # Capture both handlers
+        subscribe_handler = None
+        unsubscribe_handler = None
+
+        def capture_subscribe():
+            def decorator(fn):
+                nonlocal subscribe_handler
+                subscribe_handler = fn
+                return fn
+            return decorator
+
+        def capture_unsubscribe():
+            def decorator(fn):
+                nonlocal unsubscribe_handler
+                unsubscribe_handler = fn
+                return fn
+            return decorator
+
+        low_level.subscribe_resource = capture_subscribe
+        low_level.unsubscribe_resource = capture_unsubscribe
+        low_level.get_capabilities = MagicMock(return_value=MagicMock(resources=MagicMock(subscribe=False)))
+
+        init_mcp_subscriptions(mcp)
+
+        uri = AnyUrl("project://palette")
+        await subscribe_handler(uri)
+        assert str(uri) in _subscribed_uris
+
+        await unsubscribe_handler(uri)
+        assert str(uri) not in _subscribed_uris
+
+    async def test_unsubscribe_nonexistent_is_safe(self):
+        """Unsubscribing a URI that was never subscribed does not raise."""
+        from pixelweaver.mcp_resources import _subscribed_uris, init_mcp_subscriptions
+
+        mcp = MagicMock()
+        low_level = MagicMock()
+        mcp._mcp_server = low_level
+
+        unsubscribe_handler = None
+
+        def capture_unsubscribe():
+            def decorator(fn):
+                nonlocal unsubscribe_handler
+                unsubscribe_handler = fn
+                return fn
+            return decorator
+
+        low_level.subscribe_resource = lambda: lambda fn: fn
+        low_level.unsubscribe_resource = capture_unsubscribe
+        low_level.get_capabilities = MagicMock(return_value=MagicMock(resources=MagicMock(subscribe=False)))
+
+        init_mcp_subscriptions(mcp)
+
+        # Should not raise
+        uri = AnyUrl("project://nonexistent")
+        await unsubscribe_handler(uri)
+        assert len(_subscribed_uris) == 0
+
+    def test_get_subscribed_uris_returns_frozen_snapshot(self):
+        """get_subscribed_uris returns a frozenset copy."""
+        from pixelweaver.mcp_resources import _subscribed_uris, get_subscribed_uris
+
+        _subscribed_uris.add("project://state")
+        _subscribed_uris.add("project://palette")
+
+        snapshot = get_subscribed_uris()
+        assert isinstance(snapshot, frozenset)
+        assert snapshot == {"project://state", "project://palette"}
+
+        # Mutations to the module set do not affect the snapshot
+        _subscribed_uris.add("project://canvas/foo")
+        assert "project://canvas/foo" not in snapshot
+
+    async def test_capabilities_patched_to_advertise_subscribe(self):
+        """init_mcp_subscriptions patches get_capabilities to set subscribe=True."""
+        from pixelweaver.mcp_resources import init_mcp_subscriptions
+
+        mcp = MagicMock()
+        low_level = MagicMock()
+        mcp._mcp_server = low_level
+
+        low_level.subscribe_resource = lambda: lambda fn: fn
+        low_level.unsubscribe_resource = lambda: lambda fn: fn
+
+        # Original returns resources with subscribe=False
+        resources_cap = MagicMock(subscribe=False)
+        original_caps = MagicMock(resources=resources_cap)
+        low_level.get_capabilities = MagicMock(return_value=original_caps)
+
+        init_mcp_subscriptions(mcp)
+
+        # The patched get_capabilities should set subscribe=True
+        caps = low_level.get_capabilities(None, None)
+        assert caps.resources.subscribe is True
+
+
+# ---------------------------------------------------------------------------
+# Tests: notify_resource_subscribers
+# ---------------------------------------------------------------------------
+
+class TestNotifyResourceSubscribers:
+    async def test_sends_updated_for_each_subscribed_uri(self):
+        """notify_resource_subscribers calls send_resource_updated for each URI."""
+        from pixelweaver.mcp_resources import _subscribed_uris, notify_resource_subscribers
+
+        _subscribed_uris.add("project://state")
+        _subscribed_uris.add("project://palette")
+
+        session = AsyncMock()
+        context = MagicMock()
+        context.session = session
+
+        mcp = MagicMock()
+        mcp._mcp_server.request_context.session = session
+
+        await notify_resource_subscribers(mcp)
+
+        assert session.send_resource_updated.call_count == 2
+        called_uris = {
+            str(call.kwargs["uri"])
+            for call in session.send_resource_updated.call_args_list
+        }
+        assert called_uris == {"project://state", "project://palette"}
+
+    async def test_no_subscriptions_is_noop(self):
+        """notify_resource_subscribers does nothing when no URIs are subscribed."""
+        from pixelweaver.mcp_resources import notify_resource_subscribers
+
+        mcp = MagicMock()
+        await notify_resource_subscribers(mcp)
+
+        # Should not even attempt to access session
+        mcp._mcp_server.request_context.session.send_resource_updated.assert_not_called()
+
+    async def test_handles_missing_request_context(self):
+        """notify_resource_subscribers handles LookupError from missing context."""
+        from pixelweaver.mcp_resources import _subscribed_uris, notify_resource_subscribers
+
+        _subscribed_uris.add("project://state")
+
+        mcp = MagicMock()
+        # Simulate the ContextVar raising LookupError
+        type(mcp._mcp_server.request_context).session = property(
+            lambda self: (_ for _ in ()).throw(LookupError("no context"))
+        )
+
+        # Should not raise
+        await notify_resource_subscribers(mcp)
+
+    async def test_handles_send_failure_gracefully(self):
+        """notify_resource_subscribers continues after individual send failures."""
+        from pixelweaver.mcp_resources import _subscribed_uris, notify_resource_subscribers
+
+        _subscribed_uris.add("project://state")
+        _subscribed_uris.add("project://palette")
+
+        session = AsyncMock()
+        # First call raises, second succeeds
+        session.send_resource_updated.side_effect = [
+            Exception("network error"),
+            None,
+        ]
+
+        mcp = MagicMock()
+        mcp._mcp_server.request_context.session = session
+
+        # Should not raise despite the first send failing
+        await notify_resource_subscribers(mcp)
+
+        # Both sends were attempted
+        assert session.send_resource_updated.call_count == 2