use std::path::Path;
use std::process::Command;
mod common;
fn tempdir(name: &str) -> common::TempDir {
common::tempdir("htl-cli-pin", name)
}
fn htl(args: &[&str], cwd: &Path) -> (Option<i32>, String, String) {
let out = Command::new(common::htl_bin())
.args(args)
.current_dir(cwd)
.output()
.unwrap();
(
out.status.code(),
String::from_utf8_lossy(&out.stdout).into_owned(),
String::from_utf8_lossy(&out.stderr).into_owned(),
)
}
fn htl_line(manifest: &Path) -> String {
dep_line(manifest, "htl")
}
fn dep_line(manifest: &Path, name: &str) -> String {
let cargo = std::fs::read_to_string(manifest).unwrap();
cargo
.lines()
.find(|l| l.starts_with(&format!("{name} = ")))
.unwrap_or_else(|| panic!("no {name} dependency in:\n{cargo}"))
.to_string()
}
fn loose_dep_line<'a>(text: &'a str, name: &str) -> &'a str {
text.lines()
.find(|l| {
let t = l.trim_start();
let t = t.strip_prefix('"').unwrap_or(t);
let Some(rest) = t.strip_prefix(name) else {
return false;
};
let rest = rest.strip_prefix('"').unwrap_or(rest);
rest.trim_start().starts_with('=')
})
.unwrap_or_else(|| panic!("no {name} dependency in:\n{text}"))
}
fn checkout_path() -> String {
std::fs::canonicalize(Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."))
.unwrap()
.display()
.to_string()
.replace('\\', "/")
}
#[test]
fn pin_path_rewrites_a_release_or_checkout_pin_and_removes_mise_toml() {
let root = tempdir("path");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin", "--htl", "release"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
let manifest = dir.join("Cargo.toml");
assert!(
dir.join("mise.toml").is_file(),
"a release pin writes mise.toml"
);
let before = std::fs::read_to_string(&manifest).unwrap();
assert_eq!(
htl_line(&manifest),
format!(
"htl = {{ version = \"{}\", features = [\"async\"] }}",
env!("CARGO_PKG_VERSION")
)
);
let checkout = checkout_path();
let (code, _, stderr) = htl(&["pin", &format!("path:{checkout}"), "--no-update"], &dir);
assert_eq!(code, Some(0), "{stderr}");
assert_eq!(
htl_line(&manifest),
format!("htl = {{ path = \"{checkout}/crates/htl\", features = [\"async\"] }}")
);
assert!(!dir.join("mise.toml").exists(), "{stderr}");
let after = std::fs::read_to_string(&manifest).unwrap();
let keep = |l: &&str| !l.starts_with("htl = ") && !l.starts_with("htl-std = ");
assert_eq!(
before.lines().filter(keep).collect::<Vec<_>>(),
after.lines().filter(keep).collect::<Vec<_>>(),
"before:\n{before}\nafter:\n{after}"
);
}
#[test]
fn pin_release_writes_the_clis_version_and_mise_toml_back() {
let root = tempdir("release");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin", "--htl", "main"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
assert!(!dir.join("mise.toml").exists(), "{stderr}");
let (code, _, stderr) = htl(&["pin", "release", "--no-update"], &dir);
assert_eq!(code, Some(0), "{stderr}");
assert_eq!(
htl_line(&dir.join("Cargo.toml")),
format!(
"htl = {{ version = \"{}\", features = [\"async\"] }}",
env!("CARGO_PKG_VERSION")
)
);
let mise = std::fs::read_to_string(dir.join("mise.toml")).unwrap();
assert!(
mise.ends_with(&format!(
"\"cargo:htl-cli\" = \"{}\"\n",
env!("CARGO_PKG_VERSION")
)),
"{mise}"
);
}
#[test]
fn pin_main_writes_a_git_pin() {
let root = tempdir("main");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
let (code, _, stderr) = htl(&["pin", "main", "--no-update"], &dir);
assert_eq!(code, Some(0), "{stderr}");
let line = htl_line(&dir.join("Cargo.toml"));
assert!(line.contains("git = "), "{line}");
assert!(line.contains("branch = \"main\""), "{line}");
assert!(!line.contains("version ="), "{line}");
}
#[test]
fn the_window_targets_htl_mq_line_moves_with_the_htl_line() {
let root = tempdir("window");
let (code, _, stderr) = htl(
&["new", "w", "--target", "window", "--htl", "release"],
&root,
);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("w");
let manifest = dir.join("Cargo.toml");
assert_eq!(
htl_line(&manifest),
format!("htl = \"{}\"", env!("CARGO_PKG_VERSION"))
);
assert_eq!(
dep_line(&manifest, "htl-mq"),
format!("htl-mq = \"{}\"", env!("CARGO_PKG_VERSION"))
);
let checkout = checkout_path();
let (code, _, stderr) = htl(&["pin", &format!("path:{checkout}"), "--no-update"], &dir);
assert_eq!(code, Some(0), "{stderr}");
assert_eq!(
htl_line(&manifest),
format!("htl = {{ path = \"{checkout}/crates/htl\" }}")
);
assert_eq!(
dep_line(&manifest, "htl-mq"),
format!("htl-mq = {{ path = \"{checkout}/crates/htl-mq\" }}")
);
}
#[test]
fn the_bin_targets_htl_std_line_moves_with_the_htl_line() {
let root = tempdir("bin-std");
let (code, _, stderr) = htl(&["new", "s", "--target", "bin", "--htl", "main"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("s");
let manifest = dir.join("Cargo.toml");
assert!(
htl_line(&manifest).contains("branch = \"main\""),
"{}",
htl_line(&manifest)
);
assert!(
dep_line(&manifest, "htl-std").contains("branch = \"main\""),
"{}",
dep_line(&manifest, "htl-std")
);
let (code, _, stderr) = htl(&["pin", "release", "--no-update"], &dir);
assert_eq!(code, Some(0), "{stderr}");
assert_eq!(
htl_line(&manifest),
format!(
"htl = {{ version = \"{}\", features = [\"async\"] }}",
env!("CARGO_PKG_VERSION")
)
);
assert_eq!(
dep_line(&manifest, "htl-std"),
format!("htl-std = \"{}\"", env!("CARGO_PKG_VERSION"))
);
let checkout = checkout_path();
let (code, _, stderr) = htl(&["pin", &format!("path:{checkout}"), "--no-update"], &dir);
assert_eq!(code, Some(0), "{stderr}");
assert_eq!(
htl_line(&manifest),
format!("htl = {{ path = \"{checkout}/crates/htl\", features = [\"async\"] }}")
);
assert_eq!(
dep_line(&manifest, "htl-std"),
format!("htl-std = {{ path = \"{checkout}/crates/htl-std\" }}")
);
}
#[test]
fn the_cdylib_feature_list_survives_every_pin_kind() {
let root = tempdir("cdylib");
let (code, _, stderr) = htl(&["new", "c", "--lib", "--target", "cdylib"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("c");
let manifest = dir.join("Cargo.toml");
assert!(
htl_line(&manifest).contains("features = [\"ffi\"]"),
"{}",
htl_line(&manifest)
);
for pin in ["main", "release"] {
let (code, _, stderr) = htl(&["pin", pin, "--no-update"], &dir);
assert_eq!(code, Some(0), "{pin}: {stderr}");
assert!(
htl_line(&manifest).contains("features = [\"ffi\"]"),
"{pin}: {}",
htl_line(&manifest)
);
}
let checkout = checkout_path();
let (code, _, stderr) = htl(&["pin", &format!("path:{checkout}"), "--no-update"], &dir);
assert_eq!(code, Some(0), "{stderr}");
assert!(
htl_line(&manifest).contains("features = [\"ffi\"]"),
"{}",
htl_line(&manifest)
);
}
#[test]
fn a_toolchain_key_is_rewritten_when_present_and_left_absent_when_not() {
let root = tempdir("toolchain");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
let htl_toml = dir.join("htl.toml");
let config = std::fs::read_to_string(&htl_toml).unwrap();
std::fs::write(&htl_toml, format!("{config}\n[toolchain]\nhtl = \"0.8\"\n")).unwrap();
let (code, _, stderr) = htl(&["pin", "release", "--no-update"], &dir);
assert_eq!(code, Some(0), "{stderr}");
let after = std::fs::read_to_string(&htl_toml).unwrap();
assert!(
after.contains(&format!("htl = \"{}\"", env!("CARGO_PKG_VERSION"))),
"{after}"
);
assert!(!after.contains("htl = \"0.8\""), "{after}");
let checkout = checkout_path();
let (code, _, stderr) = htl(&["pin", &format!("path:{checkout}"), "--no-update"], &dir);
assert_eq!(code, Some(0), "{stderr}");
let after = std::fs::read_to_string(&htl_toml).unwrap();
assert!(!after.contains("[toolchain]"), "{after}");
assert!(
!after.contains(&format!("htl = \"{}\"", env!("CARGO_PKG_VERSION"))),
"{after}"
);
let (code, _, stderr) = htl(&["new", "b", "--target", "bin"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir_b = root.join("b");
let htl_toml_b = dir_b.join("htl.toml");
let before_b = std::fs::read_to_string(&htl_toml_b).unwrap();
let (code, _, stderr) = htl(&["pin", "main", "--no-update"], &dir_b);
assert_eq!(code, Some(0), "{stderr}");
assert_eq!(std::fs::read_to_string(&htl_toml_b).unwrap(), before_b);
let (code, _, stderr) = htl(&["pin", "release", "--no-update"], &dir_b);
assert_eq!(code, Some(0), "{stderr}");
assert_eq!(std::fs::read_to_string(&htl_toml_b).unwrap(), before_b);
}
#[test]
fn a_toolchain_htl_table_names_the_file_in_its_refusal() {
let root = tempdir("toolchain-table");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin", "--htl", "main"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
let htl_toml = dir.join("htl.toml");
let config = std::fs::read_to_string(&htl_toml).unwrap();
std::fs::write(
&htl_toml,
format!("{config}\n[toolchain.htl]\nfoo = \"bar\"\n"),
)
.unwrap();
let (code, _, stderr) = htl(&["pin", "release", "--no-update"], &dir);
assert_eq!(code, Some(2), "{stderr}");
assert!(stderr.contains("htl.toml"), "{stderr}");
assert!(stderr.contains("[toolchain] htl"), "{stderr}");
assert!(stderr.contains("not a plain value"), "{stderr}");
}
#[test]
fn pin_preserves_comments_around_the_rewritten_lines() {
let root = tempdir("comments");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin", "--htl", "release"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
let manifest = dir.join("Cargo.toml");
let cargo = std::fs::read_to_string(&manifest).unwrap();
let line = cargo
.lines()
.find(|l| l.starts_with("htl = "))
.unwrap()
.to_string();
let decorated = cargo.replacen(&line, &format!("# the engine\n{line} # trailing"), 1);
std::fs::write(&manifest, &decorated).unwrap();
let (code, _, stderr) = htl(&["pin", "main", "--no-update"], &dir);
assert_eq!(code, Some(0), "{stderr}");
let after_cargo = std::fs::read_to_string(&manifest).unwrap();
assert!(after_cargo.contains("# the engine\n"), "{after_cargo}");
let new_line = after_cargo
.lines()
.find(|l| l.starts_with("htl = "))
.unwrap();
assert!(new_line.ends_with("# trailing"), "{new_line}");
assert!(new_line.contains("git = "), "{new_line}");
let htl_toml = dir.join("htl.toml");
let config = std::fs::read_to_string(&htl_toml).unwrap();
std::fs::write(
&htl_toml,
format!("{config}\n[toolchain]\n# pinned deliberately\nhtl = \"0.8\" # see issue\n"),
)
.unwrap();
let (code, _, stderr) = htl(&["pin", "release", "--no-update"], &dir);
assert_eq!(code, Some(0), "{stderr}");
let after_toml = std::fs::read_to_string(&htl_toml).unwrap();
assert!(
after_toml.contains("# pinned deliberately\n"),
"{after_toml}"
);
let toolchain_line = after_toml
.lines()
.find(|l| l.trim_start().starts_with("htl = "))
.unwrap();
assert!(
toolchain_line.contains(env!("CARGO_PKG_VERSION")),
"{toolchain_line}"
);
assert!(toolchain_line.ends_with("# see issue"), "{toolchain_line}");
}
#[test]
fn a_relative_path_is_resolved_against_the_current_directory() {
let root = tempdir("relative");
let sub = root.join("sub");
std::fs::create_dir_all(&sub).unwrap();
let checkout = sub.join("checkout");
std::fs::create_dir_all(checkout.join("crates/htl")).unwrap();
std::fs::write(checkout.join("crates/htl/Cargo.toml"), "[package]\n").unwrap();
let (code, _, stderr) = htl(&["new", "demo", "--target", "bin"], &sub);
assert_eq!(code, Some(0), "{stderr}");
let (code, _, stderr) = htl(&["pin", "path:checkout", "demo", "--no-update"], &sub);
assert_eq!(code, Some(0), "{stderr}");
let expected = std::fs::canonicalize(&checkout)
.unwrap()
.display()
.to_string();
assert_eq!(
htl_line(&sub.join("demo/Cargo.toml")),
format!("htl = {{ path = \"{expected}/crates/htl\", features = [\"async\"] }}")
);
}
#[test]
fn a_path_with_no_checkout_under_it_is_refused() {
let root = tempdir("no-checkout");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
let manifest = dir.join("Cargo.toml");
let before = std::fs::read_to_string(&manifest).unwrap();
let (code, _, stderr) = htl(&["pin", "path:does-not-exist-xyz", "--no-update"], &dir);
assert_eq!(code, Some(2), "{stderr}");
assert!(stderr.contains("is not an htl checkout"), "{stderr}");
assert!(stderr.contains("no crates/htl/Cargo.toml"), "{stderr}");
assert_eq!(std::fs::read_to_string(&manifest).unwrap(), before);
std::fs::create_dir_all(root.join("empty-dir")).unwrap();
let (code, _, stderr) = htl(&["pin", "path:../empty-dir", "--no-update"], &dir);
assert_eq!(code, Some(2), "{stderr}");
assert!(stderr.contains("is not an htl checkout"), "{stderr}");
assert_eq!(std::fs::read_to_string(&manifest).unwrap(), before);
}
#[test]
fn a_number_is_refused_with_the_scaffolds_message() {
let root = tempdir("number");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
let manifest = dir.join("Cargo.toml");
let before = std::fs::read_to_string(&manifest).unwrap();
let (code, _, stderr) = htl(&["pin", "0.7.0", "--no-update"], &dir);
assert_eq!(code, Some(2), "{stderr}");
assert!(stderr.contains("unsupported htl `0.7.0`"), "{stderr}");
assert!(
stderr.contains("cargo install htl-cli --version 0.7.0"),
"{stderr}"
);
assert_eq!(
std::fs::read_to_string(&manifest).unwrap(),
before,
"{stderr}"
);
}
#[test]
fn an_unrecognised_htl_line_is_refused_with_the_patch_block() {
let root = tempdir("unrecognised");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
let manifest = dir.join("Cargo.toml");
let mise = dir.join("mise.toml");
let original = std::fs::read_to_string(&manifest).unwrap();
let original_line = htl_line(&manifest);
let rewritten = original.replacen(
&original_line,
"htl = { version = \"0.13.0\", optional = true }",
1,
);
std::fs::write(&manifest, &rewritten).unwrap();
let mise_before = std::fs::read_to_string(&mise).ok();
let (code, _, stderr) = htl(&["pin", "release", "--no-update"], &dir);
assert_eq!(code, Some(2), "{stderr}");
assert!(stderr.contains("[patch.crates-io]"), "{stderr}");
assert!(stderr.contains("htl-macros = { path ="), "{stderr}");
assert_eq!(
std::fs::read_to_string(&manifest).unwrap(),
rewritten,
"{stderr}"
);
assert_eq!(std::fs::read_to_string(&mise).ok(), mise_before, "{stderr}");
let table =
original.replacen(&original_line, "", 1) + "\n[dependencies.htl]\nversion = \"0.13.0\"\n";
std::fs::write(&manifest, &table).unwrap();
let (code, _, stderr) = htl(&["pin", "release", "--no-update"], &dir);
assert_eq!(code, Some(2), "{stderr}");
assert!(stderr.contains("[patch.crates-io]"), "{stderr}");
assert!(stderr.contains("htl-macros = { path ="), "{stderr}");
assert_eq!(
std::fs::read_to_string(&manifest).unwrap(),
table,
"{stderr}"
);
}
#[test]
fn no_htl_dependency_is_refused_without_the_patch_block() {
let root = tempdir("no-htl");
let dir = root.join("plain");
std::fs::create_dir_all(dir.join("src")).unwrap();
std::fs::write(
dir.join("Cargo.toml"),
"[package]\nname = \"plain\"\nversion = \"0.1.0\"\nedition = \"2024\"\n\n\
[dependencies]\nanyhow = \"1\"\n",
)
.unwrap();
std::fs::write(dir.join("src/lib.rs"), "").unwrap();
let before = std::fs::read_to_string(dir.join("Cargo.toml")).unwrap();
let (code, _, stderr) = htl(&["pin", "release", "--no-update"], &dir);
assert_eq!(code, Some(2), "{stderr}");
assert!(
stderr.contains("Cargo.toml has no htl dependency"),
"{stderr}"
);
assert!(stderr.contains("nothing to move"), "{stderr}");
assert!(!stderr.contains("[patch.crates-io]"), "{stderr}");
assert_eq!(
std::fs::read_to_string(dir.join("Cargo.toml")).unwrap(),
before
);
}
#[test]
fn an_htl_line_outside_dependencies_does_not_confuse_the_real_one() {
let root = tempdir("other-table");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin", "--htl", "main"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
let manifest = dir.join("Cargo.toml");
let before = std::fs::read_to_string(&manifest).unwrap();
let checkout = checkout_path();
let patch_block =
format!("[patch.crates-io]\nhtl = {{ path = \"{checkout}/crates/htl\" }}\n\n");
let with_patch = before.replacen("[dependencies]", &format!("{patch_block}[dependencies]"), 1);
assert_ne!(
with_patch, before,
"no [dependencies] header to insert the patch block before"
);
std::fs::write(&manifest, &with_patch).unwrap();
let (code, _, stderr) = htl(&["pin", &format!("path:{checkout}"), "--no-update"], &dir);
assert_eq!(code, Some(0), "{stderr}");
let after = std::fs::read_to_string(&manifest).unwrap();
assert!(!after.contains("branch = \"main\""), "{after}");
let patch_path_form = format!("htl = {{ path = \"{checkout}/crates/htl\" }}");
let dep_path_form =
format!("htl = {{ path = \"{checkout}/crates/htl\", features = [\"async\"] }}");
assert_eq!(after.matches(&patch_path_form).count(), 1, "{after}");
assert_eq!(after.matches(&dep_path_form).count(), 1, "{after}");
assert!(
after.contains(&format!("[patch.crates-io]\n{patch_path_form}")),
"{after}"
);
assert!(stderr.contains("git = "), "{stderr}");
assert!(
stderr.contains(&format!(
"-> {{ path = \"{checkout}/crates/htl\", features = [\"async\"] }}"
)),
"{stderr}"
);
}
#[test]
fn differently_spaced_htl_lines_all_move() {
for prefix in ["htl=", "htl = ", "\"htl\" = "] {
let root = tempdir("spacing");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin", "--htl", "release"], &root);
assert_eq!(code, Some(0), "{prefix}: {stderr}");
let dir = root.join("a");
let manifest = dir.join("Cargo.toml");
let original = std::fs::read_to_string(&manifest).unwrap();
let version = env!("CARGO_PKG_VERSION");
let value = format!("{{ version = \"{version}\", features = [\"async\"] }}");
let canonical = format!("htl = {value}");
let respaced = format!("{prefix}{value}");
let rewritten = original.replacen(&canonical, &respaced, 1);
assert_ne!(
rewritten, original,
"{prefix}: the canonical line was not found to replace"
);
std::fs::write(&manifest, &rewritten).unwrap();
let (code, _, stderr) = htl(&["pin", "main", "--no-update"], &dir);
assert_eq!(code, Some(0), "{prefix}: {stderr}");
let after = std::fs::read_to_string(&manifest).unwrap();
let line = loose_dep_line(&after, "htl");
assert!(line.contains("git = "), "{prefix}: {line}");
assert!(line.contains("branch = \"main\""), "{prefix}: {line}");
}
}
#[test]
fn the_summary_is_printed_before_cargo_update_runs() {
let root = tempdir("cargo-fail");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
let checkout = checkout_path();
let out = Command::new(common::htl_bin())
.args(["pin", &format!("path:{checkout}")])
.current_dir(&dir)
.env("CARGO", "/bin/false")
.output()
.unwrap();
let stderr = String::from_utf8_lossy(&out.stderr).into_owned();
assert_eq!(out.status.code(), Some(2), "{stderr}");
let cargo_line = stderr
.find("htl pin: Cargo.toml")
.unwrap_or_else(|| panic!("{stderr}"));
let failed_line = stderr
.find("cargo update failed")
.unwrap_or_else(|| panic!("{stderr}"));
assert!(cargo_line < failed_line, "{stderr}");
}
#[test]
fn an_unparsable_htl_toml_leaves_everything_else_untouched() {
let root = tempdir("atomic");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin", "--htl", "main"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
let manifest = dir.join("Cargo.toml");
let mise = dir.join("mise.toml");
let htl_toml = dir.join("htl.toml");
let cargo_before = std::fs::read_to_string(&manifest).unwrap();
assert!(!mise.exists());
std::fs::write(&htl_toml, "this is not [ valid toml").unwrap();
let (code, _, stderr) = htl(&["pin", "release", "--no-update"], &dir);
assert_ne!(code, Some(0), "{stderr}");
assert_eq!(std::fs::read_to_string(&manifest).unwrap(), cargo_before);
assert!(
!mise.exists(),
"mise.toml was written despite htl.toml failing to parse"
);
}
#[test]
fn an_unreadable_htl_toml_fails_before_anything_is_written() {
#[cfg(not(unix))]
{
println!("not unix: skipping the permission-based refusal test");
return;
}
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let root = tempdir("unreadable");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin", "--htl", "main"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
let manifest = dir.join("Cargo.toml");
let cargo_before = std::fs::read_to_string(&manifest).unwrap();
let htl_toml = dir.join("htl.toml");
std::fs::write(&htl_toml, "[toolchain]\nhtl = \"0.12.0\"\n").unwrap();
std::fs::set_permissions(&htl_toml, std::fs::Permissions::from_mode(0o000)).unwrap();
let mode = std::fs::metadata(&htl_toml).unwrap().permissions().mode() & 0o777;
let still_readable = mode == 0 && std::fs::read_to_string(&htl_toml).is_ok();
if mode != 0 || still_readable {
println!("chmod 000 did not block reading (mode {mode:o}): skipping");
std::fs::set_permissions(&htl_toml, std::fs::Permissions::from_mode(0o644)).unwrap();
return;
}
let (code, _, stderr) = htl(&["pin", "release", "--no-update"], &dir);
std::fs::set_permissions(&htl_toml, std::fs::Permissions::from_mode(0o644)).unwrap();
assert_eq!(code, Some(2), "{stderr}");
assert!(stderr.contains("htl.toml"), "{stderr}");
assert_eq!(std::fs::read_to_string(&manifest).unwrap(), cargo_before);
}
}
#[test]
fn mise_toml_as_a_directory_is_refused_before_any_write() {
let root = tempdir("mise-dir");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin", "--htl", "main"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
let manifest = dir.join("Cargo.toml");
let before = std::fs::read_to_string(&manifest).unwrap();
std::fs::create_dir(dir.join("mise.toml")).unwrap();
let (code, _, stderr) = htl(&["pin", "release", "--no-update"], &dir);
assert_eq!(code, Some(2), "{stderr}");
assert!(stderr.contains("mise.toml"), "{stderr}");
assert!(stderr.contains("not a regular file"), "{stderr}");
assert_eq!(std::fs::read_to_string(&manifest).unwrap(), before);
assert!(dir.join("mise.toml").is_dir());
}
#[test]
fn cargo_update_runs_and_the_lock_names_the_checkout() {
let root = tempdir("cargo-update");
let (code, _, stderr) = htl(&["new", "a", "--target", "bin", "--htl", "release"], &root);
assert_eq!(code, Some(0), "{stderr}");
let dir = root.join("a");
let checkout = checkout_path();
let (code, _, stderr) = htl(&["pin", &format!("path:{checkout}")], &dir);
if code != Some(0) {
let offline = [
"failed to get",
"could not resolve",
"unable to get packages",
]
.iter()
.any(|s| stderr.contains(s));
if offline {
println!("no registry access: skipping the cargo update run\n{stderr}");
return;
}
panic!("{stderr}");
}
let lock = std::fs::read_to_string(dir.join("Cargo.lock")).unwrap();
let htl_pkg = lock
.split("[[package]]")
.find(|p| p.contains("name = \"htl\"\n"))
.unwrap_or_else(|| panic!("no htl package in:\n{lock}"));
assert!(!htl_pkg.contains("source = \"registry+"), "{htl_pkg}");
}
#[test]
fn no_cargo_toml_is_refused() {
let root = tempdir("empty");
let (code, _, stderr) = htl(&["pin", "release", root.to_str().unwrap()], &root);
assert_eq!(code, Some(2), "{stderr}");
assert!(stderr.contains(&root.display().to_string()), "{stderr}");
}