mv writes Committed On, Submitted On or Completed On for the status it enters, so the board answers how long a ticket has been where it is without guessing from file mtimes. The three are mutually exclusive: entering stamps, leaving removes and re-entering restamps, so a backward move under -f leaves no stale Completed On behind. These fields are current state, like Status itself; the trail of how the ticket got there belongs to the history log. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
696 lines
25 KiB
Rust
696 lines
25 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}");
|
|
}
|
|
}
|
|
|
|
/// The listing reads the fields it prints and nothing else, so the stamps `mv` writes
|
|
/// do not reach it. Pinned against a ticket carrying one, since a listing that started
|
|
/// showing them would change the output every board and completion script parses.
|
|
#[test]
|
|
fn ls_output_is_unchanged_by_a_status_stamp() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
create_ticket(&worklane, "committed", "Stamped", "alice", "2026-06-01");
|
|
let path = worklane
|
|
.join("committed")
|
|
.join("00000000-0000-0000-0000-000000000001_stamped.md");
|
|
let before = {
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(temp.path()).arg("ls").arg("committed");
|
|
get_stdout(&mut cmd)
|
|
};
|
|
|
|
let stamped = fs::read_to_string(&path)
|
|
.unwrap()
|
|
.replace("- **Status**:", "- **Committed On**: 2026-08-22 09:14:30\n- **Status**:");
|
|
fs::write(&path, stamped).unwrap();
|
|
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(temp.path()).arg("ls").arg("committed");
|
|
let after = get_stdout(&mut cmd);
|
|
|
|
assert_eq!(after, before);
|
|
assert!(!after.contains("Committed On"), "{after}");
|
|
}
|