| """Tests for ctx-harness-install."""
|
|
|
| from __future__ import annotations
|
|
|
| import json
|
| from dataclasses import dataclass
|
| from pathlib import Path
|
| from typing import Any
|
|
|
| import harness_install
|
| import pytest
|
|
|
|
|
| def _write_harness_page(
|
| wiki: Path,
|
| slug: str = "text-to-cad",
|
| **frontmatter: Any,
|
| ) -> Path:
|
| data: dict[str, Any] = {
|
| "title": "Text to CAD",
|
| "type": "harness",
|
| "status": "cataloged",
|
| "repo_url": "https://github.com/earthtojake/text-to-cad",
|
| "tags": ["cad", "3d"],
|
| "runtimes": ["python", "node"],
|
| "setup_commands": ["python -m pip install -e ."],
|
| "verify_commands": ["python -m pytest"],
|
| }
|
| data.update(frontmatter)
|
| page = wiki / "entities" / "harnesses" / f"{slug}.md"
|
| page.parent.mkdir(parents=True, exist_ok=True)
|
| lines = ["---"]
|
| for key, value in data.items():
|
| if isinstance(value, list):
|
| lines.append(f"{key}:")
|
| lines.extend(f" - {item}" for item in value)
|
| else:
|
| lines.append(f"{key}: {value}")
|
| lines.extend(["---", "", "# Harness"])
|
| page.write_text("\n".join(lines) + "\n", encoding="utf-8")
|
| return page
|
|
|
|
|
| @dataclass
|
| class _FakeRun:
|
| returncode: int = 0
|
| stdout: str = "ok"
|
| stderr: str = ""
|
|
|
|
|
| def test_dry_run_prints_plan_without_writing(tmp_path: Path, capsys: Any) -> None:
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki)
|
| result = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=tmp_path / "manifests",
|
| dry_run=True,
|
| )
|
|
|
| assert result.status == "dry-run"
|
| assert not (tmp_path / "installs").exists()
|
| assert "Text to CAD" in capsys.readouterr().out
|
|
|
|
|
| def test_relative_custom_target_resolves_under_installs_root(tmp_path: Path) -> None:
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki)
|
|
|
| result = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=tmp_path / "manifests",
|
| target=Path("custom"),
|
| dry_run=True,
|
| )
|
|
|
| assert result.status == "dry-run"
|
| assert result.target == (tmp_path / "installs" / "custom").resolve()
|
|
|
|
|
| def test_install_copies_local_source_and_writes_manifest(tmp_path: Path) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| (source / "README.md").write_text("harness", encoding="utf-8")
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=str(source))
|
|
|
| result = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=tmp_path / "manifests",
|
| allow_local_sources=True,
|
| )
|
|
|
| assert result.status == "installed"
|
| assert (tmp_path / "installs" / "text-to-cad" / "README.md").exists()
|
| manifest = json.loads(
|
| (tmp_path / "manifests" / "text-to-cad.json").read_text(encoding="utf-8")
|
| )
|
| assert manifest["slug"] == "text-to-cad"
|
| assert manifest["status"] == "installed"
|
| assert {Path(path).as_posix() for path in manifest["attach_files"]} == {
|
| ".ctx/attach/README.md",
|
| ".ctx/attach/ctx-run.txt",
|
| ".ctx/attach/mcp.json",
|
| ".ctx/attach/python.py",
|
| }
|
| assert manifest["setup_commands_run"] == []
|
| assert manifest["verify_commands_run"] == []
|
| attach_dir = tmp_path / "installs" / "text-to-cad" / ".ctx" / "attach"
|
| assert json.loads((attach_dir / "mcp.json").read_text(encoding="utf-8")) == {
|
| "mcpServers": {"ctx-wiki": {"command": "ctx-mcp-server", "args": []}}
|
| }
|
| assert "recommend_bundle" in (attach_dir / "python.py").read_text(encoding="utf-8")
|
| assert "ctx run --model" in (attach_dir / "ctx-run.txt").read_text(encoding="utf-8")
|
|
|
|
|
| def test_write_manifest_uses_atomic_json_writer(
|
| tmp_path: Path,
|
| monkeypatch: Any,
|
| ) -> None:
|
| calls: list[tuple[Path, dict[str, Any], int | None]] = []
|
|
|
| def fake_atomic_write_json(
|
| path: Path,
|
| obj: Any,
|
| indent: int | None = 2,
|
| ) -> None:
|
| assert isinstance(obj, dict)
|
| calls.append((path, obj, indent))
|
| path.write_text(json.dumps(obj, indent=indent) + "\n", encoding="utf-8")
|
|
|
| monkeypatch.setattr(
|
| harness_install,
|
| "atomic_write_json",
|
| fake_atomic_write_json,
|
| raising=False,
|
| )
|
| record = harness_install.HarnessRecord(
|
| slug="text-to-cad",
|
| path=tmp_path / "page.md",
|
| title="Text to CAD",
|
| repo_url="https://github.com/earthtojake/text-to-cad",
|
| docs_url=None,
|
| tags=("cad",),
|
| runtimes=("python",),
|
| model_providers=("openai",),
|
| capabilities=("Generate CAD",),
|
| attach_modes=("mcp", "python-library", "ctx-run"),
|
| setup_commands=(),
|
| verify_commands=(),
|
| )
|
|
|
| path = harness_install._write_manifest(
|
| record=record,
|
| target=tmp_path / "installs" / "text-to-cad",
|
| manifest_dir=tmp_path / "manifests",
|
| setup_runs=[],
|
| verify_runs=[],
|
| attach_files=[],
|
| )
|
|
|
| assert path == tmp_path / "manifests" / "text-to-cad.json"
|
| assert calls == [(path, json.loads(path.read_text(encoding="utf-8")), 2)]
|
|
|
|
|
| def test_install_respects_catalog_attach_modes(tmp_path: Path) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=str(source), attach_modes=["mcp"])
|
|
|
| result = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=tmp_path / "manifests",
|
| allow_local_sources=True,
|
| )
|
|
|
| assert result.status == "installed"
|
| attach_dir = tmp_path / "installs" / "text-to-cad" / ".ctx" / "attach"
|
| assert (attach_dir / "README.md").exists()
|
| assert (attach_dir / "mcp.json").exists()
|
| assert not (attach_dir / "python.py").exists()
|
| assert not (attach_dir / "ctx-run.txt").exists()
|
|
|
|
|
| def test_dry_run_does_not_write_attach_files(tmp_path: Path) -> None:
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki)
|
| result = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=tmp_path / "manifests",
|
| dry_run=True,
|
| )
|
|
|
| assert result.status == "dry-run"
|
| assert not (tmp_path / "installs" / "text-to-cad" / ".ctx").exists()
|
|
|
|
|
| def test_install_accepts_file_uri_local_source_with_opt_in(tmp_path: Path) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| (source / "README.md").write_text("harness", encoding="utf-8")
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=source.as_uri())
|
|
|
| result = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=tmp_path / "manifests",
|
| allow_local_sources=True,
|
| )
|
|
|
| assert result.status == "installed"
|
| assert (tmp_path / "installs" / "text-to-cad" / "README.md").exists()
|
|
|
|
|
| def test_install_refuses_local_source_without_explicit_opt_in(tmp_path: Path) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=str(source))
|
|
|
| result = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=tmp_path / "manifests",
|
| )
|
|
|
| assert result.status == "install-failed"
|
| assert "--allow-local-source" in result.message
|
| assert not (tmp_path / "installs" / "text-to-cad").exists()
|
|
|
|
|
| def test_remote_install_requires_pinned_commit_by_default(tmp_path: Path) -> None:
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki)
|
|
|
| result = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=tmp_path / "manifests",
|
| )
|
|
|
| assert result.status == "install-failed"
|
| assert "not pinned to a commit" in result.message
|
| assert not (tmp_path / "installs" / "text-to-cad").exists()
|
|
|
|
|
| def test_remote_install_fetches_pinned_commit_and_records_manifest(
|
| tmp_path: Path,
|
| monkeypatch: Any,
|
| ) -> None:
|
| commit = "a" * 40
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, commit_sha=commit)
|
| git_calls: list[list[str]] = []
|
|
|
| def fake_run_git(args: list[str], *, timeout: int = 300) -> _FakeRun:
|
| git_calls.append(args)
|
| if args[:2] == ["clone", "--no-checkout"]:
|
| target = Path(args[-1])
|
| target.mkdir(parents=True)
|
| (target / "README.md").write_text("remote harness", encoding="utf-8")
|
| if "rev-parse" in args:
|
| return _FakeRun(stdout=f"{commit}\n")
|
| return _FakeRun()
|
|
|
| monkeypatch.setattr(harness_install, "_run_git", fake_run_git)
|
|
|
| result = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=tmp_path / "manifests",
|
| )
|
|
|
| assert result.status == "installed"
|
| assert git_calls[0][:2] == ["clone", "--no-checkout"]
|
| assert any(
|
| call[0] == "-C"
|
| and call[2:6] == ["fetch", "--depth", "1", "origin"]
|
| and call[-1] == commit
|
| for call in git_calls
|
| )
|
| assert any(
|
| call[0] == "-C" and call[2:] == ["checkout", "--detach", "FETCH_HEAD"]
|
| for call in git_calls
|
| )
|
| assert any(
|
| call[0] == "-C" and call[2:] == ["rev-parse", "HEAD"]
|
| for call in git_calls
|
| )
|
| manifest = json.loads(
|
| (tmp_path / "manifests" / "text-to-cad.json").read_text(encoding="utf-8")
|
| )
|
| assert manifest["repo_ref"] == commit
|
| assert manifest["resolved_commit"] == commit
|
|
|
|
|
| def test_install_failure_after_target_replace_rolls_back_new_target(
|
| tmp_path: Path,
|
| monkeypatch: Any,
|
| ) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| (source / "README.md").write_text("harness", encoding="utf-8")
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=str(source))
|
|
|
| def fail_attach(*_args: Any, **_kwargs: Any) -> list[Path]:
|
| raise OSError("attach write failed")
|
|
|
| monkeypatch.setattr(harness_install, "_write_attach_files", fail_attach)
|
|
|
| result = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=tmp_path / "manifests",
|
| allow_local_sources=True,
|
| )
|
|
|
| assert result.status == "install-failed"
|
| assert "attach write failed" in result.message
|
| assert not (tmp_path / "installs" / "text-to-cad").exists()
|
| assert not (tmp_path / "manifests" / "text-to-cad.json").exists()
|
|
|
|
|
| def test_install_refuses_symlink_inside_local_source(tmp_path: Path) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| outside = tmp_path / "outside.txt"
|
| outside.write_text("secret", encoding="utf-8")
|
| try:
|
| (source / "leak.txt").symlink_to(outside)
|
| except OSError as exc:
|
| pytest.skip(f"symlinks unavailable in this environment: {exc}")
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=str(source))
|
|
|
| result = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=tmp_path / "manifests",
|
| allow_local_sources=True,
|
| )
|
|
|
| assert result.status == "install-failed"
|
| assert "symlink inside harness source" in result.message
|
|
|
|
|
| def test_setup_and_verify_commands_require_explicit_flags(
|
| tmp_path: Path,
|
| monkeypatch: Any,
|
| ) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=str(source))
|
| calls: list[list[str]] = []
|
|
|
| def fake_run(cmd: list[str], **_kwargs: Any) -> _FakeRun:
|
| calls.append(cmd)
|
| return _FakeRun()
|
|
|
| monkeypatch.setattr(harness_install.subprocess, "run", fake_run)
|
|
|
| harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs-a",
|
| manifest_dir=tmp_path / "manifests-a",
|
| allow_local_sources=True,
|
| )
|
| assert calls == []
|
|
|
| harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs-b",
|
| manifest_dir=tmp_path / "manifests-b",
|
| approve_commands=True,
|
| run_verify=True,
|
| allow_local_sources=True,
|
| )
|
| assert Path(calls[0][0]).name.lower().startswith("python")
|
| assert calls[0][1:] == ["-m", "pip", "install", "-e", "."]
|
| assert Path(calls[1][0]).name.lower().startswith("python")
|
| assert calls[1][1:] == ["-m", "pytest"]
|
|
|
|
|
| def test_target_must_stay_inside_installs_root(tmp_path: Path) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=str(source))
|
|
|
| result = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=tmp_path / "manifests",
|
| target=tmp_path / "outside",
|
| )
|
|
|
| assert result.status == "invalid-target"
|
| assert not (tmp_path / "outside").exists()
|
|
|
|
|
| def test_target_cannot_be_installs_root(tmp_path: Path) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=str(source))
|
| installs_root = tmp_path / "installs"
|
|
|
| result = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=installs_root,
|
| manifest_dir=tmp_path / "manifests",
|
| target=installs_root,
|
| allow_local_sources=True,
|
| )
|
|
|
| assert result.status == "invalid-target"
|
| assert not installs_root.exists()
|
|
|
|
|
| def test_repo_url_identifier_resolves_matching_page(tmp_path: Path) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url="https://github.com/earthtojake/text-to-cad")
|
|
|
| record = harness_install.resolve_harness(
|
| "https://github.com/earthtojake/text-to-cad",
|
| wiki_path=wiki,
|
| )
|
|
|
| assert record.slug == "text-to-cad"
|
|
|
|
|
| def test_missing_harness_fails_clearly(tmp_path: Path) -> None:
|
| result = harness_install.install_harness(
|
| "missing",
|
| wiki_path=tmp_path / "wiki",
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=tmp_path / "manifests",
|
| )
|
|
|
| assert result.status == "not-found"
|
| assert "missing" in result.message
|
|
|
|
|
| def test_uninstall_removes_target_and_manifest(tmp_path: Path) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| (source / "README.md").write_text("v1", encoding="utf-8")
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=str(source))
|
| manifest_dir = tmp_path / "manifests"
|
| install = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=manifest_dir,
|
| allow_local_sources=True,
|
| )
|
| assert install.target is not None
|
| assert install.manifest_path is not None
|
|
|
| result = harness_install.uninstall_harness(
|
| "text-to-cad",
|
| manifest_dir=manifest_dir,
|
| )
|
|
|
| assert result.status == "uninstalled"
|
| assert not install.target.exists()
|
| assert not install.manifest_path.exists()
|
|
|
|
|
| def test_uninstall_marks_manifest_uninstalling_before_deleting_files(
|
| tmp_path: Path,
|
| monkeypatch: Any,
|
| ) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| (source / "README.md").write_text("v1", encoding="utf-8")
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=str(source))
|
| manifest_dir = tmp_path / "manifests"
|
| install = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=manifest_dir,
|
| allow_local_sources=True,
|
| )
|
| assert install.target is not None
|
| assert install.manifest_path is not None
|
|
|
| original_unlink = Path.unlink
|
|
|
| def fail_manifest_unlink(path: Path, *args: Any, **kwargs: Any) -> None:
|
| if path == install.manifest_path:
|
| raise OSError("crash after deleting files")
|
| return original_unlink(path, *args, **kwargs)
|
|
|
| monkeypatch.setattr(Path, "unlink", fail_manifest_unlink)
|
|
|
| result = harness_install.uninstall_harness(
|
| "text-to-cad",
|
| manifest_dir=manifest_dir,
|
| )
|
|
|
| assert result.status == "uninstall-failed"
|
| assert not install.target.exists()
|
| manifest = json.loads(install.manifest_path.read_text(encoding="utf-8"))
|
| assert manifest["status"] == "uninstalling"
|
|
|
|
|
| def test_uninstall_keep_files_only_removes_manifest(tmp_path: Path) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| (source / "README.md").write_text("v1", encoding="utf-8")
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=str(source))
|
| manifest_dir = tmp_path / "manifests"
|
| install = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=manifest_dir,
|
| allow_local_sources=True,
|
| )
|
| assert install.target is not None
|
| assert install.manifest_path is not None
|
|
|
| result = harness_install.uninstall_harness(
|
| "text-to-cad",
|
| manifest_dir=manifest_dir,
|
| keep_files=True,
|
| )
|
|
|
| assert result.status == "uninstalled"
|
| assert install.target.exists()
|
| assert not install.manifest_path.exists()
|
|
|
|
|
| def test_uninstall_refuses_manifest_target_at_installs_root(tmp_path: Path) -> None:
|
| manifest_dir = tmp_path / "manifests"
|
| manifest_dir.mkdir()
|
| installs_root = tmp_path / "installs"
|
| installs_root.mkdir()
|
| sibling = installs_root / "other"
|
| sibling.mkdir()
|
| (manifest_dir / "text-to-cad.json").write_text(
|
| json.dumps({"slug": "text-to-cad", "target": str(installs_root)}),
|
| encoding="utf-8",
|
| )
|
|
|
| result = harness_install.uninstall_harness(
|
| "text-to-cad",
|
| manifest_dir=manifest_dir,
|
| installs_root=installs_root,
|
| )
|
|
|
| assert result.status == "invalid-target"
|
| assert installs_root.exists()
|
| assert sibling.exists()
|
|
|
|
|
| def test_update_replaces_installed_target_from_catalog_source(tmp_path: Path) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| (source / "README.md").write_text("v1", encoding="utf-8")
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=str(source))
|
| manifest_dir = tmp_path / "manifests"
|
| installs_root = tmp_path / "installs"
|
| install = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=installs_root,
|
| manifest_dir=manifest_dir,
|
| allow_local_sources=True,
|
| )
|
| assert install.target is not None
|
| (source / "README.md").write_text("v2", encoding="utf-8")
|
|
|
| result = harness_install.update_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=installs_root,
|
| manifest_dir=manifest_dir,
|
| allow_local_sources=True,
|
| )
|
|
|
| assert result.status == "updated"
|
| assert (install.target / "README.md").read_text(encoding="utf-8") == "v2"
|
|
|
|
|
| def test_update_failure_preserves_existing_target_and_manifest(
|
| tmp_path: Path,
|
| monkeypatch: Any,
|
| ) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| (source / "README.md").write_text("v1", encoding="utf-8")
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=str(source))
|
| manifest_dir = tmp_path / "manifests"
|
| installs_root = tmp_path / "installs"
|
| install = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=installs_root,
|
| manifest_dir=manifest_dir,
|
| allow_local_sources=True,
|
| )
|
| assert install.target is not None
|
| assert install.manifest_path is not None
|
| before_manifest = install.manifest_path.read_text(encoding="utf-8")
|
| (source / "README.md").write_text("v2", encoding="utf-8")
|
|
|
| def fake_run(cmd: list[str], **_kwargs: Any) -> _FakeRun:
|
| return _FakeRun(returncode=1, stderr="setup failed")
|
|
|
| monkeypatch.setattr(harness_install.subprocess, "run", fake_run)
|
|
|
| result = harness_install.update_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=installs_root,
|
| manifest_dir=manifest_dir,
|
| approve_commands=True,
|
| allow_local_sources=True,
|
| )
|
|
|
| assert result.status == "install-failed"
|
| assert (install.target / "README.md").read_text(encoding="utf-8") == "v1"
|
| assert install.manifest_path.read_text(encoding="utf-8") == before_manifest
|
|
|
|
|
| def test_update_manifest_failure_rolls_back_replaced_target(
|
| tmp_path: Path,
|
| monkeypatch: Any,
|
| ) -> None:
|
| source = tmp_path / "source"
|
| source.mkdir()
|
| (source / "README.md").write_text("v1", encoding="utf-8")
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki, repo_url=str(source))
|
| manifest_dir = tmp_path / "manifests"
|
| installs_root = tmp_path / "installs"
|
| install = harness_install.install_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=installs_root,
|
| manifest_dir=manifest_dir,
|
| allow_local_sources=True,
|
| )
|
| assert install.target is not None
|
| assert install.manifest_path is not None
|
| before_manifest = install.manifest_path.read_text(encoding="utf-8")
|
| (source / "README.md").write_text("v2", encoding="utf-8")
|
|
|
| def fail_manifest(**_kwargs: Any) -> Path:
|
| raise OSError("manifest write failed")
|
|
|
| monkeypatch.setattr(harness_install, "_write_manifest", fail_manifest)
|
|
|
| result = harness_install.update_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=installs_root,
|
| manifest_dir=manifest_dir,
|
| allow_local_sources=True,
|
| )
|
|
|
| assert result.status == "install-failed"
|
| assert "manifest write failed" in result.message
|
| assert (install.target / "README.md").read_text(encoding="utf-8") == "v1"
|
| assert install.manifest_path.read_text(encoding="utf-8") == before_manifest
|
| assert not list(installs_root.glob(".text-to-cad.backup-*"))
|
|
|
|
|
| def test_update_requires_existing_manifest(tmp_path: Path) -> None:
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki)
|
|
|
| result = harness_install.update_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=tmp_path / "installs",
|
| manifest_dir=tmp_path / "manifests",
|
| )
|
|
|
| assert result.status == "not-installed"
|
|
|
|
|
| def test_update_dry_run_validates_manifest_target(tmp_path: Path) -> None:
|
| wiki = tmp_path / "wiki"
|
| _write_harness_page(wiki)
|
| manifest_dir = tmp_path / "manifests"
|
| manifest_dir.mkdir()
|
| installs_root = tmp_path / "installs"
|
| installs_root.mkdir()
|
| (manifest_dir / "text-to-cad.json").write_text(
|
| json.dumps({"slug": "text-to-cad", "target": str(installs_root)}),
|
| encoding="utf-8",
|
| )
|
|
|
| result = harness_install.update_harness(
|
| "text-to-cad",
|
| wiki_path=wiki,
|
| installs_root=installs_root,
|
| manifest_dir=manifest_dir,
|
| dry_run=True,
|
| )
|
|
|
| assert result.status == "invalid-target"
|
|
|
|
|
| def test_cataloged_commands_use_sanitized_env_and_redact_output(
|
| tmp_path: Path,
|
| monkeypatch: Any,
|
| ) -> None:
|
| monkeypatch.setenv("OPENAI_API_KEY", "sk-secret-value")
|
| captured_env: dict[str, str] = {}
|
|
|
| def fake_run(cmd: list[str], **kwargs: Any) -> _FakeRun:
|
| captured_env.update(kwargs["env"])
|
| return _FakeRun(stdout="token sk-secret-value")
|
|
|
| monkeypatch.setattr(harness_install.subprocess, "run", fake_run)
|
|
|
| run = harness_install._run_command("python --version", cwd=tmp_path)
|
|
|
| assert "OPENAI_API_KEY" not in captured_env
|
| assert run["stdout"] == f"token {harness_install._REDACTION}"
|
|
|
|
|
| def test_run_command_resolves_bare_executable(
|
| tmp_path: Path,
|
| monkeypatch: Any,
|
| ) -> None:
|
| resolved = str(tmp_path / "npx.cmd")
|
| captured_cmd: list[str] = []
|
|
|
| def fake_which(command: str, *, path: str | None = None) -> str | None:
|
| return resolved if command == "npx" else None
|
|
|
| def fake_run(cmd: list[str], **_kwargs: Any) -> _FakeRun:
|
| captured_cmd.extend(cmd)
|
| return _FakeRun(stdout="9.0.0")
|
|
|
| monkeypatch.setattr(harness_install.shutil, "which", fake_which)
|
| monkeypatch.setattr(harness_install.subprocess, "run", fake_run)
|
|
|
| run = harness_install._run_command("npx --version", cwd=tmp_path)
|
|
|
| assert run["returncode"] == 0
|
| assert captured_cmd[0] == resolved
|
|
|
|
|
| def test_split_command_preserves_windows_backslashes() -> None:
|
| parts = harness_install._split_command(
|
| r'python "C:\Users\me\script.py"',
|
| windows=True,
|
| )
|
|
|
| assert parts == ["python", r"C:\Users\me\script.py"]
|
|
|
|
|
| def test_failed_run_message_includes_redacted_output() -> None:
|
| message = harness_install._failed_run_message(
|
| "setup",
|
| "npm install",
|
| {"stderr": "token leaked", "stdout": ""},
|
| )
|
|
|
| assert message == "setup command failed: npm install: token leaked"
|
|
|
|
|
| def test_recommend_mode_prints_install_handoff(
|
| monkeypatch: Any,
|
| capsys: Any,
|
| ) -> None:
|
| calls: list[dict[str, object]] = []
|
|
|
| def fake_recommend(**kwargs: Any) -> list[dict[str, object]]:
|
| calls.append(kwargs)
|
| return [{
|
| "name": "text-to-cad",
|
| "normalized_score": 0.91,
|
| "reason": "cad tag match",
|
| }]
|
|
|
| monkeypatch.setattr(harness_install, "recommend_harnesses_for_cli", fake_recommend)
|
|
|
| rc = harness_install.main([
|
| "--recommend",
|
| "--goal",
|
| "generate CAD from text",
|
| "--model-provider",
|
| "openai",
|
| "--model",
|
| "openai/gpt-5.5",
|
| ])
|
|
|
| assert rc == 0
|
| assert calls[0]["model_provider"] == "openai"
|
| assert calls[0]["model"] == "openai/gpt-5.5"
|
| output = capsys.readouterr().out
|
| assert "Recommended harnesses" in output
|
| assert "ctx-harness-install text-to-cad --dry-run" in output
|
|
|
|
|
| def test_recommend_mode_passes_structured_harness_requirements(
|
| monkeypatch: Any,
|
| ) -> None:
|
| calls: list[dict[str, object]] = []
|
|
|
| def fake_recommend(**kwargs: Any) -> list[dict[str, object]]:
|
| calls.append(kwargs)
|
| return []
|
|
|
| monkeypatch.setattr(harness_install, "recommend_harnesses_for_cli", fake_recommend)
|
|
|
| rc = harness_install.main([
|
| "--recommend",
|
| "--goal",
|
| "build a code agent",
|
| "--model",
|
| "openai/gpt-5.5",
|
| "--harness-runtime",
|
| "windows python",
|
| "--harness-autonomy",
|
| "supervised",
|
| "--harness-tools",
|
| "filesystem shell browser",
|
| "--harness-verify",
|
| "pytest ruff",
|
| "--harness-privacy",
|
| "private repo no secrets",
|
| "--harness-attach-mode",
|
| "mcp",
|
| ])
|
|
|
| assert rc == 0
|
| assert calls[0]["harness_requirements"] == {
|
| "runtime": "windows python",
|
| "autonomy": "supervised",
|
| "tools": "filesystem shell browser",
|
| "verification": "pytest ruff",
|
| "privacy": "private repo no secrets",
|
| "attach_mode": "mcp",
|
| }
|
|
|
|
|
| def test_recommend_cli_query_includes_structured_harness_requirements(
|
| monkeypatch: Any,
|
| ) -> None:
|
| import ctx_init
|
|
|
| calls: list[dict[str, object]] = []
|
|
|
| def fake_recommend(
|
| goal: str,
|
| top_k: int = 5,
|
| model_provider: str | None = None,
|
| model: str | None = None,
|
| ) -> list[dict[str, object]]:
|
| calls.append({
|
| "goal": goal,
|
| "top_k": top_k,
|
| "model_provider": model_provider,
|
| "model": model,
|
| })
|
| return []
|
|
|
| monkeypatch.setattr(ctx_init, "recommend_harnesses", fake_recommend)
|
|
|
| harness_install.recommend_harnesses_for_cli(
|
| goal="build a code agent",
|
| model_provider="openai",
|
| model="openai/gpt-5.5",
|
| top_k=5,
|
| harness_requirements={
|
| "runtime": "windows python",
|
| "tools": "filesystem shell browser",
|
| "verification": "pytest ruff",
|
| "privacy": "private repo no secrets",
|
| "attach_mode": "mcp",
|
| },
|
| )
|
|
|
| query = str(calls[0]["goal"])
|
| assert "windows python" in query
|
| assert "filesystem shell browser" in query
|
| assert "pytest ruff" in query
|
| assert "private repo no secrets" in query
|
| assert "mcp" in query
|
|
|
|
|
| def test_recommend_no_fit_prints_custom_harness_plan(
|
| monkeypatch: Any,
|
| capsys: Any,
|
| ) -> None:
|
| monkeypatch.setattr(harness_install, "recommend_harnesses_for_cli", lambda **_: [])
|
|
|
| rc = harness_install.main([
|
| "--recommend",
|
| "--goal",
|
| "build a private CAD workflow with a local model",
|
| "--model-provider",
|
| "ollama",
|
| "--model",
|
| "ollama/llama3.1",
|
| "--harness-runtime",
|
| "linux server",
|
| "--harness-tools",
|
| "filesystem shell",
|
| "--harness-verify",
|
| "pytest",
|
| "--harness-privacy",
|
| "offline source code",
|
| "--plan-on-no-fit",
|
| ])
|
|
|
| assert rc == 0
|
| output = capsys.readouterr().out
|
| assert "No harness recommendations matched." in output
|
| assert "# Custom Harness PRD" in output
|
| assert "ctx-mcp-server" in output
|
| assert "ctx.recommend_bundle" in output
|
| assert "Windows, macOS, and Linux" in output
|
| assert "Runtime / OS: linux server" in output
|
| assert "Allowed tools/access: filesystem shell" in output
|
| assert "Verification: pytest" in output
|
| assert "Privacy/network: offline source code" in output
|
|
|
|
|
| def test_recommend_no_fit_writes_custom_harness_plan(
|
| tmp_path: Path,
|
| monkeypatch: Any,
|
| capsys: Any,
|
| ) -> None:
|
| monkeypatch.setattr(harness_install, "recommend_harnesses_for_cli", lambda **_: [])
|
| target = tmp_path / "custom-harness.md"
|
|
|
| rc = harness_install.main([
|
| "--recommend",
|
| "--goal",
|
| "repair a legacy Python service",
|
| "--model",
|
| "openrouter/openai/gpt-5.5",
|
| "--plan-on-no-fit",
|
| "--plan-output",
|
| str(target),
|
| ])
|
|
|
| assert rc == 0
|
| assert f"Custom harness plan: {target}" in capsys.readouterr().out
|
| text = target.read_text(encoding="utf-8")
|
| assert "repair a legacy Python service" in text
|
| assert "Model provider: openrouter" in text
|
| assert "openrouter/openai/gpt-5.5" in text
|
| assert "Build the harness described above" in text
|
|
|
