use super::*;
use crate::testrepo::TestRepo;
fn tree(tag: &str, scripts: &[(&str, &str)]) -> Result<TestRepo, String> {
let r = TestRepo::new(tag)?;
for n in ["a", "b", "c"] {
r.write(&format!("{n}/SPEC.md"), "# SPEC\n")?;
}
for (path, body) in scripts {
r.write(path, body)?;
}
r.commit("tree")?;
Ok(r)
}
fn pairs(es: &[Edge]) -> Vec<(&str, &str)> {
es.iter()
.map(|e| (e.from.as_str(), e.to.as_str()))
.collect()
}
#[test]
fn an_unbound_root_variable_resolves_by_its_tail() -> Result<(), String> {
let body = "REPO_ROOT=\"$1\"\nbash \"$REPO_ROOT/b/y.sh\"\n\
bash \"$REPO_ROOT/b/missing.sh\"\n";
let r = tree(
"wave-edge-root",
&[("a/x.sh", body), ("b/y.sh", "#!/bin/sh\n")],
)?;
let es = edges(r.path(), r.path());
assert_eq!(pairs(&es), vec![("a", "b")]);
assert!(es.iter().all(|e| e.inferred && e.sibling), "{es:?}");
let u: Vec<String> = unresolved_calls(r.path(), r.path())
.into_iter()
.map(|x| x.call)
.collect();
assert_eq!(u, vec!["$REPO_ROOT/b/missing.sh"]);
assert_eq!(wave(r.path(), r.path()).depth(), 2);
Ok(())
}
#[test]
fn a_braced_default_that_resolves_nothing_is_inferred() -> Result<(), String> {
let r = tree(
"wave-edge-braced",
&[
("a/x.sh", "bash \"${ROOT:-.}/b/y.sh\"\n"),
("b/y.sh", "#!/bin/sh\n"),
],
)?;
let es = edges(r.path(), r.path());
assert_eq!(pairs(&es), vec![("a", "b")]);
assert!(es.iter().all(|e| e.inferred), "{es:?}");
assert!(unresolved_calls(r.path(), r.path()).is_empty());
Ok(())
}
#[test]
fn a_bound_variable_that_misses_stays_unresolved() -> Result<(), String> {
let body = "HERE=\"$(dirname \"$0\")\"\nbash \"$HERE/b/y.sh\"\n";
let r = tree(
"wave-edge-bound",
&[("a/x.sh", body), ("b/y.sh", "#!/bin/sh\n")],
)?;
assert!(edges(r.path(), r.path()).is_empty());
let u: Vec<String> = unresolved_calls(r.path(), r.path())
.into_iter()
.map(|x| x.call)
.collect();
assert_eq!(u, vec!["$HERE/b/y.sh"]);
Ok(())
}
#[test]
fn a_lexical_call_beats_an_inferred_one() -> Result<(), String> {
let body = "bash \"${ROOT:-.}/b/y.sh\"\nbash b/y.sh\n";
let r = tree(
"wave-edge-merge",
&[("a/x.sh", body), ("b/y.sh", "#!/bin/sh\n")],
)?;
let es = edges(r.path(), r.path());
assert_eq!(pairs(&es), vec![("a", "b")]);
assert!(es.iter().all(|e| !e.inferred), "{es:?}");
Ok(())
}
#[test]
fn a_call_to_the_parent_is_an_edge_but_not_a_wait() -> Result<(), String> {
let r = TestRepo::new("wave-edge-parent")?;
r.write("p/SPEC.md", "# SPEC\n")?;
r.write("p/shared.sh", "#!/bin/sh\n")?;
r.write("p/k/SPEC.md", "# SPEC\n")?;
r.write("p/k/run.sh", "bash p/shared.sh\n")?;
r.commit("tree")?;
let es = edges(r.path(), r.path());
assert_eq!(pairs(&es), vec![("p/k", "p")]);
assert!(es.iter().all(|e| !e.sibling && !e.inferred), "{es:?}");
assert_eq!(wave(r.path(), r.path()).depth(), 1);
Ok(())
}
#[test]
fn own_calls_and_out_of_scope_calls_are_no_edge() -> Result<(), String> {
let r = tree(
"wave-edge-scope",
&[
("a/x.sh", "bash a/own.sh\nbash b/y.sh\n"),
("a/own.sh", "#!/bin/sh\n"),
("b/y.sh", "#!/bin/sh\n"),
],
)?;
assert_eq!(pairs(&edges(r.path(), r.path())), vec![("a", "b")]);
assert!(edges(r.path(), &r.path().join("a")).is_empty());
Ok(())
}
#[test]
fn cycles_group_the_loop_and_leave_out_who_waits_behind_it()
-> Result<(), String> {
let r = tree(
"wave-edge-cycle",
&[
("a/x.sh", "bash b/y.sh\n"),
("b/y.sh", "bash a/x.sh\n"),
("c/z.sh", "bash a/x.sh\n"),
],
)?;
let (s, c) = wave_with_cycles(r.path(), r.path());
assert_eq!(s.blocked, vec!["a", "b", "c"]);
assert_eq!(c, vec![vec!["a".to_string(), "b".to_string()]]);
Ok(())
}
#[test]
fn cycles_over_a_handed_dag() {
let dep = |n: &str, needs: &[&str]| CodeDep {
node: n.to_string(),
needs: needs.iter().map(|s| (*s).to_string()).collect(),
seam: Vec::new(),
};
let deps = vec![dep("a", &["a"]), dep("b", &[])];
let s = schedule(&deps);
assert_eq!(cycles(&deps, &s.blocked), vec![vec!["a".to_string()]]);
assert!(cycles(&[dep("b", &[])], &[]).is_empty());
}
#[test]
fn rust_imports_are_sibling_edges() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"));
let es = edges(root, root);
let e = es
.iter()
.find(|e| e.from == "src/cli" && e.to == "src/wave");
assert!(
e.is_some_and(|e| e.kind == EdgeKind::Blocking
&& e.sibling
&& !e.inferred),
"{e:?}"
);
assert_eq!(EdgeKind::TypeOnly.as_str(), "type-only");
}