642d5a256791
tests.rs
//! End-to-end setup tests on a temporary home with fixture configs that carry comments.
use crate::plan::apply_with;
use crate::*;
use craft_anything_evidence::ToolError;
use std::path::{Path, PathBuf};
const CLAUDE: &str =
"// Claude Code state\n{\n \"numStartups\": 3, /* keep */\n \"mcpServers\": {\n \"other\": {\"command\": \"other-server\"}, // theirs\n },\n}\n";
const CODEX: &str = "# Codex config\nmodel = \"o\" # chosen\n\n[mcp_servers.other]\ncommand = \"other-server\" # theirs\n";
const HERMES: &str = "# Hermes\nmodel: x # inline\nmcp_servers:\n # friend\n other:\n command: other-server\n";
struct Fx {
_dir: tempfile::TempDir,
host: Host,
cli: PathBuf,
}
fn fixture() -> Fx {
let dir = tempfile::tempdir().unwrap();
let home = dir.path().to_path_buf();
let mut host = Host::with_home(&home);
host.os = Os::Linux;
std::fs::create_dir_all(home.join(".claude")).unwrap();
std::fs::write(home.join(".claude.json"), CLAUDE).unwrap();
std::fs::create_dir_all(home.join(".codex")).unwrap();
std::fs::write(home.join(".codex/config.toml"), CODEX).unwrap();
std::fs::create_dir_all(home.join(".hermes")).unwrap();
std::fs::write(home.join(".hermes/config.yaml"), HERMES).unwrap();
std::fs::create_dir_all(home.join(".cursor")).unwrap(); // detected, no config yet
let cli = home.join("bin").join("craft-anything-cli");
std::fs::create_dir_all(cli.parent().unwrap()).unwrap();
std::fs::write(&cli, "#!/bin/sh\n").unwrap();
Fx { _dir: dir, host, cli }
}
fn req(fx: &Fx, clients: &[&str]) -> PlanRequest {
PlanRequest {
clients: clients.iter().map(|s| s.to_string()).collect(),
all_detected: clients.is_empty(),
command: vec![fx.cli.display().to_string(), "mcp".into()],
include_skill: true,
}
}
fn read(p: impl AsRef<Path>) -> String {
std::fs::read_to_string(p).unwrap()
}
#[test]
fn detects_installed_clients() {
let fx = fixture();
let d = detected(&fx.host);
for id in ["claude_code", "codex", "hermes", "cursor"] {
assert!(d.contains(&id), "{id}");
}
assert!(!d.contains(&"windsurf"));
}
#[test]
fn full_setup_preserves_comments_backs_up_and_is_idempotent() {
let fx = fixture();
let h = &fx.host.home;
let p = plan(&fx.host, &req(&fx, &[])).unwrap();
assert!(!p.blocked);
let kinds: Vec<(String, ActionKind)> = p.actions.iter().map(|a| (a.client.clone(), a.action)).collect();
assert!(kinds.contains(&("cursor".into(), ActionKind::Create)));
assert!(kinds.contains(&("codex".into(), ActionKind::Update)));
assert!(p.actions.iter().find(|a| a.client == "codex").unwrap().preview.contains("+ "));
// planning writes nothing
assert_eq!(read(h.join(".codex/config.toml")), CODEX);
let r = apply(&p);
assert_eq!(r.status, "configured", "{r:?}");
let claude = read(h.join(".claude.json"));
assert!(claude.contains("// Claude Code state") && claude.contains("/* keep */") && claude.contains("// theirs"));
let codex = read(h.join(".codex/config.toml"));
assert!(codex.contains("# chosen") && codex.contains("# theirs") && codex.contains("startup_timeout_sec = 30"));
let hermes = read(h.join(".hermes/config.yaml"));
assert!(hermes.contains("# friend") && hermes.contains("enabled: true"));
assert!(h.join(".cursor/mcp.json").exists());
// backups hold the originals; created files get none
assert_eq!(read(h.join(".codex/config.toml.craft-anything.backup")), CODEX);
assert!(!h.join(".cursor/mcp.json.craft-anything.backup").exists());
// skill landed in the shared folder and Claude Code's own
assert!(h.join(".agents/skills/craft-anything/SKILL.md").exists());
assert!(h.join(".claude/skills/craft-anything/SKILL.md").exists());
assert!(h.join(".hermes/skills/craft-anything/SKILL.md").exists());
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt as _;
assert_eq!(std::fs::metadata(h.join(".codex/config.toml")).unwrap().permissions().mode() & 0o777, 0o600);
}
// Second run: nothing to do.
let p2 = plan(&fx.host, &req(&fx, &[])).unwrap();
assert_eq!(p2.change_count(), 0, "{:?}", p2.actions.iter().map(|a| (&a.client, a.action)).collect::<Vec<_>>());
assert_eq!(apply(&p2).status, "unchanged");
// With no scope, setup refreshes exactly the apps we already own.
let refresh = plan(&fx.host, &PlanRequest { clients: vec![], all_detected: false, ..req(&fx, &[]) }).unwrap();
assert_eq!(refresh.actions.len(), 4);
// A new command updates; the first backup is never overwritten.
let mut moved = req(&fx, &["codex"]);
moved.command = vec!["/opt/new/craft-anything-cli".into(), "mcp".into()];
let r = apply(&plan(&fx.host, &moved).unwrap());
assert_eq!(r.status, "configured");
assert_eq!(read(h.join(".codex/config.toml.craft-anything.backup")), CODEX);
// Doctor sees the aligned registrations and the stale one.
let rep = doctor(&fx.host, &DoctorRequest { cli_path: Some(fx.cli.clone()), self_test: false, engines: false, ..Default::default() });
let get = |n: &str| rep.checks.iter().find(|c| c.name == n).unwrap().status;
assert_eq!(get("registration:claude_code"), CheckStatus::Ok);
assert_eq!(get("registration:codex"), CheckStatus::Fail); // points at a missing binary
assert!(!rep.healthy);
// Uninstall removes only ours and keeps comments and the other servers.
let u = uninstall(&fx.host);
assert_eq!(u.status, "removed", "{u:?}");
let claude = read(h.join(".claude.json"));
assert!(claude.contains("// theirs") && claude.contains("other-server") && !claude.contains("craft-anything-cli"));
let codex = read(h.join(".codex/config.toml"));
assert!(codex.contains("# theirs") && !codex.contains("craft-anything-cli"));
let hermes = read(h.join(".hermes/config.yaml"));
assert_eq!(hermes, HERMES);
assert!(!h.join(".agents/skills/craft-anything/SKILL.md").exists());
assert_eq!(uninstall(&fx.host).status, "nothing_to_remove");
}
#[test]
fn malformed_config_blocks_plan_and_uninstall() {
let fx = fixture();
let h = &fx.host.home;
assert_eq!(apply(&plan(&fx.host, &req(&fx, &["cursor"])).unwrap()).status, "configured");
std::fs::write(h.join(".codex/config.toml"), "model = [broken").unwrap();
let p = plan(&fx.host, &req(&fx, &["codex", "claude_code"])).unwrap();
assert!(p.blocked);
assert_eq!(p.actions.iter().find(|a| a.client == "codex").unwrap().action, ActionKind::Invalid);
let r = apply(&p);
assert_eq!(r.status, "blocked");
assert_eq!(read(h.join(".claude.json")), CLAUDE);
let u = uninstall(&fx.host);
assert_eq!(u.status, "blocked");
assert!(read(h.join(".cursor/mcp.json")).contains("craft-anything-cli"));
}
/// #238: Pi's folder exists but its mcp.json doesn't yet; setup creates it. An empty file is
/// still refused.
#[test]
fn pi_config_is_created_when_missing() {
let fx = fixture();
let pi = fx.host.home.join(".pi/agent/mcp.json");
std::fs::create_dir_all(pi.parent().unwrap()).unwrap();
let p = plan(&fx.host, &req(&fx, &["pi"])).unwrap();
assert!(!p.blocked, "{p:?}");
assert_eq!(apply(&p).status, "configured");
let v: serde_json::Value = serde_json::from_str(&read(&pi)).unwrap();
assert_eq!(v["mcpServers"]["craft-anything"]["args"][0], "mcp");
std::fs::write(&pi, "").unwrap();
assert!(plan(&fx.host, &req(&fx, &["pi"])).unwrap().blocked);
}
#[test]
fn strict_json_client_rejects_comments() {
let fx = fixture();
let pi = fx.host.home.join(".pi/agent/mcp.json");
std::fs::create_dir_all(pi.parent().unwrap()).unwrap();
std::fs::write(&pi, "{ // nope\n}").unwrap();
let p = plan(&fx.host, &req(&fx, &["pi"])).unwrap();
assert!(p.blocked);
std::fs::write(&pi, "{\"mcpServers\": {}}").unwrap();
let p = plan(&fx.host, &req(&fx, &["pi"])).unwrap();
assert!(!p.blocked);
assert_eq!(apply(&p).status, "configured");
let v: serde_json::Value = serde_json::from_str(&read(&pi)).unwrap();
assert_eq!(v["mcpServers"]["craft-anything"]["type"], "stdio");
}
#[test]
fn failed_readback_rolls_everything_back() {
let fx = fixture();
let h = &fx.host.home;
let p = plan(&fx.host, &req(&fx, &["claude_code", "cursor", "codex"])).unwrap();
// Writes "succeed" but the third file's content is wrong, so its read-back fails.
let calls = std::cell::Cell::new(0);
let bad = |path: &Path, b: &[u8]| -> Result<(), ToolError> {
calls.set(calls.get() + 1);
if calls.get() == 3 { craft_anything_platform::write_atomic(path, b"[mcp_servers]\n") } else { craft_anything_platform::write_atomic(path, b) }
};
let r = apply_with(&p, &bad);
assert_eq!(r.status, "failed");
assert_eq!(read(h.join(".claude.json")), CLAUDE);
assert_eq!(read(h.join(".codex/config.toml")), CODEX);
assert!(!h.join(".cursor/mcp.json").exists(), "created file must be removed");
assert!(r.results.iter().any(|x| x.outcome == Outcome::RolledBack));
assert!(r.results.iter().any(|x| x.outcome == Outcome::Failed));
}
#[test]
fn file_changed_after_plan_is_refused() {
let fx = fixture();
let p = plan(&fx.host, &req(&fx, &["codex"])).unwrap();
std::fs::write(fx.host.home.join(".codex/config.toml"), "# edited meanwhile\n").unwrap();
let r = apply(&p);
assert_eq!(r.status, "failed");
assert_eq!(read(fx.host.home.join(".codex/config.toml")), "# edited meanwhile\n");
}
#[test]
fn unknown_client_and_manual_client() {
let fx = fixture();
let e = plan(&fx.host, &req(&fx, &["nope"])).unwrap_err();
assert!(e.remediation.unwrap().contains("claude_code"));
let p = plan(&fx.host, &req(&fx, &["dsh"])).unwrap();
assert_eq!(p.actions[0].action, ActionKind::Manual);
assert!(p.actions[0].remediation.is_some());
assert!(!p.blocked);
let p = plan(&fx.host, &req(&fx, &["claude-code"])).unwrap();
assert_eq!(p.actions[0].client, "claude_code");
}
#[test]
fn foreign_entry_with_our_name_is_replaced_but_not_uninstalled() {
let fx = fixture();
let cursor = fx.host.home.join(".cursor/mcp.json");
std::fs::write(&cursor, "{\"mcpServers\": {\"craft-anything\": {\"command\": \"npx\", \"args\": [\"something\"]}}}").unwrap();
assert_eq!(uninstall(&fx.host).status, "nothing_to_remove");
let p = plan(&fx.host, &req(&fx, &["cursor"])).unwrap();
assert!(p.actions[0].reason.as_deref().unwrap_or_default().contains("replaced"));
}
#[test]
fn setup_keeps_a_crlf_config_crlf_and_a_second_run_changes_nothing() {
let fx = fixture();
let path = fx.host.home.join(".hermes/config.yaml");
let crlf = HERMES.replace('\n', "\r\n");
std::fs::write(&path, &crlf).unwrap();
let r = req(&fx, &["hermes"]);
assert_eq!(apply(&plan(&fx.host, &r).unwrap()).status, "configured");
let after = read(&path);
assert_eq!(after.matches('\n').count(), after.matches("\r\n").count(), "{after:?}");
assert!(after.starts_with(&crlf), "the person's own lines are byte-identical: {after:?}");
assert!(after.contains("craft-anything:\r\n"), "{after:?}");
assert_eq!(plan(&fx.host, &r).unwrap().change_count(), 0);
// A second run leaves the file byte for byte as it was.
apply(&plan(&fx.host, &r).unwrap());
assert_eq!(read(&path), after);
// An LF file stays LF.
std::fs::write(&path, HERMES).unwrap();
assert_eq!(apply(&plan(&fx.host, &r).unwrap()).status, "configured");
assert!(!read(&path).contains('\r'));
}
/// Repeated ids and aliases produce one write per client and an idempotent installation.
#[test]
fn repeated_client_ids_are_applied_once() {
let fx = fixture();
let request = req(&fx, &["claude_code", "claude-code", "codex", "claude_code"]);
let plan = plan(&fx.host, &request).unwrap();
assert_eq!(plan.actions.len(), 2);
assert_eq!(plan.actions[0].client, "claude_code");
assert_eq!(plan.actions[1].client, "codex");
let report = apply(&plan);
assert_eq!(report.status, "configured", "{report:?}");
assert_eq!(report.results.len(), 2);
assert!(report.results.iter().all(|r| r.outcome == Outcome::Configured));
assert_eq!(apply(&crate::plan::plan(&fx.host, &request).unwrap()).status, "unchanged");
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.