Every check over the completions read the script as text. A `contains` cannot tell a rule that fires from one whose condition stopped matching, and that is how a completion actually breaks: the clap definition moves, a list or a `__worklane_command_is` scope stops naming anything, and the rule sits in the file offering nothing while every assertion passes. So the generated script is sourced into a throwaway fish standing in a real board, with this build's directory on the front of PATH, and `complete -C` is compared against the ticket and the tag that board was given. Four deliberate breakages were used to size it: renaming the `ls` status scope, dropping `append` from `TAG_FLAGS`, renaming a flag in `TICKET_FLAGS` and dropping `show` from `TICKET_COMMANDS`. All four now fail, each naming the list at fault. **Assert the values, not the flag names.** clap emits every option's name on its own, so `--tags` and `--blocked-by` are offered with the whole dynamic half deleted; the first draft asserted those names and caught only one of the four. What the hand-written rules add is the candidates after the flag, and that is what a board under the shell makes checkable. Two traps, both paid for once. `complete -C` autoloads `~/.config/fish/completions/worklane.fish`, so the first draft passed against a deliberately broken scope because the copy installed in August still had the working rule: `set fish_complete_path` with no value is what makes the sourced script the only source, and without that line the test cannot fail. And the script is written beside the board rather than in it, since a rule that fires nothing falls back to listing the directory and the script would read as an answer. `fish --no-execute` comes with it as the floor: it catches a script that does not parse. Narrower than it sounds, and measured rather than assumed, so the limit is written on the test. An apostrophe in a `-d` description partway down re-balances against the next quote and parses, corrupting every rule in between; the same apostrophe in the last rule reaches the end unbalanced and is caught. `every_listed_command_is_a_real_subcommand` widens to every list that names a command, `CAMPAIGN_COMMANDS`, `TAG_FLAGS` and the two nested lists, so a stale entry fails by name instead of through a rule count. The counts themselves stay hardcoded and now say why: the walkers go clap → list and never see an extra entry, so the count is what catches one, and deriving it from the lists it checks would grow with the bogus entry and pass. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
304 lines
13 KiB
Rust
304 lines
13 KiB
Rust
use assert_cmd::Command;
|
|
|
|
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
|
|
|
|
fn script(shell: &str) -> String {
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
let assert = cmd.arg("completions").arg(shell).assert().success();
|
|
String::from_utf8(assert.get_output().stdout.clone()).unwrap()
|
|
}
|
|
|
|
/// Every shell clap can generate for, since the README names all five.
|
|
#[test]
|
|
fn completions_prints_a_script_for_every_shell() {
|
|
for shell in ["fish", "bash", "zsh", "elvish", "powershell"] {
|
|
let out = script(shell);
|
|
assert!(out.contains("worklane"), "the {shell} script never names the command");
|
|
// Long enough to be a script rather than an empty file with a comment in it.
|
|
assert!(out.len() > 500, "the {shell} script is {} bytes", out.len());
|
|
}
|
|
}
|
|
|
|
/// No board is looked for, the way `install-skill` looks for none: the script comes off
|
|
/// the clap definition and is the same wherever it is run. Run from a temp directory
|
|
/// with no `.worklane` above it, which every other command refuses.
|
|
#[test]
|
|
fn completions_needs_no_board() {
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(temp.path())
|
|
.arg("completions")
|
|
.arg("fish")
|
|
.assert()
|
|
.success();
|
|
}
|
|
|
|
#[test]
|
|
fn fish_gets_both_halves() {
|
|
let out = script("fish");
|
|
// clap's, which is where the subcommands and the flags come from.
|
|
assert!(out.contains("__fish_worklane_needs_command"));
|
|
assert!(out.contains("install-skill"));
|
|
// Ours, which is where the tickets come from.
|
|
assert!(out.contains("__worklane_first_arg_of"));
|
|
assert!(out.contains("worklane ls --ids"));
|
|
}
|
|
|
|
/// The fish half is fish syntax, so it must not reach any other shell's output.
|
|
#[test]
|
|
fn no_other_shell_gets_the_fish_half() {
|
|
for shell in ["bash", "zsh", "elvish", "powershell"] {
|
|
let out = script(shell);
|
|
assert!(
|
|
!out.contains("__worklane_first_arg_of"),
|
|
"fish-only helpers leaked into {shell}"
|
|
);
|
|
assert!(!out.contains("worklane ls --ids"), "the dynamic half leaked into {shell}");
|
|
}
|
|
}
|
|
|
|
/// The four statuses reach fish twice over, from clap for the `mv` option and from the
|
|
/// appended half for the `ls` positional, which clap emits nothing for.
|
|
#[test]
|
|
fn fish_is_offered_every_status() {
|
|
let out = script("fish");
|
|
for status in ["backlog", "committed", "reviewing", "done", "discarded"] {
|
|
assert!(out.contains(status), "fish is never offered {status}");
|
|
}
|
|
assert!(out.contains("-a 'backlog committed reviewing done discarded' -d status"));
|
|
}
|
|
|
|
/// A board holding one ticket and one tag, for the rules whose values come off a board.
|
|
///
|
|
/// Returned with the ticket's id and the tag, since the assertions are that those exact
|
|
/// strings are what fish offers.
|
|
fn board() -> (assert_fs::TempDir, String, String) {
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let mut init = Command::cargo_bin(BIN_NAME).unwrap();
|
|
init.current_dir(temp.path()).arg("init").assert().success();
|
|
|
|
let mut add = Command::cargo_bin(BIN_NAME).unwrap();
|
|
add.current_dir(temp.path())
|
|
.args(["add", "--title", "A ticket to complete", "--tags", "atag"])
|
|
.assert()
|
|
.success();
|
|
|
|
let mut ls = Command::cargo_bin(BIN_NAME).unwrap();
|
|
let listed = ls
|
|
.current_dir(temp.path())
|
|
.args(["ls", "--ids"])
|
|
.assert()
|
|
.success();
|
|
let listed = String::from_utf8(listed.get_output().stdout.clone()).unwrap();
|
|
let id = listed.split('\t').next().unwrap().trim().to_string();
|
|
|
|
(temp, id, "atag".to_string())
|
|
}
|
|
|
|
/// What fish would actually offer for a half-typed line, or `None` when fish is absent.
|
|
///
|
|
/// `complete -C` is fish's own answer to "what are the candidates here", so this asks the
|
|
/// question a person at a prompt asks rather than searching the script for the rule that
|
|
/// ought to produce the answer. Each candidate is a name and, after a tab, its description.
|
|
///
|
|
/// **The shell is pointed at the binary under test and stood in a real board**, which is
|
|
/// what makes the dynamic half testable at all: its rules are command substitutions calling
|
|
/// `worklane ls --ids` and `worklane tags`, so with no board and no binary they return
|
|
/// nothing and every assertion about them would pass on an empty answer. The directory of
|
|
/// `CARGO_BIN_EXE_worklane` goes on the front of PATH so the substitution runs this build
|
|
/// rather than whatever is installed.
|
|
///
|
|
/// **`fish_complete_path` is emptied first, and without that line this test cannot fail.**
|
|
/// `complete -C` autoloads completions for the command it is asked about, so a developer
|
|
/// who has ever run `worklane completions fish > ~/.config/fish/completions/worklane.fish`
|
|
/// gets that file merged into the answer. It was written by some earlier version of this
|
|
/// binary and answers for whatever the rules used to be: the first draft of this test
|
|
/// passed against a deliberately broken scope because the installed copy still had the
|
|
/// working one. Emptying the path is what makes the sourced script the only source.
|
|
fn candidates(board: &assert_fs::TempDir, line: &str) -> Option<Vec<String>> {
|
|
// Beside the board rather than in it: a rule that fires nothing falls back to listing
|
|
// the directory, and a script sitting in there would appear among the candidates and
|
|
// read like an answer.
|
|
let holder = assert_fs::TempDir::new().unwrap();
|
|
let path = holder.path().join("worklane.fish");
|
|
std::fs::write(&path, script("fish")).unwrap();
|
|
|
|
let bin_dir = std::path::Path::new(BIN_NAME).parent().unwrap();
|
|
let inherited = std::env::var("PATH").unwrap_or_default();
|
|
|
|
let asked = std::process::Command::new("fish")
|
|
.current_dir(board.path())
|
|
.env("PATH", format!("{}:{inherited}", bin_dir.display()))
|
|
.arg("-c")
|
|
.arg(format!(
|
|
"set fish_complete_path; source {}; complete -C '{line}'",
|
|
path.display()
|
|
))
|
|
.output();
|
|
|
|
match asked {
|
|
Ok(out) => Some(
|
|
String::from_utf8_lossy(&out.stdout)
|
|
.lines()
|
|
.map(str::to_string)
|
|
.collect(),
|
|
),
|
|
Err(err) if err.kind() == std::io::ErrorKind::NotFound => None,
|
|
Err(err) => panic!("could not run fish: {err}"),
|
|
}
|
|
}
|
|
|
|
/// The name half of a candidate, dropping the description fish takes after the tab.
|
|
fn names(candidates: &[String]) -> Vec<&str> {
|
|
candidates
|
|
.iter()
|
|
.map(|line| line.split('\t').next().unwrap_or(line))
|
|
.collect()
|
|
}
|
|
|
|
/// **Ask fish what it offers, instead of asserting that the rule that should make it
|
|
/// offer that is in the file.**
|
|
///
|
|
/// Every other test here reads the script as text, which cannot tell a rule that fires
|
|
/// from one whose condition stopped matching. That is how a completion actually breaks:
|
|
/// the clap definition moves, a list or a `__worklane_command_is` scope no longer names
|
|
/// anything, and the rule sits in the file offering nothing. Loading it into a real fish
|
|
/// and asking for the candidates is the only check that can see the difference.
|
|
///
|
|
/// **Asserting the values, not only the names, is the point.** clap emits every option's
|
|
/// name on its own, so `--tags` and `--blocked-by` are offered whether or not the dynamic
|
|
/// half loaded: an assertion that they appear passes with every hand-written rule deleted.
|
|
/// What those rules add is the candidates *after* the flag, and that is what is pinned
|
|
/// here, against the board `board()` puts under the shell.
|
|
///
|
|
/// Descriptions are read off deliberately and not asserted: every option carrying a
|
|
/// hand-written rule currently loses the help text clap gave it, which is its own ticket
|
|
/// rather than something to pin as correct here.
|
|
///
|
|
/// **Skipped when fish is not on PATH, and it says so.** There is no CI here and fish is
|
|
/// the shell this tool is written for, so failing a machine that never had it would be a
|
|
/// guard nobody could satisfy. A missing fish means the check did not run, not that it
|
|
/// passed.
|
|
#[test]
|
|
fn fish_offers_the_commands_the_statuses_and_the_values() {
|
|
let (temp, id, tag) = board();
|
|
|
|
let Some(commands) = candidates(&temp, "worklane ") else {
|
|
eprintln!("skipped: fish is not on PATH, so nothing asked it for candidates");
|
|
return;
|
|
};
|
|
for command in [
|
|
"add", "ls", "show", "mv", "set", "append", "relate", "campaign",
|
|
] {
|
|
assert!(
|
|
names(&commands).contains(&command),
|
|
"`worklane <TAB>` never offers {command}"
|
|
);
|
|
}
|
|
|
|
// The `ls` status positional, which clap emits nothing for, so this answer comes from
|
|
// the dynamic half alone and an empty one means that half stopped loading.
|
|
let statuses = candidates(&temp, "worklane ls ").unwrap();
|
|
for status in ["backlog", "committed", "reviewing", "done", "discarded"] {
|
|
assert!(
|
|
names(&statuses).contains(&status),
|
|
"`worklane ls <TAB>` never offers {status}"
|
|
);
|
|
}
|
|
|
|
let shells = candidates(&temp, "worklane completions ").unwrap();
|
|
for shell in ["fish", "bash", "zsh"] {
|
|
assert!(
|
|
names(&shells).contains(&shell),
|
|
"`worklane completions <TAB>` never offers {shell}"
|
|
);
|
|
}
|
|
|
|
// Every rule whose values come off the board, one per list it is generated from.
|
|
let ticket_value = [
|
|
("worklane show ", "TICKET_COMMANDS"),
|
|
("worklane chown alice ", "TICKET_SECOND_COMMANDS"),
|
|
("worklane relate --blocked-by ", "TICKET_FLAGS"),
|
|
("worklane chown --clear ", "the chown --clear rule"),
|
|
];
|
|
for (line, list) in ticket_value {
|
|
let offered = candidates(&temp, line).unwrap();
|
|
assert!(
|
|
names(&offered).contains(&id.as_str()),
|
|
"`{line}<TAB>` never offers the one ticket on the board, so {list} is not reaching it: {offered:?}"
|
|
);
|
|
}
|
|
|
|
let tag_value = [
|
|
("worklane ls --tag ", "TAG_FLAGS"),
|
|
("worklane append --tags ", "TAG_FLAGS"),
|
|
("worklane tags set ", "TAG_NESTED_COMMANDS"),
|
|
];
|
|
for (line, list) in tag_value {
|
|
let offered = candidates(&temp, line).unwrap();
|
|
assert!(
|
|
names(&offered).contains(&tag.as_str()),
|
|
"`{line}<TAB>` never offers the one tag on the board, so {list} is not reaching it: {offered:?}"
|
|
);
|
|
}
|
|
}
|
|
|
|
/// **The script is handed to fish, which parses it without running it.**
|
|
///
|
|
/// The fish half is a hand-written `format!` string carrying single quotes, command
|
|
/// substitutions and backslash line continuations, and every text assertion in this file
|
|
/// is a `contains`, which a broken script satisfies exactly as well as a correct one.
|
|
/// `--no-execute` is the parse without the run.
|
|
///
|
|
/// **What it catches is a script that does not parse**: quotes still open at the end of
|
|
/// the file, an unclosed block. That is narrower than it sounds and the limit is worth
|
|
/// writing down, because it was measured rather than assumed. An apostrophe interpolated
|
|
/// into a `-d` description partway down the file re-balances against the next quote and
|
|
/// parses, corrupting every rule in between while this test passes; the same apostrophe in
|
|
/// the *last* rule reaches the end unbalanced and is caught. So this is a floor, not an
|
|
/// oracle, and `fish_offers_the_commands_the_statuses_and_the_flags` is the one that reads
|
|
/// what the rules actually do.
|
|
///
|
|
/// Only fish, because only fish gets a hand-written half. What the other four shells are
|
|
/// given is clap's output whole, which `no_other_shell_gets_the_fish_half` pins, so a
|
|
/// syntax error there would be clap's bug and not this repo's to catch.
|
|
///
|
|
/// **Skipped when fish is not on PATH, and it says so.** The trade is deliberate: there is
|
|
/// no CI here and fish is the shell this tool is written for, so failing a machine that
|
|
/// never had it would be a guard nobody could satisfy. A missing fish means the check did
|
|
/// not run, not that it passed.
|
|
#[test]
|
|
fn fish_parses_the_script_it_is_given() {
|
|
let temp = assert_fs::TempDir::new().unwrap();
|
|
let path = temp.path().join("worklane.fish");
|
|
std::fs::write(&path, script("fish")).unwrap();
|
|
|
|
let parsed = std::process::Command::new("fish")
|
|
.arg("--no-execute")
|
|
.arg(&path)
|
|
.output();
|
|
|
|
let out = match parsed {
|
|
Ok(out) => out,
|
|
Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
|
|
eprintln!("skipped: fish is not on PATH, so the generated script went unparsed");
|
|
return;
|
|
}
|
|
Err(err) => panic!("could not run fish: {err}"),
|
|
};
|
|
|
|
assert!(
|
|
out.status.success(),
|
|
"fish refuses the script `worklane completions fish` writes:\n{}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn an_unknown_shell_is_a_usage_error() {
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
let assert = cmd.arg("completions").arg("tcsh").assert().code(2);
|
|
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
|
|
assert!(stderr.contains("invalid value 'tcsh'"), "{stderr}");
|
|
}
|