test_status_scope.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_git/test_status_scope.py
 
"""
Purpose
-------
Integration tests for the ``--scope`` flag on ``oct git status``
(Phase 4G). Validates the project / repo / auto modes that control
whether files outside the OCT project root are surfaced.
 
Responsibilities
----------------
- ``project`` (default) — only files inside the OCT project root.
- ``repo`` — every file the git index/work-tree knows about.
- ``auto`` — collapses to project when project_root == repo_root,
  otherwise behaves like repo.
 
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
import textwrap
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,
) -> subprocess.CompletedProcess:
    return subprocess.run(
        ["git", *args], cwd=repo, check=check,
        capture_output=True, text=True,
    )
 
 
def _run_status(
    project_dir: Path, *extra_args: str,
) -> subprocess.CompletedProcess:
    return subprocess.run(
        [sys.executable, "-m", "oct.cli", "git", "status", *extra_args],
        cwd=project_dir,
        capture_output=True,
        text=True,
    )
 
 
# =====================================================================
# Fixtures
# =====================================================================
 
 
@pytest.fixture
def monorepo_with_outside(tmp_path: Path) -> tuple[Path, Path]:
    """Create a monorepo and place a file outside the OCT project."""
    if not _git_available():
        pytest.skip("git binary not available on PATH")
 
    git_root = tmp_path / "monorepo"
    git_root.mkdir()
    _git(git_root, "init", "--quiet", "-b", "main")
    _git(git_root, "config", "user.email", "test@example.com")
    _git(git_root, "config", "user.name", "Test")
    _git(git_root, "config", "commit.gpgsign", "false")
 
    # Outside OCT project.
    (git_root / "outside").mkdir()
    (git_root / "outside" / "README.md").write_text(
        "# Outside\n", encoding="utf-8",
    )
 
    # OCT subproject.
    project = git_root / "subproject"
    project.mkdir()
    (project / ".option_c").mkdir()
    (project / "src").mkdir()
    (project / "tests").mkdir()
    (project / "docs").mkdir()
    (project / "logs").mkdir()
    (project / "oc_diagnostics").mkdir()
 
    (project / ".octrc.json").write_text(
        json.dumps({
            "linter": {"profile": "compact"},
            "git": {"protected_branches": ["main", "master"]},
        }, indent=2),
        encoding="utf-8",
    )
    (project / "debug_config.json").write_text(
        json.dumps({"domains": {"GIT": {"level": 1, "color": "cyan"}}}),
        encoding="utf-8",
    )
    (project / "docs" / "ARCHITECTURE.md").write_text(
        "# Architecture\n", encoding="utf-8",
    )
    (project / "pyproject.toml").write_text(
        '[project]\nname = "test_project"\n', encoding="utf-8",
    )
 
    _git(git_root, "add", "-A")
    _git(git_root, "commit", "-m", "initial", "--quiet")
 
    # Now make modifications: one inside, one outside.
    (project / "src" / "inside.py").write_text(
        "x = 1\n", encoding="utf-8",
    )
    (git_root / "outside" / "outside_change.txt").write_text(
        "y\n", encoding="utf-8",
    )
 
    return git_root.resolve(), project.resolve()
 
 
# =====================================================================
# scope=project (default)
# =====================================================================
 
 
class TestScopeProject:
 
    def test_default_excludes_outside(
        self, monorepo_with_outside,
    ) -> None:
        _git_root, project = monorepo_with_outside
        result = _run_status(project, "--json")
        assert result.returncode == 0, result.stderr
        data = json.loads(result.stdout)
        all_paths = (
            [e["path"] for e in data["staged"]]
            + [e["path"] for e in data["modified"]]
            + [e["path"] for e in data["untracked"]]
        )
        assert all("outside" not in p for p in all_paths)
        assert data["scope"] == "project"
        # out_of_project is empty in project mode.
        assert data["out_of_project"] == []
 
    def test_explicit_project_scope(
        self, monorepo_with_outside,
    ) -> None:
        _git_root, project = monorepo_with_outside
        result = _run_status(project, "--scope=project", "--json")
        data = json.loads(result.stdout)
        assert data["scope"] == "project"
 
 
# =====================================================================
# scope=repo
# =====================================================================
 
 
class TestScopeRepo:
 
    def test_repo_includes_outside(self, monorepo_with_outside) -> None:
        _git_root, project = monorepo_with_outside
        result = _run_status(project, "--scope=repo", "--json")
        assert result.returncode == 0, result.stderr
        data = json.loads(result.stdout)
        assert data["scope"] == "repo"
        out_paths = [e["path"] for e in data["out_of_project"]]
        assert any("outside" in p for p in out_paths), (
            f"Expected an 'outside/...' path in out_of_project: {out_paths}"
        )
 
    def test_terminal_section_rendered(
        self, monorepo_with_outside,
    ) -> None:
        _git_root, project = monorepo_with_outside
        result = _run_status(project, "--scope=repo")
        assert result.returncode == 0, result.stderr
        assert "Other repo files" in result.stdout
 
 
# =====================================================================
# scope=auto
# =====================================================================
 
 
class TestScopeAuto:
 
    def test_auto_in_monorepo_collapses_to_repo(
        self, monorepo_with_outside,
    ) -> None:
        _git_root, project = monorepo_with_outside
        result = _run_status(project, "--scope=auto", "--json")
        data = json.loads(result.stdout)
        # auto resolves to repo when project_root != repo_root.
        assert data["scope"] == "repo"
 
    def test_auto_in_simple_repo_collapses_to_project(
        self, temp_git_project: Path,
    ) -> None:
        # In temp_git_project, project_root == repo_root.
        result = subprocess.run(
            [
                sys.executable, "-m", "oct.cli",
                "git", "status", "--scope=auto", "--json",
            ],
            cwd=temp_git_project, capture_output=True, text=True,
        )
        assert result.returncode == 0, result.stderr
        data = json.loads(result.stdout)
        assert data["scope"] == "project"