godot-visual-smoke-test-kit 0.1.0__tar.gz

godot_visual_smoke_test_kit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Godot Visual Smoke Test Kit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

godot_visual_smoke_test_kit-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: godot-visual-smoke-test-kit
+Version: 0.1.0
+Summary: Screenshot diff and baseline helpers for Godot visual smoke tests.
+Author: Godot Visual Smoke Test Kit contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NonniGB/godot-production-toolkit/tree/main/godot-visual-smoke-test-kit
+Project-URL: Issues, https://github.com/NonniGB/godot-production-toolkit/issues
+Keywords: godot,screenshot,visual-regression,ci,gamedev
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow>=10
+Dynamic: license-file
+
+# Godot Visual Smoke Test Kit
+
+Screenshot diff and baseline helpers for Godot visual smoke tests. It reads scene/viewport config, compares PNG screenshots, writes diff images, approves baselines, and prints planned Godot capture commands.
+
+The first release keeps Godot execution out of unit tests, so the package is easy to run in CI and safe to develop without a specific engine install.
+
+## Install
+
+```powershell
+python -m pip install -e .
+```
+
+When published:
+
+```powershell
+python -m pip install godot-visual-smoke-test-kit
+```
+
+## Quick Start
+
+```powershell
+godot-visual-smoke plan visual-smoke.toml --project . --godot C:\Tools\Godot.exe
+godot-visual-smoke plan visual-smoke.toml --project . --format json
+godot-visual-smoke compare baselines\menu.png current\menu.png --diff diffs\menu.png
+godot-visual-smoke approve current\menu.png baselines\menu.png
+godot-visual-smoke compare baselines\menu.png current\menu.png --format json --output visual-report.json
+```
+
+## What It Does
+
+- Parses `visual-smoke.toml`.
+- Supports named viewport presets.
+- Compares baseline and current PNG screenshots.
+- Applies per-channel pixel tolerance.
+- Fails when changed pixel percentage exceeds the configured threshold.
+- Writes red diff images.
+- Copies approved screenshots into baseline paths.
+- Prints Godot capture commands for a project-owned helper script.
+
+## Documentation
+
+- [Configuration](docs/CONFIGURATION.md)
+- [Baseline workflow](docs/BASELINES.md)
+- [Godot capture integration](docs/GODOT_CAPTURE.md)
+- [CI usage](docs/CI.md)
+- [Troubleshooting](docs/TROUBLESHOOTING.md)
+
+## Development
+
+```powershell
+python -m pip install -e .
+python -m unittest discover -s tests -v
+godot-visual-smoke plan examples\visual-smoke.toml --project examples\tiny-godot-project
+```
+
+Examples are generic. Do not publish screenshots from private projects unless they have been reviewed.

godot_visual_smoke_test_kit-0.1.0/README.md

@@ -0,0 +1,56 @@
+# Godot Visual Smoke Test Kit
+
+Screenshot diff and baseline helpers for Godot visual smoke tests. It reads scene/viewport config, compares PNG screenshots, writes diff images, approves baselines, and prints planned Godot capture commands.
+
+The first release keeps Godot execution out of unit tests, so the package is easy to run in CI and safe to develop without a specific engine install.
+
+## Install
+
+```powershell
+python -m pip install -e .
+```
+
+When published:
+
+```powershell
+python -m pip install godot-visual-smoke-test-kit
+```
+
+## Quick Start
+
+```powershell
+godot-visual-smoke plan visual-smoke.toml --project . --godot C:\Tools\Godot.exe
+godot-visual-smoke plan visual-smoke.toml --project . --format json
+godot-visual-smoke compare baselines\menu.png current\menu.png --diff diffs\menu.png
+godot-visual-smoke approve current\menu.png baselines\menu.png
+godot-visual-smoke compare baselines\menu.png current\menu.png --format json --output visual-report.json
+```
+
+## What It Does
+
+- Parses `visual-smoke.toml`.
+- Supports named viewport presets.
+- Compares baseline and current PNG screenshots.
+- Applies per-channel pixel tolerance.
+- Fails when changed pixel percentage exceeds the configured threshold.
+- Writes red diff images.
+- Copies approved screenshots into baseline paths.
+- Prints Godot capture commands for a project-owned helper script.
+
+## Documentation
+
+- [Configuration](docs/CONFIGURATION.md)
+- [Baseline workflow](docs/BASELINES.md)
+- [Godot capture integration](docs/GODOT_CAPTURE.md)
+- [CI usage](docs/CI.md)
+- [Troubleshooting](docs/TROUBLESHOOTING.md)
+
+## Development
+
+```powershell
+python -m pip install -e .
+python -m unittest discover -s tests -v
+godot-visual-smoke plan examples\visual-smoke.toml --project examples\tiny-godot-project
+```
+
+Examples are generic. Do not publish screenshots from private projects unless they have been reviewed.

godot_visual_smoke_test_kit-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "godot-visual-smoke-test-kit"
+version = "0.1.0"
+description = "Screenshot diff and baseline helpers for Godot visual smoke tests."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [{ name = "Godot Visual Smoke Test Kit contributors" }]
+keywords = ["godot", "screenshot", "visual-regression", "ci", "gamedev"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Multimedia :: Graphics",
+  "Topic :: Software Development :: Quality Assurance"
+]
+dependencies = ["Pillow>=10"]
+
+[project.urls]
+Homepage = "https://github.com/NonniGB/godot-production-toolkit/tree/main/godot-visual-smoke-test-kit"
+Issues = "https://github.com/NonniGB/godot-production-toolkit/issues"
+
+[project.scripts]
+godot-visual-smoke = "godot_visual_smoke.cli:entrypoint"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

godot_visual_smoke_test_kit-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke/__init__.py

@@ -0,0 +1,3 @@
+"""Godot visual smoke testing helpers."""
+
+__version__ = "0.1.0"

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke/__main__.py

@@ -0,0 +1,5 @@
+from .cli import entrypoint
+
+
+if __name__ == "__main__":
+    entrypoint()

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke/approve.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+
+def approve_baseline(current: Path, baseline: Path) -> None:
+    baseline.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copyfile(current, baseline)

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke/cli.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from .approve import approve_baseline
+from .config import load_config
+from .diff import compare_images
+from .reporting import render_json_result, render_text_result
+from .runner import build_godot_command
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    if args.command == "compare":
+        return _compare(args)
+    if args.command == "approve":
+        approve_baseline(Path(args.current), Path(args.baseline))
+        return 0
+    if args.command == "plan":
+        return _plan(args)
+    parser.print_help()
+    return 2
+
+
+def entrypoint() -> None:
+    raise SystemExit(main())
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="godot-visual-smoke",
+        description="Compare and approve Godot visual smoke screenshots.",
+    )
+    parser.add_argument("--version", action="version", version="godot-visual-smoke 0.1.0")
+    subparsers = parser.add_subparsers(dest="command")
+
+    compare = subparsers.add_parser("compare", help="Compare baseline and current screenshots.")
+    compare.add_argument("baseline")
+    compare.add_argument("current")
+    compare.add_argument("--diff", help="Optional diff image path.")
+    compare.add_argument("--pixel-tolerance", type=int, default=0)
+    compare.add_argument("--max-changed-percent", type=float, default=0.0)
+    compare.add_argument("--format", choices=["text", "json"], default="text")
+    compare.add_argument("--output")
+    compare.add_argument("--fail-on", choices=["diff", "none"], default="diff")
+
+    approve = subparsers.add_parser("approve", help="Copy current screenshot to baseline.")
+    approve.add_argument("current")
+    approve.add_argument("baseline")
+
+    plan = subparsers.add_parser("plan", help="Print Godot capture commands from visual-smoke.toml.")
+    plan.add_argument("config")
+    plan.add_argument("--project", required=True)
+    plan.add_argument("--godot", default="godot")
+    plan.add_argument("--format", choices=["text", "json"], default="text")
+    return parser
+
+
+def _compare(args: argparse.Namespace) -> int:
+    result = compare_images(
+        Path(args.baseline),
+        Path(args.current),
+        diff_path=Path(args.diff) if args.diff else None,
+        pixel_tolerance=args.pixel_tolerance,
+        max_changed_percent=args.max_changed_percent,
+    )
+    rendered = render_json_result(result) if args.format == "json" else render_text_result(result)
+    if args.output:
+        output = Path(args.output)
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(rendered + "\n", encoding="utf-8")
+    else:
+        print(rendered)
+    return 1 if args.fail_on == "diff" and not result.passed else 0
+
+
+def _plan(args: argparse.Namespace) -> int:
+    config = load_config(Path(args.config))
+    planned_commands = []
+    for scene in config.scenes:
+        viewport = config.viewports[scene.viewport]
+        output = Path(config.output_dir) / f"{scene.name}.png"
+        command = build_godot_command(
+            godot=Path(args.godot),
+            project=Path(args.project),
+            scene=scene.path,
+            width=viewport.width,
+            height=viewport.height,
+            output=output,
+        )
+        planned_commands.append(
+            {
+                "name": scene.name,
+                "scene": scene.path,
+                "viewport": {
+                    "name": viewport.name,
+                    "width": viewport.width,
+                    "height": viewport.height,
+                },
+                "output": str(output),
+                "command": command,
+                "shell": " ".join(command),
+            }
+        )
+    if args.format == "json":
+        print(json.dumps({"commands": planned_commands}, indent=2, sort_keys=True))
+    else:
+        for planned in planned_commands:
+            print(planned["shell"])
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke/config.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+
+from .models import SceneSpec, SmokeConfig, Viewport
+
+
+def load_config(path: Path) -> SmokeConfig:
+    data = tomllib.loads(path.read_text(encoding="utf-8"))
+    settings = data.get("settings", {})
+    viewports = {
+        name: Viewport(name=name, width=int(values["width"]), height=int(values["height"]))
+        for name, values in data.get("viewports", {}).items()
+    }
+    scenes = [
+        SceneSpec(name=str(scene["name"]), path=str(scene["path"]), viewport=str(scene["viewport"]))
+        for scene in data.get("scenes", [])
+    ]
+    return SmokeConfig(
+        pixel_tolerance=int(settings.get("pixel_tolerance", 0)),
+        max_changed_percent=float(settings.get("max_changed_percent", 0.0)),
+        output_dir=str(settings.get("output_dir", "visual-smoke-output")),
+        viewports=viewports,
+        scenes=scenes,
+    )

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke/diff.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from PIL import Image
+
+from .models import DiffResult
+
+
+def compare_images(
+    baseline: Path,
+    current: Path,
+    *,
+    diff_path: Path | None = None,
+    pixel_tolerance: int = 0,
+    max_changed_percent: float = 0.0,
+) -> DiffResult:
+    with Image.open(baseline) as baseline_image, Image.open(current) as current_image:
+        base = baseline_image.convert("RGBA")
+        curr = current_image.convert("RGBA")
+        if base.size != curr.size:
+            width, height = curr.size
+            total = width * height
+            return DiffResult(
+                str(baseline),
+                str(current),
+                width,
+                height,
+                total,
+                total,
+                100.0,
+                255,
+                False,
+                reason=f"Image size differs: baseline {base.size}, current {curr.size}.",
+            )
+
+        width, height = base.size
+        diff_image = Image.new("RGBA", base.size, (0, 0, 0, 0))
+        changed = 0
+        max_delta = 0
+        for y in range(height):
+            for x in range(width):
+                base_pixel = base.getpixel((x, y))
+                curr_pixel = curr.getpixel((x, y))
+                delta = max(abs(base_pixel[index] - curr_pixel[index]) for index in range(4))
+                max_delta = max(max_delta, delta)
+                if delta > pixel_tolerance:
+                    changed += 1
+                    diff_image.putpixel((x, y), (255, 0, 0, 255))
+
+        total = width * height
+        changed_percent = round((changed / total) * 100, 4) if total else 0.0
+        passed = changed_percent <= max_changed_percent
+        if diff_path:
+            diff_path.parent.mkdir(parents=True, exist_ok=True)
+            diff_image.save(diff_path)
+        return DiffResult(
+            str(baseline),
+            str(current),
+            width,
+            height,
+            changed,
+            total,
+            changed_percent,
+            max_delta,
+            passed,
+        )

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke/models.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class Viewport:
+    name: str
+    width: int
+    height: int
+
+
+@dataclass(frozen=True)
+class SceneSpec:
+    name: str
+    path: str
+    viewport: str
+
+
+@dataclass(frozen=True)
+class SmokeConfig:
+    pixel_tolerance: int = 0
+    max_changed_percent: float = 0.0
+    output_dir: str = "visual-smoke-output"
+    viewports: dict[str, Viewport] = field(default_factory=dict)
+    scenes: list[SceneSpec] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class DiffResult:
+    baseline: str
+    current: str
+    width: int
+    height: int
+    changed_pixels: int
+    total_pixels: int
+    changed_percent: float
+    max_delta: int
+    passed: bool
+    reason: str = ""
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "baseline": self.baseline,
+            "current": self.current,
+            "width": self.width,
+            "height": self.height,
+            "changed_pixels": self.changed_pixels,
+            "total_pixels": self.total_pixels,
+            "changed_percent": self.changed_percent,
+            "max_delta": self.max_delta,
+            "passed": self.passed,
+            "reason": self.reason,
+        }

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke/reporting.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import json
+
+from .models import DiffResult
+
+
+def render_text_result(result: DiffResult) -> str:
+    status = "PASS" if result.passed else "FAIL"
+    lines = [
+        f"Visual smoke diff: {status}",
+        f"Changed pixels: {result.changed_pixels}/{result.total_pixels} ({result.changed_percent:.4f}%).",
+        f"Max delta: {result.max_delta}.",
+    ]
+    if result.reason:
+        lines.append(result.reason)
+    return "\n".join(lines)
+
+
+def render_json_result(result: DiffResult) -> str:
+    return json.dumps(result.to_dict(), indent=2, sort_keys=True)

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke/runner.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def build_godot_command(
+    *,
+    godot: Path,
+    project: Path,
+    scene: str,
+    width: int,
+    height: int,
+    output: Path,
+) -> list[str]:
+    return [
+        str(godot),
+        "--headless",
+        "--path",
+        str(project),
+        "--resolution",
+        f"{width}x{height}",
+        "--script",
+        "res://addons/visual_smoke/capture_scene.gd",
+        "--scene",
+        scene,
+        "--output",
+        str(output),
+    ]

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke_test_kit.egg-info/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: godot-visual-smoke-test-kit
+Version: 0.1.0
+Summary: Screenshot diff and baseline helpers for Godot visual smoke tests.
+Author: Godot Visual Smoke Test Kit contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NonniGB/godot-production-toolkit/tree/main/godot-visual-smoke-test-kit
+Project-URL: Issues, https://github.com/NonniGB/godot-production-toolkit/issues
+Keywords: godot,screenshot,visual-regression,ci,gamedev
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow>=10
+Dynamic: license-file
+
+# Godot Visual Smoke Test Kit
+
+Screenshot diff and baseline helpers for Godot visual smoke tests. It reads scene/viewport config, compares PNG screenshots, writes diff images, approves baselines, and prints planned Godot capture commands.
+
+The first release keeps Godot execution out of unit tests, so the package is easy to run in CI and safe to develop without a specific engine install.
+
+## Install
+
+```powershell
+python -m pip install -e .
+```
+
+When published:
+
+```powershell
+python -m pip install godot-visual-smoke-test-kit
+```
+
+## Quick Start
+
+```powershell
+godot-visual-smoke plan visual-smoke.toml --project . --godot C:\Tools\Godot.exe
+godot-visual-smoke plan visual-smoke.toml --project . --format json
+godot-visual-smoke compare baselines\menu.png current\menu.png --diff diffs\menu.png
+godot-visual-smoke approve current\menu.png baselines\menu.png
+godot-visual-smoke compare baselines\menu.png current\menu.png --format json --output visual-report.json
+```
+
+## What It Does
+
+- Parses `visual-smoke.toml`.
+- Supports named viewport presets.
+- Compares baseline and current PNG screenshots.
+- Applies per-channel pixel tolerance.
+- Fails when changed pixel percentage exceeds the configured threshold.
+- Writes red diff images.
+- Copies approved screenshots into baseline paths.
+- Prints Godot capture commands for a project-owned helper script.
+
+## Documentation
+
+- [Configuration](docs/CONFIGURATION.md)
+- [Baseline workflow](docs/BASELINES.md)
+- [Godot capture integration](docs/GODOT_CAPTURE.md)
+- [CI usage](docs/CI.md)
+- [Troubleshooting](docs/TROUBLESHOOTING.md)
+
+## Development
+
+```powershell
+python -m pip install -e .
+python -m unittest discover -s tests -v
+godot-visual-smoke plan examples\visual-smoke.toml --project examples\tiny-godot-project
+```
+
+Examples are generic. Do not publish screenshots from private projects unless they have been reviewed.

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke_test_kit.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+src/godot_visual_smoke/__init__.py
+src/godot_visual_smoke/__main__.py
+src/godot_visual_smoke/approve.py
+src/godot_visual_smoke/cli.py
+src/godot_visual_smoke/config.py
+src/godot_visual_smoke/diff.py
+src/godot_visual_smoke/models.py
+src/godot_visual_smoke/reporting.py
+src/godot_visual_smoke/runner.py
+src/godot_visual_smoke_test_kit.egg-info/PKG-INFO
+src/godot_visual_smoke_test_kit.egg-info/SOURCES.txt
+src/godot_visual_smoke_test_kit.egg-info/dependency_links.txt
+src/godot_visual_smoke_test_kit.egg-info/entry_points.txt
+src/godot_visual_smoke_test_kit.egg-info/requires.txt
+src/godot_visual_smoke_test_kit.egg-info/top_level.txt
+tests/test_approve_runner.py
+tests/test_cli.py
+tests/test_config.py
+tests/test_diff.py

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke_test_kit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke_test_kit.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+godot-visual-smoke = godot_visual_smoke.cli:entrypoint

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke_test_kit.egg-info/requires.txt

@@ -0,0 +1 @@
+Pillow>=10

godot_visual_smoke_test_kit-0.1.0/src/godot_visual_smoke_test_kit.egg-info/top_level.txt

@@ -0,0 +1 @@
+godot_visual_smoke

godot_visual_smoke_test_kit-0.1.0/tests/test_approve_runner.py

@@ -0,0 +1,71 @@
+import tempfile
+import unittest
+import json
+from contextlib import redirect_stdout
+from io import StringIO
+from pathlib import Path
+
+from godot_visual_smoke.cli import main
+from godot_visual_smoke.approve import approve_baseline
+from godot_visual_smoke.runner import build_godot_command
+
+
+class ApproveRunnerTests(unittest.TestCase):
+    def test_approve_copies_current_to_baseline(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            current = root / "current.png"
+            baseline = root / "baselines" / "menu.png"
+            current.write_bytes(b"png-data")
+
+            approve_baseline(current, baseline)
+
+            self.assertEqual(baseline.read_bytes(), b"png-data")
+
+    def test_builds_godot_command(self) -> None:
+        command = build_godot_command(
+            godot=Path("Godot.exe"),
+            project=Path("project"),
+            scene="res://scenes/menu.tscn",
+            width=720,
+            height=1280,
+            output=Path("out/menu.png"),
+        )
+
+        self.assertIn("--path", command)
+        self.assertIn("project", command)
+        self.assertIn("--resolution", command)
+        self.assertIn("720x1280", command)
+
+    def test_plan_cli_can_emit_json_for_automation(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            config = root / "visual-smoke.toml"
+            project = root / "project"
+            project.mkdir()
+            config.write_text(
+                """
+[viewports.phone]
+width = 720
+height = 1280
+
+[[scenes]]
+name = "menu"
+path = "res://scenes/menu.tscn"
+viewport = "phone"
+""",
+                encoding="utf-8",
+            )
+            stdout = StringIO()
+
+            with redirect_stdout(stdout):
+                exit_code = main(["plan", str(config), "--project", str(project), "--format", "json"])
+
+            payload = json.loads(stdout.getvalue())
+            self.assertEqual(exit_code, 0)
+            self.assertEqual(payload["commands"][0]["scene"], "res://scenes/menu.tscn")
+            self.assertEqual(payload["commands"][0]["viewport"]["width"], 720)
+
+
+if __name__ == "__main__":
+    unittest.main()

godot_visual_smoke_test_kit-0.1.0/tests/test_cli.py

@@ -0,0 +1,50 @@
+from contextlib import redirect_stdout
+from io import StringIO
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from PIL import Image
+
+from godot_visual_smoke.cli import main
+
+
+class CliTests(unittest.TestCase):
+    def test_cli_prints_version(self) -> None:
+        stdout = StringIO()
+
+        with self.assertRaises(SystemExit) as raised:
+            with redirect_stdout(stdout):
+                main(["--version"])
+
+        self.assertEqual(raised.exception.code, 0)
+        self.assertIn("godot-visual-smoke 0.1.0", stdout.getvalue())
+
+    def test_compare_cli_writes_json_report(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            baseline = root / "baseline.png"
+            current = root / "current.png"
+            output = root / "report.json"
+            Image.new("RGBA", (1, 1), (0, 0, 0, 255)).save(baseline)
+            Image.new("RGBA", (1, 1), (255, 255, 255, 255)).save(current)
+
+            exit_code = main(
+                [
+                    "compare",
+                    str(baseline),
+                    str(current),
+                    "--format",
+                    "json",
+                    "--output",
+                    str(output),
+                ]
+            )
+
+            self.assertEqual(exit_code, 1)
+            self.assertEqual(json.loads(output.read_text(encoding="utf-8"))["changed_pixels"], 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

godot_visual_smoke_test_kit-0.1.0/tests/test_config.py

@@ -0,0 +1,39 @@
+import tempfile
+import unittest
+from pathlib import Path
+
+from godot_visual_smoke.config import load_config
+
+
+class ConfigTests(unittest.TestCase):
+    def test_loads_scene_and_viewport_config(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "visual-smoke.toml"
+            path.write_text(
+                """
+[settings]
+pixel_tolerance = 2
+max_changed_percent = 0.5
+
+[viewports.portrait_phone]
+width = 720
+height = 1280
+
+[[scenes]]
+name = "menu"
+path = "res://scenes/menu.tscn"
+viewport = "portrait_phone"
+""",
+                encoding="utf-8",
+            )
+
+            config = load_config(path)
+
+            self.assertEqual(config.pixel_tolerance, 2)
+            self.assertEqual(config.max_changed_percent, 0.5)
+            self.assertEqual(config.viewports["portrait_phone"].width, 720)
+            self.assertEqual(config.scenes[0].path, "res://scenes/menu.tscn")
+
+
+if __name__ == "__main__":
+    unittest.main()

godot_visual_smoke_test_kit-0.1.0/tests/test_diff.py

@@ -0,0 +1,44 @@
+import tempfile
+import unittest
+from pathlib import Path
+
+from PIL import Image
+
+from godot_visual_smoke.diff import compare_images
+
+
+class DiffTests(unittest.TestCase):
+    def test_compare_images_counts_changed_pixels_and_writes_diff(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            baseline = root / "baseline.png"
+            current = root / "current.png"
+            diff = root / "diff.png"
+            Image.new("RGBA", (2, 2), (0, 0, 0, 255)).save(baseline)
+            image = Image.new("RGBA", (2, 2), (0, 0, 0, 255))
+            image.putpixel((1, 1), (255, 0, 0, 255))
+            image.save(current)
+
+            result = compare_images(baseline, current, diff_path=diff, pixel_tolerance=0, max_changed_percent=0)
+
+            self.assertFalse(result.passed)
+            self.assertEqual(result.changed_pixels, 1)
+            self.assertAlmostEqual(result.changed_percent, 25.0)
+            self.assertTrue(diff.exists())
+
+    def test_compare_images_passes_with_pixel_tolerance(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            baseline = root / "baseline.png"
+            current = root / "current.png"
+            Image.new("RGBA", (1, 1), (10, 10, 10, 255)).save(baseline)
+            Image.new("RGBA", (1, 1), (11, 10, 10, 255)).save(current)
+
+            result = compare_images(baseline, current, pixel_tolerance=1, max_changed_percent=0)
+
+            self.assertTrue(result.passed)
+            self.assertEqual(result.changed_pixels, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()