test_workspace_status.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_git/test_workspace_status.py
 
"""
Purpose
-------
Integration test for L1 / F1 leanest first cut: ``oct git status``
invoked from a workspace root (a directory containing
``.option_c_workspace.json``) succeeds without the
``--root-dir . --allow-outside-project`` escape hatch that pre-F1
users needed.
 
Responsibilities
----------------
- Verify that placing a workspace manifest at a parent directory
  makes ``oct git status`` work from that parent.
- Verify backwards compat: ``oct git status`` from inside a
  subproject still resolves to the subproject root (not the
  workspace root).
 
Diagnostics
-----------
Domain: GIT-TESTS
Levels:
    L2 -- test lifecycle
    L3 -- assertion details
"""
 
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_status(
    cwd: Path, *extra_args: str,
) -> subprocess.CompletedProcess:
    return subprocess.run(
        [sys.executable, "-m", "oct.cli", "git", "status", *extra_args],
        cwd=cwd, capture_output=True, text=True,
    )
 
 
@pytest.fixture
def workspace_with_subproject(tmp_path: Path) -> tuple[Path, Path]:
    """Create a workspace with one Option C subproject inside.
 
    Layout::
 
        <ws_root>/
        ├── .option_c_workspace.json
        ├── .git/
        └── subproj/
            ├── .option_c/
            ├── .octrc.json
            ├── pyproject.toml
            ├── docs/ARCHITECTURE.md
            ├── oc_diagnostics/
            ├── tests/
            ├── logs/
            ├── debug_config.json
            └── src/
    """
    if not _git_available():
        pytest.skip("git binary not available on PATH")
 
    ws_root = tmp_path / "myws"
    ws_root.mkdir()
    _git(ws_root, "init", "--quiet", "-b", "main")
    _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": "Test Workspace",
        "subprojects": [{"path": "subproj", "name": "subproj"}],
    }
    (ws_root / ".option_c_workspace.json").write_text(
        json.dumps(manifest, indent=2), encoding="utf-8",
    )
 
    sub = ws_root / "subproj"
    sub.mkdir()
    (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(
        '[project]\nname = "subproj"\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",
    )
 
    _git(ws_root, "add", "-A")
    _git(ws_root, "commit", "-m", "initial", "--quiet")
 
    return ws_root.resolve(), sub.resolve()
 
 
# =====================================================================
# L1 win: status from workspace root
# =====================================================================
 
 
class TestWorkspaceStatusFromRoot:
 
    def test_status_from_workspace_root_works(
        self, workspace_with_subproject,
    ) -> None:
        ws_root, _sub = workspace_with_subproject
        result = _run_status(ws_root)
        assert result.returncode == 0, result.stderr
        # Should show the branch line (no "Could not locate project root").
        assert "On branch main" in result.stdout
        assert "Could not locate project root" not in result.stderr
 
 
# =====================================================================
# Backwards compat: status from inside subproject still works
# =====================================================================
 
 
# =====================================================================
# F1.2 fan-out: workspace_view JSON + per-subproject grouping
# =====================================================================
 
 
@pytest.fixture
def workspace_with_two_subprojects(tmp_path: Path):
    """Two-subproject workspace fixture for F1.2 fan-out tests."""
    if not _git_available():
        pytest.skip("git binary not available on PATH")
 
    ws_root = tmp_path / "ws2"
    ws_root.mkdir()
    _git(ws_root, "init", "--quiet", "-b", "main")
    _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": "Two-Sub Workspace",
        "workspace_files": ["CLAUDE.md", "README.md"],
        "subprojects": [
            {"path": "alpha", "name": "alpha", "profile": "compact"},
            {"path": "beta", "name": "beta", "profile": "compact"},
        ],
    }
    (ws_root / ".option_c_workspace.json").write_text(
        json.dumps(manifest, indent=2), encoding="utf-8",
    )
 
    for sp_name in ("alpha", "beta"):
        sub = ws_root / sp_name
        sub.mkdir()
        (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 = "{sp_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",
        )
 
    # Workspace-level files.
    (ws_root / "CLAUDE.md").write_text("# CLAUDE\n", encoding="utf-8")
    (ws_root / "README.md").write_text("# README\n", encoding="utf-8")
 
    _git(ws_root, "add", "-A")
    _git(ws_root, "commit", "-m", "initial", "--quiet")
 
    return (
        ws_root.resolve(),
        (ws_root / "alpha").resolve(),
        (ws_root / "beta").resolve(),
    )
 
 
class TestWorkspaceFanOut:
 
    def test_workspace_view_present_in_json(
        self, workspace_with_two_subprojects,
    ) -> None:
        ws_root, _alpha, _beta = workspace_with_two_subprojects
        result = _run_status(ws_root, "--json")
        assert result.returncode == 0, result.stderr
        data = json.loads(result.stdout)
        assert "workspace_view" in data
        assert data["workspace_view"] is not None
        assert set(data["workspace_view"].keys()) == {
            "alpha", "beta", "workspace",
        }
 
    def test_status_groups_by_subproject(
        self, workspace_with_two_subprojects,
    ) -> None:
        ws_root, alpha, beta = workspace_with_two_subprojects
        # Stage one file in each subproject.
        (alpha / "src" / "a.py").write_text("x = 1\n", encoding="utf-8")
        (beta / "src" / "b.py").write_text("x = 2\n", encoding="utf-8")
        _git(ws_root, "add", "alpha/src/a.py", "beta/src/b.py")
 
        result = _run_status(ws_root, "--json")
        assert result.returncode == 0, result.stderr
        data = json.loads(result.stdout)
        wv = data["workspace_view"]
        # Each subproject sees its own staged file.
        alpha_paths = [e["path"] for e in wv["alpha"]["staged"]]
        beta_paths = [e["path"] for e in wv["beta"]["staged"]]
        assert "src/a.py" in alpha_paths
        assert "src/b.py" in beta_paths
        # No cross-leak.
        assert "src/b.py" not in alpha_paths
        assert "src/a.py" not in beta_paths
 
    def test_workspace_files_route_to_workspace_bucket(
        self, workspace_with_two_subprojects,
    ) -> None:
        ws_root, _alpha, _beta = workspace_with_two_subprojects
        # Modify a workspace-level file (CLAUDE.md is in workspace_files).
        (ws_root / "CLAUDE.md").write_text(
            "# CLAUDE — modified\n", encoding="utf-8",
        )
        result = _run_status(ws_root, "--json")
        data = json.loads(result.stdout)
        wv = data["workspace_view"]
        # CLAUDE.md should appear in the workspace bucket.
        ws_modified = [e["path"] for e in wv["workspace"]["modified"]]
        assert "CLAUDE.md" in ws_modified
        # And NOT in any subproject bucket.
        for sp_name in ("alpha", "beta"):
            sp_modified = [e["path"] for e in wv[sp_name]["modified"]]
            assert "CLAUDE.md" not in sp_modified
 
    def test_legacy_keys_preserved(
        self, workspace_with_two_subprojects,
    ) -> None:
        ws_root, alpha, _beta = workspace_with_two_subprojects
        (alpha / "src" / "x.py").write_text("x = 1\n", encoding="utf-8")
        _git(ws_root, "add", "alpha/src/x.py")
        result = _run_status(ws_root, "--json")
        data = json.loads(result.stdout)
        # Top-level legacy keys still present and populated.
        assert "staged" in data
        assert "modified" in data
        assert "untracked" in data
        # The flat staged list still includes the file (workspace-relative).
        flat_paths = [e["path"] for e in data["staged"]]
        assert any("x.py" in p for p in flat_paths)
 
 
class TestWorkspaceStatusFromSubproject:
 
    def test_status_from_subproject_resolves_to_subproject(
        self, workspace_with_subproject,
    ) -> None:
        _ws_root, sub = workspace_with_subproject
        # Add an unstaged change inside the subproject so we have
        # something to look at.
        (sub / "src" / "new.py").write_text(
            "x = 1\n", encoding="utf-8",
        )
        result = _run_status(sub, "--json")
        assert result.returncode == 0, result.stderr
        data = json.loads(result.stdout)
        # Untracked path should be subproject-relative ("src/new.py"),
        # NOT workspace-relative ("subproj/src/new.py").
        untracked_paths = [e["path"] for e in data["untracked"]]
        assert any("src/new.py" in p for p in untracked_paths), (
            f"expected subproject-relative path, got: {untracked_paths}"
        )
        assert all("subproj/" not in p for p in untracked_paths), (
            f"backwards-compat broken: workspace prefix appeared in "
            f"subproject-mode output: {untracked_paths}"
        )