@agent-webui/ai-desk-harness-gimp 1.0.29-beta1

package/python/agent-harness/cli_anything/gimp/tests/TEST.md

@@ -0,0 +1,137 @@
+# GIMP CLI Harness - Test Documentation
+
+## Test Inventory
+
+| File | Test Classes | Test Count | Focus |
+|------|-------------|------------|-------|
+| `test_core.py` | 5 | 66 | Unit tests for project, layers, filters, canvas, session |
+| `test_full_e2e.py` | 9 | 37 | E2E workflows with real image I/O and pixel verification |
+| **Total** | **14** | **103** | |
+
+## Unit Tests (`test_core.py`)
+
+All unit tests use synthetic/in-memory data only. No external files or disk I/O required.
+
+### TestProject (9 tests)
+- Create project with defaults, custom dimensions, and named profiles
+- Reject invalid color modes and negative/zero dimensions
+- Save to JSON and re-open roundtrip
+- Open nonexistent file raises error
+- Get project info and list available profiles
+
+### TestLayers (19 tests)
+- Add single and multiple layers; add at specific position
+- Reject invalid blend mode and out-of-range opacity
+- Remove layer by index; reject invalid index
+- Duplicate layer, move layer between positions
+- Set properties: opacity, visible, name; reject invalid property
+- Get single layer and list all layers
+- Verify layer IDs are unique across additions
+- Solid color layer and text layer creation
+
+### TestFilters (16 tests)
+- List all available filters; list by category
+- Get filter info; unknown filter raises error
+- Validate filter params with defaults; reject out-of-range values; reject unknown filter
+- Add filter to layer; reject invalid layer index; reject unknown filter name
+- Remove filter from layer
+- Set filter param on existing filter
+- List filters on a layer
+- All registered filters have a valid engine field
+
+### TestCanvas (11 tests)
+- Resize canvas with default and custom anchor
+- Reject invalid (zero/negative) canvas size
+- Scale canvas proportionally
+- Crop canvas; reject out-of-bounds and invalid crop regions
+- Set color mode; reject invalid mode
+- Set DPI
+- Get canvas info returns correct dimensions/mode/DPI
+
+### TestSession (11 tests)
+- Create session; set and get project; get project when none set raises error
+- Undo/redo cycle preserves state
+- Undo on empty stack is no-op; redo on empty stack is no-op
+- New snapshot clears redo stack
+- Session status reports undo/redo depth
+- Save session to file
+- List history entries
+- Max undo limit enforced
+
+## End-to-End Tests (`test_full_e2e.py`)
+
+E2E tests use real files: PNG images via PIL/Pillow, numpy arrays for pixel-level verification.
+
+### TestProjectLifecycle (3 tests)
+- Create, save, and open project roundtrip preserving all fields
+- Project with layers survives save/load roundtrip
+- Project info reflects accurate layer counts after additions
+
+### TestLayerOperations (2 tests)
+- Add layer from a real image file (PIL Image saved to temp file)
+- Multiple layers maintain correct ordering
+
+### TestFilterRendering (7 tests)
+- Brightness filter increases pixel values (verified with numpy mean)
+- Contrast filter increases pixel spread (verified with numpy std)
+- Invert filter flips all color values
+- Gaussian blur reduces high-frequency content
+- Sepia filter applies correct color cast
+- Multiple filters chain together correctly
+- Horizontal flip mirror-reverses pixel columns
+
+### TestExportFormats (4 tests)
+- Export to JPEG produces valid JPEG file
+- Export to WebP produces valid WebP file
+- Export to BMP produces valid BMP file
+- Overwrite protection prevents clobbering existing files
+
+### TestBlendModes (3 tests)
+- Multiply mode darkens output compared to base layer
+- Screen mode brightens output compared to base layer
+- Difference mode produces expected pixel delta
+
+### TestCanvasRendering (1 test)
+- Scale canvas and export; verify output image dimensions match
+
+### TestMediaProbing (5 tests)
+- Probe PNG file returns correct dimensions and format
+- Probe JPEG file returns correct info
+- Probe nonexistent file raises error
+- Check media reports all files present
+- Check media reports missing files
+
+### TestSessionIntegration (2 tests)
+- Undo reverses a layer addition
+- Undo reverses a filter addition
+
+### TestCLISubprocess (7 tests)
+- `--help` prints usage info
+- `project new` creates a project
+- `project new --json` returns valid JSON output
+- `project profiles` lists available profiles
+- `filter list-available` lists all filters
+- `export presets` lists export presets
+- Full workflow via JSON CLI (create, add layer, add filter, export)
+
+### TestRealWorldWorkflows (5 tests)
+- Photo editing workflow: open image, adjust brightness/contrast, apply sharpen, export
+- Collage workflow: create canvas, add multiple image layers, position them, export
+- Text overlay workflow: add text layer over image, style it, export
+- Batch filter workflow: apply same filter chain to multiple layers
+- Save and load complex project with many layers, filters, and settings
+
+## Test Results
+
+```
+============================= test session starts ==============================
+platform linux -- Python 3.13.11, pytest-9.0.2, pluggy-1.5.0
+rootdir: /root/cli-anything
+plugins: langsmith-0.5.1, anyio-4.12.0
+collected 103 items
+
+test_core.py   66 passed
+test_full_e2e.py   37 passed
+
+============================= 103 passed in 3.05s ==============================
+```

package/python/agent-harness/cli_anything/gimp/tests/__init__.py

@@ -0,0 +1 @@
+"""GIMP CLI - Tests package."""

package/python/agent-harness/cli_anything/gimp/tests/test_core.py

@@ -0,0 +1,478 @@
+"""Unit tests for GIMP CLI core modules.
+
+Tests use synthetic data only — no real images or external dependencies.
+"""
+
+import json
+import os
+import sys
+import tempfile
+import pytest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from cli_anything.gimp.core.project import create_project, open_project, save_project, get_project_info, list_profiles
+from cli_anything.gimp.core.layers import (
+    add_layer, add_from_file, remove_layer, duplicate_layer, move_layer,
+    set_layer_property, get_layer, list_layers, BLEND_MODES,
+)
+from cli_anything.gimp.core.filters import (
+    list_available, get_filter_info, validate_params, add_filter,
+    remove_filter, set_filter_param, list_filters, FILTER_REGISTRY,
+)
+from cli_anything.gimp.core.canvas import (
+    resize_canvas, scale_canvas, crop_canvas, set_mode, set_dpi, get_canvas_info,
+)
+from cli_anything.gimp.core.session import Session
+
+
+# ── Project Tests ────────────────────────────────────────────────
+
+class TestProject:
+    def test_create_default(self):
+        proj = create_project()
+        assert proj["canvas"]["width"] == 1920
+        assert proj["canvas"]["height"] == 1080
+        assert proj["canvas"]["color_mode"] == "RGB"
+        assert proj["version"] == "1.0"
+
+    def test_create_with_dimensions(self):
+        proj = create_project(width=800, height=600, dpi=150)
+        assert proj["canvas"]["width"] == 800
+        assert proj["canvas"]["height"] == 600
+        assert proj["canvas"]["dpi"] == 150
+
+    def test_create_with_profile(self):
+        proj = create_project(profile="hd720p")
+        assert proj["canvas"]["width"] == 1280
+        assert proj["canvas"]["height"] == 720
+
+    def test_create_invalid_mode(self):
+        with pytest.raises(ValueError, match="Invalid color mode"):
+            create_project(color_mode="XYZ")
+
+    def test_create_invalid_dimensions(self):
+        with pytest.raises(ValueError, match="must be positive"):
+            create_project(width=0, height=100)
+
+    def test_save_and_open(self):
+        proj = create_project(name="test_project")
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False, mode="w") as f:
+            path = f.name
+        try:
+            save_project(proj, path)
+            loaded = open_project(path)
+            assert loaded["name"] == "test_project"
+            assert loaded["canvas"]["width"] == 1920
+        finally:
+            os.unlink(path)
+
+    def test_open_nonexistent(self):
+        with pytest.raises(FileNotFoundError):
+            open_project("/nonexistent/path.json")
+
+    def test_get_info(self):
+        proj = create_project(name="info_test")
+        info = get_project_info(proj)
+        assert info["name"] == "info_test"
+        assert info["layer_count"] == 0
+        assert "canvas" in info
+
+    def test_list_profiles(self):
+        profiles = list_profiles()
+        assert len(profiles) > 0
+        names = [p["name"] for p in profiles]
+        assert "hd1080p" in names
+        assert "4k" in names
+
+
+# ── Layer Tests ──────────────────────────────────────────────────
+
+class TestLayers:
+    def _make_project(self):
+        return create_project()
+
+    def test_add_layer(self):
+        proj = self._make_project()
+        layer = add_layer(proj, name="Test", layer_type="image")
+        assert layer["name"] == "Test"
+        assert layer["type"] == "image"
+        assert len(proj["layers"]) == 1
+
+    def test_add_multiple_layers(self):
+        proj = self._make_project()
+        add_layer(proj, name="Bottom")
+        add_layer(proj, name="Top")
+        assert len(proj["layers"]) == 2
+        assert proj["layers"][0]["name"] == "Top"  # Top of stack
+
+    def test_add_layer_with_position(self):
+        proj = self._make_project()
+        add_layer(proj, name="First")
+        add_layer(proj, name="Second", position=1)
+        assert proj["layers"][1]["name"] == "Second"
+
+    def test_add_layer_invalid_mode(self):
+        proj = self._make_project()
+        with pytest.raises(ValueError, match="Invalid blend mode"):
+            add_layer(proj, blend_mode="invalid")
+
+    def test_add_layer_invalid_opacity(self):
+        proj = self._make_project()
+        with pytest.raises(ValueError, match="Opacity"):
+            add_layer(proj, opacity=1.5)
+
+    def test_remove_layer(self):
+        proj = self._make_project()
+        add_layer(proj, name="A")
+        add_layer(proj, name="B")
+        removed = remove_layer(proj, 0)
+        assert removed["name"] == "B"
+        assert len(proj["layers"]) == 1
+
+    def test_remove_layer_invalid_index(self):
+        proj = self._make_project()
+        with pytest.raises(ValueError, match="No layers"):
+            remove_layer(proj, 0)
+
+    def test_duplicate_layer(self):
+        proj = self._make_project()
+        add_layer(proj, name="Original")
+        dup = duplicate_layer(proj, 0)
+        assert dup["name"] == "Original copy"
+        assert len(proj["layers"]) == 2
+
+    def test_move_layer(self):
+        proj = self._make_project()
+        add_layer(proj, name="A")
+        add_layer(proj, name="B")
+        add_layer(proj, name="C")
+        move_layer(proj, 0, 2)
+        assert proj["layers"][2]["name"] == "C"
+
+    def test_set_property_opacity(self):
+        proj = self._make_project()
+        add_layer(proj, name="Test")
+        set_layer_property(proj, 0, "opacity", 0.5)
+        assert proj["layers"][0]["opacity"] == 0.5
+
+    def test_set_property_visible(self):
+        proj = self._make_project()
+        add_layer(proj, name="Test")
+        set_layer_property(proj, 0, "visible", "false")
+        assert proj["layers"][0]["visible"] is False
+
+    def test_set_property_name(self):
+        proj = self._make_project()
+        add_layer(proj, name="Old")
+        set_layer_property(proj, 0, "name", "New")
+        assert proj["layers"][0]["name"] == "New"
+
+    def test_set_property_invalid(self):
+        proj = self._make_project()
+        add_layer(proj, name="Test")
+        with pytest.raises(ValueError, match="Unknown property"):
+            set_layer_property(proj, 0, "bogus", "value")
+
+    def test_get_layer(self):
+        proj = self._make_project()
+        add_layer(proj, name="Test")
+        layer = get_layer(proj, 0)
+        assert layer["name"] == "Test"
+
+    def test_list_layers(self):
+        proj = self._make_project()
+        add_layer(proj, name="A")
+        add_layer(proj, name="B")
+        result = list_layers(proj)
+        assert len(result) == 2
+        assert result[0]["name"] == "B"
+
+    def test_layer_ids_unique(self):
+        proj = self._make_project()
+        l1 = add_layer(proj, name="A")
+        l2 = add_layer(proj, name="B")
+        assert l1["id"] != l2["id"]
+
+    def test_solid_layer(self):
+        proj = self._make_project()
+        layer = add_layer(proj, name="Red", layer_type="solid", fill="#ff0000")
+        assert layer["type"] == "solid"
+        assert layer["fill"] == "#ff0000"
+
+    def test_text_layer(self):
+        proj = self._make_project()
+        layer = add_layer(proj, name="Title", layer_type="text")
+        assert layer["type"] == "text"
+        assert "text" in layer
+        assert "font_size" in layer
+
+
+# ── Filter Tests ─────────────────────────────────────────────────
+
+class TestFilters:
+    def _make_project_with_layer(self):
+        proj = create_project()
+        add_layer(proj, name="Test")
+        return proj
+
+    def test_list_available(self):
+        filters = list_available()
+        assert len(filters) > 10
+        names = [f["name"] for f in filters]
+        assert "brightness" in names
+        assert "gaussian_blur" in names
+
+    def test_list_by_category(self):
+        blurs = list_available(category="blur")
+        assert all(f["category"] == "blur" for f in blurs)
+        assert len(blurs) >= 3
+
+    def test_get_filter_info(self):
+        info = get_filter_info("brightness")
+        assert info["name"] == "brightness"
+        assert "factor" in info["params"]
+
+    def test_get_filter_info_unknown(self):
+        with pytest.raises(ValueError, match="Unknown filter"):
+            get_filter_info("nonexistent")
+
+    def test_validate_params(self):
+        params = validate_params("brightness", {"factor": 1.5})
+        assert params["factor"] == 1.5
+
+    def test_validate_params_defaults(self):
+        params = validate_params("brightness", {})
+        assert params["factor"] == 1.0
+
+    def test_validate_params_out_of_range(self):
+        with pytest.raises(ValueError, match="maximum"):
+            validate_params("brightness", {"factor": 100.0})
+
+    def test_validate_params_unknown(self):
+        with pytest.raises(ValueError, match="Unknown parameters"):
+            validate_params("brightness", {"bogus": 1.0})
+
+    def test_add_filter(self):
+        proj = self._make_project_with_layer()
+        result = add_filter(proj, "brightness", 0, {"factor": 1.2})
+        assert result["name"] == "brightness"
+        assert proj["layers"][0]["filters"][0]["name"] == "brightness"
+
+    def test_add_filter_invalid_layer(self):
+        proj = self._make_project_with_layer()
+        with pytest.raises(IndexError):
+            add_filter(proj, "brightness", 5, {})
+
+    def test_add_filter_unknown(self):
+        proj = self._make_project_with_layer()
+        with pytest.raises(ValueError, match="Unknown filter"):
+            add_filter(proj, "nonexistent", 0, {})
+
+    def test_remove_filter(self):
+        proj = self._make_project_with_layer()
+        add_filter(proj, "brightness", 0, {"factor": 1.2})
+        removed = remove_filter(proj, 0, 0)
+        assert removed["name"] == "brightness"
+        assert len(proj["layers"][0]["filters"]) == 0
+
+    def test_set_filter_param(self):
+        proj = self._make_project_with_layer()
+        add_filter(proj, "brightness", 0, {"factor": 1.0})
+        set_filter_param(proj, 0, "factor", 1.5, 0)
+        assert proj["layers"][0]["filters"][0]["params"]["factor"] == 1.5
+
+    def test_list_filters(self):
+        proj = self._make_project_with_layer()
+        add_filter(proj, "brightness", 0, {"factor": 1.2})
+        add_filter(proj, "contrast", 0, {"factor": 1.1})
+        result = list_filters(proj, 0)
+        assert len(result) == 2
+        assert result[0]["name"] == "brightness"
+        assert result[1]["name"] == "contrast"
+
+    def test_all_filters_have_valid_engine(self):
+        valid_engines = {"pillow_enhance", "pillow_ops", "pillow_filter",
+                         "pillow_transform", "custom"}
+        for name, spec in FILTER_REGISTRY.items():
+            assert spec["engine"] in valid_engines, f"Filter '{name}' has invalid engine"
+
+
+# ── Canvas Tests ─────────────────────────────────────────────────
+
+class TestCanvas:
+    def _make_project(self):
+        return create_project(width=800, height=600)
+
+    def test_resize_canvas(self):
+        proj = self._make_project()
+        result = resize_canvas(proj, 1000, 800)
+        assert proj["canvas"]["width"] == 1000
+        assert proj["canvas"]["height"] == 800
+        assert "old_size" in result
+
+    def test_resize_canvas_with_anchor(self):
+        proj = self._make_project()
+        add_layer(proj, name="Test")
+        resize_canvas(proj, 1000, 800, anchor="top-left")
+        assert proj["layers"][0]["offset_x"] == 0
+        assert proj["layers"][0]["offset_y"] == 0
+
+    def test_resize_canvas_invalid_size(self):
+        proj = self._make_project()
+        with pytest.raises(ValueError, match="must be positive"):
+            resize_canvas(proj, 0, 100)
+
+    def test_scale_canvas(self):
+        proj = self._make_project()
+        add_layer(proj, name="Test", width=800, height=600)
+        result = scale_canvas(proj, 400, 300)
+        assert proj["canvas"]["width"] == 400
+        assert proj["canvas"]["height"] == 300
+        assert proj["layers"][0]["width"] == 400
+        assert proj["layers"][0]["height"] == 300
+
+    def test_crop_canvas(self):
+        proj = self._make_project()
+        result = crop_canvas(proj, 100, 100, 500, 400)
+        assert proj["canvas"]["width"] == 400
+        assert proj["canvas"]["height"] == 300
+
+    def test_crop_canvas_out_of_bounds(self):
+        proj = self._make_project()
+        with pytest.raises(ValueError, match="exceeds canvas"):
+            crop_canvas(proj, 0, 0, 1000, 1000)
+
+    def test_crop_canvas_invalid_region(self):
+        proj = self._make_project()
+        with pytest.raises(ValueError, match="Invalid crop"):
+            crop_canvas(proj, 500, 500, 100, 100)
+
+    def test_set_mode(self):
+        proj = self._make_project()
+        result = set_mode(proj, "RGBA")
+        assert proj["canvas"]["color_mode"] == "RGBA"
+        assert result["old_mode"] == "RGB"
+
+    def test_set_mode_invalid(self):
+        proj = self._make_project()
+        with pytest.raises(ValueError, match="Invalid color mode"):
+            set_mode(proj, "XYZ")
+
+    def test_set_dpi(self):
+        proj = self._make_project()
+        result = set_dpi(proj, 300)
+        assert proj["canvas"]["dpi"] == 300
+
+    def test_get_canvas_info(self):
+        proj = self._make_project()
+        info = get_canvas_info(proj)
+        assert info["width"] == 800
+        assert info["height"] == 600
+        assert "megapixels" in info
+
+
+# ── Session Tests ────────────────────────────────────────────────
+
+class TestSession:
+    def test_create_session(self):
+        sess = Session()
+        assert not sess.has_project()
+
+    def test_set_project(self):
+        sess = Session()
+        proj = create_project()
+        sess.set_project(proj)
+        assert sess.has_project()
+
+    def test_get_project_no_project(self):
+        sess = Session()
+        with pytest.raises(RuntimeError, match="No project loaded"):
+            sess.get_project()
+
+    def test_undo_redo(self):
+        sess = Session()
+        proj = create_project(name="original")
+        sess.set_project(proj)
+
+        sess.snapshot("change name")
+        proj["name"] = "modified"
+
+        assert proj["name"] == "modified"
+        sess.undo()
+        assert sess.get_project()["name"] == "original"
+        sess.redo()
+        assert sess.get_project()["name"] == "modified"
+
+    def test_undo_empty(self):
+        sess = Session()
+        sess.set_project(create_project())
+        with pytest.raises(RuntimeError, match="Nothing to undo"):
+            sess.undo()
+
+    def test_redo_empty(self):
+        sess = Session()
+        sess.set_project(create_project())
+        with pytest.raises(RuntimeError, match="Nothing to redo"):
+            sess.redo()
+
+    def test_snapshot_clears_redo(self):
+        sess = Session()
+        proj = create_project(name="v1")
+        sess.set_project(proj)
+
+        sess.snapshot("v2")
+        proj["name"] = "v2"
+
+        sess.undo()
+        assert sess.get_project()["name"] == "v1"
+
+        # New snapshot should clear redo stack
+        sess.snapshot("v3")
+        sess.get_project()["name"] = "v3"
+
+        with pytest.raises(RuntimeError, match="Nothing to redo"):
+            sess.redo()
+
+    def test_status(self):
+        sess = Session()
+        proj = create_project(name="test")
+        sess.set_project(proj, "/tmp/test.json")
+        status = sess.status()
+        assert status["has_project"] is True
+        assert status["project_path"] == "/tmp/test.json"
+        assert status["undo_count"] == 0
+
+    def test_save_session(self):
+        sess = Session()
+        proj = create_project(name="save_test")
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+            path = f.name
+        try:
+            sess.set_project(proj, path)
+            saved = sess.save_session()
+            assert os.path.exists(saved)
+            with open(saved) as f:
+                loaded = json.load(f)
+            assert loaded["name"] == "save_test"
+        finally:
+            os.unlink(path)
+
+    def test_list_history(self):
+        sess = Session()
+        proj = create_project()
+        sess.set_project(proj)
+        sess.snapshot("action 1")
+        sess.snapshot("action 2")
+        history = sess.list_history()
+        assert len(history) == 2
+        assert history[0]["description"] == "action 2"
+
+    def test_max_undo(self):
+        sess = Session()
+        sess.MAX_UNDO = 5
+        proj = create_project()
+        sess.set_project(proj)
+        for i in range(10):
+            sess.snapshot(f"action {i}")
+        assert len(sess._undo_stack) == 5