test: Add golden test infrastructure

Golden test fixtures for the new dependabot-grpc-fixer.py script will be
stored in tests/cookiecutter/scripts/fixtures/fixer_cases with one
sub-directory per test case, where each test case is composed of the
expected inputs and outputs.

Signed-off-by: Leandro Lucarella <luca-frequenz@llucax.com>

Author: llucax

tests/cookiecutter/scripts/test_dependabot-grpc-fixer.py

@@ -5,6 +5,7 @@
 import re
 import shutil
 import sys
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Protocol, cast
 
@@ -43,6 +44,119 @@ def _load_fixer() -> FixerModule:
 
 fixer = _load_fixer()
 
+CASE_ROOT = Path(__file__).with_name("fixtures") / "dependabot-grpc-fixer"
+
+
+@dataclass(frozen=True)
+class Case:
+    """A single file-based test case."""
+
+    path: Path
+    stdout_exact: str | None
+    stdout_contains: str | None
+    stderr_exact: str | None
+    stderr_contains: str | None
+
+    @property
+    def expected_pyproject(self) -> Path:
+        """Return the expected `pyproject.toml` path for the case."""
+        return self.path / "expected" / "pyproject.toml"
+
+
+def _case_dirs() -> list[Path]:
+    """Return all fixture case directories."""
+    case_dirs = sorted(path for path in CASE_ROOT.iterdir() if path.is_dir())
+    if not case_dirs:
+        raise AssertionError(f"no fixture cases found in {CASE_ROOT}")
+    return case_dirs
+
+
+def _read_optional(path: Path) -> str | None:
+    """Read a file if it exists."""
+    if path.exists():
+        return path.read_text(encoding="utf-8")
+    return None
+
+
+def _read_contains(path: Path) -> str | None:
+    """Read a partial-match expectation if it exists."""
+    if path.exists():
+        return path.read_text(encoding="utf-8").rstrip("\n")
+    return None
+
+
+def _load_case(case_dir: Path) -> Case:
+    """Load a case and its optional output expectations."""
+    expected_dir = case_dir / "expected"
+    return Case(
+        path=case_dir,
+        stdout_exact=_read_optional(expected_dir / "stdout.txt"),
+        stdout_contains=_read_contains(expected_dir / "stdout.contains.txt"),
+        stderr_exact=_read_optional(expected_dir / "stderr.txt"),
+        stderr_contains=_read_contains(expected_dir / "stderr.contains.txt"),
+    )
+
+
+def _prepare_workspace(
+    case: Case,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> Path:
+    """Copy fixture inputs into a temp workspace and set env vars."""
+    input_dir = case.path / "input"
+    input_pyproject = input_dir / "pyproject.toml"
+    if input_pyproject.exists():
+        shutil.copyfile(input_pyproject, tmp_path / fixer.PYPROJECT.name)
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(sys, "argv", [str(FIXER_PATH)])
+    input_metadata = input_dir / "dependabot-metadata.json"
+    monkeypatch.setenv(
+        "UPDATED_DEPENDENCIES_JSON",
+        input_metadata.read_text(encoding="utf-8") if input_metadata.exists() else "",
+    )
+    return tmp_path / fixer.PYPROJECT.name
+
+
+@pytest.mark.parametrize(
+    "case", map(_load_case, _case_dirs()), ids=lambda case: case.path.name
+)
+def test_fixer_cases(
+    case: Case,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """Apply each case and compare the rewritten files and output."""
+    workspace = _prepare_workspace(case, tmp_path, monkeypatch)
+    if case.stderr_exact is not None or case.stderr_contains is not None:
+        with pytest.raises(SystemExit) as excinfo:
+            fixer.main()
+        assert excinfo.value.code == 1
+    else:
+        fixer.main()
+
+    captured = capsys.readouterr()
+
+    if case.stdout_exact is not None:
+        assert captured.out == case.stdout_exact
+    elif case.stdout_contains is not None:
+        assert case.stdout_contains in captured.out
+    else:
+        assert captured.out == ""
+
+    if case.stderr_exact is not None:
+        assert captured.err == case.stderr_exact
+    elif case.stderr_contains is not None:
+        assert case.stderr_contains in captured.err
+    else:
+        assert captured.err == ""
+
+    expected_pyproject = case.expected_pyproject
+    if expected_pyproject.exists():
+        assert workspace.read_text(encoding="utf-8") == expected_pyproject.read_text(
+            encoding="utf-8"
+        )
+
 
 @pytest.mark.parametrize(
     ("dependency", "version", "original", "expected"),