test_git_init.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_git/test_git_init.py
 
"""
Purpose
-------
Integration tests for ``oct git init`` (Phase 4C — G-C1/G-C3).
 
Responsibilities
----------------
- Verify init bootstraps a git repo on a bare directory.
- Verify .gitignore merge logic (append-only, no duplicates).
- Verify .gitattributes creation and merge.
- Verify --dry-run, --no-hooks, --github flags.
- Verify idempotent re-runs.
- Verify audit trail is written.
 
Diagnostics
-----------
Domain: GIT-TESTS
Levels:
    L2 — test lifecycle
    L3 — assertion details
    L4 — deep tracing
 
Contracts
---------
- All tests use tmp_path so they are automatically cleaned up.
"""
 
import json
import shutil
import subprocess
import sys
from pathlib import Path
 
import pytest
 
 
# =====================================================================
# Helpers
# =====================================================================
 
 
def _git_available() -> bool:
    return shutil.which("git") is not None
 
 
def _git(repo: Path, *args: str, check: bool = True):
    return subprocess.run(
        ["git", *args],
        cwd=repo,
        check=check,
        capture_output=True,
        text=True,
    )
 
 
def _run_init(root: Path, *extra_args: str) -> subprocess.CompletedProcess:
    """Run ``oct git init`` in a subprocess with *root* as cwd."""
    return subprocess.run(
        [sys.executable, "-m", "oct.cli", "git", "init", *extra_args],
        cwd=root,
        capture_output=True,
        text=True,
    )
 
 
def _make_option_c_dir(tmp_path: Path, name: str = "fresh") -> Path:
    """Create a directory with minimal Option C project structure.
 
    Includes docs/, tests/, oc_diagnostics/ so find_project_root works.
    """
    root = tmp_path / name
    root.mkdir()
    (root / "docs").mkdir()
    (root / "tests").mkdir()
    (root / "oc_diagnostics").mkdir()
    (root / "logs").mkdir()
    (root / "src").mkdir()
    (root / "pyproject.toml").write_text(
        f'[project]\nname = "{name}"\n', encoding="utf-8",
    )
    return root
 
 
def _make_git_project(tmp_path: Path, name: str = "existing") -> Path:
    """Create an Option C project inside a real git repo with one commit."""
    root = _make_option_c_dir(tmp_path, name)
    _git(root, "init", "--quiet", "-b", "main")
    _git(root, "config", "user.email", "test@example.com")
    _git(root, "config", "user.name", "Test")
    _git(root, "config", "commit.gpgsign", "false")
    _git(root, "add", "-A")
    _git(root, "commit", "-m", "initial", "--quiet")
    return root
 
 
# =====================================================================
# Init on a non-git directory
# =====================================================================
 
 
class TestInitFresh:
    """Init on a directory that is not yet a git repo."""
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_creates_git_repo(self, tmp_path):
        root = _make_option_c_dir(tmp_path)
        result = _run_init(root)
        assert result.returncode == 0, result.stderr
        assert (root / ".git").is_dir()
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_creates_gitignore(self, tmp_path):
        root = _make_option_c_dir(tmp_path)
        result = _run_init(root)
        assert result.returncode == 0, result.stderr
        gi = root / ".gitignore"
        assert gi.is_file()
        content = gi.read_text(encoding="utf-8")
        assert "__pycache__/" in content
        assert ".env" in content
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_creates_gitattributes(self, tmp_path):
        root = _make_option_c_dir(tmp_path)
        result = _run_init(root)
        assert result.returncode == 0, result.stderr
        ga = root / ".gitattributes"
        assert ga.is_file()
        content = ga.read_text(encoding="utf-8")
        assert "*.py text eol=lf" in content
        assert "*.pem binary" in content
        assert "*.key binary" in content
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_gitignore_has_marker_comments(self, tmp_path):
        root = _make_option_c_dir(tmp_path)
        _run_init(root)
        content = (root / ".gitignore").read_text(encoding="utf-8")
        assert "# --- Option C defaults ---" in content
        assert "# --- end Option C ---" in content
 
 
# =====================================================================
# Idempotent re-run
# =====================================================================
 
 
class TestIdempotent:
    """Running init twice should not duplicate entries."""
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_no_duplicates_on_rerun(self, tmp_path):
        root = _make_git_project(tmp_path)
        _run_init(root)
        first_gi = (root / ".gitignore").read_text(encoding="utf-8")
 
        # Second run.
        result = _run_init(root)
        assert result.returncode == 0
        second_gi = (root / ".gitignore").read_text(encoding="utf-8")
        assert first_gi == second_gi
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_reports_up_to_date(self, tmp_path):
        root = _make_git_project(tmp_path)
        _run_init(root)
        result = _run_init(root)
        assert "already up-to-date" in result.stdout
 
 
# =====================================================================
# .gitignore merge logic
# =====================================================================
 
 
class TestGitignoreMerge:
    """Merge preserves existing entries and only appends missing ones."""
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_preserves_existing_entries(self, tmp_path):
        root = _make_git_project(tmp_path)
        existing = "# My custom ignores\nnode_modules/\n*.log\n"
        (root / ".gitignore").write_text(existing, encoding="utf-8")
 
        _run_init(root)
        content = (root / ".gitignore").read_text(encoding="utf-8")
        assert "node_modules/" in content
        assert "*.log" in content
        assert "__pycache__/" in content  # newly added
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_skips_already_present_entries(self, tmp_path):
        root = _make_git_project(tmp_path)
        # Pre-seed with some Option C entries.
        (root / ".gitignore").write_text(
            "__pycache__/\n.venv/\n", encoding="utf-8",
        )
        _run_init(root)
        content = (root / ".gitignore").read_text(encoding="utf-8")
        # Should only appear once.
        assert content.count("__pycache__/") == 1
 
 
# =====================================================================
# .gitattributes merge logic
# =====================================================================
 
 
class TestGitattributesMerge:
    """Merge creates or extends .gitattributes."""
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_creates_from_scratch(self, tmp_path):
        root = _make_git_project(tmp_path)
        _run_init(root)
        ga = root / ".gitattributes"
        assert ga.is_file()
        content = ga.read_text(encoding="utf-8")
        assert "*.py text eol=lf" in content
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_merges_existing(self, tmp_path):
        root = _make_git_project(tmp_path)
        (root / ".gitattributes").write_text(
            "*.py text eol=lf\n", encoding="utf-8",
        )
        _run_init(root)
        content = (root / ".gitattributes").read_text(encoding="utf-8")
        assert "*.pem binary" in content
        # Existing entry not duplicated.
        assert content.count("*.py text eol=lf") == 1
 
 
# =====================================================================
# --dry-run
# =====================================================================
 
 
class TestDryRun:
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_no_files_created(self, tmp_path):
        root = _make_option_c_dir(tmp_path)
        result = _run_init(root, "--dry-run")
        assert result.returncode == 0
        assert "[DRY RUN]" in result.stdout
        assert not (root / ".gitignore").is_file()
        assert not (root / ".gitattributes").is_file()
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_dry_run_on_existing_repo(self, tmp_path):
        root = _make_git_project(tmp_path)
        result = _run_init(root, "--dry-run")
        assert result.returncode == 0
        assert "[DRY RUN]" in result.stdout
 
 
# =====================================================================
# --no-hooks
# =====================================================================
 
 
class TestNoHooks:
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_skips_hooks(self, tmp_path):
        root = _make_git_project(tmp_path)
        result = _run_init(root, "--no-hooks")
        assert result.returncode == 0
        assert not (root / ".pre-commit-config.yaml").is_file()
        assert "Skipped hook installation" in result.stdout
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_hooks_installed_by_default(self, tmp_path):
        root = _make_git_project(tmp_path)
        result = _run_init(root)
        assert result.returncode == 0
        assert (root / ".pre-commit-config.yaml").is_file()
 
 
# =====================================================================
# --github
# =====================================================================
 
 
class TestGitHub:
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_creates_workflow(self, tmp_path):
        root = _make_git_project(tmp_path)
        result = _run_init(root, "--github")
        assert result.returncode == 0
        wf = root / ".github" / "workflows" / "option-c.yml"
        assert wf.is_file()
        content = wf.read_text(encoding="utf-8")
        assert "oct lint" in content
        assert "oct format" in content
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_no_workflow_without_flag(self, tmp_path):
        root = _make_git_project(tmp_path)
        _run_init(root)
        assert not (root / ".github").exists()
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_workflow_idempotent(self, tmp_path):
        root = _make_git_project(tmp_path)
        _run_init(root, "--github")
        first = (root / ".github" / "workflows" / "option-c.yml").read_text(
            encoding="utf-8",
        )
        result = _run_init(root, "--github")
        assert "already exists" in result.stdout
        second = (root / ".github" / "workflows" / "option-c.yml").read_text(
            encoding="utf-8",
        )
        assert first == second
 
 
# =====================================================================
# Audit trail
# =====================================================================
 
 
class TestAuditTrail:
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_audit_record_written(self, tmp_path):
        root = _make_git_project(tmp_path)
        result = _run_init(root)
        assert result.returncode == 0
        # Audit files are JSONL in logs/oct_git_audit*.jsonl.
        audit_files = list((root / "logs").glob("oct_git_audit*.jsonl"))
        if audit_files:
            content = audit_files[0].read_text(encoding="utf-8")
            assert "oct git init" in content