Files
worklane/tests/cmd_ls.rs
T
Ansho ReiandClaude Opus 5 373ba519b3 Add a worklane completions command, and bump to 0.17.0
Every argument worklane takes names a ticket, a status, a shell or a skill, and
the shell offered a directory listing for all of them. `completions <shell>`
prints a script for fish, bash, zsh, elvish and powershell, following what frig
does, which is where the shape of this comes from.

Two halves, because neither alone is enough. `clap_complete` generates the
structure from the clap definition, so a flag added to `command.rs` is completed
without anyone touching `completions.rs`, and fish gets a hand-written block
appended for what only the board knows. That block runs `worklane ls --ids` in a
command substitution, one run per keypress, 2.5ms in release on a board of
seventy-five tickets.

A status is a `util::Status` value enum now rather than a string, which was the
plan's third step and pays for itself three ways. clap refuses an unknown one at
parse time naming the four, so `cmd_mv`'s `valid_statuses` and the status half of
`cmd_ls`'s error are gone and exit 2 is what an unreal status gets, the bargain
`--due` and `--priority` already take. `status_dirs()` and `DONE` are derived
from `Status::ALL`, so the flow is written once. And clap emits the four for `mv
--status` itself. Only half free: the fish generator emits nothing for the
possible values of a *positional*, so `ls <status>` and `completions <shell>` are
listed in the appended half after all, read off the enums with `possible_values`
rather than by hand.

`ls --ids` is the machine-readable listing, and prints the short id, a tab and
the title rather than the id alone. Both readers want both fields: fish takes
what follows a tab as the description, which is what makes `worklane show <TAB>`
a list of titles instead of hex, and a script takes the id back with `cut -f1`.
It includes done, where the decorated listing leaves done out, because a
completion has to be able to name a finished ticket and `show` is most often
pointed at one. It skips a missing status directory rather than refusing, since
an error printed over a shell prompt is worse than no candidates, and the
listing still refuses one so a person can act on it. The filters all still
apply, and an unknown `--campaign` is still refused ahead of everything.

Adding the mode tipped `cmd_ls` over the boundary AGENTS.md names, so it takes an
`LsArgs`, the way `add` took `AddArgs`.

More than the criteria asked, since the cost of each was a name in a list:
tickets are completed for `set`, `append`, `relate`, `check`, `uncheck`, the
second argument of `chown` and `assign`, and `relate`'s three target flags, plus
the skill names read off `install::SKILLS`. The three lists are kept honest by
tests that walk the clap definition and fail on a ticket-taking subcommand
missing from them, or listed at the wrong position. Nested subcommands are not
walked: `campaign` is the only one, none of its three takes a ticket, and the
token counting could not tell them apart if one did.

Position is counted rather than inferred. `__worklane_first_arg_of` reads
`$tokens[2]` and the token count instead of `__fish_seen_subcommand_from`,
because `campaign ls` and `campaign show` are also an `ls` and a `show` that fish
has seen, and matching against the ticket list to find the position would run
worklane again inside the condition.

Files are turned off for the command and back on for `tui`, which is the one
argument that really is a path. The ticket said worklane takes no file arguments;
it takes those.

Campaigns and tags are completed nowhere, which needs a listing they do not have:
55ee6e3. And since fish runs whatever is on PATH, the completions are only as
current as the installed binary, an older one without `--ids` completing
nothing. That is in the README beside the install line.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-22 20:02:37 +02:00

665 lines
24 KiB
Rust

use assert_cmd::Command;
use assert_fs::TempDir;
use assert_fs::fixture::{PathChild, PathCreateDir};
use std::fs;
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
fn setup_worklane(temp: &TempDir) -> std::path::PathBuf {
let worklane = temp.child(".worklane");
worklane.create_dir_all().unwrap();
for dir in ["backlog", "committed", "reviewing", "done"] {
worklane.child(dir).create_dir_all().unwrap();
}
worklane.path().to_path_buf()
}
fn create_ticket(
worklane_dir: &std::path::Path,
status: &str,
title: &str,
owner: &str,
due: &str,
) {
let ticket_body = format!(
"# {}\n\
\n\
## Description\n\
test desc\n\
\n\
## Acceptance Criteria\n\
- [ ] test\n\
\n\
## Implementation Plan\n\
- test\n\
\n\
## Metadata\n\
\n\
- **ID**: 00000000-0000-0000-0000-000000000001\n\
- **Tags**: test\n\
- **Due**: {}\n\
- **Owner**: {}\n\
- **Status**: {}\n\
",
title, due, owner, status
);
let slug = title
.to_lowercase()
.chars()
.filter(|c| c.is_alphanumeric() || *c == ' ' || *c == '-' || *c == '_')
.map(|c| if c == ' ' { '-' } else { c })
.collect::<String>();
let filename = format!("00000000-0000-0000-0000-000000000001_{}.md", slug);
fs::write(worklane_dir.join(status).join(&filename), ticket_body).unwrap();
}
fn get_stdout(cmd: &mut Command) -> String {
let assert = cmd.assert();
String::from_utf8(assert.get_output().stdout.clone()).unwrap()
}
#[test]
fn ls_without_status_shows_overview() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane, "backlog", "Feature A", "alice", "2026-06-01");
create_ticket(&worklane, "backlog", "Feature B", "bob", "2026-07-01");
create_ticket(&worklane, "committed", "Feature C", "charlie", "2026-08-01");
create_ticket(&worklane, "done", "Feature D", "dave", "2026-09-01");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).arg("ls").assert().success();
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("BACKLOG"));
assert!(stdout.contains("2 tickets"));
assert!(stdout.contains("COMMITTED"));
assert!(stdout.contains("1 ticket"));
assert!(stdout.contains("DONE"));
assert!(stdout.contains("Feature A"));
assert!(stdout.contains("Feature B"));
assert!(stdout.contains("Feature C"));
}
#[test]
fn ls_with_status_filters_tickets() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane, "backlog", "Feature A", "alice", "2026-06-01");
create_ticket(&worklane, "committed", "Feature B", "bob", "2026-07-01");
create_ticket(&worklane, "reviewing", "Feature C", "charlie", "2026-08-01");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).arg("ls").args(["committed"]);
cmd.assert().success();
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Feature B"));
}
#[test]
fn ls_with_invalid_status_fails() {
let temp = TempDir::new().unwrap();
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.arg("ls")
.args(["nonexistent"])
.assert()
.failure();
}
#[test]
fn ls_listed_tickets_sorted_alphabetically() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane, "backlog", "Zebra", "alice", "2026-06-01");
create_ticket(&worklane, "backlog", "Apple", "bob", "2026-07-01");
create_ticket(&worklane, "backlog", "Mango", "charlie", "2026-08-01");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.arg("ls")
.args(["backlog"])
.assert()
.success();
let stdout = get_stdout(&mut cmd);
let apple_pos = stdout.find("Apple");
let mango_pos = stdout.find("Mango");
let zebra_pos = stdout.find("Zebra");
assert!(apple_pos.is_some() && mango_pos.is_some() && zebra_pos.is_some());
assert!(apple_pos.unwrap() < mango_pos.unwrap());
assert!(mango_pos.unwrap() < zebra_pos.unwrap());
}
#[test]
fn ls_empty_status_shows_message() {
let temp = TempDir::new().unwrap();
let _worklane = setup_worklane(&temp);
// Intentionally leave "done" empty
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.arg("ls")
.args(["done"])
.assert()
.success();
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("No tickets in 'done'"));
}
#[test]
fn ls_displays_owner_and_due() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket(&worklane, "backlog", "Test ticket", "alice", "2026-12-31");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.arg("ls")
.args(["backlog"])
.assert()
.success();
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("alice"));
assert!(stdout.contains("2026-12-31"));
}
/// Both the abbreviated id and the created-at column used to slice by byte
/// offset, so either a short name or a multibyte character panicked.
#[test]
fn ls_handles_short_and_non_ascii_filenames() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
for filename in ["ab.md", "émigré-ticket.md", "日本語.md"] {
fs::write(
worklane.join("backlog").join(filename),
"# Odd Name\n\n## Metadata\n\n- **Owner**: alice\n- **Status**: backlog\n",
)
.unwrap();
}
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).arg("ls").arg("backlog").assert().success();
let stdout = get_stdout(&mut cmd);
assert_eq!(stdout.matches("Odd Name").count(), 3);
}
#[test]
fn ls_survives_a_malformed_created_at() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
fs::write(
worklane.join("backlog").join("00000000-0000-0000-0000-000000000009_bad-date.md"),
"# Bad Date\n\n## Metadata\n\n- **Created At**: 日本語日本語日本語\n- **Status**: backlog\n",
)
.unwrap();
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).arg("ls").arg("backlog").assert().success();
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Bad Date"));
// Unparseable, so the timestamp column is dropped rather than printed raw
assert!(!stdout.contains("日本語"));
}
fn create_ticket_with_priority(worklane_dir: &std::path::Path, title: &str, priority: &str) {
let slug: String = title.to_lowercase().replace(' ', "-");
let body = format!(
"# {}\n\n## Metadata\n\n- **ID**: 00000000-0000-0000-0000-00000000000{}\n\
- **Priority**: {}\n- **Tags**: test\n- **Due**: _Not set_\n\
- **Owner**: alice\n- **Status**: backlog\n",
title,
slug.len() % 10,
priority
);
let filename = format!("0000000{}-0000-0000-0000-000000000001_{}.md", slug.len() % 10, slug);
fs::write(worklane_dir.join("backlog").join(filename), body).unwrap();
}
#[test]
fn ls_sorts_by_priority_then_title() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket_with_priority(&worklane, "Zebra urgent", "1");
create_ticket_with_priority(&worklane, "Apple later", "4");
create_ticket_with_priority(&worklane, "Middle one", "2");
create_ticket(&worklane, "backlog", "No priority at all", "alice", "_Not set_");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).arg("ls").arg("backlog");
let stdout = get_stdout(&mut cmd);
let at = |needle: &str| stdout.find(needle).unwrap_or_else(|| panic!("{needle} missing"));
assert!(at("Zebra urgent") < at("Middle one"), "priority 1 must lead");
assert!(at("Middle one") < at("Apple later"), "2 before 4");
// Unset sorts last even though its title would come first alphabetically
assert!(at("Apple later") < at("No priority at all"), "unset must trail");
}
#[test]
fn ls_filters_by_priority_and_composes_with_status() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket_with_priority(&worklane, "Urgent one", "1");
create_ticket_with_priority(&worklane, "Lower one", "3");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["ls", "backlog", "--priority", "1"]);
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Urgent one"));
assert!(!stdout.contains("Lower one"), "filter let a level 3 through");
// Same filter without a status, through the grouped listing
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).args(["ls", "--priority", "3"]);
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Lower one"));
assert!(!stdout.contains("Urgent one"));
}
#[test]
fn ls_shows_a_mark_for_the_level() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket_with_priority(&worklane, "Top level", "1");
create_ticket_with_priority(&worklane, "Bottom level", "5");
create_ticket(&worklane, "backlog", "Nothing set", "alice", "_Not set_");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).arg("ls").arg("backlog");
let stdout = get_stdout(&mut cmd);
// Piped, so no escapes: the glyph is carrying the level by itself
assert!(!stdout.contains('\u{1b}'));
assert!(stdout.contains("\u{25cf}\u{25cf} "), "no full meter for level 1 in {stdout:?}");
assert!(stdout.contains("\u{25cb}\u{25cb} "), "no empty meter for level 5");
assert!(stdout.contains("\u{b7}\u{b7} "), "no unset mark");
// The raw number is not what the listing shows
assert!(!stdout.contains(" 1 "), "the digit leaked into the row");
}
/// A ticket whose Tags field is whatever the test needs it to be, written verbatim so a
/// missing field, an unset one and a real list are all reachable.
fn create_ticket_with_tags(
worklane_dir: &std::path::Path,
status: &str,
title: &str,
tags: &str,
priority: &str,
) {
let slug: String = title.to_lowercase().replace(' ', "-");
let body = format!(
"# {title}\n\n## Metadata\n\n - **ID**: 00000000-0000-0000-0000-000000000001\n - **Priority**: {priority}\n{tags} - **Due**: _Not set_\n- **Owner**: alice\n- **Status**: {status}\n"
);
fs::write(
worklane_dir
.join(status)
.join(format!("00000000-0000-0000-0000-000000000001_{slug}.md")),
body,
)
.unwrap();
}
/// The Tags line as a ticket carries it, for the common case of a real list.
fn tags(list: &str) -> String {
format!("- **Tags**: {list}\n")
}
#[test]
fn ls_filters_by_tag_and_composes_with_status_and_priority() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket_with_tags(&worklane, "backlog", "Tagged bug", &tags("bug,cli"), "1");
create_ticket_with_tags(&worklane, "backlog", "Tagged feature", &tags("feature"), "1");
create_ticket_with_tags(&worklane, "backlog", "Lower bug", &tags("bug"), "3");
create_ticket_with_tags(&worklane, "committed", "Started bug", &tags("bug"), "1");
// Alone, through the grouped listing: every status, only the tagged tickets.
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).args(["ls", "--tag", "bug"]);
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Tagged bug"), "{stdout}");
assert!(stdout.contains("Lower bug"), "{stdout}");
assert!(stdout.contains("Started bug"), "a tagged ticket in another status was dropped");
assert!(!stdout.contains("Tagged feature"), "an untagged ticket came through");
// The counts are filtered too, since they are the same collect.
assert!(stdout.contains("[BACKLOG] 2 tickets"), "{stdout}");
assert!(stdout.contains("[COMMITTED] 1 ticket"), "{stdout}");
// With the status positional.
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["ls", "backlog", "--tag", "bug"]);
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Tagged bug"));
assert!(stdout.contains("Lower bug"));
assert!(!stdout.contains("Started bug"), "the status was ignored");
// With --priority, and with both: none asked for is everything kept, so the three
// compose without a rule per pair.
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["ls", "--tag", "bug", "--priority", "1"]);
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Tagged bug"));
assert!(stdout.contains("Started bug"));
assert!(!stdout.contains("Lower bug"), "the priority was ignored");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["ls", "backlog", "--tag", "bug", "--priority", "1"]);
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Tagged bug"));
assert!(!stdout.contains("Lower bug"), "the priority was ignored");
assert!(!stdout.contains("Started bug"), "the status was ignored");
assert!(!stdout.contains("Tagged feature"), "the tag was ignored");
}
/// The field is a list of whole values, not a string to search: a ticket tagged `bugfix`
/// is not a ticket tagged `bug`, and neither is one tagged `Bug`. Case sensitive is the
/// opinion the field already takes, since `tag_color` draws those two differently.
#[test]
fn ls_matches_a_whole_tag_value_and_not_a_substring_or_another_case() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket_with_tags(&worklane, "backlog", "Real bug", &tags("bug"), "2");
create_ticket_with_tags(&worklane, "backlog", "Only bugfix", &tags("bugfix"), "2");
create_ticket_with_tags(&worklane, "backlog", "Capital Bug", &tags("Bug"), "2");
// A value that only appears with its neighbours around it, so a match on the raw
// field would find it and a match on the split values cannot.
create_ticket_with_tags(&worklane, "backlog", "Spaced list", &tags("cli, filter"), "2");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["ls", "backlog", "--tag", "bug"]);
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Real bug"), "{stdout}");
assert!(!stdout.contains("Only bugfix"), "bug matched bugfix");
assert!(!stdout.contains("Capital Bug"), "bug matched Bug");
// Trimmed on the way in, so the space after the comma is not part of the tag.
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["ls", "backlog", "--tag", "filter"]);
assert!(get_stdout(&mut cmd).contains("Spaced list"));
// And the field as written is not itself a tag.
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["ls", "backlog", "--tag", "cli, filter"]);
let stdout = get_stdout(&mut cmd);
assert!(!stdout.contains("Spaced list"), "the whole field matched as one tag");
}
/// No tags is no match, however the ticket spells it: the field absent, unset, or empty.
#[test]
fn ls_never_matches_a_ticket_carrying_no_tags() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket_with_tags(&worklane, "backlog", "Has one", &tags("bug"), "2");
create_ticket_with_tags(&worklane, "backlog", "Field unset", &tags("_None_"), "2");
create_ticket_with_tags(&worklane, "backlog", "Field empty", "- **Tags**:\n", "2");
create_ticket_with_tags(&worklane, "backlog", "Field missing", "", "2");
create_ticket_with_tags(&worklane, "backlog", "Only commas", &tags(", ,"), "2");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["ls", "backlog", "--tag", "bug"]);
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Has one"), "{stdout}");
for absent in ["Field unset", "Field empty", "Field missing", "Only commas"] {
assert!(!stdout.contains(absent), "{absent} matched a tag it does not carry");
}
// Nor does an empty tag reach the filter: the value parser refuses it, so nothing is
// listed rather than everything.
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["ls", "backlog", "--tag", ""]);
cmd.assert().failure().code(2);
}
/// A tag nothing carries lists nothing and still succeeds. The message is the one `ls`
/// already gives for a filter that empties a status, rather than a second one invented
/// here for tags alone.
#[test]
fn ls_with_a_tag_nothing_carries_lists_nothing() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket_with_tags(&worklane, "backlog", "Tagged bug", &tags("bug"), "2");
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["ls", "backlog", "--tag", "frontend"]);
cmd.assert().success();
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["ls", "backlog", "--tag", "frontend"]);
let stdout = get_stdout(&mut cmd);
assert!(!stdout.contains("Tagged bug"), "{stdout}");
assert!(stdout.contains("No tickets in 'backlog' status."), "{stdout}");
// Through the grouped listing the counts go to zero and no section is drawn.
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).args(["ls", "--tag", "frontend"]);
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("[BACKLOG] 0 tickets"), "{stdout}");
assert!(!stdout.contains("Tagged bug"), "{stdout}");
}
/// A ticket with an id of its own, since `create_ticket` gives every fixture the same
/// uuid and `--ids` is the one output where the id is the whole point.
fn create_ticket_with_id(
worklane_dir: &std::path::Path,
status: &str,
title: &str,
uuid: &str,
tags: &str,
) {
let ticket_body = format!(
"# {title}\n\n## Metadata\n\n- **ID**: {uuid}\n- **Tags**: {tags}\n- **Owner**: alice\n- **Status**: {status}\n"
);
let filename = format!("{uuid}_{}.md", slug(title));
fs::write(worklane_dir.join(status).join(filename), ticket_body).unwrap();
}
/// The slug rule, as AGENTS.md requires: derived, never written by hand.
fn slug(title: &str) -> String {
title
.to_lowercase()
.chars()
.filter(|c| c.is_alphanumeric() || *c == ' ' || *c == '-' || *c == '_')
.map(|c| if c == ' ' { '-' } else { c })
.collect()
}
/// One ticket per line, the seven-character id then a tab then the title, and nothing
/// else: no heading, no counts, no owner or due column.
#[test]
fn ls_ids_prints_the_id_and_the_title_and_nothing_else() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket_with_id(
&worklane,
"backlog",
"Feature A",
"1b78a24c-0000-0000-0000-000000000001",
"bug",
);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).args(["ls", "--ids"]);
cmd.assert().success();
let stdout = get_stdout(&mut cmd);
assert_eq!(stdout, "1b78a24\tFeature A\n", "{stdout:?}");
}
/// Every status, done included, where the decorated listing leaves done out. A
/// completion has to be able to name a finished ticket.
#[test]
fn ls_ids_includes_done_and_narrows_to_a_named_status() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket_with_id(
&worklane,
"backlog",
"Still open",
"aaaaaaa1-0000-0000-0000-000000000001",
"bug",
);
create_ticket_with_id(
&worklane,
"done",
"Finished",
"bbbbbbb2-0000-0000-0000-000000000002",
"bug",
);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).args(["ls", "--ids"]);
let stdout = get_stdout(&mut cmd);
assert!(stdout.contains("Still open"), "{stdout}");
assert!(stdout.contains("Finished"), "a done ticket cannot be named: {stdout}");
// The decorated listing is unchanged: done is counted, not listed.
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).arg("ls");
let stdout = get_stdout(&mut cmd);
assert!(!stdout.contains("Finished"), "{stdout}");
// The positional still narrows it.
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).args(["ls", "done", "--ids"]);
let stdout = get_stdout(&mut cmd);
assert_eq!(stdout, "bbbbbbb\tFinished\n", "{stdout:?}");
}
/// The filters apply to `--ids` exactly as they do to the listing, so a completion can
/// be narrowed the same way.
#[test]
fn ls_ids_still_takes_the_filters() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket_with_id(
&worklane,
"backlog",
"Tagged bug",
"aaaaaaa1-0000-0000-0000-000000000001",
"bug",
);
create_ticket_with_id(
&worklane,
"backlog",
"Tagged cli",
"bbbbbbb2-0000-0000-0000-000000000002",
"cli",
);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).args(["ls", "--ids", "--tag", "cli"]);
let stdout = get_stdout(&mut cmd);
assert_eq!(stdout, "bbbbbbb\tTagged cli\n", "{stdout:?}");
}
/// An unknown campaign is refused before anything is read, even here. A completion that
/// listed the whole board because the name was misspelled would be worse than one that
/// printed nothing.
#[test]
fn ls_ids_still_refuses_an_unknown_campaign() {
let temp = TempDir::new().unwrap();
let worklane = setup_worklane(&temp);
create_ticket_with_id(
&worklane,
"backlog",
"Feature A",
"aaaaaaa1-0000-0000-0000-000000000001",
"bug",
);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path())
.args(["ls", "--ids", "--campaign", "no such campaign"]);
cmd.assert().failure();
}
/// A status the board is missing is skipped rather than refused, unlike the listing:
/// the caller is a shell filling in candidates, and an error printed over the prompt is
/// worse there than no candidates.
#[test]
fn ls_ids_is_quiet_about_a_missing_status_directory() {
let temp = TempDir::new().unwrap();
let worklane = temp.child(".worklane");
worklane.create_dir_all().unwrap();
worklane.child("backlog").create_dir_all().unwrap();
create_ticket_with_id(
worklane.path(),
"backlog",
"Feature A",
"aaaaaaa1-0000-0000-0000-000000000001",
"bug",
);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).args(["ls", "--ids"]);
cmd.assert().success();
let stdout = get_stdout(&mut cmd);
assert_eq!(stdout, "aaaaaaa\tFeature A\n", "{stdout:?}");
// The listing still says so, since a person reading it can act on it.
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
cmd.current_dir(temp.path()).args(["ls", "done"]);
let assert = cmd.assert().failure();
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
assert!(stderr.contains("No 'done' directory"), "{stderr}");
}
/// A status outside the four is clap's to refuse now, so it is a usage error naming the
/// four rather than a runtime one.
#[test]
fn ls_names_the_four_statuses_when_given_another() {
let temp = TempDir::new().unwrap();
setup_worklane(&temp);
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
let assert = cmd
.current_dir(temp.path())
.args(["ls", "nonexistent"])
.assert()
.code(2);
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
assert!(stderr.contains("invalid value 'nonexistent'"), "{stderr}");
for status in ["backlog", "committed", "reviewing", "done"] {
assert!(stderr.contains(status), "{status} is not offered: {stderr}");
}
}