use crate::common::{run_rsconstruct_with_env, setup_project_with_config, setup_test_project};
use serde_json::Value;
#[test]
fn tools_list_shows_all_registry_tools() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let output = run_rsconstruct_with_env(project_path, &["tool", "list"], &[("NO_COLOR", "1")]);
assert!(
output.status.success(),
"tool list failed: {}",
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(
!stdout.is_empty(),
"tool list should show at least one tool"
);
assert!(
stdout.contains("clojure"),
"registry list should include all known tools, e.g. clojure"
);
let row = |tool: &str| {
stdout
.lines()
.find(|l| l.split('│').nth(1).is_some_and(|c| c.trim() == tool))
.unwrap_or_else(|| panic!("no row for {tool}:\n{stdout}"))
.to_string()
};
assert!(row("ruff").contains("checker.ruff"), "{}", row("ruff"));
assert!(
row("gcc").contains("generator.cc_single_file, +1 more"),
"{}",
row("gcc")
);
assert!(row("clojure").contains("(none)"), "{}", row("clojure"));
assert!(row("python3").contains(" more"), "{}", row("python3"));
}
#[test]
fn tools_list_json_names_each_tools_processors() {
let temp_dir = setup_test_project();
let output = run_rsconstruct_with_env(temp_dir.path(), &["--json", "tool", "list"], &[]);
assert!(
output.status.success(),
"tool list --json failed: {}",
String::from_utf8_lossy(&output.stderr)
);
let entries: Vec<Value> = serde_json::from_slice(&output.stdout).unwrap();
let processors = |tool: &str| -> Vec<String> {
let entry = entries
.iter()
.find(|e| e["tool"] == tool)
.unwrap_or_else(|| panic!("no entry for {tool}"));
entry["processor"]
.as_array()
.unwrap()
.iter()
.map(|p| p.as_str().unwrap().to_string())
.collect()
};
assert_eq!(processors("ruff"), ["processor.checker.ruff"]);
assert!(processors("clojure").is_empty());
}
#[test]
fn tools_list_json_names_install_targets() {
let temp_dir = setup_test_project();
let output = run_rsconstruct_with_env(temp_dir.path(), &["--json", "tool", "list"], &[]);
assert!(
output.status.success(),
"tool list --json failed: {}",
String::from_utf8_lossy(&output.stderr)
);
let entries: Vec<Value> = serde_json::from_slice(&output.stdout).unwrap();
let entry = |tool: &str| -> &Value {
entries
.iter()
.find(|e| e["tool"] == tool)
.unwrap_or_else(|| panic!("no entry for {tool}"))
};
let method = |tool: &str, name: &str| -> &Value {
entry(tool)["install_methods"]
.as_array()
.unwrap()
.iter()
.find(|m| m["method"] == name)
.unwrap_or_else(|| panic!("{tool} has no {name} method"))
};
assert_eq!(entry("ruff")["preferred"], "project");
assert_eq!(
method("ruff", "pip")["slots"],
serde_json::json!(["project", "machine"])
);
assert_eq!(
method("ruff", "pip")["targets"],
serde_json::json!(["project", "machine"])
);
assert_eq!(entry("drawio")["preferred"], "machine");
assert_eq!(
method("drawio", "binary")["targets"],
serde_json::json!(["machine"])
);
assert_eq!(entry("clojure")["preferred"], "machine");
assert_eq!(method("clojure", "brew")["slots"], serde_json::json!([]));
}
#[test]
fn tools_list_shows_configured_tools() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let output = run_rsconstruct_with_env(
project_path,
&["tool", "list-configured"],
&[("NO_COLOR", "1")],
);
assert!(
output.status.success(),
"tool list-configured failed: {}",
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(
!stdout.is_empty(),
"tool list-configured should show at least one tool"
);
assert!(
stdout.contains("("),
"Expected processor name in parentheses for each tool"
);
}
const TERA_AND_DISABLED_RUFF: &str = "[processor.generator.tera]\nsrc_dirs = [\"tera.templates\"]\n\n[processor.checker.ruff]\nsrc_dirs = [\"src\"]\nenabled = false\n";
#[test]
fn tools_list_configured_hides_disabled_processors_unless_all() {
let temp_dir = setup_project_with_config(TERA_AND_DISABLED_RUFF);
let project_path = temp_dir.path();
std::fs::create_dir_all(project_path.join("tera.templates")).unwrap();
let output_default = run_rsconstruct_with_env(
project_path,
&["tool", "list-configured"],
&[("NO_COLOR", "1")],
);
let output_all = run_rsconstruct_with_env(
project_path,
&["tool", "list-configured", "-a"],
&[("NO_COLOR", "1")],
);
assert!(output_default.status.success());
assert!(output_all.status.success());
let stdout_default = String::from_utf8_lossy(&output_default.stdout);
let stdout_all = String::from_utf8_lossy(&output_all.stdout);
assert!(
!stdout_default.contains("ruff"),
"a disabled processor's tool was listed without --all: {stdout_default}"
);
assert!(
stdout_all.contains("ruff") && stdout_all.contains("processor.checker.ruff"),
"--all must list the disabled processor's tool: {stdout_all}"
);
let json_default = run_rsconstruct_with_env(
project_path,
&["--json", "tool", "list-configured"],
&[("NO_COLOR", "1")],
);
let entries: Vec<Value> = serde_json::from_slice(&json_default.stdout).unwrap();
assert!(!entries.iter().any(|e| e["tool"] == "ruff"), "{entries:?}");
let json_all = run_rsconstruct_with_env(
project_path,
&["--json", "tool", "list-configured", "--all"],
&[("NO_COLOR", "1")],
);
let entries: Vec<Value> = serde_json::from_slice(&json_all.stdout).unwrap();
assert!(entries.iter().any(|e| e["tool"] == "ruff"), "{entries:?}");
}
#[test]
fn tool_lock_and_check_skip_disabled_processors() {
let temp_dir = setup_project_with_config(TERA_AND_DISABLED_RUFF);
let project_path = temp_dir.path();
std::fs::create_dir_all(project_path.join("tera.templates")).unwrap();
let output = run_rsconstruct_with_env(project_path, &["tool", "lock"], &[("NO_COLOR", "1")]);
assert!(
output.status.success(),
"tool lock failed: {}",
String::from_utf8_lossy(&output.stderr)
);
let lock = std::fs::read_to_string(project_path.join("rsconstruct.lock")).unwrap();
assert!(
!lock.contains("ruff"),
"the lock gained an entry for a disabled processor's tool:\n{lock}"
);
let output = run_rsconstruct_with_env(
project_path,
&["tool", "check"],
&[("NO_COLOR", "1"), ("CI", "true")],
);
assert!(
output.status.success(),
"tool check asked for a disabled processor's tool: {}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn ci_build_checks_the_lock_for_the_processors_that_build_only() {
let temp_dir = setup_project_with_config(TERA_AND_DISABLED_RUFF);
let project_path = temp_dir.path();
std::fs::create_dir_all(project_path.join("tera.templates")).unwrap();
std::fs::create_dir_all(project_path.join("src")).unwrap();
std::fs::write(project_path.join("src/a.py"), "x = 1\n").unwrap();
let lock = "version = 1\n";
std::fs::write(project_path.join("rsconstruct.lock"), lock).unwrap();
let ci = &[("NO_COLOR", "1"), ("CI", "true")];
let output = run_rsconstruct_with_env(project_path, &["build"], ci);
assert!(
output.status.success(),
"CI build asked for a disabled processor's tool: {}",
String::from_utf8_lossy(&output.stderr)
);
let enabled = TERA_AND_DISABLED_RUFF.replace("enabled = false", "enabled = true");
std::fs::write(project_path.join("rsconstruct.toml"), &enabled).unwrap();
let output = run_rsconstruct_with_env(project_path, &["build"], ci);
assert!(
!output.status.success(),
"an enabled processor with an unlocked tool passed the CI build"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(stderr.contains("ruff"), "{stderr}");
let output =
run_rsconstruct_with_env(project_path, &["build", "-x", "processor.checker.ruff"], ci);
assert!(
output.status.success(),
"CI build asked for an excluded processor's tool: {}",
String::from_utf8_lossy(&output.stderr)
);
std::fs::remove_file(project_path.join("src/a.py")).unwrap();
let output = run_rsconstruct_with_env(project_path, &["build"], ci);
assert!(
output.status.success(),
"CI build asked for the tool of a processor with no products: {}",
String::from_utf8_lossy(&output.stderr)
);
let after = std::fs::read_to_string(project_path.join("rsconstruct.lock")).unwrap();
assert_eq!(after, lock, "CI must not rewrite the lock");
}
#[test]
fn tools_list_json() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let output = run_rsconstruct_with_env(
project_path,
&["--json", "tool", "list"],
&[("NO_COLOR", "1")],
);
assert!(
output.status.success(),
"tool list --json failed: {}",
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout);
let entries: Vec<serde_json::Value> =
serde_json::from_str(&stdout).expect("Expected valid JSON array");
for entry in &entries {
assert!(
entry.get("tool").is_some(),
"Entry should have 'tool' field"
);
assert!(
entry.get("processor").is_some(),
"Entry should have 'processor' field"
);
assert!(
entry["processor"].is_array(),
"'processor' should be an array"
);
}
}
#[test]
fn tools_check_succeeds() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let lock_output =
run_rsconstruct_with_env(project_path, &["tool", "lock"], &[("NO_COLOR", "1")]);
assert!(
lock_output.status.success(),
"tool lock failed: {}",
String::from_utf8_lossy(&lock_output.stderr)
);
let output = run_rsconstruct_with_env(project_path, &["tool", "check"], &[("NO_COLOR", "1")]);
assert!(
output.status.success(),
"tool check failed: {}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn tool_lock_writes_rsconstruct_lock_once() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let first = run_rsconstruct_with_env(project_path, &["tool", "lock"], &[("NO_COLOR", "1")]);
assert!(
first.status.success(),
"tool lock failed: {}",
String::from_utf8_lossy(&first.stderr)
);
let stdout = String::from_utf8_lossy(&first.stdout);
assert!(stdout.contains("Created rsconstruct.lock"), "{stdout}");
let lock = std::fs::read_to_string(project_path.join("rsconstruct.lock")).unwrap();
assert!(lock.contains("version = 1\n"), "{lock}");
assert!(!lock.contains("[rsconstruct]"), "{lock}");
let second = run_rsconstruct_with_env(project_path, &["tool", "lock"], &[("NO_COLOR", "1")]);
assert!(second.status.success());
let stdout = String::from_utf8_lossy(&second.stdout);
assert!(stdout.contains("up to date"), "{stdout}");
let again = std::fs::read_to_string(project_path.join("rsconstruct.lock")).unwrap();
assert_eq!(lock, again);
}
#[test]
fn ci_build_requires_the_lock() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let output = run_rsconstruct_with_env(
project_path,
&["build"],
&[("NO_COLOR", "1"), ("CI", "true")],
);
assert!(
!output.status.success(),
"build without a lock passed in CI"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(stderr.contains("No rsconstruct.lock found"), "{stderr}");
let lock = run_rsconstruct_with_env(project_path, &["tool", "lock"], &[("NO_COLOR", "1")]);
assert!(lock.status.success());
let output = run_rsconstruct_with_env(
project_path,
&["build"],
&[("NO_COLOR", "1"), ("CI", "true")],
);
assert!(
output.status.success(),
"CI build with a lock failed: {}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn legacy_rsconstruct_table_is_accepted_and_dropped_on_rewrite() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let lock = "version = 1\n\n[rsconstruct]\nversion = \"0.0.1\"\n";
std::fs::write(project_path.join("rsconstruct.lock"), lock).unwrap();
for args in [
&["tool", "install", "project"][..],
&["tool", "check"],
&["build"],
] {
let output =
run_rsconstruct_with_env(project_path, args, &[("NO_COLOR", "1"), ("CI", "true")]);
assert!(
output.status.success(),
"{args:?} failed in CI: {}",
String::from_utf8_lossy(&output.stderr)
);
}
let after = std::fs::read_to_string(project_path.join("rsconstruct.lock")).unwrap();
assert_eq!(after, lock, "CI must not rewrite the lock");
let output = run_rsconstruct_with_env(project_path, &["tool", "lock"], &[("NO_COLOR", "1")]);
assert!(
output.status.success(),
"{}",
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(stdout.contains("- rsconstruct 0.0.1"), "{stdout}");
assert!(stdout.contains("Updated rsconstruct.lock"), "{stdout}");
let rewritten = std::fs::read_to_string(project_path.join("rsconstruct.lock")).unwrap();
assert!(!rewritten.contains("[rsconstruct]"), "{rewritten}");
}
#[test]
fn ci_rejects_a_lock_that_does_not_match() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let stale = "version = 1\n\n[cargo]\ncargo-unused = \"1.0.0\"\n";
std::fs::write(project_path.join("rsconstruct.lock"), stale).unwrap();
let output = run_rsconstruct_with_env(
project_path,
&["tool", "install", "project"],
&[("NO_COLOR", "1"), ("CI", "true")],
);
assert!(
!output.status.success(),
"tool install project accepted a stale lock in CI"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(stderr.contains("cargo cargo-unused"), "{stderr}");
let after = std::fs::read_to_string(project_path.join("rsconstruct.lock")).unwrap();
assert_eq!(after, stale, "CI must not rewrite the lock");
let output = run_rsconstruct_with_env(project_path, &["tool", "lock"], &[("NO_COLOR", "1")]);
assert!(output.status.success());
let repaired = std::fs::read_to_string(project_path.join("rsconstruct.lock")).unwrap();
assert!(!repaired.contains("cargo-unused"), "{repaired}");
}
#[test]
fn tool_lock_upgrade_named_rejects_names_the_project_does_not_lock() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let old = "version = 1\n";
std::fs::write(project_path.join("rsconstruct.lock"), old).unwrap();
for name in ["nosuch", "rsconstruct"] {
let output = run_rsconstruct_with_env(
project_path,
&["tool", "lock", "--upgrade", name],
&[("NO_COLOR", "1")],
);
assert!(!output.status.success(), "{name} was accepted");
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains(&format!("not a tool this project locks: {name}")),
"{stderr}"
);
let unchanged = std::fs::read_to_string(project_path.join("rsconstruct.lock")).unwrap();
assert_eq!(unchanged, old);
}
}
#[test]
fn legacy_tools_versions_is_rejected() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
std::fs::write(project_path.join(".tools.versions"), "{}").unwrap();
let output = run_rsconstruct_with_env(project_path, &["tool", "lock"], &[("NO_COLOR", "1")]);
assert!(!output.status.success());
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(stderr.contains("Delete .tools.versions"), "{stderr}");
}
#[test]
fn tools_stats_shows_summary() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let output = run_rsconstruct_with_env(project_path, &["tool", "stats"], &[("NO_COLOR", "1")]);
assert!(
output.status.success(),
"tool stats failed: {}",
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(stdout.contains("Tool"), "Expected 'Tool' table header");
assert!(
stdout.contains("Runtime summary:"),
"Expected 'Runtime summary:' section"
);
assert!(stdout.contains("Total:"), "Expected 'Total:' summary line");
assert!(stdout.contains("installed"), "Expected 'installed' count");
}
#[test]
fn tools_stats_json() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let output = run_rsconstruct_with_env(
project_path,
&["--json", "tool", "stats"],
&[("NO_COLOR", "1")],
);
assert!(
output.status.success(),
"tool stats --json failed: {}",
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout);
let parsed: Value = serde_json::from_str(&stdout).expect("Expected valid JSON");
assert!(parsed.get("tools").is_some(), "Expected 'tools' field");
assert!(
parsed.get("runtimes").is_some(),
"Expected 'runtimes' field"
);
assert!(parsed.get("summary").is_some(), "Expected 'summary' field");
let tools = parsed["tools"]
.as_array()
.expect("'tools' should be an array");
assert!(!tools.is_empty(), "tools array should not be empty");
for tool in tools {
assert!(tool.get("name").is_some(), "Tool entry should have 'name'");
assert!(
tool.get("installed").is_some(),
"Tool entry should have 'installed'"
);
assert!(
tool.get("runtime").is_some(),
"Tool entry should have 'runtime'"
);
assert!(
tool.get("processor").is_some(),
"Tool entry should have 'processors'"
);
}
let runtimes = parsed["runtimes"]
.as_array()
.expect("'runtimes' should be an array");
for rt in runtimes {
assert!(
rt.get("runtime").is_some(),
"Runtime entry should have 'runtime'"
);
assert!(
rt.get("total").is_some(),
"Runtime entry should have 'total'"
);
assert!(
rt.get("installed").is_some(),
"Runtime entry should have 'installed'"
);
assert!(
rt.get("missing").is_some(),
"Runtime entry should have 'missing'"
);
}
let summary = &parsed["summary"];
assert!(
summary.get("total_tools").is_some(),
"Summary should have 'total_tools'"
);
assert!(
summary.get("installed").is_some(),
"Summary should have 'installed'"
);
assert!(
summary.get("missing").is_some(),
"Summary should have 'missing'"
);
let total_tools = summary["total_tools"].as_u64().unwrap();
assert_eq!(
total_tools as usize,
tools.len(),
"summary.total_tools should match tools array length"
);
let installed = summary["installed"].as_u64().unwrap();
let missing = summary["missing"].as_u64().unwrap();
assert_eq!(
installed + missing,
total_tools,
"installed + missing should equal total_tools"
);
}
#[test]
fn tools_list_uses_only_implemented_install_methods() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let output = run_rsconstruct_with_env(
project_path,
&["--json", "tool", "list"],
&[("NO_COLOR", "1")],
);
assert!(
output.status.success(),
"tool list --json failed: {}",
String::from_utf8_lossy(&output.stderr)
);
const IMPLEMENTED: &[&str] = &[
"apt",
"dnf",
"pacman",
"brew",
"snap",
"pip",
"npm",
"npm-ci",
"npm-install",
"cargo",
"gem",
"binary",
"manual",
];
let parsed: Value =
serde_json::from_slice(&output.stdout).expect("tool list --json should emit valid JSON");
let tools = parsed
.as_array()
.expect("tool list --json should be an array");
assert!(!tools.is_empty(), "registry should not be empty");
for tool in tools {
let name = tool["tool"].as_str().unwrap_or("<unnamed>");
let methods = tool["install_methods"]
.as_array()
.expect("tool should have install_methods");
assert!(
!methods.is_empty(),
"tool '{name}' has no install method at all"
);
for m in methods {
let method = m["method"]
.as_str()
.expect("install method should have a 'method' string");
assert!(
IMPLEMENTED.contains(&method),
"tool '{name}' declares install method '{method}', which tools::run() does not implement",
);
}
}
}
#[test]
fn tools_list_names_are_bare_binaries_not_paths() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let output = run_rsconstruct_with_env(
project_path,
&["--json", "tool", "list"],
&[("NO_COLOR", "1")],
);
assert!(
output.status.success(),
"tool list --json failed: {}",
String::from_utf8_lossy(&output.stderr)
);
let parsed: Value =
serde_json::from_slice(&output.stdout).expect("tool list --json should emit valid JSON");
let tools = parsed
.as_array()
.expect("tool list --json should be an array");
assert!(!tools.is_empty(), "registry should not be empty");
for tool in tools {
let name = tool["tool"]
.as_str()
.expect("tool should have a 'tool' name string");
assert!(
!name.contains('/'),
"tool '{name}' is a path, not a bare binary name; which() would resolve it \
relative to the cwd and report it missing from anywhere else. Use the bare \
binary name here and put the vendored path in the processor's `command` config.",
);
}
}
#[test]
fn tools_install_machine_all_covers_every_entry() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let output = run_rsconstruct_with_env(
project_path,
&["--json", "tool", "list"],
&[("NO_COLOR", "1")],
);
assert!(
output.status.success(),
"tool list --json failed: {}",
String::from_utf8_lossy(&output.stderr)
);
let parsed: Value =
serde_json::from_slice(&output.stdout).expect("tool list --json should emit valid JSON");
let no_machine: Vec<&str> = parsed
.as_array()
.expect("array")
.iter()
.filter(|tool| {
!tool["install_methods"].as_array().is_some_and(|ms| {
ms.iter().any(|m| {
m["slots"]
.as_array()
.is_some_and(|s| s.iter().any(|t| t == "machine"))
})
})
})
.map(|tool| tool["tool"].as_str().unwrap_or("<unnamed>"))
.collect();
assert!(
no_machine.is_empty(),
"these tools have no machine install, so `tool install machine --all` cannot provision them: {no_machine:?}",
);
}
#[test]
fn tools_install_bare_lists_its_targets() {
let temp_dir = setup_test_project();
let output =
run_rsconstruct_with_env(temp_dir.path(), &["tool", "install"], &[("NO_COLOR", "1")]);
assert!(
!output.status.success(),
"bare `tool install` should not install"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(stderr.contains("machine"), "{stderr}");
assert!(stderr.contains("project"), "{stderr}");
assert!(
!stderr.contains("--interactive"),
"flags belong to --help: {stderr}"
);
}
#[test]
fn tools_install_project_name_follows_the_project_slot() {
let temp_dir = setup_test_project();
let root = temp_dir.path();
let output = run_rsconstruct_with_env(root, &["tool", "install", "project", "drawio"], &[]);
assert!(!output.status.success());
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("tool install machine drawio"),
"a tool with no project install should point at the machine: {stderr}"
);
let output = run_rsconstruct_with_env(root, &["tool", "install", "project", "ruff"], &[]);
assert!(!output.status.success());
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("uv add --dev ruff"),
"a Python tool uv.lock does not pin should say how to pin it: {stderr}"
);
}
#[test]
fn tools_install_all_conflicts_with_tool_name() {
let temp_dir = setup_test_project();
let project_path = temp_dir.path();
let output = run_rsconstruct_with_env(
project_path,
&["tool", "install", "machine", "--all", "ruff"],
&[("NO_COLOR", "1")],
);
assert!(
!output.status.success(),
"`tool install machine --all ruff` should be rejected"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("cannot be used with"),
"expected a clap conflict error, got: {stderr}",
);
}
#[test]
fn locked_tools_are_installed_into_the_project_from_the_store() {
let project = setup_project_with_config("[processor.checker.rumdl]\nsrc_dirs = [\"docs\"]\n");
let root = project.path();
std::fs::create_dir_all(root.join("docs")).unwrap();
std::fs::write(root.join("docs/a.md"), "# A\n").unwrap();
let lock = |exe_sha: &str| {
format!(
"version = 1\n\n[binary.rumdl]\nurl = \"https://example.invalid/rumdl.tar.gz\"\n\
sha256 = \"aa\"\nexecutable_sha256 = \"{exe_sha}\"\n"
)
};
std::fs::write(root.join("rsconstruct.lock"), lock("feed")).unwrap();
let scratch = tempfile::TempDir::new().unwrap();
let store = scratch.path().join("store");
let ran = scratch.path().join("ran");
let stored = store.join("binary/rumdl@sha256-feed/bin/rumdl");
std::fs::create_dir_all(stored.parent().unwrap()).unwrap();
std::fs::write(
&stored,
format!("#!/bin/sh\necho \"$@\" >> {}\n", ran.display()),
)
.unwrap();
crate::common::make_executable(&stored);
let store_env = store.to_str().unwrap();
let run = |args: &[&str], ci: bool| {
let mut env = vec![("NO_COLOR", "1"), ("RSCONSTRUCT_TOOL_STORE", store_env)];
if ci {
env.push(("CI", "true"));
}
run_rsconstruct_with_env(root, args, &env)
};
let ok = |out: &std::process::Output, what: &str| {
assert!(
out.status.success(),
"{what} failed:\n{}\n{}",
String::from_utf8_lossy(&out.stdout),
String::from_utf8_lossy(&out.stderr)
);
};
let out = run(&["tool", "install", "project"], false);
ok(&out, "tool install project");
let stdout = String::from_utf8_lossy(&out.stdout);
assert!(
stdout.contains("binary rumdl sha256-feed (linked from the tool store)"),
"{stdout}"
);
let linked = root.join(".rsconstruct/tools/bin/rumdl");
let ino =
|p: &std::path::Path| std::os::unix::fs::MetadataExt::ino(&std::fs::metadata(p).unwrap());
assert_eq!(
ino(&linked),
ino(&stored),
"the project's copy is not a hard link"
);
ok(&run(&["tool", "check"], false), "tool check");
ok(&run(&["build"], true), "CI build");
let calls = std::fs::read_to_string(&ran).expect("the project's rumdl never ran");
assert!(calls.contains("a.md"), "{calls}");
ok(&run(&["cache", "clear"], false), "cache clear");
assert!(linked.exists(), "cache clear removed the project's tools");
ok(
&run(&["tool", "check"], false),
"tool check after cache clear",
);
std::fs::write(root.join("rsconstruct.lock"), lock("beef")).unwrap();
let out = run(&["tool", "check"], false);
assert!(!out.status.success(), "tool check accepted a drifted tool");
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(
stderr.contains("binary rumdl — locked sha256-beef, installed sha256-feed"),
"{stderr}"
);
}