add more tests; fix missing translation

Author: ericls

db/migrations/000006_changes_array.down.sql

@@ -1,9 +1,9 @@
 -- Restore empty arrays to empty objects
 UPDATE image_table SET changes = '{}' WHERE changes = '[]';
 
--- Unwrap single-element arrays back to bare objects
+-- Unwrap single-element arrays back to bare objects (skip non-array rows)
 UPDATE image_table
   SET changes = changes->0
-  WHERE jsonb_array_length(changes) = 1;
+  WHERE jsonb_typeof(changes) = 'array' AND jsonb_array_length(changes) = 1;
 
 ALTER TABLE image_table ALTER COLUMN changes SET DEFAULT '{}';

editing/blur_test.go

@@ -0,0 +1,169 @@
+package editing
+
+import (
+	"bytes"
+	"image"
+	"image/color"
+	"image/png"
+	"testing"
+)
+
+// makeBlurTestPNG creates a solid-color PNG of the given size.
+func makeBlurTestPNG(w, h int, c color.Color) []byte {
+	img := image.NewRGBA(image.Rect(0, 0, w, h))
+	for y := range h {
+		for x := range w {
+			img.Set(x, y, c)
+		}
+	}
+	var buf bytes.Buffer
+	if err := png.Encode(&buf, img); err != nil {
+		panic(err)
+	}
+	return buf.Bytes()
+}
+
+// --- NewBlurChange validation ---
+
+func TestNewBlurChange_ValidParams(t *testing.T) {
+	_, err := NewBlurChange(BlurParams{
+		Region: BlurRegion{X1: 0.1, Y1: 0.1, X2: 0.9, Y2: 0.9},
+		Radius: 10,
+	})
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+}
+
+func TestNewBlurChange_CoordOutOfRange(t *testing.T) {
+	cases := []BlurRegion{
+		{X1: -0.1, Y1: 0, X2: 0.5, Y2: 0.5},
+		{X1: 0, Y1: 0, X2: 1.1, Y2: 0.5},
+		{X1: 0, Y1: -0.1, X2: 0.5, Y2: 0.5},
+		{X1: 0, Y1: 0, X2: 0.5, Y2: 1.1},
+	}
+	for _, r := range cases {
+		if _, err := NewBlurChange(BlurParams{Region: r, Radius: 5}); err == nil {
+			t.Errorf("expected error for region %+v", r)
+		}
+	}
+}
+
+func TestNewBlurChange_ZeroArea(t *testing.T) {
+	cases := []BlurRegion{
+		{X1: 0.5, Y1: 0.1, X2: 0.5, Y2: 0.9}, // x1 == x2
+		{X1: 0.1, Y1: 0.5, X2: 0.9, Y2: 0.5}, // y1 == y2
+		{X1: 0.8, Y1: 0.1, X2: 0.2, Y2: 0.9}, // x1 > x2
+	}
+	for _, r := range cases {
+		if _, err := NewBlurChange(BlurParams{Region: r, Radius: 5}); err == nil {
+			t.Errorf("expected error for zero-area region %+v", r)
+		}
+	}
+}
+
+func TestNewBlurChange_RadiusOutOfRange(t *testing.T) {
+	validRegion := BlurRegion{X1: 0.1, Y1: 0.1, X2: 0.9, Y2: 0.9}
+	for _, r := range []int{0, -1, 101} {
+		if _, err := NewBlurChange(BlurParams{Region: validRegion, Radius: r}); err == nil {
+			t.Errorf("expected error for radius %d", r)
+		}
+	}
+}
+
+// --- BlurEditor.Apply ---
+
+func TestBlurApply_PreservesDimensions(t *testing.T) {
+	base := makeBlurTestPNG(200, 150, color.RGBA{255, 0, 0, 255})
+	c, _ := NewBlurChange(BlurParams{
+		Region: BlurRegion{X1: 0.2, Y1: 0.2, X2: 0.8, Y2: 0.8},
+		Radius: 5,
+	})
+	editor := &BlurEditor{}
+	result, mime, err := editor.Apply(base, c, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if mime != "image/png" {
+		t.Fatalf("expected image/png, got %s", mime)
+	}
+	img, err := png.Decode(bytes.NewReader(result))
+	if err != nil {
+		t.Fatal(err)
+	}
+	b := img.Bounds()
+	if b.Dx() != 200 || b.Dy() != 150 {
+		t.Fatalf("expected 200x150, got %dx%d", b.Dx(), b.Dy())
+	}
+}
+
+func TestBlurApply_OnlyBlursRegion(t *testing.T) {
+	// Image: left half red, right half blue.
+	img := image.NewRGBA(image.Rect(0, 0, 100, 100))
+	for y := range 100 {
+		for x := range 100 {
+			if x < 50 {
+				img.Set(x, y, color.RGBA{255, 0, 0, 255})
+			} else {
+				img.Set(x, y, color.RGBA{0, 0, 255, 255})
+			}
+		}
+	}
+	var buf bytes.Buffer
+	png.Encode(&buf, img)
+
+	// Blur only the right half.
+	c, _ := NewBlurChange(BlurParams{
+		Region: BlurRegion{X1: 0.5, Y1: 0, X2: 1.0, Y2: 1.0},
+		Radius: 5,
+	})
+	editor := &BlurEditor{}
+	result, _, err := editor.Apply(buf.Bytes(), c, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	out, _ := png.Decode(bytes.NewReader(result))
+	// Left half pixel should still be pure red.
+	r, g, b, _ := out.At(10, 50).RGBA()
+	if r != 0xffff || g != 0 || b != 0 {
+		t.Fatalf("expected unblurred red pixel at (10,50), got r=%d g=%d b=%d", r>>8, g>>8, b>>8)
+	}
+}
+
+func TestBlurApply_InvalidBase(t *testing.T) {
+	c, _ := NewBlurChange(BlurParams{
+		Region: BlurRegion{X1: 0.1, Y1: 0.1, X2: 0.9, Y2: 0.9},
+		Radius: 5,
+	})
+	editor := &BlurEditor{}
+	if _, _, err := editor.Apply([]byte("not an image"), c, nil); err == nil {
+		t.Fatal("expected error for invalid base image")
+	}
+}
+
+func TestBlurApply_InvalidJSON(t *testing.T) {
+	base := makeBlurTestPNG(100, 100, color.White)
+	editor := &BlurEditor{}
+	if _, _, err := editor.Apply(base, Change{Type: "blur", Params: []byte("not json")}, nil); err == nil {
+		t.Fatal("expected error for invalid params JSON")
+	}
+}
+
+func TestBlurApply_RadiusIndependence(t *testing.T) {
+	// Both radius=1 and radius=50 should complete without error on a real image.
+	base := makeBlurTestPNG(300, 300, color.RGBA{128, 64, 200, 255})
+	editor := &BlurEditor{}
+	for _, radius := range []int{1, 50, 100} {
+		c, _ := NewBlurChange(BlurParams{
+			Region: BlurRegion{X1: 0.1, Y1: 0.1, X2: 0.9, Y2: 0.9},
+			Radius: radius,
+		})
+		result, _, err := editor.Apply(base, c, nil)
+		if err != nil {
+			t.Fatalf("radius %d: unexpected error: %v", radius, err)
+		}
+		if len(result) == 0 {
+			t.Fatalf("radius %d: empty result", radius)
+		}
+	}
+}

editing/changeset.go

@@ -32,6 +32,10 @@ type ApplyResult struct {
 // ApplyChangeSet applies each Change in the ChangeSet in order, piping
 // output bytes into the next step, then serializes the full ChangeSet.
 func ApplyChangeSet(cs ChangeSet, baseImageId string, fetchImage FetchImageFunc) (*ApplyResult, error) {
+	if len(cs) == 0 {
+		return nil, fmt.Errorf("change set must contain at least one change")
+	}
+
 	currentBytes, err := fetchImage(baseImageId)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch base image: %w", err)

web_client/src/localization/th.json

@@ -166,7 +166,18 @@
       "derivedFrom": "ต้นฉบับ: {{name}}",
       "watermarkApplied": "ใส่ลายน้ำสำเร็จ",
       "watermarkFailed": "ใส่ลายน้ำไม่สำเร็จ",
-      "watermark": "ลายน้ำ"
+      "watermark": "ลายน้ำ",
+      "blur": "เบลอ",
+      "blurApplied": "ใช้เอฟเฟกต์เบลอสำเร็จ",
+      "blurFailed": "ใช้เอฟเฟกต์เบลอไม่สำเร็จ"
+    },
+    "blurTool": {
+      "hint": "ลากบนภาพเพื่อเลือกพื้นที่ที่ต้องการเบลอ",
+      "noRegion": "ยังไม่ได้เลือกพื้นที่",
+      "regionSelected": "({{x1}}%, {{y1}}%) → ({{x2}}%, {{y2}}%)",
+      "radius": "ความแรงของเบลอ: {{value}}",
+      "applying": "กำลังใช้งาน...",
+      "applyBlur": "ใช้เอฟเฟกต์เบลอ"
     },
     "watermarkTool": {
       "overlayImage": "ภาพซ้อนทับ",