test_workspace_ignore.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_git/test_workspace_ignore.py
 
"""
Purpose
-------
Integration tests for the F1.4 workspace-aware ``oct git ignore``
``--scope`` flag and the matching ``oct git init`` workspace-mode
behaviour (which augments the workspace-root ``.gitignore`` with the
manifest's ``ignore_at_workspace_scope[]`` patterns).
 
Responsibilities
----------------
- ``oct git ignore --scope=workspace`` writes to the workspace
  root's ``.gitignore``, even when invoked from inside a subproject.
- ``oct git ignore --scope=project`` writes to the
  ``project_root``'s ``.gitignore`` (subproject if invoked there;
  workspace root if invoked there).
- ``oct git ignore --scope=nearest`` (the default) targets the
  workspace root when CWD is the workspace root, otherwise the
  subproject's ``.gitignore``.
- ``oct git init`` at workspace scope merges the manifest's
  ``ignore_at_workspace_scope[]`` patterns into the workspace
  ``.gitignore``.
 
Diagnostics
-----------
Domain: GIT-TESTS
Levels:
    L2 -- test lifecycle
    L3 -- assertion details
 
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 _git(repo: Path, *args: str, check: bool = True):
    return subprocess.run(
        ["git", *args], cwd=repo, check=check,
        capture_output=True, text=True,
    )
 
 
def _run_ignore(
    cwd: Path, *extra_args: str,
) -> subprocess.CompletedProcess:
    return subprocess.run(
        [sys.executable, "-m", "oct.cli", "git", "ignore", *extra_args],
        cwd=cwd, capture_output=True, text=True,
    )
 
 
def _run_init(
    cwd: Path, *extra_args: str,
) -> subprocess.CompletedProcess:
    return subprocess.run(
        [sys.executable, "-m", "oct.cli", "git", "init", *extra_args],
        cwd=cwd, capture_output=True, text=True,
    )
 
 
def _make_subproject(parent: Path, name: str) -> Path:
    sub = parent / name
    sub.mkdir(parents=True, exist_ok=True)
    (sub / ".option_c").mkdir()
    (sub / "src").mkdir()
    (sub / "tests").mkdir()
    (sub / "docs").mkdir()
    (sub / "logs").mkdir()
    (sub / "oc_diagnostics").mkdir()
    (sub / ".octrc.json").write_text(
        json.dumps({"linter": {"profile": "compact"}}),
        encoding="utf-8",
    )
    (sub / "pyproject.toml").write_text(
        f'[project]\nname = "{name}"\n', encoding="utf-8",
    )
    (sub / "debug_config.json").write_text(
        json.dumps({"domains": {"GIT": {"level": 1, "color": "cyan"}}}),
        encoding="utf-8",
    )
    (sub / "docs" / "ARCHITECTURE.md").write_text(
        "# Architecture\n", encoding="utf-8",
    )
    return sub
 
 
@pytest.fixture
def workspace_with_subproject(tmp_path: Path):
    """Build a workspace with one subproject for scope tests."""
    if not _git_available():
        pytest.skip("git binary not available on PATH")
 
    ws_root = tmp_path / "ws"
    ws_root.mkdir()
    _git(ws_root, "init", "--quiet", "-b", "feature/test")
    _git(ws_root, "config", "user.email", "test@example.com")
    _git(ws_root, "config", "user.name", "Test")
    _git(ws_root, "config", "commit.gpgsign", "false")
 
    manifest = {
        "version": "1.0",
        "name": "Scope Test Workspace",
        "ignore_at_workspace_scope": [
            ".claude/settings.local.json",
            ".claude/worktrees/**",
        ],
        "subprojects": [
            {"path": "alpha", "name": "alpha", "profile": "compact"},
        ],
    }
    (ws_root / ".option_c_workspace.json").write_text(
        json.dumps(manifest, indent=2), encoding="utf-8",
    )
 
    alpha = _make_subproject(ws_root, "alpha")
    _git(ws_root, "add", "-A")
    _git(ws_root, "commit", "-m", "initial", "--quiet")
 
    return ws_root.resolve(), alpha.resolve()
 
 
# =====================================================================
# --scope=workspace
# =====================================================================
 
 
class TestScopeWorkspace:
 
    def test_writes_to_workspace_gitignore_from_workspace_root(
        self, workspace_with_subproject,
    ) -> None:
        ws_root, _alpha = workspace_with_subproject
        result = _run_ignore(
            ws_root, "*.tmp", "--scope=workspace",
        )
        assert result.returncode == 0, result.stderr
        ws_gitignore = (ws_root / ".gitignore").read_text(encoding="utf-8")
        assert "*.tmp" in ws_gitignore
 
    def test_writes_to_workspace_gitignore_from_subproject(
        self, workspace_with_subproject,
    ) -> None:
        ws_root, alpha = workspace_with_subproject
        result = _run_ignore(
            alpha, "*.scratch", "--scope=workspace",
        )
        assert result.returncode == 0, result.stderr
        ws_gitignore = (ws_root / ".gitignore").read_text(encoding="utf-8")
        assert "*.scratch" in ws_gitignore
        # Subproject .gitignore not touched (still doesn't exist).
        assert not (alpha / ".gitignore").is_file()
 
    def test_scope_workspace_outside_workspace_errors(
        self, tmp_path: Path,
    ) -> None:
        if not _git_available():
            pytest.skip("git not on PATH")
        # Create a single-project setup (no workspace manifest).
        proj = tmp_path / "proj"
        proj.mkdir()
        _git(proj, "init", "--quiet", "-b", "main")
        _git(proj, "config", "user.email", "t@e.com")
        _git(proj, "config", "user.name", "T")
        _git(proj, "config", "commit.gpgsign", "false")
        _make_subproject(proj.parent, proj.name)
        _git(proj, "add", "-A")
        _git(proj, "commit", "-m", "init", "--quiet")
 
        result = _run_ignore(proj, "*.tmp", "--scope=workspace")
        assert result.returncode == 1
        assert "workspace manifest" in result.stderr.lower()
 
 
# =====================================================================
# --scope=project
# =====================================================================
 
 
class TestScopeProject:
 
    def test_writes_to_subproject_gitignore(
        self, workspace_with_subproject,
    ) -> None:
        ws_root, alpha = workspace_with_subproject
        result = _run_ignore(
            alpha, "build/", "--scope=project",
        )
        assert result.returncode == 0, result.stderr
        # Subproject .gitignore created with the new pattern.
        assert (alpha / ".gitignore").is_file()
        content = (alpha / ".gitignore").read_text(encoding="utf-8")
        assert "build/" in content
        # Workspace .gitignore not touched by this scope.
        ws_content = (ws_root / ".gitignore").read_text(
            encoding="utf-8",
        ) if (ws_root / ".gitignore").is_file() else ""
        assert "build/" not in ws_content
 
 
# =====================================================================
# --scope=nearest (default)
# =====================================================================
 
 
class TestScopeNearest:
 
    def test_default_at_workspace_root_targets_workspace(
        self, workspace_with_subproject,
    ) -> None:
        ws_root, _alpha = workspace_with_subproject
        # No --scope flag -> default to "nearest". From the workspace
        # root, that is the workspace gitignore.
        result = _run_ignore(ws_root, "*.bak")
        assert result.returncode == 0, result.stderr
        ws_content = (ws_root / ".gitignore").read_text(encoding="utf-8")
        assert "*.bak" in ws_content
 
    def test_default_at_subproject_targets_subproject(
        self, workspace_with_subproject,
    ) -> None:
        ws_root, alpha = workspace_with_subproject
        result = _run_ignore(alpha, "*.cache")
        assert result.returncode == 0, result.stderr
        # Subproject .gitignore created.
        assert (alpha / ".gitignore").is_file()
        sp_content = (alpha / ".gitignore").read_text(encoding="utf-8")
        assert "*.cache" in sp_content
        # Workspace .gitignore not touched.
        ws_path = ws_root / ".gitignore"
        ws_content = (
            ws_path.read_text(encoding="utf-8")
            if ws_path.is_file() else ""
        )
        assert "*.cache" not in ws_content
 
 
# =====================================================================
# oct git init workspace-aware (ignore_at_workspace_scope merged)
# =====================================================================
 
 
class TestInitWorkspaceAware:
 
    def test_init_at_workspace_root_merges_ignore_patterns(
        self, workspace_with_subproject,
    ) -> None:
        ws_root, _alpha = workspace_with_subproject
        # Remove the .gitignore the fixture may have committed so we
        # measure init's contribution from a clean state.
        gi = ws_root / ".gitignore"
        if gi.is_file():
            gi.unlink()
 
        result = _run_init(ws_root)
        assert result.returncode == 0, result.stderr
        assert gi.is_file(), "init should have created .gitignore"
        content = gi.read_text(encoding="utf-8")
        # Standard OCT defaults are present.
        assert "__pycache__/" in content
        # Manifest's workspace-scope additions are present.
        assert ".claude/settings.local.json" in content
        assert ".claude/worktrees/**" in content
 
    def test_init_at_subproject_does_not_use_workspace_patterns(
        self, workspace_with_subproject,
    ) -> None:
        _ws_root, alpha = workspace_with_subproject
        # Remove subproject .gitignore if it exists.
        gi = alpha / ".gitignore"
        if gi.is_file():
            gi.unlink()
 
        result = _run_init(alpha)
        assert result.returncode == 0, result.stderr
        if gi.is_file():
            content = gi.read_text(encoding="utf-8")
            # Standard defaults only — workspace patterns must NOT
            # leak into subproject .gitignore via init.
            assert ".claude/settings.local.json" not in content
            assert ".claude/worktrees/**" not in content
 
 
# =====================================================================
# Backwards compat: outside any workspace, behaviour unchanged
# =====================================================================
 
 
class TestBackwardsCompat:
 
    def test_no_workspace_scope_nearest_returns_project(
        self, tmp_path: Path,
    ) -> None:
        if not _git_available():
            pytest.skip("git not on PATH")
        proj = tmp_path / "single"
        _make_subproject(tmp_path, "single")
        _git(proj, "init", "--quiet", "-b", "main")
        _git(proj, "config", "user.email", "t@e.com")
        _git(proj, "config", "user.name", "T")
        _git(proj, "config", "commit.gpgsign", "false")
        _git(proj, "add", "-A")
        _git(proj, "commit", "-m", "init", "--quiet")
 
        # Default scope (nearest) on a single-project setup writes to
        # the project .gitignore.
        result = _run_ignore(proj, "*.tmp")
        assert result.returncode == 0, result.stderr
        assert (proj / ".gitignore").is_file()
        content = (proj / ".gitignore").read_text(encoding="utf-8")
        assert "*.tmp" in content