use crate::common::TestResult;
use serde_json::Value;
use std::{path::Path, process::Command};
struct Apoc {
root: tempfile::TempDir,
runtime: tempfile::TempDir,
}
impl Apoc {
fn new(griz_home: &Path) -> Result<Self, Box<dyn std::error::Error>> {
let root = tempfile::tempdir()?;
let runtime = tempfile::Builder::new().prefix("gz").tempdir_in("/tmp")?;
let config = serde_json::json!({ "mcpServers": { "griz": {
"type": "stdio",
"command": env!("CARGO_BIN_EXE_griz"),
"args": ["--mcp"],
"env": { "GRIZ_HOME": griz_home },
}}});
std::fs::write(root.path().join(".claude.json"), config.to_string())?;
Ok(Self { root, runtime })
}
fn command(&self, cwd: &Path) -> Command {
let mut command = Command::new("apoc");
command
.current_dir(cwd)
.env("APOC_HOME", self.root.path())
.env("APOC_MCP_ROOT", self.root.path())
.env("APOC_RUNTIME_DIR", self.runtime.path())
.env("XDG_DATA_HOME", self.root.path().join("xdg"))
.env("APOC_MCP_DISCOVERY", "1");
command
}
fn run(
&self,
cwd: &Path,
program: &str,
key: &str,
) -> Result<Value, Box<dyn std::error::Error>> {
let output = self
.command(cwd)
.args(["code", "run", program, "--purpose", "griz composition test"])
.args(["--idempotency-key", key, "--format", "json"])
.output()?;
Ok(serde_json::from_slice(&output.stdout)?)
}
}
impl Drop for Apoc {
fn drop(&mut self) {
let _ = self
.command(self.root.path())
.args(["daemon", "stop", "--purpose", "stop test daemon"])
.args(["--idempotency-key", "griz-compose-stop"])
.output();
}
}
const PROGRAM: &str = r#"
const found = await griz.find({ literal: "oldName", root: W, expect_matches: 3 });
const ops = found.matches.map(m => ({ op: "replace", path: m.path, range: m.range,
find: { text: m.text }, replace: "new_name", expect_hash: m.file_hash }));
const plan = await griz.plan({ ops, root: W, purpose: "rename", idempotency_key: "plan", expect_edits: 3 });
const applied = await griz.apply({ plan: plan.id, purpose: "write", idempotency_key: "apply" });
const check = await apoc.execution_command({ executable: "sh", cwd: W,
arg: ["-c", "grep -q new_name a.rs && exit 3 || exit 0"], expect_exit_code: [0],
purpose: "a check that fails after the rename", idempotency_key: "check" });
let undone = null;
if (check.outcome !== "passed") undone = await griz.undo({ operation: applied.id, purpose: "roll back", idempotency_key: "undo" });
return { matches: found.total, applied: applied.outcome, check: check.outcome, undone: undone && undone.outcome };
"#;
#[test]
#[ignore = "needs apoc on PATH"]
fn apoc_program_applies_checks_and_rolls_back_through_griz() -> TestResult {
let work = tempfile::tempdir()?;
let griz_home = tempfile::tempdir()?;
std::fs::create_dir_all(work.path().join(".git"))?;
std::fs::write(
work.path().join("a.rs"),
"let oldName = 1;\nuse_it(oldName);\n",
)?;
std::fs::write(work.path().join("b.rs"), "oldName();\n")?;
let apoc = Apoc::new(griz_home.path())?;
let program = format!("const W = {:?};\n{PROGRAM}", work.path());
for attempt in ["first", "retry"] {
let state = apoc.run(work.path(), &program, attempt)?;
assert_eq!(state["status"], "completed", "{state}");
let result = &state["result"];
assert_eq!(result["matches"], 3, "{state}");
assert_eq!(
(result["applied"].as_str(), result["check"].as_str()),
(Some("passed"), Some("failed"))
);
assert_eq!(result["undone"], "passed");
}
assert_eq!(
std::fs::read_to_string(work.path().join("a.rs"))?,
"let oldName = 1;\nuse_it(oldName);\n"
);
let log = Command::new(env!("CARGO_BIN_EXE_griz"))
.args(["log", "--json"])
.env("GRIZ_HOME", griz_home.path())
.output()?;
let log: Value = serde_json::from_slice(&log.stdout)?;
let kinds: Vec<_> = log["operations"]
.as_array()
.ok_or("no log")?
.iter()
.map(|op| op["kind"].clone())
.collect();
assert_eq!(
kinds,
[serde_json::json!("undo"), serde_json::json!("apply")],
"a retried program must not write twice"
);
Ok(())
}