test: add composer and template test suites (43 tests, all passing)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

tasks.md

@@ -473,19 +473,19 @@
 
 任务：
 
-- [ ] 编写 `tests/test_composer.py`
+- [x] 编写 `tests/test_composer.py`
-- [ ] 编写 `tests/test_templates.py`
+- [x] 编写 `tests/test_templates.py`
-- [ ] 测试透明 PNG 合成
+- [x] 测试透明 PNG 合成
-- [ ] 测试缩放参数
+- [x] 测试缩放参数
-- [ ] 测试旋转中心
+- [x] 测试旋转中心
-- [ ] 测试文件扫描
+- [x] 测试文件扫描
-- [ ] 测试模板读写
+- [x] 测试模板读写
-- [ ] 测试批量任务生成
+- [x] 测试批量任务生成
 
 验收：
 
-- [ ] 核心逻辑测试不依赖 GUI
+- [x] 核心逻辑测试不依赖 GUI
-- [ ] 测试可在 Python 3.7 环境运行
+- [x] 测试可在 Python 3.7 环境运行
 
 ## 16. 打包
 

tests/test_composer.py

@@ -0,0 +1,211 @@
+"""Tests for core.composer — no GUI dependency."""
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+from PIL import Image
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from core.composer import compose
+from core.models import ExportOptions, TransformState
+
+# ---------------------------------------------------------------------------
+# helpers
+# ---------------------------------------------------------------------------
+
+def _rgba(w, h, color=(200, 200, 200, 255)):
+    return Image.new("RGBA", (w, h), color)
+
+
+class _TmpDir:
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp())
+
+    def tearDown(self):
+        shutil.rmtree(str(self.tmp), ignore_errors=True)
+
+    def _save(self, img: Image.Image, name: str) -> Path:
+        p = self.tmp / name
+        img.save(str(p))
+        return p
+
+    def _compose(self, garment, print_img, state, fmt="PNG", quality=90):
+        ext = ".jpg" if fmt.upper() in ("JPG", "JPEG") else ".png"
+        g = self._save(garment, "garment.png")   # garment always PNG
+        p = self._save(print_img, "print.png")
+        out = self.tmp / ("out" + ext)
+        opts = ExportOptions(output_format=fmt, quality=quality)
+        return compose(g, p, state, opts, out), out
+
+
+# ---------------------------------------------------------------------------
+# Transparency tests
+# ---------------------------------------------------------------------------
+
+class TestTransparency(_TmpDir, unittest.TestCase):
+    def test_fully_transparent_print_leaves_garment_unchanged(self):
+        """An all-alpha-0 print must not modify the garment pixels."""
+        garment = _rgba(100, 100, (200, 200, 200, 255))
+        print_img = Image.new("RGBA", (40, 40), (255, 0, 0, 0))  # fully transparent
+
+        state = TransformState(x=30, y=30, width=40, height=40)
+        result, out_path = self._compose(garment, print_img, state)
+
+        self.assertTrue(result.success, result.error)
+        out = Image.open(str(out_path)).convert("RGBA")
+        r, g, b, _ = out.getpixel((50, 50))
+        self.assertEqual((r, g, b), (200, 200, 200))
+
+    def test_opaque_print_overwrites_garment_pixels(self):
+        """Fully opaque blue print should cover garment in the print area."""
+        garment = _rgba(100, 100, (200, 200, 200, 255))
+        print_img = _rgba(20, 20, (0, 0, 255, 255))
+
+        state = TransformState(x=40, y=40, width=20, height=20)
+        result, out_path = self._compose(garment, print_img, state)
+
+        self.assertTrue(result.success, result.error)
+        out = Image.open(str(out_path)).convert("RGBA")
+        r, g, b, _ = out.getpixel((50, 50))   # center of print area
+        self.assertEqual((r, g, b), (0, 0, 255))
+
+
+# ---------------------------------------------------------------------------
+# Scaling tests
+# ---------------------------------------------------------------------------
+
+class TestScaling(_TmpDir, unittest.TestCase):
+    def test_print_is_scaled_to_state_dimensions(self):
+        """A 10×10 print scaled to 60×80 should fill that region."""
+        garment = _rgba(200, 200)
+        print_img = _rgba(10, 10, (255, 0, 0, 255))
+
+        state = TransformState(x=70, y=60, width=60, height=80)
+        result, out_path = self._compose(garment, print_img, state)
+
+        self.assertTrue(result.success, result.error)
+        out = Image.open(str(out_path)).convert("RGBA")
+        # Inside print area → red
+        r, g, b, _ = out.getpixel((100, 100))
+        self.assertEqual((r, g, b), (255, 0, 0))
+        # Outside print area → garment gray
+        r2, g2, b2, _ = out.getpixel((10, 10))
+        self.assertEqual((r2, g2, b2), (200, 200, 200))
+
+    def test_output_dimensions_match_garment(self):
+        """Output size must always equal the garment size, regardless of print size."""
+        gw, gh = 320, 480
+        garment = _rgba(gw, gh)
+        print_img = _rgba(10, 10, (0, 255, 0, 255))
+
+        state = TransformState(x=100, y=100, width=80, height=80)
+        result, out_path = self._compose(garment, print_img, state)
+
+        self.assertTrue(result.success, result.error)
+        out = Image.open(str(out_path))
+        self.assertEqual(out.size, (gw, gh))
+
+
+# ---------------------------------------------------------------------------
+# Rotation centre tests
+# ---------------------------------------------------------------------------
+
+class TestRotation(_TmpDir, unittest.TestCase):
+    def test_rotation_centre_fixed_for_square(self):
+        """After 90° CW rotation of a square print, its centre stays at (cx, cy)."""
+        garment = _rgba(200, 200)
+        print_img = _rgba(20, 20, (255, 0, 0, 255))
+
+        # Centre = (90+10, 90+10) = (100, 100)
+        state = TransformState(x=90, y=90, width=20, height=20, rotation=90)
+        result, out_path = self._compose(garment, print_img, state)
+
+        self.assertTrue(result.success, result.error)
+        out = Image.open(str(out_path)).convert("RGBA")
+        r, g, b, _ = out.getpixel((100, 100))
+        self.assertEqual((r, g, b), (255, 0, 0), "Centre pixel must be from the print")
+
+    def test_zero_rotation_same_as_no_rotation(self):
+        """rotation=0 should produce the same result as not specifying rotation."""
+        garment = _rgba(100, 100)
+        print_img = _rgba(20, 20, (0, 0, 255, 255))
+
+        state = TransformState(x=40, y=40, width=20, height=20, rotation=0)
+        result, out_path = self._compose(garment, print_img, state)
+
+        self.assertTrue(result.success, result.error)
+        out = Image.open(str(out_path)).convert("RGBA")
+        r, g, b, _ = out.getpixel((50, 50))
+        self.assertEqual((r, g, b), (0, 0, 255))
+
+
+# ---------------------------------------------------------------------------
+# Edge cases
+# ---------------------------------------------------------------------------
+
+class TestEdgeCases(_TmpDir, unittest.TestCase):
+    def test_print_partially_outside_canvas_no_error(self):
+        """Print whose bounding box extends beyond the canvas should not raise."""
+        garment = _rgba(50, 50)
+        print_img = _rgba(20, 20, (255, 0, 0, 255))
+
+        state = TransformState(x=45, y=45, width=20, height=20)
+        result, _ = self._compose(garment, print_img, state)
+        self.assertTrue(result.success, result.error)
+
+    def test_invalid_zero_dimensions_returns_failure(self):
+        """width=0 or height=0 must return a ComposeResult with success=False."""
+        garment = _rgba(100, 100)
+        print_img = _rgba(10, 10)
+
+        g = self._save(garment, "g.png")
+        p = self._save(print_img, "p.png")
+        out = self.tmp / "out.png"
+
+        state = TransformState(x=0, y=0, width=0, height=0)
+        result = compose(g, p, state, ExportOptions(), out)
+
+        self.assertFalse(result.success)
+        self.assertTrue(result.error)
+
+    def test_missing_garment_file_returns_failure(self):
+        """Non-existent garment path must return failure without raising."""
+        p = self._save(_rgba(10, 10), "p.png")
+        out = self.tmp / "out.png"
+
+        state = TransformState(x=0, y=0, width=10, height=10)
+        result = compose(self.tmp / "no_such_file.png", p, state, ExportOptions(), out)
+
+        self.assertFalse(result.success)
+
+
+# ---------------------------------------------------------------------------
+# JPG output
+# ---------------------------------------------------------------------------
+
+class TestJpgOutput(_TmpDir, unittest.TestCase):
+    def test_jpg_export_creates_file(self):
+        garment = _rgba(100, 100)
+        print_img = _rgba(30, 30, (0, 200, 0, 255))
+
+        state = TransformState(x=35, y=35, width=30, height=30)
+        result, out_path = self._compose(garment, print_img, state, fmt="JPG")
+
+        self.assertTrue(result.success, result.error)
+        self.assertTrue(out_path.exists())
+
+    def test_jpg_export_no_alpha_error(self):
+        """JPG export must not raise due to alpha channel handling."""
+        garment = _rgba(80, 80, (255, 255, 255, 255))
+        print_img = Image.new("RGBA", (20, 20), (255, 0, 0, 128))  # semi-transparent
+
+        state = TransformState(x=30, y=30, width=20, height=20)
+        result, _ = self._compose(garment, print_img, state, fmt="JPG")
+        self.assertTrue(result.success, result.error)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_templates.py

@@ -0,0 +1,374 @@
+"""Tests for template service, file scanning, and batch pair generation.
+No GUI dependency — runs in pure Python 3.7.
+"""
+import json
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+import services.file_service as _file_service
+
+
+def _patch_config_dir(tmpdir):
+    """Return a context-manager that redirects get_config_path to tmpdir."""
+    class _Ctx:
+        def __enter__(self):
+            self._orig = _file_service.get_config_path
+            _file_service.get_config_path = lambda name: Path(tmpdir) / name
+            return self
+
+        def __exit__(self, *_):
+            _file_service.get_config_path = self._orig
+
+    return _Ctx()
+
+
+# ---------------------------------------------------------------------------
+# Template service
+# ---------------------------------------------------------------------------
+
+class TestBuiltinTemplates(unittest.TestCase):
+    def test_builtins_are_present(self):
+        from services.template_service import get_builtin_templates
+        builtins = get_builtin_templates()
+        self.assertGreater(len(builtins), 0)
+
+    def test_builtins_marked_as_builtin(self):
+        from services.template_service import get_builtin_templates
+        for t in get_builtin_templates():
+            self.assertEqual(t.type, "builtin")
+
+    def test_builtins_have_valid_ratios(self):
+        from services.template_service import get_builtin_templates
+        for t in get_builtin_templates():
+            self.assertGreater(t.width_ratio, 0)
+            self.assertGreater(t.height_ratio, 0)
+
+
+class TestCustomTemplates(unittest.TestCase):
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp())
+        self._ctx = _patch_config_dir(self.tmp)
+        self._ctx.__enter__()
+
+    def tearDown(self):
+        self._ctx.__exit__(None, None, None)
+        shutil.rmtree(str(self.tmp), ignore_errors=True)
+
+    def _make_template(self, name, **kwargs):
+        from core.models import Template
+        defaults = dict(x_ratio=0.1, y_ratio=0.1, width_ratio=0.3, height_ratio=0.3,
+                        rotation=0.0, type="custom")
+        defaults.update(kwargs)
+        return Template(name=name, **defaults)
+
+    def test_missing_file_returns_empty(self):
+        from services.template_service import load_custom_templates
+        self.assertEqual(load_custom_templates(), [])
+
+    def test_add_and_reload(self):
+        from services.template_service import add_template, load_custom_templates
+        t = self._make_template("模板A", x_ratio=0.2, y_ratio=0.3,
+                                width_ratio=0.4, height_ratio=0.4, rotation=15.0)
+        add_template(t)
+
+        loaded = load_custom_templates()
+        self.assertEqual(len(loaded), 1)
+        lt = loaded[0]
+        self.assertEqual(lt.name, "模板A")
+        self.assertAlmostEqual(lt.x_ratio, 0.2)
+        self.assertAlmostEqual(lt.y_ratio, 0.3)
+        self.assertAlmostEqual(lt.rotation, 15.0)
+        self.assertEqual(lt.type, "custom")
+
+    def test_add_overwrites_same_name(self):
+        from services.template_service import add_template, load_custom_templates
+        add_template(self._make_template("重名", x_ratio=0.1))
+        add_template(self._make_template("重名", x_ratio=0.9))
+
+        loaded = load_custom_templates()
+        self.assertEqual(len(loaded), 1)
+        self.assertAlmostEqual(loaded[0].x_ratio, 0.9)
+
+    def test_get_all_templates_order(self):
+        from services.template_service import add_template, get_all_templates, get_builtin_templates
+        builtin_count = len(get_builtin_templates())
+        add_template(self._make_template("自定义"))
+
+        all_t = get_all_templates()
+        self.assertEqual(len(all_t), builtin_count + 1)
+        for t in all_t[:builtin_count]:
+            self.assertEqual(t.type, "builtin")
+        self.assertEqual(all_t[-1].type, "custom")
+
+    def test_rename_template(self):
+        from services.template_service import add_template, rename_template, load_custom_templates
+        add_template(self._make_template("旧名"))
+        rename_template("旧名", "新名")
+        loaded = load_custom_templates()
+        self.assertEqual(loaded[0].name, "新名")
+
+    def test_rename_nonexistent_raises_value_error(self):
+        from services.template_service import rename_template
+        with self.assertRaises(ValueError):
+            rename_template("不存在", "随便")
+
+    def test_rename_empty_name_raises_value_error(self):
+        from services.template_service import add_template, rename_template
+        add_template(self._make_template("有名"))
+        with self.assertRaises(ValueError):
+            rename_template("有名", "   ")
+
+    def test_delete_template(self):
+        from services.template_service import add_template, delete_template, load_custom_templates
+        add_template(self._make_template("删我"))
+        delete_template("删我")
+        self.assertEqual(load_custom_templates(), [])
+
+    def test_delete_nonexistent_raises_value_error(self):
+        from services.template_service import delete_template
+        with self.assertRaises(ValueError):
+            delete_template("不存在")
+
+    def test_corrupt_entry_is_skipped_others_load(self):
+        """A malformed entry in templates.json must not block valid entries."""
+        templates_file = self.tmp / "templates.json"
+        payload = {
+            "templates": [
+                {"name": "好的", "x_ratio": 0.1, "y_ratio": 0.1,
+                 "width_ratio": 0.3, "height_ratio": 0.3},
+                {"name": "坏的"},      # missing width_ratio / height_ratio
+                {"name": ""},          # empty name
+                {"name": "零比例", "x_ratio": 0.0, "y_ratio": 0.0,
+                 "width_ratio": 0.0, "height_ratio": 0.0},   # zero ratios
+            ]
+        }
+        templates_file.parent.mkdir(parents=True, exist_ok=True)
+        templates_file.write_text(json.dumps(payload), encoding="utf-8")
+
+        from services.template_service import load_custom_templates
+        loaded = load_custom_templates()
+        self.assertEqual(len(loaded), 1)
+        self.assertEqual(loaded[0].name, "好的")
+
+    def test_corrupt_json_returns_empty(self):
+        """Completely invalid JSON in templates.json should return empty list."""
+        templates_file = self.tmp / "templates.json"
+        templates_file.parent.mkdir(parents=True, exist_ok=True)
+        templates_file.write_text("{not valid json", encoding="utf-8")
+
+        from services.template_service import load_custom_templates
+        self.assertEqual(load_custom_templates(), [])
+
+
+# ---------------------------------------------------------------------------
+# Template model: to_transform_state
+# ---------------------------------------------------------------------------
+
+class TestTemplateToTransformState(unittest.TestCase):
+    def test_basic_conversion(self):
+        from core.models import Template
+        t = Template(
+            name="t", x_ratio=0.25, y_ratio=0.25,
+            width_ratio=0.5, height_ratio=0.5, rotation=30.0,
+        )
+        state = t.to_transform_state(400, 600)
+        self.assertAlmostEqual(state.x, 100.0)
+        self.assertAlmostEqual(state.y, 150.0)
+        self.assertAlmostEqual(state.width, 200.0)
+        self.assertAlmostEqual(state.height, 300.0)
+        self.assertAlmostEqual(state.rotation, 30.0)
+
+    def test_zero_rotation(self):
+        from core.models import Template
+        t = Template(name="t", x_ratio=0.0, y_ratio=0.0,
+                     width_ratio=1.0, height_ratio=1.0, rotation=0.0)
+        state = t.to_transform_state(100, 200)
+        self.assertAlmostEqual(state.rotation, 0.0)
+        self.assertAlmostEqual(state.width, 100.0)
+        self.assertAlmostEqual(state.height, 200.0)
+
+
+# ---------------------------------------------------------------------------
+# File scanning
+# ---------------------------------------------------------------------------
+
+class TestFileScan(unittest.TestCase):
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp())
+
+    def tearDown(self):
+        shutil.rmtree(str(self.tmp), ignore_errors=True)
+
+    def _png(self, path: Path):
+        from PIL import Image
+        path.parent.mkdir(parents=True, exist_ok=True)
+        Image.new("RGB", (1, 1)).save(str(path), "PNG")
+
+    def test_scans_flat_folder(self):
+        from services.file_service import scan_image_folder
+        self._png(self.tmp / "a.png")
+        self._png(self.tmp / "b.png")
+        assets = scan_image_folder(self.tmp)
+        self.assertEqual(len(assets), 2)
+
+    def test_recurses_into_subfolders(self):
+        from services.file_service import scan_image_folder
+        self._png(self.tmp / "root.png")
+        self._png(self.tmp / "sub" / "child.png")
+        self._png(self.tmp / "sub" / "deep" / "deeper.png")
+        assets = scan_image_folder(self.tmp)
+        self.assertEqual(len(assets), 3)
+
+    def test_skips_unsupported_formats(self):
+        from services.file_service import scan_image_folder
+        self._png(self.tmp / "ok.png")
+        (self.tmp / "ignored.txt").write_text("text")
+        (self.tmp / "ignored.pdf").write_bytes(b"%PDF")
+        assets = scan_image_folder(self.tmp)
+        self.assertEqual(len(assets), 1)
+
+    def test_supports_jpg_and_webp_extensions(self):
+        from services.file_service import scan_image_folder
+        from PIL import Image
+        Image.new("RGB", (1, 1)).save(str(self.tmp / "img.jpg"), "JPEG")
+        Image.new("RGB", (1, 1)).save(str(self.tmp / "img.jpeg"), "JPEG")
+        # .webp: just check extension recognition; create a renamed png
+        self._png(self.tmp / "img.png")
+        assets = scan_image_folder(self.tmp)
+        self.assertEqual(len(assets), 3)
+
+    def test_assets_selected_by_default(self):
+        from services.file_service import scan_image_folder
+        self._png(self.tmp / "img.png")
+        assets = scan_image_folder(self.tmp)
+        self.assertTrue(assets[0].selected)
+
+    def test_nonexistent_dir_raises_oserror(self):
+        from services.file_service import scan_image_folder
+        with self.assertRaises(OSError):
+            scan_image_folder(self.tmp / "nonexistent")
+
+    def test_file_path_raises_oserror(self):
+        from services.file_service import scan_image_folder
+        f = self.tmp / "f.png"
+        self._png(f)
+        with self.assertRaises(OSError):
+            scan_image_folder(f)   # path is a file, not a directory
+
+
+# ---------------------------------------------------------------------------
+# Batch pair generation (core.batch._build_pairs)
+# ---------------------------------------------------------------------------
+
+class TestBatchPairs(unittest.TestCase):
+    def setUp(self):
+        from core.models import BatchMode
+        from core.batch import _build_pairs
+        self.build = _build_pairs
+        self.Mode = BatchMode
+        self.paths = lambda *names: [Path(n) for n in names]
+
+    def test_full_combo_all_combinations(self):
+        g = self.paths("g1", "g2")
+        p = self.paths("p1", "p2", "p3")
+        pairs = self.build(g, p, self.Mode.FULL_COMBO)
+        self.assertEqual(len(pairs), 6)   # 2 × 3
+
+    def test_full_combo_order(self):
+        g = self.paths("g1", "g2")
+        p = self.paths("p1", "p2")
+        pairs = self.build(g, p, self.Mode.FULL_COMBO)
+        expected = [(Path("g1"), Path("p1")), (Path("g1"), Path("p2")),
+                    (Path("g2"), Path("p1")), (Path("g2"), Path("p2"))]
+        self.assertEqual(pairs, expected)
+
+    def test_many_garments_uses_first_print(self):
+        g = self.paths("g1", "g2", "g3")
+        p = self.paths("p1", "p2")
+        pairs = self.build(g, p, self.Mode.MANY_GARMENTS)
+        self.assertEqual(len(pairs), 3)
+        self.assertTrue(all(pr[1] == Path("p1") for pr in pairs))
+
+    def test_many_garments_empty_prints_returns_empty(self):
+        g = self.paths("g1", "g2")
+        pairs = self.build(g, [], self.Mode.MANY_GARMENTS)
+        self.assertEqual(pairs, [])
+
+    def test_many_prints_uses_first_garment(self):
+        g = self.paths("g1", "g2")
+        p = self.paths("p1", "p2", "p3")
+        pairs = self.build(g, p, self.Mode.MANY_PRINTS)
+        self.assertEqual(len(pairs), 3)
+        self.assertTrue(all(pr[0] == Path("g1") for pr in pairs))
+
+    def test_many_prints_empty_garments_returns_empty(self):
+        p = self.paths("p1", "p2")
+        pairs = self.build([], p, self.Mode.MANY_PRINTS)
+        self.assertEqual(pairs, [])
+
+    def test_one_to_one_zips_lists(self):
+        g = self.paths("g1", "g2", "g3")
+        p = self.paths("p1", "p2")
+        pairs = self.build(g, p, self.Mode.ONE_TO_ONE)
+        self.assertEqual(len(pairs), 2)   # zip stops at shorter
+        self.assertEqual(pairs[0], (Path("g1"), Path("p1")))
+        self.assertEqual(pairs[1], (Path("g2"), Path("p2")))
+
+    def test_empty_inputs_return_empty(self):
+        pairs = self.build([], [], self.Mode.FULL_COMBO)
+        self.assertEqual(pairs, [])
+
+
+# ---------------------------------------------------------------------------
+# Batch result summary (run_batch, single-failure resilience)
+# ---------------------------------------------------------------------------
+
+class TestBatchRunSingleFailure(unittest.TestCase):
+    """Verify that run_batch continues even when one item fails."""
+
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp())
+
+    def tearDown(self):
+        shutil.rmtree(str(self.tmp), ignore_errors=True)
+
+    def _png(self, name, color=(200, 200, 200)):
+        from PIL import Image
+        p = self.tmp / name
+        Image.new("RGB", (50, 50), color).save(str(p), "PNG")
+        return p
+
+    def test_single_bad_file_does_not_stop_batch(self):
+        from core.batch import run_batch
+        from core.models import BatchMode, BatchOptions, ExportOptions, TransformState
+
+        good1 = self._png("g1.png", (200, 200, 200))
+        good2 = self._png("g2.png", (100, 100, 100))
+        print_img = self._png("p.png", (255, 0, 0))
+        bad_file = self.tmp / "nonexistent.png"
+
+        garments = [good1, bad_file, good2]
+        prints = [print_img]
+        transform = TransformState(x=10, y=10, width=20, height=20)
+        opts = BatchOptions(
+            mode=BatchMode.MANY_GARMENTS,
+            export_options=ExportOptions(
+                output_dir=str(self.tmp / "out"),
+                output_format="PNG",
+            ),
+        )
+        result = run_batch(garments, prints, transform, opts)
+
+        self.assertEqual(result.total, 3)
+        self.assertEqual(result.success_count, 2)
+        self.assertEqual(result.failure_count, 1)
+        self.assertFalse(result.results[1].success)   # bad_file entry failed
+
+
+if __name__ == "__main__":
+    unittest.main()