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> { // 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 ` 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 ` never offers {status}" ); } let shells = candidates(&temp, "worklane completions ").unwrap(); for shell in ["fish", "bash", "zsh"] { assert!( names(&shells).contains(&shell), "`worklane completions ` 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}` 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}` 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}"); }