test_changelog.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_git/test_changelog.py
 
"""
Purpose
-------
Tests for the changelog generator (Phase 4E — G-E1, G-E2, G-E10).
 
Responsibilities
----------------
- Validate ``collect_changelog_entries`` parsing and filtering.
- Validate ``format_changelog`` output format (Keep a Changelog).
- Validate ``changelog_to_json`` structured output.
- Integration tests for ``oct git changelog`` CLI command.
 
Diagnostics
-----------
Domain: GIT-TESTS
Levels:
    L2 — test lifecycle
    L3 — test details
    L4 — deep tracing
 
Contracts
---------
- All tests use the ``temp_git_project`` fixture from conftest.
- CLI tests use subprocess invocation.
"""
 
import json
import subprocess
import sys
from pathlib import Path
 
import pytest
 
from tests_git.conftest import _git, commit_file
 
 
# =====================================================================
# Unit tests — collect_changelog_entries
# =====================================================================
 
 
class TestCollectEntries:
    """Tests for collect_changelog_entries()."""
 
    def test_feat_and_fix_commits(self, temp_git_project: Path) -> None:
        """Feat and fix commits produce correct sections."""
        from oct.git.changelog import collect_changelog_entries
 
        _git(temp_git_project, "checkout", "-b", "feature/test")
        commit_file(temp_git_project, "src/a.py", "# a\n", "feat: add feature A")
        commit_file(temp_git_project, "src/b.py", "# b\n", "fix: resolve crash on startup")
 
        entries = collect_changelog_entries(temp_git_project)
        sections = [e.section for e in entries]
        assert "Added" in sections
        assert "Fixed" in sections
 
    def test_non_conventional_skipped(self, temp_git_project: Path) -> None:
        """Non-conventional commit messages are silently skipped."""
        from oct.git.changelog import collect_changelog_entries
 
        _git(temp_git_project, "checkout", "-b", "feature/test2")
        commit_file(temp_git_project, "src/c.py", "# c\n", "just a random message")
        commit_file(temp_git_project, "src/d.py", "# d\n", "feat: real feature")
 
        entries = collect_changelog_entries(temp_git_project)
        assert len(entries) == 1
        assert entries[0].section == "Added"
 
    def test_since_ref_limits_scope(self, temp_git_project: Path) -> None:
        """--since ref limits entries to commits after ref."""
        from oct.git.changelog import collect_changelog_entries
 
        _git(temp_git_project, "checkout", "-b", "feature/test3")
        commit_file(temp_git_project, "src/e.py", "# e\n", "feat: old feature")
        # Tag here as a boundary.
        _git(temp_git_project, "tag", "v0.1.0")
        commit_file(temp_git_project, "src/f.py", "# f\n", "feat: new feature")
 
        entries = collect_changelog_entries(temp_git_project, since_ref="v0.1.0")
        assert len(entries) == 1
        assert entries[0].subject == "new feature"
 
    def test_empty_repo_returns_empty(self, tmp_path: Path) -> None:
        """Fresh repo with no conventional commits returns empty."""
        from oct.git.changelog import collect_changelog_entries
 
        repo = tmp_path / "empty"
        repo.mkdir()
        _git(repo, "init", "-b", "main")
        _git(repo, "config", "user.email", "t@t.com")
        _git(repo, "config", "user.name", "T")
        (repo / "f.txt").write_text("x", encoding="utf-8")
        _git(repo, "add", ".")
        _git(repo, "commit", "-m", "initial", "--quiet")
 
        entries = collect_changelog_entries(repo)
        assert entries == []
 
    def test_scope_preserved(self, temp_git_project: Path) -> None:
        """Scopes in commit messages are preserved in entries."""
        from oct.git.changelog import collect_changelog_entries
 
        _git(temp_git_project, "checkout", "-b", "feature/scope")
        commit_file(temp_git_project, "src/g.py", "# g\n", "feat(auth): add token validation")
 
        entries = collect_changelog_entries(temp_git_project)
        scoped = [e for e in entries if e.scope == "auth"]
        assert len(scoped) == 1
        assert scoped[0].subject == "add token validation"
 
    def test_breaking_change_detected(self, temp_git_project: Path) -> None:
        """Breaking changes are detected from ! marker."""
        from oct.git.changelog import collect_changelog_entries
 
        _git(temp_git_project, "checkout", "-b", "feature/breaking")
        commit_file(temp_git_project, "src/h.py", "# h\n", "feat!: remove deprecated API")
 
        entries = collect_changelog_entries(temp_git_project)
        breaking = [e for e in entries if e.breaking]
        assert len(breaking) == 1
 
 
# =====================================================================
# Unit tests — format_changelog
# =====================================================================
 
 
class TestFormatChangelog:
    """Tests for format_changelog()."""
 
    def test_sections_grouped_in_order(self) -> None:
        """Entries are grouped by section in canonical order."""
        from oct.git.changelog import ChangelogEntry, format_changelog
 
        entries = [
            ChangelogEntry(section="Fixed", scope=None, subject="fix bug", breaking=False, sha="abc"),
            ChangelogEntry(section="Added", scope=None, subject="add thing", breaking=False, sha="def"),
            ChangelogEntry(section="Security", scope=None, subject="patch vuln", breaking=False, sha="ghi"),
        ]
        text = format_changelog(entries)
        # Added should appear before Fixed, and Fixed before Security.
        added_pos = text.index("### Added")
        fixed_pos = text.index("### Fixed")
        security_pos = text.index("### Security")
        assert added_pos < fixed_pos < security_pos
 
    def test_release_version_header(self) -> None:
        """--release produces version header with date."""
        from oct.git.changelog import ChangelogEntry, format_changelog
 
        entries = [
            ChangelogEntry(section="Added", scope=None, subject="new", breaking=False, sha="abc"),
        ]
        text = format_changelog(entries, version="v1.0.0")
        assert "## [v1.0.0]" in text
 
    def test_unreleased_header(self) -> None:
        """Without version, header is [Unreleased]."""
        from oct.git.changelog import ChangelogEntry, format_changelog
 
        entries = [
            ChangelogEntry(section="Added", scope=None, subject="new", breaking=False, sha="abc"),
        ]
        text = format_changelog(entries)
        assert "## [Unreleased]" in text
 
    def test_breaking_prefix(self) -> None:
        """Breaking changes get BREAKING prefix."""
        from oct.git.changelog import ChangelogEntry, format_changelog
 
        entries = [
            ChangelogEntry(section="Added", scope=None, subject="remove old API", breaking=True, sha="abc"),
        ]
        text = format_changelog(entries)
        assert "**BREAKING:**" in text
 
    def test_empty_entries(self) -> None:
        """Empty entries produce minimal valid output."""
        from oct.git.changelog import format_changelog
 
        text = format_changelog([])
        assert "## [Unreleased]" in text
        assert "No notable changes." in text
 
 
# =====================================================================
# Unit tests — changelog_to_json
# =====================================================================
 
 
class TestChangelogJson:
    """Tests for changelog_to_json()."""
 
    def test_json_structure(self) -> None:
        """JSON output has expected schema."""
        from oct.git.changelog import ChangelogEntry, changelog_to_json
 
        entries = [
            ChangelogEntry(section="Added", scope="auth", subject="tokens", breaking=False, sha="a1b"),
            ChangelogEntry(section="Fixed", scope=None, subject="crash", breaking=False, sha="c2d"),
        ]
        data = changelog_to_json(entries, version="v2.0.0")
        assert data["version"] == "v2.0.0"
        assert data["total_entries"] == 2
        assert "Added" in data["sections"]
        assert "Fixed" in data["sections"]
 
    def test_json_unreleased(self) -> None:
        """Without version, JSON shows 'Unreleased'."""
        from oct.git.changelog import changelog_to_json
 
        data = changelog_to_json([], version=None)
        assert data["version"] == "Unreleased"
 
 
# =====================================================================
# CLI integration tests — oct git changelog
# =====================================================================
 
 
def _run_changelog(root: Path, *extra_args: str) -> subprocess.CompletedProcess:
    """Run ``oct git changelog`` as a subprocess."""
    return subprocess.run(
        [sys.executable, "-m", "oct", "git", "changelog", *extra_args],
        cwd=root,
        capture_output=True,
        text=True,
    )
 
 
class TestChangelogCommand:
    """CLI integration tests for oct git changelog."""
 
    def test_dry_run(self, temp_git_project: Path) -> None:
        """--dry-run prints changelog to stdout."""
        _git(temp_git_project, "checkout", "-b", "feature/cl")
        commit_file(temp_git_project, "src/x.py", "# x\n", "feat: add X")
 
        result = _run_changelog(temp_git_project, "--dry-run")
        assert result.returncode == 0
        assert "Unreleased" in result.stdout or "Added" in result.stdout
 
    def test_json_output(self, temp_git_project: Path) -> None:
        """--json produces valid JSON."""
        _git(temp_git_project, "checkout", "-b", "feature/json")
        commit_file(temp_git_project, "src/y.py", "# y\n", "fix: patch Y")
 
        result = _run_changelog(temp_git_project, "--json")
        assert result.returncode == 0
        data = json.loads(result.stdout)
        assert "version" in data
        assert "sections" in data
 
    def test_release_writes_file(self, temp_git_project: Path) -> None:
        """--release writes CHANGELOG.md."""
        _git(temp_git_project, "checkout", "-b", "feature/release")
        commit_file(temp_git_project, "src/z.py", "# z\n", "feat: add Z")
 
        result = _run_changelog(temp_git_project, "--release", "v1.0.0")
        assert result.returncode == 0
 
        changelog = temp_git_project / "CHANGELOG.md"
        assert changelog.is_file()
        content = changelog.read_text(encoding="utf-8")
        assert "v1.0.0" in content
 
    def test_since_flag(self, temp_git_project: Path) -> None:
        """--since limits scope."""
        _git(temp_git_project, "checkout", "-b", "feature/since")
        commit_file(temp_git_project, "src/s1.py", "# s1\n", "feat: first")
        _git(temp_git_project, "tag", "v0.0.1")
        commit_file(temp_git_project, "src/s2.py", "# s2\n", "feat: second")
 
        result = _run_changelog(temp_git_project, "--json", "--since", "v0.0.1")
        assert result.returncode == 0
        data = json.loads(result.stdout)
        assert data["total_entries"] == 1
 
    def test_audit_trail(self, temp_git_project: Path) -> None:
        """Changelog command writes audit record."""
        _git(temp_git_project, "checkout", "-b", "feature/audit")
        commit_file(temp_git_project, "src/a.py", "# a\n", "feat: audited")
 
        result = _run_changelog(temp_git_project, "--dry-run")
        assert result.returncode == 0
        # Audit file should exist in .oct-audit/.
        audit_dir = temp_git_project / ".oct-audit"
        if audit_dir.is_dir():
            audit_files = list(audit_dir.glob("*.jsonl"))
            assert len(audit_files) >= 1