pixelweaver 0.1.0

package/server/tests/test_protocol.py

@@ -0,0 +1,125 @@
+"""Tests for the WebSocket JSON protocol message models."""
+
+import pytest
+from pydantic import ValidationError
+
+from pixelweaver.protocol import (
+    CommandAckMessage,
+    CommandBroadcastMessage,
+    CommandMessage,
+    CommandRejectMessage,
+    ErrorMessage,
+    RedoMessage,
+    StateSyncMessage,
+    SyncRequestMessage,
+    UndoMessage,
+    parse_client_message,
+)
+
+# ---------------------------------------------------------------------------
+# Client -> Server message parsing
+# ---------------------------------------------------------------------------
+
+
+class TestParseClientMessage:
+    def test_parse_command(self):
+        raw = {
+            "type": "command",
+            "id": "msg-1",
+            "command": {
+                "type": "draw_pixels",
+                "plugin": "builtin/pencil",
+                "version": "1.0.0",
+                "params": {"x": 10, "y": 20},
+                "id": "cmd-1",
+                "timestamp": 1234567890,
+            },
+        }
+        msg = parse_client_message(raw)
+        assert isinstance(msg, CommandMessage)
+        assert msg.id == "msg-1"
+        assert msg.command.type == "draw_pixels"
+        assert msg.command.plugin == "builtin/pencil"
+        assert msg.command.params == {"x": 10, "y": 20}
+
+    def test_parse_sync_request(self):
+        raw = {"type": "sync_request", "id": "msg-2"}
+        msg = parse_client_message(raw)
+        assert isinstance(msg, SyncRequestMessage)
+        assert msg.id == "msg-2"
+
+    def test_parse_undo(self):
+        raw = {"type": "undo", "id": "msg-3"}
+        msg = parse_client_message(raw)
+        assert isinstance(msg, UndoMessage)
+
+    def test_parse_redo(self):
+        raw = {"type": "redo", "id": "msg-4"}
+        msg = parse_client_message(raw)
+        assert isinstance(msg, RedoMessage)
+
+    def test_unknown_type_raises(self):
+        with pytest.raises(ValueError, match="Unknown message type"):
+            parse_client_message({"type": "bogus", "id": "x"})
+
+    def test_missing_type_raises(self):
+        with pytest.raises(ValueError, match="Unknown message type"):
+            parse_client_message({"id": "x"})
+
+    def test_malformed_command_raises(self):
+        """Command message missing required 'command' field."""
+        with pytest.raises(Exception):
+            parse_client_message({"type": "command", "id": "x"})
+
+    def test_command_missing_inner_fields_raises(self):
+        """Command payload missing required fields."""
+        with pytest.raises(Exception):
+            parse_client_message({
+                "type": "command",
+                "id": "msg-1",
+                "command": {"type": "draw"},
+                # missing plugin, version, id, timestamp
+            })
+
+
+# ---------------------------------------------------------------------------
+# Server -> Client models (construction)
+# ---------------------------------------------------------------------------
+
+
+class TestServerMessages:
+    def test_command_ack(self):
+        msg = CommandAckMessage(id="msg-1", command_id="cmd-1")
+        d = msg.model_dump()
+        assert d["type"] == "command_ack"
+        assert d["success"] is True
+        assert d["id"] == "msg-1"
+
+    def test_command_reject(self):
+        msg = CommandRejectMessage(id="msg-1", command_id="cmd-1", error="Bad pixel")
+        d = msg.model_dump()
+        assert d["type"] == "command_reject"
+        assert d["error"] == "Bad pixel"
+
+    def test_state_sync(self):
+        msg = StateSyncMessage(id="msg-1", state={"project": None})
+        d = msg.model_dump()
+        assert d["type"] == "state_sync"
+        assert d["state"]["project"] is None
+
+    def test_command_broadcast(self):
+        msg = CommandBroadcastMessage(command={"type": "draw"}, source="mcp")
+        d = msg.model_dump()
+        assert d["type"] == "command_broadcast"
+        assert d["source"] == "mcp"
+
+    def test_error(self):
+        msg = ErrorMessage(id="msg-1", error="Something went wrong")
+        d = msg.model_dump()
+        assert d["type"] == "error"
+        assert d["error"] == "Something went wrong"
+
+    def test_ack_type_literal_enforced(self):
+        """The type field must be the literal value."""
+        with pytest.raises(ValidationError):
+            CommandAckMessage(type="wrong", id="x", command_id="y")

package/server/tests/test_state.py

@@ -0,0 +1,87 @@
+"""Tests for FrameState and multi-frame CanvasState accessors."""
+
+import pytest
+
+from pixelweaver.state import CanvasState, FrameState, ServerState
+
+
+class TestFrameState:
+    def test_creation_defaults(self):
+        f = FrameState(id="abc")
+        assert f.id == "abc"
+        assert f.duration_ms is None
+        assert f.pixel_data == {}
+
+    def test_creation_with_data(self):
+        data = {"layer-1": b"\x00" * 16}
+        f = FrameState(id="xyz", duration_ms=100, pixel_data=data)
+        assert f.duration_ms == 100
+        assert f.pixel_data["layer-1"] == b"\x00" * 16
+
+
+class TestCanvasFrameAccessors:
+    def _make_canvas(self, n_frames: int = 3) -> CanvasState:
+        frames = [FrameState(id=f"frame-{i}") for i in range(n_frames)]
+        canvas = CanvasState(
+            name="test",
+            width=8,
+            height=8,
+            layers=[],
+            frames=frames,
+        )
+        return canvas
+
+    def test_current_frame(self):
+        canvas = self._make_canvas()
+        canvas.current_frame_index = 1
+        assert canvas.current_frame().id == "frame-1"
+
+    def test_current_frame_clamps(self):
+        canvas = self._make_canvas()
+        canvas.current_frame_index = 99
+        assert canvas.current_frame().id == "frame-2"  # last frame
+
+    def test_current_frame_empty_raises(self):
+        canvas = self._make_canvas(0)
+        with pytest.raises(ValueError, match="no frames"):
+            canvas.current_frame()
+
+    def test_frame_at(self):
+        canvas = self._make_canvas()
+        assert canvas.frame_at(2).id == "frame-2"
+
+    def test_frame_at_out_of_range(self):
+        canvas = self._make_canvas()
+        with pytest.raises(IndexError):
+            canvas.frame_at(5)
+
+    def test_frame_count(self):
+        canvas = self._make_canvas()
+        assert canvas.frame_count == 3
+
+    def test_frame_count_empty(self):
+        canvas = self._make_canvas(0)
+        assert canvas.frame_count == 0
+
+
+class TestCreateProjectSeedsFrames:
+    def test_new_project_has_one_frame(self):
+        state = ServerState()
+        state.create_project("test-proj", 16, 16)
+        project = state.projects["test-proj"]
+        canvas = list(project.canvases.values())[0]
+        assert canvas.frame_count == 1
+        frame = canvas.frames[0]
+        assert frame.id  # non-empty UUID
+        assert frame.duration_ms is None
+
+    def test_frame_pixel_data_is_sole_owner(self):
+        """Pixel data lives only in FrameState, not on CanvasState."""
+        state = ServerState()
+        state.create_project("test-proj", 4, 4)
+        canvas = list(state.projects["test-proj"].canvases.values())[0]
+        assert not hasattr(canvas, "pixel_data") or "pixel_data" not in canvas.__dataclass_fields__
+        # Pixel data is accessible through the frame
+        layer_id = canvas.layers[0]["id"]
+        assert layer_id in canvas.frames[0].pixel_data
+        assert len(canvas.frames[0].pixel_data[layer_id]) == 4 * 4 * 4

package/server/tests/test_storage.py

@@ -0,0 +1,306 @@
+"""Tests for project file I/O (save, load, list, export)."""
+
+import json
+import uuid
+from pathlib import Path
+
+import pytest
+
+from pixelweaver.state import CanvasState, FrameState, ProjectState, ServerState
+from pixelweaver.storage import export_frame_png, list_projects, load_project, save_project
+
+
+@pytest.fixture()
+def tmp_data_dir(tmp_path: Path) -> str:
+    """Provide a temporary data directory path as a string."""
+    return str(tmp_path)
+
+
+@pytest.fixture()
+def sample_project() -> ProjectState:
+    """Create a sample project with one canvas and one layer."""
+    state = ServerState()
+    project = state.create_project("test-project", 16, 16)
+    return project
+
+
+def _make_multi_frame_project() -> ProjectState:
+    """Create a project with one canvas containing two frames and two layers.
+
+    Frame 0: layer-a has red pixels, layer-b has green pixels.
+    Frame 1: layer-a has blue pixels, layer-b has white pixels.
+    Each frame has duration_ms set (None for frame 0, 200 for frame 1).
+    """
+    w, h = 4, 4
+    layer_a_id = "layer-a"
+    layer_b_id = "layer-b"
+
+    # 4x4 RGBA = 64 bytes per layer
+    red_px = (b"\xff\x00\x00\xff") * (w * h)
+    green_px = (b"\x00\xff\x00\xff") * (w * h)
+    blue_px = (b"\x00\x00\xff\xff") * (w * h)
+    white_px = (b"\xff\xff\xff\xff") * (w * h)
+
+    frame0 = FrameState(
+        id=str(uuid.uuid4()),
+        duration_ms=None,
+        pixel_data={layer_a_id: red_px, layer_b_id: green_px},
+    )
+    frame1 = FrameState(
+        id=str(uuid.uuid4()),
+        duration_ms=200,
+        pixel_data={layer_a_id: blue_px, layer_b_id: white_px},
+    )
+
+    canvas = CanvasState(
+        name="canvas-0",
+        width=w,
+        height=h,
+        layers=[
+            {"id": layer_a_id, "name": "Layer A", "visible": True, "opacity": 1.0},
+            {"id": layer_b_id, "name": "Layer B", "visible": True, "opacity": 1.0},
+        ],
+        frames=[frame0, frame1],
+        current_frame_index=1,
+        global_fps=24.0,
+        origin_x=5,
+        origin_y=10,
+    )
+
+    project = ProjectState(name="multi-frame-project", width=w, height=h)
+    project.canvases["canvas-0"] = canvas
+    return project
+
+
+class TestSaveAndLoad:
+    def test_save_creates_expected_files(self, tmp_data_dir: str, sample_project: ProjectState):
+        save_project(sample_project, tmp_data_dir)
+
+        project_dir = Path(tmp_data_dir) / "test-project"
+        assert project_dir.is_dir()
+        assert (project_dir / "project.json").is_file()
+        assert (project_dir / "history.json").is_file()
+        assert (project_dir / "canvases" / "canvas-0" / "canvas.json").is_file()
+        assert (project_dir / "canvases" / "canvas-0" / "frames.json").is_file()
+
+        # Verify project.json content
+        meta = json.loads((project_dir / "project.json").read_text())
+        assert meta["name"] == "test-project"
+        assert meta["width"] == 16
+        assert meta["height"] == 16
+        assert "canvas-0" in meta["canvases"]
+
+    def test_save_creates_frames_json(self, tmp_data_dir: str, sample_project: ProjectState):
+        save_project(sample_project, tmp_data_dir)
+
+        frames_json_path = (
+            Path(tmp_data_dir) / "test-project" / "canvases" / "canvas-0" / "frames.json"
+        )
+        manifest = json.loads(frames_json_path.read_text())
+
+        assert "frames" in manifest
+        assert len(manifest["frames"]) == 1
+        assert "id" in manifest["frames"][0]
+        assert manifest["current_frame_index"] == 0
+        assert manifest["global_fps"] == 12.0
+        assert manifest["origin_x"] == 0
+        assert manifest["origin_y"] == 0
+
+    def test_save_creates_uuid_frame_dirs(self, tmp_data_dir: str, sample_project: ProjectState):
+        save_project(sample_project, tmp_data_dir)
+
+        canvas_dir = Path(tmp_data_dir) / "test-project" / "canvases" / "canvas-0"
+        manifest = json.loads((canvas_dir / "frames.json").read_text())
+        frame_id = manifest["frames"][0]["id"]
+
+        # Frame directory should be named by UUID, not "0"
+        frame_dir = canvas_dir / "frames" / frame_id
+        assert frame_dir.is_dir()
+        assert not (canvas_dir / "frames" / "0").exists()
+
+        # There should be at least one layer PNG
+        pngs = list(frame_dir.glob("layer-*.png"))
+        assert len(pngs) == 1
+
+    def test_save_cleans_up_old_frame_dirs(self, tmp_data_dir: str, sample_project: ProjectState):
+        """Old frames/0/ directory should be removed after save."""
+        # Create a fake old-format directory
+        canvas_dir = Path(tmp_data_dir) / "test-project" / "canvases" / "canvas-0"
+        old_frame_dir = canvas_dir / "frames" / "0"
+        old_frame_dir.mkdir(parents=True, exist_ok=True)
+        (old_frame_dir / "layer-fake.png").write_bytes(b"fake")
+
+        save_project(sample_project, tmp_data_dir)
+
+        # Old "0" directory should be gone
+        assert not old_frame_dir.exists()
+
+    def test_round_trip(self, tmp_data_dir: str, sample_project: ProjectState):
+        """Save then load should produce an equivalent project."""
+        # Add a command to history before saving
+        sample_project.command_history.append({"type": "draw_pixels", "id": "cmd-1"})
+
+        save_project(sample_project, tmp_data_dir)
+        loaded = load_project(f"{tmp_data_dir}/test-project")
+
+        assert loaded.name == sample_project.name
+        assert loaded.width == sample_project.width
+        assert loaded.height == sample_project.height
+        assert len(loaded.canvases) == len(sample_project.canvases)
+        assert "canvas-0" in loaded.canvases
+        assert len(loaded.command_history) == 1
+        assert loaded.command_history[0]["id"] == "cmd-1"
+
+        # Pixel data should round-trip through PNG
+        orig_canvas = sample_project.canvases["canvas-0"]
+        loaded_canvas = loaded.canvases["canvas-0"]
+        assert len(loaded_canvas.layers) == len(orig_canvas.layers)
+        orig_pd = orig_canvas.current_frame().pixel_data
+        loaded_pd = loaded_canvas.current_frame().pixel_data
+        assert len(loaded_pd) == len(orig_pd)
+
+        for layer_id in orig_pd:
+            assert layer_id in loaded_pd
+            assert loaded_pd[layer_id] == orig_pd[layer_id]
+
+    def test_round_trip_preserves_frame_ids(self, tmp_data_dir: str, sample_project: ProjectState):
+        """Frame UUIDs should survive a save/load round-trip."""
+        orig_frame_id = sample_project.canvases["canvas-0"].frames[0].id
+
+        save_project(sample_project, tmp_data_dir)
+        loaded = load_project(f"{tmp_data_dir}/test-project")
+
+        loaded_frame_id = loaded.canvases["canvas-0"].frames[0].id
+        assert loaded_frame_id == orig_frame_id
+
+    def test_round_trip_preserves_frame_metadata(self, tmp_data_dir: str):
+        """current_frame_index, global_fps, origin should round-trip."""
+        project = _make_multi_frame_project()
+
+        save_project(project, tmp_data_dir)
+        loaded = load_project(f"{tmp_data_dir}/multi-frame-project")
+
+        loaded_canvas = loaded.canvases["canvas-0"]
+        assert loaded_canvas.current_frame_index == 1
+        assert loaded_canvas.global_fps == 24.0
+        assert loaded_canvas.origin_x == 5
+        assert loaded_canvas.origin_y == 10
+
+    def test_multi_frame_round_trip(self, tmp_data_dir: str):
+        """Two frames with different pixel data should round-trip correctly."""
+        project = _make_multi_frame_project()
+        orig_canvas = project.canvases["canvas-0"]
+
+        save_project(project, tmp_data_dir)
+        loaded = load_project(f"{tmp_data_dir}/multi-frame-project")
+        loaded_canvas = loaded.canvases["canvas-0"]
+
+        # Same number of frames
+        assert len(loaded_canvas.frames) == 2
+
+        # Frame IDs preserved
+        assert loaded_canvas.frames[0].id == orig_canvas.frames[0].id
+        assert loaded_canvas.frames[1].id == orig_canvas.frames[1].id
+
+        # duration_ms preserved
+        assert loaded_canvas.frames[0].duration_ms is None
+        assert loaded_canvas.frames[1].duration_ms == 200
+
+        # Pixel data preserved for all layers in both frames
+        for i in range(2):
+            orig_pd = orig_canvas.frames[i].pixel_data
+            loaded_pd = loaded_canvas.frames[i].pixel_data
+            assert set(loaded_pd.keys()) == set(orig_pd.keys())
+            for layer_id in orig_pd:
+                assert loaded_pd[layer_id] == orig_pd[layer_id]
+
+    def test_multi_frame_creates_separate_dirs(self, tmp_data_dir: str):
+        """Each frame should get its own UUID-named directory on disk."""
+        project = _make_multi_frame_project()
+        orig_canvas = project.canvases["canvas-0"]
+
+        save_project(project, tmp_data_dir)
+
+        canvas_dir = Path(tmp_data_dir) / "multi-frame-project" / "canvases" / "canvas-0"
+        for frame in orig_canvas.frames:
+            frame_dir = canvas_dir / "frames" / frame.id
+            assert frame_dir.is_dir()
+            # Each frame should have PNGs for both layers
+            pngs = list(frame_dir.glob("layer-*.png"))
+            assert len(pngs) == 2
+
+    def test_load_missing_frames_json_raises(self, tmp_data_dir: str):
+        """Loading a canvas without frames.json should raise FileNotFoundError."""
+        # Create minimal project structure without frames.json
+        project_dir = Path(tmp_data_dir) / "old-project"
+        canvas_dir = project_dir / "canvases" / "canvas-0"
+        canvas_dir.mkdir(parents=True)
+
+        (project_dir / "project.json").write_text(json.dumps({
+            "name": "old-project", "width": 16, "height": 16, "canvases": ["canvas-0"],
+        }))
+        (canvas_dir / "canvas.json").write_text(json.dumps({
+            "name": "canvas-0", "width": 16, "height": 16, "layers": [],
+        }))
+
+        with pytest.raises(FileNotFoundError, match="frames.json"):
+            load_project(str(project_dir))
+
+
+class TestListProjects:
+    def test_empty_dir(self, tmp_data_dir: str):
+        assert list_projects(tmp_data_dir) == []
+
+    def test_nonexistent_dir(self):
+        assert list_projects("/nonexistent/path") == []
+
+    def test_lists_saved_projects(self, tmp_data_dir: str, sample_project: ProjectState):
+        save_project(sample_project, tmp_data_dir)
+        names = list_projects(tmp_data_dir)
+        assert names == ["test-project"]
+
+    def test_ignores_non_project_dirs(self, tmp_data_dir: str):
+        """Directories without project.json should not be listed."""
+        (Path(tmp_data_dir) / "not-a-project").mkdir()
+        assert list_projects(tmp_data_dir) == []
+
+
+class TestExportFramePng:
+    def test_export_produces_png_bytes(self, sample_project: ProjectState):
+        png_bytes = export_frame_png(sample_project, "canvas-0", 0)
+        # PNG files start with the PNG magic bytes
+        assert png_bytes[:8] == b"\x89PNG\r\n\x1a\n"
+
+    def test_export_nonexistent_canvas_raises(self, sample_project: ProjectState):
+        with pytest.raises(ValueError, match="not found"):
+            export_frame_png(sample_project, "no-such-canvas", 0)
+
+    def test_export_nonzero_frame(self):
+        """Exporting frame 1 should produce valid PNG with that frame's pixel data."""
+        project = _make_multi_frame_project()
+        png_bytes = export_frame_png(project, "canvas-0", 1)
+        assert png_bytes[:8] == b"\x89PNG\r\n\x1a\n"
+
+        # Verify the composited image contains frame 1's data (blue + white)
+        from io import BytesIO
+        from PIL import Image
+
+        img = Image.open(BytesIO(png_bytes)).convert("RGBA")
+        assert img.size == (4, 4)
+
+        # Frame 1: layer-a is blue, layer-b is white (composited on top)
+        # Alpha composite of blue over transparent, then white over that = white
+        pixel = img.getpixel((0, 0))
+        assert pixel == (255, 255, 255, 255)
+
+    def test_export_each_frame_differs(self):
+        """Each frame should export different pixel content."""
+        project = _make_multi_frame_project()
+        png0 = export_frame_png(project, "canvas-0", 0)
+        png1 = export_frame_png(project, "canvas-0", 1)
+        assert png0 != png1
+
+    def test_export_out_of_range_frame_raises(self, sample_project: ProjectState):
+        """Out-of-range frame index should raise IndexError."""
+        with pytest.raises(IndexError, match="out of range"):
+            export_frame_png(sample_project, "canvas-0", 5)