| """Tests for the clean-host contract runner."""
|
|
|
| from __future__ import annotations
|
|
|
| import json
|
| import os
|
| import sys
|
| from dataclasses import dataclass
|
| from pathlib import Path
|
| from typing import Mapping, Sequence
|
|
|
| import pytest
|
|
|
| from scripts.clean_host_contract import (
|
| CommandRunner,
|
| CompletedCommand,
|
| LIVE_CLAUDE_ACK_ENV,
|
| LIVE_CLAUDE_ACK_VALUE,
|
| _assert_fake_claude_hook_output,
|
| _assert_live_claude_sentinel,
|
| _append_live_claude_sentinel_hooks,
|
| _live_claude_command,
|
| assert_inside,
|
| isolated_env,
|
| make_paths,
|
| run_contract,
|
| venv_script,
|
| write_fake_claude_cli,
|
| write_fake_litellm,
|
| write_tiny_repo,
|
| )
|
|
|
|
|
| @dataclass(frozen=True)
|
| class RecordedRun:
|
| args: tuple[str, ...]
|
| cwd: Path
|
| env: dict[str, str]
|
| check: bool
|
| timeout_seconds: float | None
|
|
|
|
|
| class RecordingRunner(CommandRunner):
|
| def __init__(self, venv: Path) -> None:
|
| self.calls: list[tuple[str, ...]] = []
|
| self.records: list[RecordedRun] = []
|
| self.venv = venv
|
|
|
| def run(
|
| self,
|
| args: Sequence[str],
|
| *,
|
| cwd: Path,
|
| env: Mapping[str, str],
|
| check: bool = True,
|
| timeout_seconds: float | None = None,
|
| ) -> CompletedCommand:
|
| call = tuple(args)
|
| self.calls.append(call)
|
| self.records.append(
|
| RecordedRun(
|
| args=call,
|
| cwd=cwd,
|
| env=dict(env),
|
| check=check,
|
| timeout_seconds=timeout_seconds,
|
| )
|
| )
|
| if call[:4] == (sys.executable, "-m", "pip", "wheel"):
|
| outdir = Path(call[call.index("--wheel-dir") + 1])
|
| outdir.mkdir(parents=True, exist_ok=True)
|
| (outdir / "claude_ctx-0.0.0-py3-none-any.whl").write_bytes(b"wheel")
|
| elif call[:3] == (sys.executable, "-m", "venv"):
|
| scripts = self.venv / ("Scripts" if os.name == "nt" else "bin")
|
| scripts.mkdir(parents=True, exist_ok=True)
|
| (scripts / ("python.exe" if os.name == "nt" else "python")).write_text("")
|
| for name in ("ctx-init", "ctx-scan-repo", "ctx"):
|
| suffix = ".exe" if os.name == "nt" else ""
|
| (scripts / f"{name}{suffix}").write_text("")
|
| elif call and Path(call[0]).name.startswith("ctx-init"):
|
| home = Path(os.environ.get("CTX_TEST_HOME_OVERRIDE", ""))
|
| if home:
|
| settings = home / ".claude" / "settings.json"
|
| settings.parent.mkdir(parents=True, exist_ok=True)
|
| settings.write_text("{}", encoding="utf-8")
|
| elif call and Path(call[0]).name.startswith("ctx-scan-repo"):
|
| output = Path(call[call.index("--output") + 1])
|
| output.write_text("{}", encoding="utf-8")
|
| elif any(Path(part).name == "fake_claude.py" for part in call):
|
| stdout = json.dumps({
|
| "hook_commands": 5,
|
| "failed": 0,
|
| "commands": [
|
| {"command": "ctx.adapters.claude_code.hooks.context_monitor"},
|
| {"command": "skill_add_detector"},
|
| {"command": "ctx.adapters.claude_code.hooks.bundle_orchestrator"},
|
| {"command": "usage_tracker"},
|
| {"command": "ctx.adapters.claude_code.hooks.lifecycle_hooks"},
|
| ],
|
| })
|
| return CompletedCommand(call, cwd, 0, stdout, "")
|
| elif call and Path(call[0]).name.startswith("claude"):
|
| if "-p" in call:
|
| sentinel = self.venv.parent / "live-claude-hooks.jsonl"
|
| sentinel.write_text(
|
| "\n".join([
|
| json.dumps({
|
| "event": "PostToolUse",
|
| "hook_event_name": "PostToolUse",
|
| "cwd": str(self.venv.parent / "tiny-fastapi-repo"),
|
| }),
|
| json.dumps({
|
| "event": "Stop",
|
| "hook_event_name": "Stop",
|
| "cwd": str(self.venv.parent / "tiny-fastapi-repo"),
|
| }),
|
| ]),
|
| encoding="utf-8",
|
| )
|
| return CompletedCommand(call, cwd, 0, "claude preflight\n", "")
|
| stdout = '{"stop_reason": "tool_denied"}' if "--deny-tool" in call else ""
|
| rc = 2 if "--deny-tool" in call else 0
|
| return CompletedCommand(call, cwd, rc, stdout, "")
|
|
|
|
|
| def test_isolated_env_redirects_user_state(tmp_path: Path) -> None:
|
| paths = make_paths(tmp_path)
|
| env = isolated_env(paths, extra_pythonpath=paths.fake_modules)
|
|
|
| assert env["HOME"] == str(paths.home)
|
| assert env["USERPROFILE"] == str(paths.home)
|
| assert env["APPDATA"] == str(paths.appdata)
|
| assert env["LOCALAPPDATA"] == str(paths.localappdata)
|
| assert env["XDG_CONFIG_HOME"] == str(paths.xdg_config)
|
| assert env["XDG_CACHE_HOME"] == str(paths.xdg_cache)
|
| assert env["PIP_CACHE_DIR"] == str(paths.pip_cache)
|
| assert env["PYTHONPATH"].split(os.pathsep)[0] == str(paths.fake_modules)
|
|
|
|
|
| def test_isolated_env_does_not_inherit_caller_pythonpath(
|
| tmp_path: Path,
|
| monkeypatch: pytest.MonkeyPatch,
|
| ) -> None:
|
| paths = make_paths(tmp_path)
|
| monkeypatch.setenv("PYTHONPATH", str(tmp_path / "src"))
|
|
|
| no_extra = isolated_env(paths)
|
| with_extra = isolated_env(paths, extra_pythonpath=paths.fake_modules)
|
|
|
| assert "PYTHONPATH" not in no_extra
|
| assert with_extra["PYTHONPATH"] == str(paths.fake_modules)
|
|
|
|
|
| def test_isolated_env_does_not_inherit_caller_secrets(
|
| tmp_path: Path,
|
| monkeypatch: pytest.MonkeyPatch,
|
| ) -> None:
|
| paths = make_paths(tmp_path)
|
| monkeypatch.setenv("OPENAI_API_KEY", "sk-test")
|
| monkeypatch.setenv("GITHUB_TOKEN", "ghp-test")
|
| monkeypatch.setenv("CTX_WIKI_DIR", str(tmp_path / "real-wiki"))
|
| monkeypatch.setenv("CLAUDE_HOME", str(tmp_path / "real-claude"))
|
|
|
| env = isolated_env(paths)
|
|
|
| assert "OPENAI_API_KEY" not in env
|
| assert "GITHUB_TOKEN" not in env
|
| assert "CTX_WIKI_DIR" not in env
|
| assert "CLAUDE_HOME" not in env
|
|
|
|
|
| def test_assert_inside_rejects_escape(tmp_path: Path) -> None:
|
| assert_inside(tmp_path / "child", tmp_path)
|
| with pytest.raises(AssertionError):
|
| assert_inside(tmp_path.parent, tmp_path)
|
|
|
|
|
| def test_venv_script_prefers_platform_entrypoint(tmp_path: Path) -> None:
|
| venv = tmp_path / "venv"
|
| if os.name == "nt":
|
| scripts = venv / "Scripts"
|
| expected = scripts / "ctx-init.exe"
|
| else:
|
| scripts = venv / "bin"
|
| expected = scripts / "ctx-init"
|
| scripts.mkdir(parents=True)
|
| expected.write_text("", encoding="utf-8")
|
|
|
| assert venv_script(venv, "ctx-init") == expected
|
|
|
|
|
| def test_fake_litellm_can_emit_stop_or_tool_call(tmp_path: Path) -> None:
|
| fake = write_fake_litellm(tmp_path)
|
| body = fake.read_text(encoding="utf-8")
|
|
|
| assert "clean host contract response" in body
|
| assert "CTX_FAKE_LITELLM_TOOL_CALL" in body
|
| assert "tool_calls" in body
|
|
|
|
|
| def test_fake_claude_cli_executes_post_tool_and_stop_hooks(tmp_path: Path) -> None:
|
| fake = write_fake_claude_cli(tmp_path)
|
| body = fake.read_text(encoding="utf-8")
|
|
|
| assert "PostToolUse" in body
|
| assert "Stop" in body
|
| assert "subprocess.run" in body
|
| assert "shell=True" in body
|
| assert "shlex.split(command)" not in body
|
|
|
|
|
| def test_fake_claude_hook_output_requires_all_generated_hooks() -> None:
|
| good = json.dumps({
|
| "hook_commands": 5,
|
| "failed": 0,
|
| "commands": [
|
| {"command": "ctx.adapters.claude_code.hooks.context_monitor"},
|
| {"command": "skill_add_detector"},
|
| {"command": "ctx.adapters.claude_code.hooks.bundle_orchestrator"},
|
| {"command": "usage_tracker"},
|
| {"command": "ctx.adapters.claude_code.hooks.lifecycle_hooks"},
|
| ],
|
| })
|
| _assert_fake_claude_hook_output(good)
|
|
|
| missing = json.dumps({
|
| "hook_commands": 4,
|
| "failed": 0,
|
| "commands": [{"command": "usage_tracker"}],
|
| })
|
| with pytest.raises(AssertionError):
|
| _assert_fake_claude_hook_output(missing)
|
|
|
|
|
| def test_tiny_repo_contains_fastapi_signals(tmp_path: Path) -> None:
|
| write_tiny_repo(tmp_path)
|
|
|
| assert "fastapi" in (tmp_path / "pyproject.toml").read_text(encoding="utf-8")
|
| assert "FastAPI" in (tmp_path / "app" / "main.py").read_text(encoding="utf-8")
|
|
|
|
|
| def test_contract_command_sequence_without_real_build(tmp_path: Path, monkeypatch) -> None:
|
| paths = make_paths(tmp_path)
|
| runner = RecordingRunner(paths.venv)
|
| monkeypatch.setenv("CTX_TEST_HOME_OVERRIDE", str(paths.home))
|
| monkeypatch.setenv("HOME", str(tmp_path / "real-home"))
|
| monkeypatch.setenv("APPDATA", str(tmp_path / "real-appdata"))
|
| monkeypatch.setenv("LOCALAPPDATA", str(tmp_path / "real-localappdata"))
|
| monkeypatch.setenv("PIP_CACHE_DIR", str(tmp_path / "real-pip-cache"))
|
| monkeypatch.setenv("PYTHONPATH", str(tmp_path / "real-pythonpath"))
|
|
|
| run_contract(
|
| project_root=tmp_path,
|
| temp_root=tmp_path,
|
| fast=True,
|
| runner=runner,
|
| )
|
|
|
| joined = [" ".join(call) for call in runner.calls]
|
| assert any("-m pip wheel" in call for call in joined)
|
| assert any("-m venv" in call for call in joined)
|
| assert any("-m pip install" in call for call in joined)
|
| assert any("ctx-init" in call and "--hooks" in call for call in joined)
|
| assert any("fake_claude.py" in call and "--settings" in call for call in joined)
|
| assert any("ctx-scan-repo" in call and "--recommend" in call for call in joined)
|
| assert any("ctx run" in call or "ctx.exe run" in call for call in joined)
|
| assert any("--deny-tool ctx__wiki_get" in call for call in joined)
|
|
|
| assert runner.records
|
| for record in runner.records:
|
| assert_inside(record.cwd, paths.root)
|
| assert record.env["HOME"] == str(paths.home)
|
| assert record.env["USERPROFILE"] == str(paths.home)
|
| assert record.env["APPDATA"] == str(paths.appdata)
|
| assert record.env["LOCALAPPDATA"] == str(paths.localappdata)
|
| assert record.env["XDG_CONFIG_HOME"] == str(paths.xdg_config)
|
| assert record.env["XDG_CACHE_HOME"] == str(paths.xdg_cache)
|
| assert record.env["PIP_CACHE_DIR"] == str(paths.pip_cache)
|
| assert record.env.get("PYTHONPATH") in (None, str(paths.fake_modules))
|
| assert str(tmp_path / "real-pythonpath") not in record.env.values()
|
| denied_records = [
|
| record for record in runner.records
|
| if "--deny-tool" in record.args
|
| ]
|
| assert denied_records
|
| assert denied_records[0].check is False
|
|
|
|
|
| def test_live_claude_command_is_bounded_and_streamed(tmp_path: Path) -> None:
|
| command = _live_claude_command(
|
| claude_bin=tmp_path / "claude",
|
| settings_json=tmp_path / "settings.json",
|
| max_budget_usd=0.02,
|
| )
|
|
|
| assert command[:2] == [str(tmp_path / "claude"), "--settings"]
|
| assert "--output-format" in command
|
| assert "stream-json" in command
|
| assert "--include-hook-events" in command
|
| assert "--max-budget-usd" in command
|
| assert "0.02" in command
|
| assert "--allowedTools" in command
|
| assert "Bash(python --version)" in command
|
| assert "-p" in command
|
|
|
|
|
| def test_live_claude_sentinel_hooks_are_appended_to_settings(tmp_path: Path) -> None:
|
| settings_json = tmp_path / "settings.json"
|
| sentinel_script = tmp_path / "live_sentinel.py"
|
| sentinel_jsonl = tmp_path / "live_sentinel.jsonl"
|
| settings_json.write_text(
|
| json.dumps({
|
| "hooks": {
|
| "PostToolUse": [{"matcher": ".*", "hooks": []}],
|
| "Stop": [{"hooks": []}],
|
| }
|
| }),
|
| encoding="utf-8",
|
| )
|
|
|
| _append_live_claude_sentinel_hooks(
|
| settings_json=settings_json,
|
| python_bin=tmp_path / "python",
|
| sentinel_script=sentinel_script,
|
| sentinel_jsonl=sentinel_jsonl,
|
| )
|
|
|
| settings = json.loads(settings_json.read_text(encoding="utf-8"))
|
| commands = [
|
| hook["command"]
|
| for entries in settings["hooks"].values()
|
| for entry in entries
|
| for hook in entry["hooks"]
|
| if hook.get("command")
|
| ]
|
| joined = "\n".join(commands)
|
| assert str(sentinel_script) in joined
|
| assert str(sentinel_jsonl) in joined
|
| assert "PostToolUse" in settings["hooks"]
|
| assert "Stop" in settings["hooks"]
|
|
|
|
|
| def test_live_claude_sentinel_requires_post_tool_and_stop(tmp_path: Path) -> None:
|
| sentinel_jsonl = tmp_path / "sentinel.jsonl"
|
| sentinel_jsonl.write_text(
|
| "\n".join([
|
| json.dumps({"event": "PostToolUse", "cwd": str(tmp_path)}),
|
| json.dumps({"event": "Stop", "cwd": str(tmp_path)}),
|
| ]),
|
| encoding="utf-8",
|
| )
|
| _assert_live_claude_sentinel(sentinel_jsonl, expected_cwd=tmp_path)
|
|
|
| sentinel_jsonl.write_text(
|
| json.dumps({"event": "PostToolUse", "cwd": str(tmp_path)}),
|
| encoding="utf-8",
|
| )
|
| with pytest.raises(AssertionError):
|
| _assert_live_claude_sentinel(sentinel_jsonl, expected_cwd=tmp_path)
|
|
|
|
|
| def test_live_claude_ack_required_before_running_live_host(
|
| tmp_path: Path,
|
| monkeypatch: pytest.MonkeyPatch,
|
| ) -> None:
|
| paths = make_paths(tmp_path)
|
| runner = RecordingRunner(paths.venv)
|
| monkeypatch.setenv("CTX_TEST_HOME_OVERRIDE", str(paths.home))
|
| monkeypatch.delenv(LIVE_CLAUDE_ACK_ENV, raising=False)
|
|
|
| with pytest.raises(AssertionError, match=LIVE_CLAUDE_ACK_ENV):
|
| run_contract(
|
| project_root=tmp_path,
|
| temp_root=tmp_path,
|
| fast=True,
|
| runner=runner,
|
| run_live_claude=True,
|
| )
|
|
|
| assert not any(
|
| call and Path(call[0]).name.startswith("claude")
|
| for call in runner.calls
|
| )
|
|
|
|
|
| def test_live_claude_gate_runs_only_when_acknowledged(
|
| tmp_path: Path,
|
| monkeypatch: pytest.MonkeyPatch,
|
| ) -> None:
|
| paths = make_paths(tmp_path)
|
| runner = RecordingRunner(paths.venv)
|
| claude_bin = tmp_path / ("claude.exe" if os.name == "nt" else "claude")
|
| monkeypatch.setenv("CTX_TEST_HOME_OVERRIDE", str(paths.home))
|
| monkeypatch.setenv(LIVE_CLAUDE_ACK_ENV, LIVE_CLAUDE_ACK_VALUE)
|
|
|
| run_contract(
|
| project_root=tmp_path,
|
| temp_root=tmp_path,
|
| fast=True,
|
| runner=runner,
|
| run_live_claude=True,
|
| live_claude_max_budget_usd=0.02,
|
| live_claude_bin=claude_bin,
|
| )
|
|
|
| live_calls = [
|
| call
|
| for call in runner.calls
|
| if call and Path(call[0]).name.startswith("claude")
|
| ]
|
| assert [call[1:] for call in live_calls[:2]] == [("--version",), ("auth", "status")]
|
| prompt_calls = [call for call in live_calls if "-p" in call]
|
| assert len(prompt_calls) == 1
|
| live_call = prompt_calls[0]
|
| assert "--settings" in live_call
|
| assert str(paths.home / ".claude" / "settings.json") in live_call
|
| assert "--include-hook-events" in live_call
|
| assert "--max-budget-usd" in live_call
|
| assert "0.02" in live_call
|
| assert (paths.root / "live-claude-hooks.jsonl").exists()
|
|
|
