test_git_ignore.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_git/test_git_ignore.py
 
"""
Purpose
-------
Integration tests for ``oct git ignore`` (Phase 4G).
 
Responsibilities
----------------
- Verify pattern addition into the OCT-managed block.
- Verify pattern removal from the OCT-managed block.
- Verify ``--list`` partitions OCT-managed and user patterns.
- Verify pattern validation rejects unsafe inputs.
- Verify the same fenced block is shared with ``oct git init``.
- Verify JSON output schema.
- Verify audit trail.
 
Diagnostics
-----------
Domain: GIT-TESTS
Levels:
    L2 -- test lifecycle
    L3 -- assertion details
    L4 -- deep tracing
 
Contracts
---------
- All tests use subprocess invocation against ``oct.cli``.
- All tests use tmp_path fixtures so they are automatically cleaned up.
"""
 
import json
import shutil
import subprocess
import sys
from pathlib import Path
 
import pytest
 
 
def _git_available() -> bool:
    return shutil.which("git") is not None
 
 
def _run_ignore(
    root: Path, *extra_args: str,
) -> subprocess.CompletedProcess:
    """Run ``oct git ignore`` in a subprocess."""
    return subprocess.run(
        [sys.executable, "-m", "oct.cli", "git", "ignore", *extra_args],
        cwd=root,
        capture_output=True,
        text=True,
    )
 
 
# =====================================================================
# Add patterns
# =====================================================================
 
 
class TestIgnoreAddPattern:
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_appends_to_oct_block(self, temp_git_project: Path) -> None:
        result = _run_ignore(temp_git_project, "*.tmp")
        assert result.returncode == 0, result.stderr
        text = (temp_git_project / ".gitignore").read_text(encoding="utf-8")
        assert "*.tmp" in text
        assert "# --- Option C defaults ---" in text
        assert "# --- end Option C ---" in text
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_duplicate_is_noop(self, temp_git_project: Path) -> None:
        _run_ignore(temp_git_project, "*.tmp")
        result = _run_ignore(temp_git_project, "*.tmp")
        assert result.returncode == 0, result.stderr
        # Pattern should not be duplicated.
        text = (temp_git_project / ".gitignore").read_text(encoding="utf-8")
        assert text.count("*.tmp") == 1
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_multiple_patterns(self, temp_git_project: Path) -> None:
        result = _run_ignore(
            temp_git_project, "*.tmp", "*.log", "scratch/",
        )
        assert result.returncode == 0, result.stderr
        text = (temp_git_project / ".gitignore").read_text(encoding="utf-8")
        for pat in ("*.tmp", "*.log", "scratch/"):
            assert pat in text
 
 
# =====================================================================
# Remove patterns
# =====================================================================
 
 
class TestIgnoreRemovePattern:
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_remove_from_oct_block(self, temp_git_project: Path) -> None:
        _run_ignore(temp_git_project, "*.tmp")
        result = _run_ignore(temp_git_project, "--remove", "*.tmp")
        assert result.returncode == 0, result.stderr
        text = (temp_git_project / ".gitignore").read_text(encoding="utf-8")
        assert "*.tmp" not in text
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_remove_outside_block_refused(
        self, temp_git_project: Path,
    ) -> None:
        # First create the OCT block by adding any pattern.
        _run_ignore(temp_git_project, "*.tmp")
        # Now append a user-managed pattern *outside* the block.
        gitignore = temp_git_project / ".gitignore"
        existing = gitignore.read_text(encoding="utf-8")
        if not existing.endswith("\n"):
            existing += "\n"
        gitignore.write_text(
            existing + "user_managed.txt\n", encoding="utf-8",
        )
        result = _run_ignore(
            temp_git_project, "--remove", "user_managed.txt",
        )
        assert result.returncode == 1
        assert "outside the oct-managed block" in result.stderr.lower()
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_remove_nonexistent_pattern(
        self, temp_git_project: Path,
    ) -> None:
        _run_ignore(temp_git_project, "*.tmp")  # ensure block exists
        result = _run_ignore(
            temp_git_project, "--remove", "does_not_exist.xyz",
        )
        assert result.returncode == 1
        assert "not found" in result.stderr.lower()
 
 
# =====================================================================
# List
# =====================================================================
 
 
class TestIgnoreList:
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_list_partitions_correctly(
        self, temp_git_project: Path,
    ) -> None:
        # Pre-populate with a user pattern.
        gitignore = temp_git_project / ".gitignore"
        existing = gitignore.read_text(encoding="utf-8") if gitignore.is_file() else ""
        gitignore.write_text(
            existing + "\nuser_managed.txt\n", encoding="utf-8",
        )
        # Add an OCT-managed pattern.
        _run_ignore(temp_git_project, "*.tmp")
 
        result = _run_ignore(temp_git_project, "--list", "--json")
        assert result.returncode == 0, result.stderr
        data = json.loads(result.stdout)
        assert "*.tmp" in data["oct_managed"]
        assert "user_managed.txt" in data["other"]
        assert "user_managed.txt" not in data["oct_managed"]
 
 
# =====================================================================
# Validation
# =====================================================================
 
 
class TestIgnoreValidation:
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_negation_rejected(self, temp_git_project: Path) -> None:
        result = _run_ignore(temp_git_project, "!important.txt")
        assert result.returncode == 1
        assert "negation" in result.stderr.lower()
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_absolute_pattern_rejected(
        self, temp_git_project: Path,
    ) -> None:
        result = _run_ignore(temp_git_project, "/absolute")
        assert result.returncode == 1
        assert "absolute" in result.stderr.lower()
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_bad_chars_rejected(self, temp_git_project: Path) -> None:
        result = _run_ignore(temp_git_project, "bad pattern with spaces")
        assert result.returncode == 1
 
 
# =====================================================================
# Shared fenced block
# =====================================================================
 
 
class TestIgnoreFencedBlockShared:
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_oct_init_and_oct_ignore_share_block(
        self, temp_git_project: Path,
    ) -> None:
        # Run oct git init to populate the OCT-managed block.
        subprocess.run(
            [sys.executable, "-m", "oct.cli", "git", "init"],
            cwd=temp_git_project, capture_output=True, text=True,
        )
        # Now add a pattern via oct git ignore.
        result = _run_ignore(temp_git_project, "*.scratch")
        assert result.returncode == 0, result.stderr
 
        text = (temp_git_project / ".gitignore").read_text(encoding="utf-8")
        # There should be exactly one OCT block, not two.
        assert text.count("# --- Option C defaults ---") == 1
        assert text.count("# --- end Option C ---") == 1
        # Both the init defaults and the new pattern should be present.
        assert "*.scratch" in text
 
 
# =====================================================================
# JSON
# =====================================================================
 
 
class TestIgnoreJson:
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_add_json_schema(self, temp_git_project: Path) -> None:
        result = _run_ignore(temp_git_project, "--json", "*.tmp")
        assert result.returncode == 0, result.stderr
        data = json.loads(result.stdout)
        assert data["operation"] == "add"
        assert data["patterns_added"] == ["*.tmp"]
        assert data["exit_code"] == 0
 
 
# =====================================================================
# Audit
# =====================================================================
 
 
class TestIgnoreAudit:
 
    @pytest.mark.skipif(not _git_available(), reason="git not on PATH")
    def test_audit_record_written(self, temp_git_project: Path) -> None:
        result = _run_ignore(temp_git_project, "*.tmp")
        assert result.returncode == 0, result.stderr
 
        audit_dir = temp_git_project / "logs"
        audit_files = list(audit_dir.glob("git-audit-*.jsonl"))
        assert audit_files, "no audit file written"
 
        found = False
        for af in audit_files:
            for line in af.read_text(encoding="utf-8").splitlines():
                try:
                    rec = json.loads(line)
                except json.JSONDecodeError:
                    continue
                if rec.get("command") == "oct git ignore":
                    found = True
                    break
            if found:
                break
        assert found, "no 'oct git ignore' audit record found"