test_git_status_monorepo.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_git/test_git_status_monorepo.py
 
"""
Purpose
-------
Integration tests for ``oct git status`` in monorepo layouts where the
git repo root differs from the OCT project root.
 
Responsibilities
----------------
- Verify that ``oct git status`` resolves file paths correctly when
  the OCT project lives in a subdirectory of the git repo.
- Verify that no false "File too short" or "Missing module docstring"
  warnings appear on well-formed files.
- Verify that files outside the project scope are excluded.
- Verify that duplicate entries do not appear across staged/modified
  sections.
 
Diagnostics
-----------
Domain: GIT-TESTS
Levels:
    L2 — test lifecycle
    L3 — assertion details
    L4 — deep tracing
 
Contracts
---------
- Every test uses the ``monorepo_project`` fixture.
- Tests never modify the system git config.
"""
 
import json
import shutil
import subprocess
import sys
import textwrap
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,
) -> subprocess.CompletedProcess:
    """Run a git command inside *repo*."""
    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:
    """Run ``oct git status`` from inside the OCT project subdirectory."""
    return subprocess.run(
        [sys.executable, "-m", "oct.cli", "git", "status", *extra_args],
        cwd=project_dir,
        capture_output=True,
        text=True,
    )
 
 
_COMPLIANT_TEMPLATE = textwrap.dedent("""\
    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    # {rel_path}
 
    \"\"\"
    Purpose
    -------
    Test module for monorepo layout validation.
 
    Responsibilities
    ----------------
    - Placeholder for monorepo integration tests.
 
    Diagnostics
    -----------
    Domain: TEST
    Levels:
        L1 — errors
        L2 — lifecycle
        L3 — details
        L4 — deep trace
 
    Contracts
    ---------
    - None.
    \"\"\"
 
    from oc_diagnostics import _dbg
 
    func = "placeholder"
    _dbg("TEST", func, "loaded", 2)
""")
 
 
# =====================================================================
# Fixtures
# =====================================================================
 
 
@pytest.fixture
def monorepo_project(tmp_path: Path) -> tuple[Path, Path]:
    """Create a monorepo where the OCT project is a subdirectory.
 
    Layout::
 
        <git_root>/
        ├── .git/
        ├── other_project/
        │   └── README.md
        └── subproject/            ← OCT project root
            ├── .option_c/
            ├── .octrc.json
            ├── oc_diagnostics/
            ├── docs/
            │   └── ARCHITECTURE.md
            ├── logs/
            ├── src/
            ├── tests/
            └── pyproject.toml
 
    Returns ``(git_root, project_root)`` where ``project_root`` is
    ``git_root / "subproject"``.
 
    The project directory is named ``subproject`` (not ``oct``) so that
    running ``python -m oct.cli`` in a subprocess does not shadow the
    installed ``oct`` package.
    """
    if not _git_available():
        pytest.skip("git binary not available on PATH")
 
    git_root = tmp_path / "monorepo"
    git_root.mkdir()
 
    # Init git at the monorepo level.
    _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")
 
    # Another project outside the OCT subproject.
    (git_root / "other_project").mkdir()
    (git_root / "other_project" / "README.md").write_text(
        "# Other project\n", encoding="utf-8",
    )
 
    # OCT project subdirectory.
    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()
 
    octrc = {
        "linter": {"profile": "compact"},
        "git": {"protected_branches": ["main", "master"]},
    }
    (project / ".octrc.json").write_text(
        json.dumps(octrc, indent=2), encoding="utf-8",
    )
 
    debug_cfg = {
        "domains": {
            "GIT": {"level": 1, "color": "cyan"},
            "TEST": {"level": 1, "color": "white"},
        },
    }
    (project / "debug_config.json").write_text(
        json.dumps(debug_cfg, indent=2), encoding="utf-8",
    )
 
    (project / "docs" / "ARCHITECTURE.md").write_text(
        "# Architecture\n\nStub for testing.\n", encoding="utf-8",
    )
 
    (project / "pyproject.toml").write_text(
        '[project]\nname = "test_project"\n', encoding="utf-8",
    )
 
    # Initial commit at the monorepo root.
    _git(git_root, "add", "-A")
    _git(git_root, "commit", "-m", "initial: monorepo structure", "--quiet")
 
    return git_root.resolve(), project.resolve()
 
 
# =====================================================================
# Tests: Path resolution
# =====================================================================
 
 
class TestMonorepoPathResolution:
    """Verify that files resolve correctly when project root != git root."""
 
    def test_staged_file_no_false_warnings(self, monorepo_project):
        """A well-formed file should get [OK], not 'File too short'."""
        git_root, project = monorepo_project
        # Write a compliant file inside the OCT project.
        path = project / "src" / "good.py"
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_text(
            _COMPLIANT_TEMPLATE.format(rel_path="src/good.py"),
            encoding="utf-8",
        )
 
        # Companion test file.
        test_file = project / "tests" / "test_good.py"
        test_file.write_text(
            '"""Stub test for good."""\n\ndef test_good():\n    pass\n',
            encoding="utf-8",
        )
 
        # Stage from the git root (as git would see it).
        _git(git_root, "add", "subproject/src/good.py")
 
        result = _run_status(project, "--json")
        assert result.returncode == 0, result.stderr
 
        data = json.loads(result.stdout)
        staged_paths = [e["path"] for e in data["staged"]]
        staged_statuses = [e["status"] for e in data["staged"]]
 
        # The file should appear in staged.
        assert any("good.py" in p for p in staged_paths), (
            f"good.py not in staged: {staged_paths}"
        )
 
        # It should be compliant, not flagged.
        for entry in data["staged"]:
            if "good.py" in entry["path"]:
                assert entry["status"] == "ok", (
                    f"Expected ok but got {entry['status']}: "
                    f"{entry['issues']}"
                )
                assert "File too short" not in str(entry["issues"])
                assert "Missing module docstring" not in str(entry["issues"])
 
    def test_files_outside_project_excluded(self, monorepo_project):
        """Files in other_project/ should not appear in oct git status."""
        git_root, project = monorepo_project
 
        # Modify a file outside the OCT project.
        readme = git_root / "other_project" / "README.md"
        readme.write_text("# Changed\n", encoding="utf-8")
        _git(git_root, "add", "other_project/README.md")
 
        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"]]
        )
        for p in all_paths:
            assert "other_project" not in p, (
                f"File outside project scope appeared: {p}"
            )
 
 
# =====================================================================
# Tests: Deduplication
# =====================================================================
 
 
class TestDeduplication:
    """Verify no spurious duplicates across sections."""
 
    def test_staged_file_not_duplicated_in_modified(self, monorepo_project):
        """A file that is only staged should not also appear as modified."""
        git_root, project = monorepo_project
 
        path = project / "src" / "only_staged.py"
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_text(
            _COMPLIANT_TEMPLATE.format(rel_path="src/only_staged.py"),
            encoding="utf-8",
        )
 
        _git(git_root, "add", "subproject/src/only_staged.py")
 
        result = _run_status(project, "--json")
        assert result.returncode == 0, result.stderr
 
        data = json.loads(result.stdout)
        staged_paths = {e["path"] for e in data["staged"]}
        modified_paths = {e["path"] for e in data["modified"]}
 
        overlap = staged_paths & modified_paths
        assert not overlap, f"Duplicate entries in staged and modified: {overlap}"