Files
worklane/tests/cmd_completions.rs

312 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();
// Isolated HOME and XDG so `init` cannot decide on a real machine's boards config:
// the board has to be local no matter whose machine runs the suite.
init.current_dir(temp.path())
.env("HOME", temp.path())
.env("XDG_CONFIG_HOME", temp.path().join("config"))
.env("XDG_DATA_HOME", temp.path().join("data"))
.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}");
}