lgit-cli 3.7.0__py3-none-any.whl

lgit/testing/fixture.py

@@ -0,0 +1,386 @@
+"""Fixture manifests, on-disk fixture loading, and golden-file I/O."""
+
+from __future__ import annotations
+
+import json
+import tomllib
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, Self
+
+from lgit.models import AnalysisDetail, ChangelogCategory, ConventionalAnalysis
+
+FIXTURES_DIR = "tests/fixtures"
+
+
+@dataclass(slots=True)
+class FixtureEntry:
+    """Manifest entry for one fixture."""
+
+    description: str
+    tags: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_mapping(cls, data: Mapping[str, Any]) -> Self:
+        return cls(description=str(data.get("description", "")), tags=_string_list(data.get("tags", [])))
+
+
+@dataclass(slots=True)
+class Manifest:
+    """Fixture manifest loaded from ``manifest.toml``."""
+
+    fixtures: dict[str, FixtureEntry] = field(default_factory=dict)
+
+    @classmethod
+    def load(cls, fixtures_dir: str | Path) -> Self:
+        path = Path(fixtures_dir) / "manifest.toml"
+        if not path.exists():
+            return cls()
+        with path.open("rb") as handle:
+            data = tomllib.load(handle)
+        raw = data.get("fixtures", {})
+        if not isinstance(raw, Mapping):
+            raise ValueError(f"invalid fixture manifest: {path}")
+        return cls(
+            {
+                str(name): FixtureEntry.from_mapping(entry if isinstance(entry, Mapping) else {})
+                for name, entry in raw.items()
+            }
+        )
+
+    def save(self, fixtures_dir: str | Path) -> None:
+        path = Path(fixtures_dir) / "manifest.toml"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        lines: list[str] = []
+        for name in sorted(self.fixtures):
+            entry = self.fixtures[name]
+            lines.append(f"[fixtures.{name}]")
+            lines.append(f"description = {_toml_value(entry.description)}")
+            lines.append(f"tags = {_toml_value(entry.tags)}")
+            lines.append("")
+        path.write_text("\n".join(lines), encoding="utf-8")
+
+    def add(self, name: str, entry: FixtureEntry) -> None:
+        self.fixtures[name] = entry
+
+
+@dataclass(slots=True)
+class FixtureMeta:
+    """Metadata captured with a fixture."""
+
+    source_repo: str
+    source_commit: str
+    description: str
+    captured_at: str
+    tags: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_mapping(cls, data: Mapping[str, Any]) -> Self:
+        return cls(
+            source_repo=str(data.get("source_repo", "")),
+            source_commit=str(data.get("source_commit", "")),
+            description=str(data.get("description", "")),
+            captured_at=str(data.get("captured_at", "")),
+            tags=_string_list(data.get("tags", [])),
+        )
+
+
+@dataclass(slots=True)
+class FixtureContext:
+    """Analysis context captured for deterministic fixture runs."""
+
+    recent_commits: str | None = None
+    common_scopes: str | None = None
+    project_context: str | None = None
+    user_context: str | None = None
+
+    @classmethod
+    def from_mapping(cls, data: Mapping[str, Any]) -> Self:
+        return cls(
+            recent_commits=_optional_str(data.get("recent_commits")),
+            common_scopes=_optional_str(data.get("common_scopes")),
+            project_context=_optional_str(data.get("project_context")),
+            user_context=_optional_str(data.get("user_context")),
+        )
+
+    def to_mapping(self) -> dict[str, str]:
+        return {
+            key: value
+            for key, value in {
+                "recent_commits": self.recent_commits,
+                "common_scopes": self.common_scopes,
+                "project_context": self.project_context,
+                "user_context": self.user_context,
+            }.items()
+            if value is not None
+        }
+
+
+@dataclass(slots=True)
+class FixtureInput:
+    """Frozen inputs used by the analysis harness."""
+
+    diff: str
+    stat: str
+    scope_candidates: str = ""
+    context: FixtureContext = field(default_factory=FixtureContext)
+
+
+@dataclass(slots=True)
+class Golden:
+    """Expected fixture output."""
+
+    analysis: ConventionalAnalysis
+    final_message: str = ""
+
+
+@dataclass(slots=True)
+class Fixture:
+    """A complete fixture loaded from or saved to disk."""
+
+    name: str
+    meta: FixtureMeta
+    input: FixtureInput
+    golden: Golden | None = None
+
+    @classmethod
+    def load(cls, fixtures_dir: str | Path, name: str) -> Self:
+        fixture_dir = Path(fixtures_dir) / name
+        if not fixture_dir.exists():
+            raise FileNotFoundError(f"fixture {name!r} not found at {fixture_dir}")
+
+        meta_path = fixture_dir / "meta.toml"
+        if not meta_path.exists():
+            raise FileNotFoundError(f"fixture {name!r} missing meta.toml")
+        meta = FixtureMeta.from_mapping(_read_toml(meta_path))
+
+        input_dir = fixture_dir / "input"
+        diff = _read_text(input_dir / "diff.patch")
+        stat = _read_text(input_dir / "stat.txt")
+        scope_candidates = _read_text(input_dir / "scope_candidates.txt", missing_ok=True)
+        context_path = input_dir / "context.toml"
+        context = FixtureContext.from_mapping(_read_toml(context_path)) if context_path.exists() else FixtureContext()
+
+        golden = None
+        golden_dir = fixture_dir / "golden"
+        analysis_path = golden_dir / "analysis.json"
+        if analysis_path.exists():
+            analysis = analysis_from_json(analysis_path.read_text(encoding="utf-8"))
+            final_message = _read_text(golden_dir / "final.txt", missing_ok=True)
+            golden = Golden(analysis=analysis, final_message=final_message)
+
+        return cls(name=name, meta=meta, input=FixtureInput(diff, stat, scope_candidates, context), golden=golden)
+
+    def save(self, fixtures_dir: str | Path) -> None:
+        fixture_dir = Path(fixtures_dir) / self.name
+        input_dir = fixture_dir / "input"
+        golden_dir = fixture_dir / "golden"
+        input_dir.mkdir(parents=True, exist_ok=True)
+
+        _write_toml(
+            fixture_dir / "meta.toml",
+            {
+                "source_repo": self.meta.source_repo,
+                "source_commit": self.meta.source_commit,
+                "description": self.meta.description,
+                "captured_at": self.meta.captured_at,
+                "tags": self.meta.tags,
+            },
+        )
+        (input_dir / "diff.patch").write_text(self.input.diff, encoding="utf-8")
+        (input_dir / "stat.txt").write_text(self.input.stat, encoding="utf-8")
+        (input_dir / "scope_candidates.txt").write_text(self.input.scope_candidates, encoding="utf-8")
+        _write_toml(input_dir / "context.toml", self.input.context.to_mapping())
+
+        if self.golden is not None:
+            golden_dir.mkdir(parents=True, exist_ok=True)
+            (golden_dir / "analysis.json").write_text(analysis_to_json(self.golden.analysis), encoding="utf-8")
+            (golden_dir / "final.txt").write_text(self.golden.final_message, encoding="utf-8")
+
+    def update_golden(self, analysis: ConventionalAnalysis, final_message: str) -> None:
+        self.golden = Golden(analysis=analysis, final_message=final_message)
+
+
+async def add_fixture(
+    fixtures_dir: str | Path, commit_hash: str, name: str, repo_dir: str | Path = ".", config: Any | None = None
+) -> Fixture:
+    """Create a fixture from a commit and add it to the manifest."""
+
+    from lgit.analysis import extract_scope_candidates
+    from lgit.git import extract_style_patterns, get_common_scopes, get_git_diff, get_git_stat, get_recent_commits
+    from lgit.repo import RepoMetadata
+
+    diff = get_git_diff("commit", commit_hash, repo_dir, config)
+    stat = get_git_stat("commit", commit_hash, repo_dir, config)
+    scope_candidates, _ = extract_scope_candidates("commit", commit_hash, str(repo_dir), config)
+
+    recent_commits = None
+    common_scopes = None
+    try:
+        commits = get_recent_commits(repo_dir, 20)
+        patterns = extract_style_patterns(commits)
+        recent_commits = None if patterns is None else patterns.format_for_prompt()
+    except Exception:
+        recent_commits = None
+    try:
+        scopes = get_common_scopes(repo_dir, 100)
+        common_scopes = ", ".join(f"{scope} ({count})" for scope, count in scopes[:10]) or None
+    except Exception:
+        common_scopes = None
+    project_context = RepoMetadata.detect(repo_dir).format_for_prompt()
+
+    fixture = Fixture(
+        name=name,
+        meta=FixtureMeta(
+            source_repo=str(repo_dir),
+            source_commit=commit_hash,
+            description=f"Fixture from commit {commit_hash}",
+            captured_at=datetime.now(UTC).isoformat(),
+            tags=[],
+        ),
+        input=FixtureInput(
+            diff=diff,
+            stat=stat,
+            scope_candidates=scope_candidates,
+            context=FixtureContext(
+                recent_commits=recent_commits, common_scopes=common_scopes, project_context=project_context
+            ),
+        ),
+    )
+    root = Path(fixtures_dir)
+    root.mkdir(parents=True, exist_ok=True)
+    fixture.save(root)
+    manifest = Manifest.load(root)
+    manifest.add(name, FixtureEntry(description=f"From commit {commit_hash}", tags=[]))
+    manifest.save(root)
+    return fixture
+
+
+def discover_fixtures(fixtures_dir: str | Path) -> list[str]:
+    """Return sorted fixture directory names under ``fixtures_dir``."""
+
+    root = Path(fixtures_dir)
+    if not root.exists():
+        return []
+    return sorted(path.name for path in root.iterdir() if path.is_dir() and (path / "meta.toml").exists())
+
+
+def load_fixtures(fixtures_dir: str | Path, names: list[str] | None = None) -> list[Fixture]:
+    selected = discover_fixtures(fixtures_dir) if names is None else names
+    return [Fixture.load(fixtures_dir, name) for name in selected]
+
+
+def analysis_from_json(content: str) -> ConventionalAnalysis:
+    data = json.loads(content)
+    if not isinstance(data, Mapping):
+        raise ValueError("analysis JSON must be an object")
+    details = tuple(_detail_from_json(item) for item in (data.get("details") or ()))
+    issue_refs = tuple(str(item) for item in (data.get("issue_refs") or ()))
+    return ConventionalAnalysis(
+        commit_type=str(data.get("type", data.get("commit_type", "chore"))),
+        scope=_optional_str(data.get("scope")),
+        summary=_optional_str(data.get("summary")),
+        details=details,
+        issue_refs=issue_refs,
+    )
+
+
+def analysis_to_json(analysis: ConventionalAnalysis) -> str:
+    return json.dumps(analysis_to_mapping(analysis), indent=2, ensure_ascii=False) + "\n"
+
+
+def analysis_to_mapping(analysis: ConventionalAnalysis) -> dict[str, Any]:
+    data: dict[str, Any] = {"type": str(analysis.commit_type)}
+    if analysis.scope is not None:
+        data["scope"] = str(analysis.scope)
+    if analysis.summary:
+        data["summary"] = analysis.summary
+    data["details"] = [_detail_to_json(detail) for detail in analysis.details]
+    data["issue_refs"] = list(analysis.issue_refs)
+    return data
+
+
+def _detail_from_json(item: Any) -> AnalysisDetail:
+    if isinstance(item, Mapping):
+        raw_category = item.get("changelog_category")
+        category = ChangelogCategory.from_name(str(raw_category)) if raw_category not in (None, "") else None
+        return AnalysisDetail(
+            text=str(item.get("text", "")),
+            changelog_category=category,
+            user_visible=bool(item.get("user_visible", False)),
+        )
+    return AnalysisDetail.simple(str(item))
+
+
+def _detail_to_json(detail: AnalysisDetail) -> dict[str, Any]:
+    data: dict[str, Any] = {"text": detail.text}
+    if detail.changelog_category is not None:
+        data["changelog_category"] = detail.changelog_category.value
+    data["user_visible"] = bool(detail.user_visible)
+    return data
+
+
+def _read_toml(path: Path) -> dict[str, Any]:
+    with path.open("rb") as handle:
+        data = tomllib.load(handle)
+    return dict(data)
+
+
+def _read_text(path: Path, *, missing_ok: bool = False) -> str:
+    if missing_ok and not path.exists():
+        return ""
+    return path.read_text(encoding="utf-8")
+
+
+def _write_toml(path: Path, data: Mapping[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lines = [f"{key} = {_toml_value(value)}" for key, value in data.items() if value is not None]
+    path.write_text("\n".join(lines) + ("\n" if lines else ""), encoding="utf-8")
+
+
+def _toml_value(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, int | float):
+        return str(value)
+    if isinstance(value, list | tuple):
+        return "[" + ", ".join(_toml_value(item) for item in value) + "]"
+    text = str(value)
+    if "\n" in text:
+        return '"""' + text.replace('"""', '\\"\\"\\"') + '"""'
+    return json.dumps(text, ensure_ascii=False)
+
+
+def _optional_str(value: Any) -> str | None:
+    if value is None:
+        return None
+    text = str(value)
+    return text if text else None
+
+
+def _string_list(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, str):
+        return [value]
+    return [str(item) for item in value]
+
+
+__all__ = [
+    "FIXTURES_DIR",
+    "Fixture",
+    "FixtureContext",
+    "FixtureEntry",
+    "FixtureInput",
+    "FixtureMeta",
+    "Golden",
+    "Manifest",
+    "add_fixture",
+    "analysis_from_json",
+    "analysis_to_json",
+    "analysis_to_mapping",
+    "discover_fixtures",
+    "load_fixtures",
+]

lgit/testing/report.py

@@ -0,0 +1,201 @@
+"""Dark HTML report generation for fixture test results."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from datetime import UTC, datetime
+from html import escape
+from pathlib import Path
+
+from .fixture import Fixture
+from .runner import RunResult, TestSummary
+
+
+def generate_html_report(results: Sequence[RunResult], fixtures: Sequence[Fixture], output_path: str | Path) -> Path:
+    """Write a dark HTML fixture report and return the output path."""
+
+    path = Path(output_path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(render_report(results, fixtures, TestSummary.from_results(list(results))), encoding="utf-8")
+    return path
+
+
+def render_report(results: Sequence[RunResult], fixtures: Sequence[Fixture], summary: TestSummary | None = None) -> str:
+    summary = TestSummary.from_results(list(results)) if summary is None else summary
+    fixture_by_name = {fixture.name: fixture for fixture in fixtures}
+    rows = "\n".join(_render_fixture_result(result, fixture_by_name.get(result.name)) for result in results)
+    generated = datetime.now(UTC).strftime("%Y-%m-%d %H:%M:%S UTC")
+    return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>lgit Fixture Test Report</title>
+  <style>
+    :root {{
+      --bg: #0d1117;
+      --fg: #c9d1d9;
+      --muted: #8b949e;
+      --border: #30363d;
+      --card: #161b22;
+      --green: #3fb950;
+      --red: #f85149;
+      --yellow: #d29922;
+      --blue: #58a6ff;
+      --purple: #a371f7;
+    }}
+    * {{ box-sizing: border-box; }}
+    body {{ margin: 0; padding: 2rem; background: var(--bg); color: var(--fg); font: 15px/1.55 -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }}
+    .container {{ max-width: 1400px; margin: 0 auto; }}
+    h1 {{ margin: 0 0 .5rem; font-size: 1.8rem; }}
+    .timestamp {{ color: var(--muted); margin: 0 0 1.5rem; }}
+    .summary {{ display: flex; flex-wrap: wrap; gap: 1rem; margin-bottom: 2rem; }}
+    .stat {{ min-width: 120px; padding: 1rem 1.25rem; background: var(--card); border: 1px solid var(--border); border-radius: 8px; }}
+    .stat-value {{ font-size: 2rem; font-weight: 700; }}
+    .stat-label {{ color: var(--muted); font-size: .85rem; }}
+    .passed .stat-value, .match {{ color: var(--green); }}
+    .failed .stat-value, .mismatch, .error-color {{ color: var(--red); }}
+    .no-golden .stat-value, .warn {{ color: var(--yellow); }}
+    .fixture {{ margin-bottom: 1rem; background: var(--card); border: 1px solid var(--border); border-radius: 8px; overflow: hidden; }}
+    .fixture-header {{ display: flex; justify-content: space-between; align-items: center; gap: 1rem; padding: 1rem 1.25rem; cursor: pointer; border-bottom: 1px solid var(--border); }}
+    .fixture-header:hover {{ background: rgba(255, 255, 255, .035); }}
+    .fixture-name {{ font-weight: 650; word-break: break-word; }}
+    .badge {{ white-space: nowrap; padding: .25rem .7rem; border-radius: 999px; font-size: .8rem; font-weight: 600; }}
+    .badge.passed {{ color: var(--green); background: rgba(63, 185, 80, .13); }}
+    .badge.failed, .badge.error {{ color: var(--red); background: rgba(248, 81, 73, .13); }}
+    .badge.no-golden {{ color: var(--yellow); background: rgba(210, 153, 34, .13); }}
+    .fixture-content {{ display: none; padding: 1.25rem; }}
+    .fixture.expanded .fixture-content {{ display: block; }}
+    .diff-row {{ display: flex; gap: 1rem; margin-bottom: .45rem; }}
+    .diff-label {{ width: 6rem; min-width: 6rem; color: var(--muted); font-weight: 600; }}
+    .comparison {{ display: grid; grid-template-columns: 1fr 1fr; gap: 1rem; margin-top: 1.25rem; }}
+    @media (max-width: 900px) {{ .comparison {{ grid-template-columns: 1fr; }} }}
+    h3 {{ margin: 0 0 .5rem; text-transform: uppercase; letter-spacing: .05em; font-size: .78rem; }}
+    h3.golden {{ color: var(--purple); }}
+    h3.actual {{ color: var(--blue); }}
+    .message-box, .error-message {{ white-space: pre-wrap; word-break: break-word; padding: 1rem; border-radius: 8px; font: 13px/1.5 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }}
+    .message-box {{ background: var(--bg); border: 1px solid var(--border); }}
+    .error-message {{ color: var(--red); background: rgba(248, 81, 73, .08); border: 1px solid rgba(248, 81, 73, .5); }}
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>lgit Fixture Test Report</h1>
+    <p class="timestamp">Generated: {escape(generated)}</p>
+    <div class="summary">
+      {_stat("Total", summary.total)}
+      {_stat("Passed", summary.passed, "passed")}
+      {_stat("Failed", summary.failed, "failed")}
+      {_stat("No Golden", summary.no_golden, "no-golden")}
+      {_stat("Errors", summary.errors, "failed")}
+    </div>
+    {rows}
+  </div>
+  <script>
+    document.querySelectorAll('.fixture-header').forEach((header) => {{
+      header.addEventListener('click', () => header.parentElement.classList.toggle('expanded'));
+    }});
+    document.querySelectorAll('.fixture.failed, .fixture.error').forEach((fixture) => fixture.classList.add('expanded'));
+  </script>
+</body>
+</html>
+"""
+
+
+def _stat(label: str, value: int, css: str = "") -> str:
+    return f'<div class="stat {css}"><div class="stat-value">{value}</div><div class="stat-label">{escape(label)}</div></div>'
+
+
+def _render_fixture_result(result: RunResult, fixture: Fixture | None) -> str:
+    status_class, status_text = _status(result)
+    body = _render_error(result.error) if result.error else _render_success_body(result, fixture)
+    return f"""
+    <section class="fixture {status_class}">
+      <div class="fixture-header">
+        <span class="fixture-name">{escape(result.name)}</span>
+        <span class="badge {status_class}">{status_text}</span>
+      </div>
+      <div class="fixture-content">{body}</div>
+    </section>"""
+
+
+def _render_success_body(result: RunResult, fixture: Fixture | None) -> str:
+    if result.comparison is None:
+        return _render_actual_only(result)
+    cmp = result.comparison
+    golden = fixture.golden if fixture is not None else None
+    type_row = ""
+    golden_message = ""
+    if golden is not None:
+        type_row = _diff_row(
+            "Type",
+            f"{escape(str(golden.analysis.commit_type))} &rarr; {escape(str(result.analysis.commit_type))}",
+            "match" if cmp.type_match else "mismatch",
+        )
+        golden_message = f"""
+        <div>
+          <h3 class="golden">Golden (Expected)</h3>
+          <div class="message-box">{escape(golden.final_message or _analysis_summary(golden.analysis))}</div>
+        </div>"""
+    scope_value = escape(cmp.scope_diff or _scope_text(result.analysis, none="(none)"))
+    details_value = f"{cmp.golden_detail_count} golden &rarr; {cmp.actual_detail_count} actual"
+    return f"""
+      <div>
+        {type_row}
+        {_diff_row("Scope", scope_value, "match" if cmp.scope_match else "mismatch")}
+        {_diff_row("Details", details_value)}
+      </div>
+      <div class="comparison">
+        {golden_message}
+        <div>
+          <h3 class="actual">Actual (Current)</h3>
+          <div class="message-box">{escape(result.final_message)}</div>
+        </div>
+      </div>"""
+
+
+def _render_actual_only(result: RunResult) -> str:
+    return f"""
+      <div>
+        {_diff_row("Type", escape(str(result.analysis.commit_type)))}
+        {_diff_row("Scope", escape(_scope_text(result.analysis, none="(none)")))}
+        {_diff_row("Details", f"{len(result.analysis.details)} points")}
+        <h3 class="actual" style="margin-top: 1rem;">Generated Message</h3>
+        <div class="message-box">{escape(result.final_message)}</div>
+      </div>"""
+
+
+def _render_error(error: str | None) -> str:
+    return f'<div class="error-message">{escape(error or "")}</div>'
+
+
+def _diff_row(label: str, value: str, css: str = "") -> str:
+    return f'<div class="diff-row"><span class="diff-label">{escape(label)}:</span><span class="{css}">{value}</span></div>'
+
+
+def _status(result: RunResult) -> tuple[str, str]:
+    if result.error is not None:
+        return "error", "Error"
+    if result.comparison is None:
+        return "no-golden", "No Golden"
+    return ("passed", "Passed") if result.comparison.passed else ("failed", "Failed")
+
+
+def _scope_text(analysis: object, *, none: str = "null") -> str:
+    scope = getattr(analysis, "scope", None)
+    return none if scope is None else str(scope)
+
+
+def _analysis_summary(analysis: object) -> str:
+    commit_type = str(getattr(analysis, "commit_type", ""))
+    scope = getattr(analysis, "scope", None)
+    summary = getattr(analysis, "summary", None)
+    details = getattr(analysis, "details", ())
+    header = commit_type + (f"({scope})" if scope else "")
+    if summary:
+        header += f": {summary}"
+    detail_lines = "\n".join(f"- {getattr(detail, 'text', detail)}" for detail in details)
+    return header + ("\n\n" + detail_lines if detail_lines else "")
+
+
+__all__ = ["generate_html_report", "render_report"]