pixelweaver 0.1.0

package/server/tests/test_mcp_bridge.py

@@ -0,0 +1,293 @@
+"""Tests for the MCP bridge (state serialization round-trip and REST endpoints)."""
+
+from __future__ import annotations
+
+from pixelweaver.main import state
+from pixelweaver.mcp_bridge import deserialize_into_state, serialize_state
+from pixelweaver.state import CanvasState, FrameState, ProjectState, ServerState
+
+
+class TestSerializationRoundTrip:
+    """serialize_state -> deserialize_into_state preserves all data."""
+
+    def test_empty_state_round_trips(self):
+        original = ServerState()
+        data = serialize_state(original)
+        restored = ServerState()
+        deserialize_into_state(restored, data)
+
+        assert restored.active_project is None
+        assert restored.projects == {}
+
+    def test_project_with_canvas_round_trips(self):
+        original = ServerState()
+        original.create_project("sprite-1", 16, 16)
+
+        data = serialize_state(original)
+        restored = ServerState()
+        deserialize_into_state(restored, data)
+
+        assert restored.active_project == "sprite-1"
+        assert "sprite-1" in restored.projects
+
+        project = restored.projects["sprite-1"]
+        assert project.width == 16
+        assert project.height == 16
+        assert "canvas-0" in project.canvases
+
+        canvas = project.canvases["canvas-0"]
+        assert canvas.width == 16
+        assert canvas.height == 16
+        assert len(canvas.layers) == 1
+        layer_id = canvas.layers[0]["id"]
+        assert layer_id in canvas.current_frame().pixel_data
+        # Default is transparent RGBA
+        assert len(canvas.current_frame().pixel_data[layer_id]) == 16 * 16 * 4
+
+    def test_pixel_data_preserved(self):
+        """Pixel data survives base64 encode/decode round-trip."""
+        original = ServerState()
+        original.create_project("art", 4, 4)
+        canvas = original.projects["art"].canvases["canvas-0"]
+        layer_id = canvas.layers[0]["id"]
+
+        # Paint some non-zero pixels
+        pixel_data = bytearray(canvas.current_frame().pixel_data[layer_id])
+        pixel_data[0:4] = [255, 0, 0, 255]  # red pixel at (0, 0)
+        pixel_data[4:8] = [0, 255, 0, 128]  # semi-transparent green at (1, 0)
+        canvas.current_frame().pixel_data[layer_id] = bytes(pixel_data)
+
+        data = serialize_state(original)
+        restored = ServerState()
+        deserialize_into_state(restored, data)
+
+        restored_canvas = restored.projects["art"].canvases["canvas-0"]
+        restored_data = restored_canvas.current_frame().pixel_data[layer_id]
+        assert restored_data[0:4] == bytes([255, 0, 0, 255])
+        assert restored_data[4:8] == bytes([0, 255, 0, 128])
+
+    def test_command_history_preserved(self):
+        original = ServerState()
+        original.create_project("hist", 8, 8)
+        project = original.projects["hist"]
+        project.command_history.append({"type": "draw_pixels", "id": "cmd-1"})
+        project.redo_stack.append({"type": "draw_rect", "id": "cmd-2"})
+
+        data = serialize_state(original)
+        restored = ServerState()
+        deserialize_into_state(restored, data)
+
+        rp = restored.projects["hist"]
+        assert len(rp.command_history) == 1
+        assert rp.command_history[0]["type"] == "draw_pixels"
+        assert len(rp.redo_stack) == 1
+        assert rp.redo_stack[0]["type"] == "draw_rect"
+
+    def test_multiple_projects(self):
+        original = ServerState()
+        original.create_project("a", 8, 8)
+        original.create_project("b", 16, 16)
+        original.active_project = "b"
+
+        data = serialize_state(original)
+        restored = ServerState()
+        deserialize_into_state(restored, data)
+
+        assert restored.active_project == "b"
+        assert "a" in restored.projects
+        assert "b" in restored.projects
+
+
+    def test_multiple_frames_round_trip(self):
+        """All frames with different pixel data survive serialization."""
+        original = ServerState()
+        original.create_project("anim", 2, 2)
+        canvas = original.projects["anim"].canvases["canvas-0"]
+        layer_id = canvas.layers[0]["id"]
+
+        # Paint frame 0 red
+        canvas.frames[0].pixel_data[layer_id] = bytes([255, 0, 0, 255] * 4)
+
+        # Add a second frame with green pixels
+        frame2 = FrameState(
+            id="frame-2-id",
+            duration_ms=200,
+            pixel_data={layer_id: bytes([0, 255, 0, 255] * 4)},
+        )
+        canvas.frames.append(frame2)
+        canvas.current_frame_index = 1
+        canvas.global_fps = 24.0
+
+        data = serialize_state(original)
+        restored = ServerState()
+        deserialize_into_state(restored, data)
+
+        rc = restored.projects["anim"].canvases["canvas-0"]
+        assert len(rc.frames) == 2
+        # Frame 0: red pixels
+        assert rc.frames[0].pixel_data[layer_id] == bytes([255, 0, 0, 255] * 4)
+        # Frame 1: green pixels, correct id and duration
+        assert rc.frames[1].id == "frame-2-id"
+        assert rc.frames[1].duration_ms == 200
+        assert rc.frames[1].pixel_data[layer_id] == bytes([0, 255, 0, 255] * 4)
+        # Canvas-level animation state preserved
+        assert rc.current_frame_index == 1
+        assert rc.global_fps == 24.0
+
+    def test_frame_ids_and_durations_preserved(self):
+        """Frame IDs and per-frame durations survive serialization."""
+        original = ServerState()
+        original.create_project("dur", 1, 1)
+        canvas = original.projects["dur"].canvases["canvas-0"]
+        layer_id = canvas.layers[0]["id"]
+
+        # Set a known ID and duration on the default frame
+        canvas.frames[0].id = "stable-id-1"
+        canvas.frames[0].duration_ms = 100
+
+        # Add frames with varying durations (including None = use global fps)
+        for i, dur in enumerate([None, 250, 500], start=2):
+            canvas.frames.append(FrameState(
+                id=f"stable-id-{i}",
+                duration_ms=dur,
+                pixel_data={layer_id: bytes(4)},
+            ))
+
+        data = serialize_state(original)
+        restored = ServerState()
+        deserialize_into_state(restored, data)
+
+        rc = restored.projects["dur"].canvases["canvas-0"]
+        assert len(rc.frames) == 4
+        assert [f.id for f in rc.frames] == [
+            "stable-id-1", "stable-id-2", "stable-id-3", "stable-id-4",
+        ]
+        assert [f.duration_ms for f in rc.frames] == [100, None, 250, 500]
+
+    def test_legacy_flat_pixel_data_deserialization(self):
+        """Deserializing legacy format (flat pixel_data, no frames key) works."""
+        # Simulate the old serialized format that lacks a 'frames' key
+        import base64
+        pixel_bytes = bytes([128, 64, 32, 255] * 4)
+        legacy_data = {
+            "projects": {
+                "old-proj": {
+                    "name": "old-proj",
+                    "width": 2,
+                    "height": 2,
+                    "canvases": {
+                        "canvas-0": {
+                            "name": "canvas-0",
+                            "width": 2,
+                            "height": 2,
+                            "layers": [{"id": "layer-1", "name": "Layer 0",
+                                        "visible": True, "opacity": 1.0}],
+                            "pixel_data": {
+                                "layer-1": base64.b64encode(pixel_bytes).decode("ascii"),
+                            },
+                        },
+                    },
+                    "command_history": [],
+                    "redo_stack": [],
+                },
+            },
+            "active_project": "old-proj",
+        }
+
+        restored = ServerState()
+        deserialize_into_state(restored, legacy_data)
+
+        canvas = restored.projects["old-proj"].canvases["canvas-0"]
+        assert len(canvas.frames) == 1
+        assert canvas.current_frame().pixel_data["layer-1"] == pixel_bytes
+
+
+class TestStateSyncEndpoints:
+    """Test the /api/state/full and /api/state/sync REST endpoints."""
+
+    def test_get_full_state_empty(self, client):
+        response = client.get("/api/state/full")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["projects"] == {}
+        assert data["active_project"] is None
+
+    def test_get_full_state_with_project(self, client, tmp_path):
+        from pixelweaver.config import set_data_dir
+        set_data_dir(str(tmp_path))
+
+        # Create a project via the REST API
+        client.post("/api/projects", json={
+            "name": "test-proj",
+            "width": 8,
+            "height": 8,
+        })
+
+        response = client.get("/api/state/full")
+        assert response.status_code == 200
+        data = response.json()
+        assert "test-proj" in data["projects"]
+        assert data["active_project"] == "test-proj"
+
+        # Check canvas and frame data are included
+        project = data["projects"]["test-proj"]
+        assert "canvas-0" in project["canvases"]
+        canvas = project["canvases"]["canvas-0"]
+        assert canvas["width"] == 8
+        assert len(canvas["frames"]) == 1  # one frame
+        assert len(canvas["frames"][0]["pixel_data"]) == 1  # one layer
+
+    def test_sync_state_overwrites(self, client):
+        """POST /api/state/sync replaces the server state."""
+        # Server starts empty
+        response = client.get("/api/state/full")
+        assert response.json()["projects"] == {}
+
+        # Build a state payload manually
+        s = ServerState()
+        s.create_project("synced", 12, 12)
+        payload = serialize_state(s)
+
+        # Push it
+        response = client.post("/api/state/sync", json=payload)
+        assert response.status_code == 200
+        assert response.json()["success"] is True
+
+        # Verify the server now has the project
+        response = client.get("/api/state/full")
+        data = response.json()
+        assert "synced" in data["projects"]
+        assert data["active_project"] == "synced"
+
+    def test_sync_state_round_trip(self, client, tmp_path):
+        """Full round trip: create project, pull state, modify, push back."""
+        from pixelweaver.config import set_data_dir
+        set_data_dir(str(tmp_path))
+
+        # Create project via REST
+        client.post("/api/projects", json={
+            "name": "round-trip",
+            "width": 4,
+            "height": 4,
+        })
+
+        # Pull state
+        response = client.get("/api/state/full")
+        data = response.json()
+
+        # Modify locally (simulate MCP adding a command to history)
+        local_state = ServerState()
+        deserialize_into_state(local_state, data)
+        project = local_state.projects["round-trip"]
+        project.command_history.append({"type": "draw_pixels", "id": "test-cmd"})
+
+        # Push back
+        modified = serialize_state(local_state)
+        response = client.post("/api/state/sync", json=modified)
+        assert response.status_code == 200
+
+        # Verify the server has the command in history
+        response = client.get("/api/state/full")
+        proj_data = response.json()["projects"]["round-trip"]
+        assert len(proj_data["command_history"]) == 1
+        assert proj_data["command_history"][0]["id"] == "test-cmd"

package/server/tests/test_mcp_lock.py

@@ -0,0 +1,34 @@
+"""Tests for the MCP sequential lock."""
+
+from __future__ import annotations
+
+import pytest
+
+from pixelweaver.mcp_lock import MCPLock
+
+
+class TestMCPLock:
+    @pytest.mark.asyncio
+    async def test_acquire_release(self):
+        """Lock can be acquired and released."""
+        lock = MCPLock()
+        assert not lock.is_locked
+        await lock.acquire()
+        assert lock.is_locked
+        lock.release()
+        assert not lock.is_locked
+
+    @pytest.mark.asyncio
+    async def test_is_locked_reflects_state(self):
+        """is_locked accurately reports the lock state across transitions."""
+        lock = MCPLock()
+        assert not lock.is_locked
+        await lock.acquire()
+        assert lock.is_locked
+        lock.release()
+        assert not lock.is_locked
+        # Re-acquire
+        await lock.acquire()
+        assert lock.is_locked
+        lock.release()
+        assert not lock.is_locked