test_oct_install.py

Go to the documentation of this file.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# tests/tests_install/test_oct_install.py
 
"""
Purpose
-------
Validate the B1.4 ``oct install --editable`` safety wrapper. The
heart of the command is the preflight matrix; the actual ``pip
install -e`` subprocess is mocked because we don't want test runs to
mutate the real venv's site-packages.
 
Responsibilities
----------------
- Cover each preflight refusal: not-an-Option-C-project, inside a
  worktree, wrong venv, existing shadow install.
- Cover each override flag (--allow-worktree, --use-active-venv,
  --reinstall, --allow-outside-project).
- Cover the success path (preflights green, pip mocked to exit 0,
  post-install diagnostics printed).
- Cover the JSON output schema for both refusal and success.
 
Diagnostics
-----------
Domain: GIT-TESTS
Levels:
    L2 -- test lifecycle
    L3 -- assertion details
 
Contracts
---------
- Tests use ``CliRunner`` from Click rather than spawning a
  subprocess. This lets us monkey-patch the subprocess call cleanly.
- Tests must not modify the developer's actual venv. Every
  ``subprocess.run`` is patched to a stub that returns
  ``returncode=0`` without performing any work.
"""
 
import json
from pathlib import Path
from unittest.mock import patch, MagicMock
 
import pytest
from click.testing import CliRunner
 
from oct.install.oct_install import oct_install_cmd
 
 
# =====================================================================
# Helpers
# =====================================================================
 
 
def _make_oc_project(root: Path, name: str = "myproj") -> Path:
    """Create the minimum-marker Option C project layout."""
    root.mkdir(parents=True, exist_ok=True)
    (root / "pyproject.toml").write_text(
        f'[project]\nname = "{name}"\n', encoding="utf-8",
    )
    (root / ".octrc.json").write_text(
        '{"linter": {"profile": "compact"}}',
        encoding="utf-8",
    )
    return root.resolve()
 
 
def _make_venv(root: Path) -> Path:
    """Create a venv-shaped directory (just the markers we look at)."""
    venv = root / ".venv"
    venv.mkdir(parents=True, exist_ok=True)
    bin_dir = venv / ("Scripts" if (venv / "Scripts").exists()
                       or _is_windows() else "bin")
    bin_dir.mkdir(exist_ok=True)
    return venv.resolve()
 
 
def _is_windows() -> bool:
    import sys as _sys
    return _sys.platform.startswith("win")
 
 
# =====================================================================
# Preflight: not an Option C project
# =====================================================================
 
 
class TestPreflightNotOcProject:
 
    def test_target_missing_pyproject_refuses(self, tmp_path: Path) -> None:
        bad = tmp_path / "not_oc"
        bad.mkdir()
        (bad / ".octrc.json").write_text("{}", encoding="utf-8")
        # No pyproject.toml -> not an Option C project.
        runner = CliRunner()
        with runner.isolated_filesystem(temp_dir=tmp_path):
            result = runner.invoke(
                oct_install_cmd, ["--editable", str(bad)],
            )
        assert result.exit_code == 1
        assert "not an Option C project" in result.output
 
    def test_target_missing_octrc_refuses(self, tmp_path: Path) -> None:
        bad = tmp_path / "no_octrc"
        bad.mkdir()
        (bad / "pyproject.toml").write_text(
            '[project]\nname = "x"\n', encoding="utf-8",
        )
        runner = CliRunner()
        with runner.isolated_filesystem(temp_dir=tmp_path):
            result = runner.invoke(
                oct_install_cmd, ["--editable", str(bad)],
            )
        assert result.exit_code == 1
        assert "not an Option C project" in result.output
 
 
# =====================================================================
# Preflight: inside a Claude Code worktree
# =====================================================================
 
 
class TestPreflightWorktree:
 
    def test_worktree_target_refuses(self, tmp_path: Path) -> None:
        # Build a Claude Code worktree-style path.
        wt_root = tmp_path / ".claude" / "worktrees" / "abc123"
        target = _make_oc_project(wt_root)
        runner = CliRunner()
        with runner.isolated_filesystem(temp_dir=tmp_path):
            result = runner.invoke(
                oct_install_cmd, ["--editable", str(target)],
            )
        assert result.exit_code == 1
        assert "Claude Code worktree" in result.output
 
    def test_allow_worktree_overrides(self, tmp_path: Path) -> None:
        wt_root = tmp_path / ".claude" / "worktrees" / "abc123"
        target = _make_oc_project(wt_root)
        runner = CliRunner()
        with patch("oct.install.oct_install.subprocess.run") as mock_run, \
             patch(
                 "oct.install.oct_install._active_venv_root",
                 return_value=None,
             ), \
             patch(
                 "oct.install.oct_install._pip_show_location",
                 return_value=None,
             ):
            mock_run.return_value = MagicMock(
                returncode=0, stdout="", stderr="",
            )
            result = runner.invoke(oct_install_cmd, [
                "--editable", str(target),
                "--allow-worktree", "--use-active-venv",
                "--allow-outside-project",
            ])
        assert result.exit_code == 0, result.output
 
 
# =====================================================================
# Preflight: venv match
# =====================================================================
 
 
class TestPreflightVenv:
 
    def test_no_active_venv_refuses(self, tmp_path: Path) -> None:
        target = _make_oc_project(tmp_path / "proj")
        _make_venv(target)
        runner = CliRunner()
        with patch(
            "oct.install.oct_install._active_venv_root",
            return_value=None,
        ):
            result = runner.invoke(
                oct_install_cmd, ["--editable", str(target)],
            )
        assert result.exit_code == 1
        assert "no active venv" in result.output
 
    def test_wrong_venv_refuses(self, tmp_path: Path) -> None:
        target = _make_oc_project(tmp_path / "proj")
        _make_venv(target)
        wrong_venv = tmp_path / "elsewhere" / ".venv"
        wrong_venv.mkdir(parents=True)
        runner = CliRunner()
        with patch(
            "oct.install.oct_install._active_venv_root",
            return_value=wrong_venv.resolve(),
        ):
            result = runner.invoke(
                oct_install_cmd, ["--editable", str(target)],
            )
        assert result.exit_code == 1
        assert "active venv is at" in result.output
 
    def test_use_active_venv_skips_check(self, tmp_path: Path) -> None:
        target = _make_oc_project(tmp_path / "proj")
        _make_venv(target)
        wrong_venv = tmp_path / "elsewhere" / ".venv"
        wrong_venv.mkdir(parents=True)
        runner = CliRunner()
        with patch(
            "oct.install.oct_install._active_venv_root",
            return_value=wrong_venv.resolve(),
        ), patch(
            "oct.install.oct_install._pip_show_location",
            return_value=None,
        ), patch(
            "oct.install.oct_install.subprocess.run",
        ) as mock_run:
            mock_run.return_value = MagicMock(
                returncode=0, stdout="", stderr="",
            )
            result = runner.invoke(oct_install_cmd, [
                "--editable", str(target),
                "--use-active-venv", "--allow-outside-project",
            ])
        assert result.exit_code == 0, result.output
 
 
# =====================================================================
# Preflight: existing-shadow detection
# =====================================================================
 
 
class TestPreflightShadow:
 
    def test_shadow_in_other_worktree_refuses(self, tmp_path: Path) -> None:
        target = _make_oc_project(tmp_path / "proj")
        _make_venv(target)
        other_worktree = tmp_path / "other_proj"
        other_worktree.mkdir()
        runner = CliRunner()
        with patch(
            "oct.install.oct_install._active_venv_root",
            return_value=(target / ".venv").resolve(),
        ), patch(
            "oct.install.oct_install._pip_show_location",
            return_value=other_worktree.resolve(),
        ):
            result = runner.invoke(oct_install_cmd, [
                "--editable", str(target),
                "--allow-outside-project",
            ])
        assert result.exit_code == 1
        assert "already installed" in result.output
        assert "silently shadow" in result.output
 
    def test_shadow_with_reinstall_proceeds(self, tmp_path: Path) -> None:
        target = _make_oc_project(tmp_path / "proj")
        _make_venv(target)
        other_worktree = tmp_path / "other_proj"
        other_worktree.mkdir()
        runner = CliRunner()
        with patch(
            "oct.install.oct_install._active_venv_root",
            return_value=(target / ".venv").resolve(),
        ), patch(
            "oct.install.oct_install._pip_show_location",
            return_value=other_worktree.resolve(),
        ), patch(
            "oct.install.oct_install.subprocess.run",
        ) as mock_run:
            mock_run.return_value = MagicMock(
                returncode=0, stdout="", stderr="",
            )
            result = runner.invoke(oct_install_cmd, [
                "--editable", str(target),
                "--reinstall", "--allow-outside-project",
            ])
        assert result.exit_code == 0, result.output
 
 
# =====================================================================
# Success path + JSON
# =====================================================================
 
 
class TestSuccessPath:
 
    def test_clean_install_succeeds_and_prints_diagnostics(
        self, tmp_path: Path,
    ) -> None:
        target = _make_oc_project(tmp_path / "proj")
        _make_venv(target)
        runner = CliRunner()
        with patch(
            "oct.install.oct_install._active_venv_root",
            return_value=(target / ".venv").resolve(),
        ), patch(
            "oct.install.oct_install._pip_show_location",
        ) as mock_show, patch(
            "oct.install.oct_install._which_oct",
            return_value=Path("/fake/bin/oct"),
        ), patch(
            "oct.install.oct_install.subprocess.run",
        ) as mock_run:
            mock_run.return_value = MagicMock(
                returncode=0, stdout="", stderr="",
            )
            # Pre-install: not yet installed; post-install: located at target.
            mock_show.side_effect = [None, target]
            result = runner.invoke(oct_install_cmd, [
                "--editable", str(target),
                "--allow-outside-project",
            ])
        assert result.exit_code == 0, result.output
        assert "myproj installed" in result.output
 
    def test_json_success_schema(self, tmp_path: Path) -> None:
        target = _make_oc_project(tmp_path / "proj")
        _make_venv(target)
        runner = CliRunner()
        with patch(
            "oct.install.oct_install._active_venv_root",
            return_value=(target / ".venv").resolve(),
        ), patch(
            "oct.install.oct_install._pip_show_location",
        ) as mock_show, patch(
            "oct.install.oct_install._which_oct",
            return_value=Path("/fake/bin/oct"),
        ), patch(
            "oct.install.oct_install.subprocess.run",
        ) as mock_run:
            mock_run.return_value = MagicMock(
                returncode=0, stdout="", stderr="",
            )
            mock_show.side_effect = [None, target]
            result = runner.invoke(oct_install_cmd, [
                "--editable", str(target),
                "--allow-outside-project", "--json",
            ])
        assert result.exit_code == 0, result.output
        data = json.loads(result.output)
        assert data["operation"] == "install"
        assert data["package"] == "myproj"
        assert data["exit_code"] == 0
        assert "oct_binary" in data
        assert "installed_location" in data
 
    def test_json_refusal_schema(self, tmp_path: Path) -> None:
        bad = tmp_path / "not_oc"
        bad.mkdir()
        runner = CliRunner()
        result = runner.invoke(oct_install_cmd, [
            "--editable", str(bad), "--json",
        ])
        assert result.exit_code == 1
        data = json.loads(result.output)
        assert data["exit_code"] == 1
        assert data["errors"]
        assert any("not an Option C project" in e for e in data["errors"])
 
 
# =====================================================================
# --editable required
# =====================================================================
 
 
class TestEditableRequired:
 
    def test_missing_editable_refuses(self, tmp_path: Path) -> None:
        target = _make_oc_project(tmp_path / "proj")
        runner = CliRunner()
        result = runner.invoke(oct_install_cmd, [str(target)])
        assert result.exit_code == 1
        assert "--editable" in result.output