Tickets carry a Tags field, but ls could not select on it: finding what is tagged bug meant reading the board. Step 1 of the plan was already done by e41802b, which put tags: Vec<String> on TicketItem through parse_tags, so this is the flag, the filter and the tests. Whole values, not the field. parse_tags has already split and trimmed the comma-separated field, so filter_by_tag compares against those values: --tag bug is not answered by a ticket tagged bugfix, --tag "cli, filter" matches nothing because the field as written is not itself a tag, and a ticket with no tags matches none, however it spells it. Case sensitive, which is the opinion the field already takes everywhere else. tag_color draws Bug and bug in two colours because they are two tags to the field, and a filter that folded them would list tickets carrying a tag nobody asked for while hiding exactly the split a grooming sweep is looking for. One tag per invocation. Several would have to decide between and and or, and that decision is its own ticket, along with substring or regex matching and a tag filter on the board. A tag nothing carries lists nothing rather than being refused, deliberately the opposite of --campaign. A campaign is an object that exists or does not, so it is resolved before anything is read; a tag is free text with no registry, and refusing an unknown one would mean maintaining a vocabulary the format does not have. An emptied status keeps the message ls already gives rather than one per filter naming what excluded them, which is what --priority and --campaign already do. The filter goes through filtered, the one call the three collect sites share, so the counts are filtered by the same set as the rows. Every filter is an Option and none asked for keeps everything, which is what makes them compose in any combination. cmd_ls is now at four filters and the directory, two of them adjacent &Option<String> parameters a caller can swap silently: left as positionals rather than refactored mid-feature, with AGENTS.md recording that the next filter takes an LsArgs struct the way add took AddArgs. assets/PLAN.md said in as many words that there was no tag filter yet, so it would have been actively wrong. It now says what --tag can and cannot answer: it finds what is tagged bug, it does not enumerate the vocabulary, which is the question a grooming sweep starts from. The README's ls row also gained --campaign, which had never been documented there. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
473 lines
18 KiB
Rust
473 lines
18 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}");
|
|
}
|