Layout only, no behaviour and no wording. 161 hunks across 22 files, 98 of them rustfmt joining a call or a message onto the one line it fits on. The config it formats to, and how its four numbers were arrived at, is the commit before this one. Separate so that it is reviewable by not being read: nothing here is a decision, and every decision is next door. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
710 lines
26 KiB
Rust
710 lines
26 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}");
|
|
}
|