campaign ls printed every campaign and offered no way to narrow it, and the row was assembled by hand, so a long title pushed the standing out of line with the row above it and the created date the file already carries was not shown at all. --state takes open, done or empty and matches against Standing::state(), so the derived value keeps one definition: a campaign reads [open] in the listing if and only if --state open lists it. --state rather than --status, which names one of the five ticket statuses everywhere else and would invite --state backlog here. empty is the third value because an empty campaign derives None deliberately, and a filter that could not reach those would leave what has been filed and forgotten answerable only by reading the whole listing. A filter that matches nothing names the value back, since a silent listing reads as the other empty case. The filter reaches --ids as well, the way ls --ids keeps its own, and is the only thing that makes that path count members: an unfiltered completion is as cheap as it was. The columns are measured on the raw values and padded before anything is painted, the rule metadata_cells follows. The codename is measured with the title rather than given a column of its own: a campaign filed without one spends nothing on it, so a column for it would be one most rows pad into and some leave empty, and what a reader lines up is where a name ends and its progress begins. A flag's possible values now come off the command that holds the flag, so campaign ls --state reaches ls's own arguments rather than campaign's. The prompt offered nothing there while fish offered the three values, which made a liar of the rule that a ValueEnum added anywhere is typeable on the board the day it is added. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
1901 lines
69 KiB
Rust
1901 lines
69 KiB
Rust
use assert_cmd::Command;
|
|
use assert_fs::TempDir;
|
|
use assert_fs::fixture::{PathChild, PathCreateDir};
|
|
use std::fs;
|
|
use std::path::{Path, PathBuf};
|
|
|
|
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
|
|
|
|
/// Two campaigns, so a filter has something to exclude, and three tickets: one in each
|
|
/// campaign and one in neither.
|
|
const CAMP_A: &str = "aa11bb22-33cc-4dd4-8ee5-ff6677889900";
|
|
const CAMP_B: &str = "bb22cc33-44dd-4ee5-8ff6-001122334455";
|
|
const MEMBER: &str = "641e3d5c-1b0e-4d2f-9a7e-3c8b5f0a2d61";
|
|
const OTHER: &str = "b1b2c3d4-5e6f-4a7b-8c9d-0e1f2a3b4c5d";
|
|
const LONER: &str = "f1f2f3f4-5a6b-4c7d-8e9f-0a1b2c3d4e5f";
|
|
/// A second done member, for the one test that needs two in one column to see an order.
|
|
const LATE: &str = "a9a8a7a6-5b4c-4d3e-8f2a-1b0c9d8e7f60";
|
|
|
|
fn setup_worklane(temp: &TempDir) -> PathBuf {
|
|
let worklane = temp.child(".worklane");
|
|
worklane.create_dir_all().unwrap();
|
|
|
|
for dir in ["backlog", "committed", "reviewing", "done", "campaigns"] {
|
|
worklane.child(dir).create_dir_all().unwrap();
|
|
}
|
|
|
|
worklane.path().to_path_buf()
|
|
}
|
|
|
|
fn slug(title: &str) -> String {
|
|
title
|
|
.to_lowercase()
|
|
.chars()
|
|
.filter(|c| c.is_alphanumeric() || *c == ' ' || *c == '-' || *c == '_')
|
|
.map(|c| if c == ' ' { '-' } else { c })
|
|
.collect()
|
|
}
|
|
|
|
/// A ticket with a ticked criterion, a section the tool knows nothing about and a
|
|
/// metadata field it has never heard of, so every test can check that an assignment
|
|
/// leaves all three exactly as they were.
|
|
///
|
|
/// Deliberately carries no Campaign field: no ticket written before campaigns existed
|
|
/// has one, and `add` still does not write one, so the insertion path is what every
|
|
/// assignment goes through.
|
|
fn create_ticket(worklane: &Path, status: &str, title: &str, uuid: &str) -> PathBuf {
|
|
let path = worklane
|
|
.join(status)
|
|
.join(format!("{}_{}.md", uuid, slug(title)));
|
|
|
|
fs::write(
|
|
&path,
|
|
format!(
|
|
"# {title}\n\
|
|
\n\
|
|
## Description\n\
|
|
Prose that mentions **Campaign**: not a field, in the body.\n\
|
|
\n\
|
|
## Acceptance Criteria\n\
|
|
- [x] Crit one\n\
|
|
\n\
|
|
## Implementation Plan\n\
|
|
1. Step one\n\
|
|
\n\
|
|
## Notes\n\
|
|
A handwritten note the tool knows nothing about.\n\
|
|
\n\
|
|
## Metadata\n\
|
|
\n\
|
|
- **ID**: {uuid}\n\
|
|
- **Priority**: 3\n\
|
|
- **Tags**: alpha\n\
|
|
- **Due**: _Not set_\n\
|
|
- **Handled By Team**: ops\n\
|
|
- **Owner**: alice\n\
|
|
- **Created At**: 2026-08-21 02:10:17\n\
|
|
- **Status**: {status}\n"
|
|
),
|
|
)
|
|
.unwrap();
|
|
|
|
path
|
|
}
|
|
|
|
fn create_campaign(worklane: &Path, title: &str, uuid: &str) -> PathBuf {
|
|
let path = worklane
|
|
.join("campaigns")
|
|
.join(format!("{}_{}.md", uuid, slug(title)));
|
|
|
|
fs::write(
|
|
&path,
|
|
format!(
|
|
"# {title}\n\
|
|
\n\
|
|
## Description\n\
|
|
What has to ship together.\n\
|
|
\n\
|
|
## Metadata\n\
|
|
\n\
|
|
- **ID**: {uuid}\n\
|
|
- **Owner**: alice\n\
|
|
- **Created At**: 2026-08-21 02:10:17\n"
|
|
),
|
|
)
|
|
.unwrap();
|
|
|
|
path
|
|
}
|
|
|
|
fn board(temp: &TempDir) -> PathBuf {
|
|
let worklane = setup_worklane(temp);
|
|
create_campaign(&worklane, "v1 release", CAMP_A);
|
|
create_campaign(&worklane, "v2 release", CAMP_B);
|
|
create_ticket(&worklane, "backlog", "The member", MEMBER);
|
|
create_ticket(&worklane, "done", "The other member", OTHER);
|
|
create_ticket(&worklane, "backlog", "The loner", LONER);
|
|
worklane
|
|
}
|
|
|
|
fn run(temp: &TempDir, args: &[&str]) -> std::process::Output {
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(temp.path()).args(args);
|
|
cmd.assert().get_output().clone()
|
|
}
|
|
|
|
fn stdout(out: &std::process::Output) -> String {
|
|
String::from_utf8_lossy(&out.stdout).to_string()
|
|
}
|
|
|
|
fn stderr(out: &std::process::Output) -> String {
|
|
String::from_utf8_lossy(&out.stderr).to_string()
|
|
}
|
|
|
|
/// A listing with its column padding collapsed, for an assertion about what a row says
|
|
/// rather than about where its columns sit.
|
|
///
|
|
/// The alignment is the subject of `campaign_ls_lines_its_columns_up_whatever_the_titles_are`
|
|
/// and of the colour test beside `cmd_campaign_ls`; every other test is about the words,
|
|
/// and one that spelled the padding out would have to be edited whenever a fixture gained
|
|
/// a longer title.
|
|
fn squeezed(listing: &str) -> String {
|
|
listing
|
|
.lines()
|
|
.map(|line| line.split_whitespace().collect::<Vec<_>>().join(" "))
|
|
.collect::<Vec<_>>()
|
|
.join("\n")
|
|
}
|
|
|
|
fn find(worklane: &Path, uuid: &str) -> PathBuf {
|
|
for status in ["backlog", "committed", "reviewing", "done"] {
|
|
for entry in fs::read_dir(worklane.join(status))
|
|
.unwrap()
|
|
.filter_map(|e| e.ok())
|
|
{
|
|
if entry.file_name().to_string_lossy().starts_with(uuid) {
|
|
return entry.path();
|
|
}
|
|
}
|
|
}
|
|
|
|
panic!("no file for ticket {uuid}");
|
|
}
|
|
|
|
/// A campaign's content by uuid, found rather than named, since `campaign set --title`
|
|
/// renames the file and a test that named it would be asserting the old name.
|
|
fn campaign_file(worklane: &Path, uuid: &str) -> String {
|
|
for entry in fs::read_dir(worklane.join("campaigns"))
|
|
.unwrap()
|
|
.filter_map(|e| e.ok())
|
|
{
|
|
if entry.file_name().to_string_lossy().starts_with(uuid) {
|
|
return fs::read_to_string(entry.path()).unwrap();
|
|
}
|
|
}
|
|
|
|
panic!("no file for campaign {uuid}");
|
|
}
|
|
|
|
fn ticket(worklane: &Path, uuid: &str) -> String {
|
|
fs::read_to_string(find(worklane, uuid)).unwrap()
|
|
}
|
|
|
|
fn campaigns(worklane: &Path) -> Vec<String> {
|
|
let mut names: Vec<String> = fs::read_dir(worklane.join("campaigns"))
|
|
.unwrap()
|
|
.filter_map(|e| e.ok())
|
|
.map(|e| e.file_name().to_string_lossy().to_string())
|
|
.collect();
|
|
names.sort();
|
|
names
|
|
}
|
|
|
|
// ------------------------------------------------------------------ filing one --
|
|
|
|
#[test]
|
|
fn campaign_add_writes_a_uuid_title_description_and_metadata() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let out = run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"add",
|
|
"--title",
|
|
"v1 release",
|
|
"--description",
|
|
"Everything that ships together.",
|
|
"--owner",
|
|
"alice",
|
|
],
|
|
);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
|
|
let names = campaigns(&worklane);
|
|
assert_eq!(names.len(), 1, "{names:?}");
|
|
let name = &names[0];
|
|
assert!(name.ends_with("_v1-release.md"), "{name}");
|
|
|
|
let content = fs::read_to_string(worklane.join("campaigns").join(name)).unwrap();
|
|
assert!(content.starts_with("# v1 release\n"), "{content}");
|
|
assert!(content.contains("Everything that ships together."), "{content}");
|
|
assert!(content.contains("- **Owner**: alice"), "{content}");
|
|
assert!(content.contains("- **Created At**: 20"), "{content}");
|
|
|
|
// The uuid in the file is the one in the filename, since that is what `assign`
|
|
// stores and what every lookup compares against.
|
|
let uuid = name.split('_').next().unwrap();
|
|
assert!(content.contains(&format!("- **ID**: {uuid}")), "{content}");
|
|
}
|
|
|
|
/// A campaign has no status, so its file carries none. A Status field would be a second
|
|
/// place for a state that is derived, and the two would disagree the moment a member
|
|
/// moved.
|
|
#[test]
|
|
fn a_campaign_carries_no_status_and_no_criteria() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
run(&temp, &["campaign", "add", "--title", "v1 release"]);
|
|
|
|
let name = campaigns(&worklane).remove(0);
|
|
let content = fs::read_to_string(worklane.join("campaigns").join(name)).unwrap();
|
|
|
|
assert!(!content.contains("**Status**"), "{content}");
|
|
assert!(!content.contains("Acceptance Criteria"), "{content}");
|
|
assert!(!content.contains("Implementation Plan"), "{content}");
|
|
}
|
|
|
|
#[test]
|
|
fn nothing_is_created_without_a_title() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let out = run(&temp, &["campaign", "add", "--description", "No title here."]);
|
|
|
|
assert_eq!(out.status.code(), Some(2), "{}", stderr(&out));
|
|
assert!(campaigns(&worklane).is_empty(), "{:?}", campaigns(&worklane));
|
|
}
|
|
|
|
#[test]
|
|
fn init_creates_the_campaigns_directory() {
|
|
let temp = TempDir::new().unwrap();
|
|
|
|
// Isolated HOME and XDG so `init` cannot decide on a real machine's boards config:
|
|
// the board has to be local no matter whose machine runs the suite.
|
|
let mut init = Command::cargo_bin(BIN_NAME).unwrap();
|
|
let out = init
|
|
.current_dir(temp.path())
|
|
.env("HOME", temp.path())
|
|
.env("XDG_CONFIG_HOME", temp.path().join("config"))
|
|
.env("XDG_DATA_HOME", temp.path().join("data"))
|
|
.arg("init")
|
|
.output()
|
|
.unwrap();
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
|
|
assert!(temp.child(".worklane").child("campaigns").path().is_dir());
|
|
}
|
|
|
|
/// A board made before campaigns existed has no such directory, and a `worklane init`
|
|
/// over a live board to get one would be a strange thing to have to do.
|
|
#[test]
|
|
fn the_campaigns_directory_is_created_for_a_board_that_predates_it() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = temp.child(".worklane");
|
|
worklane.create_dir_all().unwrap();
|
|
for dir in ["backlog", "committed", "reviewing", "done"] {
|
|
worklane.child(dir).create_dir_all().unwrap();
|
|
}
|
|
assert!(!worklane.child("campaigns").path().exists());
|
|
|
|
let out = run(&temp, &["campaign", "add", "--title", "v1 release"]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
|
|
assert_eq!(campaigns(worklane.path()).len(), 1);
|
|
}
|
|
|
|
// -------------------------------------------------------------------- assigning --
|
|
|
|
#[test]
|
|
fn assign_writes_the_campaign_field_in_the_metadata_section() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let out = run(&temp, &["assign", "v1 release", MEMBER]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
|
|
let content = ticket(&worklane, MEMBER);
|
|
assert!(content.contains(&format!("- **Campaign**: {CAMP_A}")), "{content}");
|
|
|
|
// Scoped to the section: the description quotes the marker, and the field has to
|
|
// land under the heading rather than over the prose.
|
|
let metadata = content.split("## Metadata").nth(1).unwrap();
|
|
assert!(metadata.contains(&format!("- **Campaign**: {CAMP_A}")), "{content}");
|
|
assert!(
|
|
content.contains("Prose that mentions **Campaign**: not a field, in the body."),
|
|
"the description was rewritten: {content}"
|
|
);
|
|
}
|
|
|
|
/// The field goes in its place among the others rather than at the end, so Status stays
|
|
/// last, which is where every file already keeps it.
|
|
#[test]
|
|
fn the_field_is_inserted_before_status() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
|
|
let content = ticket(&worklane, MEMBER);
|
|
let campaign_at = content.find("- **Campaign**:").unwrap();
|
|
let status_at = content.find("- **Status**:").unwrap();
|
|
assert!(campaign_at < status_at, "{content}");
|
|
}
|
|
|
|
/// All three tiers, since a campaign is addressed the way a ticket is: a uuid prefix, a
|
|
/// title substring, and a substring reaching the middle of the filename.
|
|
#[test]
|
|
fn a_campaign_resolves_by_uuid_prefix_title_or_filename() {
|
|
for search in ["aa11", "v1 release", "4dd4"] {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let out = run(&temp, &["assign", search, MEMBER]);
|
|
assert!(out.status.success(), "{search}: {}", stderr(&out));
|
|
assert!(
|
|
ticket(&worklane, MEMBER).contains(&format!("- **Campaign**: {CAMP_A}")),
|
|
"{search}: {}",
|
|
ticket(&worklane, MEMBER)
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_ticket_names_at_most_one_campaign() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
let out = run(&temp, &["assign", "v2 release", MEMBER]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
|
|
let content = ticket(&worklane, MEMBER);
|
|
assert_eq!(
|
|
content.matches("- **Campaign**:").count(),
|
|
1,
|
|
"reassigning added a second field: {content}"
|
|
);
|
|
assert!(content.contains(&format!("- **Campaign**: {CAMP_B}")), "{content}");
|
|
assert!(!content.contains(CAMP_A), "{content}");
|
|
}
|
|
|
|
#[test]
|
|
fn assigning_the_campaign_already_named_writes_nothing() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
let before = ticket(&worklane, MEMBER);
|
|
|
|
let out = run(&temp, &["assign", "v1 release", MEMBER]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(stdout(&out).contains("already in campaign"), "{}", stdout(&out));
|
|
assert_eq!(ticket(&worklane, MEMBER), before);
|
|
}
|
|
|
|
/// The campaign is resolved before the ticket is touched, so a call naming a good
|
|
/// ticket and a campaign that does not exist writes nothing at all.
|
|
#[test]
|
|
fn an_unknown_campaign_leaves_the_ticket_alone() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
let before = ticket(&worklane, MEMBER);
|
|
|
|
let out = run(&temp, &["assign", "v9 release", MEMBER]);
|
|
|
|
assert!(!out.status.success());
|
|
assert!(stderr(&out).contains("No campaign found matching"), "{}", stderr(&out));
|
|
assert_eq!(ticket(&worklane, MEMBER), before);
|
|
}
|
|
|
|
#[test]
|
|
fn content_the_tool_does_not_know_survives_an_assignment() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
|
|
let content = ticket(&worklane, MEMBER);
|
|
assert!(content.contains("## Notes"), "{content}");
|
|
assert!(
|
|
content.contains("A handwritten note the tool knows nothing about."),
|
|
"{content}"
|
|
);
|
|
assert!(content.contains("- **Handled By Team**: ops"), "{content}");
|
|
// And the ticked criterion is still ticked.
|
|
assert!(content.contains("- [x] Crit one"), "{content}");
|
|
}
|
|
|
|
/// One field, one writer. `assign` owns Campaign the way `chown` owns Owner.
|
|
#[test]
|
|
fn neither_add_nor_set_offers_a_campaign_flag() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let added = run(&temp, &["add", "--title", "New one", "--campaign", "v1 release"]);
|
|
assert_eq!(added.status.code(), Some(2), "{}", stderr(&added));
|
|
|
|
let set = run(&temp, &["set", MEMBER, "--campaign", "v1 release"]);
|
|
assert_eq!(set.status.code(), Some(2), "{}", stderr(&set));
|
|
|
|
// The stored shape, not the bare marker: the fixture description quotes the marker
|
|
// on purpose, so an unscoped match here would pass whatever the commands did.
|
|
assert!(!ticket(&worklane, MEMBER).contains("- **Campaign**:"));
|
|
}
|
|
|
|
// --------------------------------------------------------------------- reading --
|
|
|
|
#[test]
|
|
fn campaign_ls_lists_campaigns_with_their_member_counts() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
run(&temp, &["assign", "v1 release", OTHER]);
|
|
|
|
let out = run(&temp, &["campaign", "ls"]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
|
|
let listing = squeezed(&stdout(&out));
|
|
// One of the two members is in done, so the campaign is open and half finished.
|
|
assert!(listing.contains("v1 release | 1/2 done [open]"), "{listing}");
|
|
// Nothing has been filed against the other one.
|
|
assert!(listing.contains("v2 release | no members"), "{listing}");
|
|
}
|
|
|
|
/// The machine-readable listing, the same two fields and the same shape as `ls --ids`.
|
|
#[test]
|
|
fn campaign_ls_ids_prints_the_id_and_the_title_tab_separated() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
|
|
let out = run(&temp, &["campaign", "ls", "--ids"]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
|
|
let listing = stdout(&out);
|
|
assert_eq!(
|
|
listing.lines().collect::<Vec<_>>(),
|
|
vec![
|
|
format!("{}\tv1 release", &CAMP_A[..7]),
|
|
format!("{}\tv2 release", &CAMP_B[..7]),
|
|
]
|
|
);
|
|
|
|
// Nothing decorated: no heading, no member count, no escape.
|
|
assert!(!listing.contains("Campaigns:"), "{listing}");
|
|
assert!(!listing.contains("done"), "{listing}");
|
|
assert!(!listing.contains('\u{1b}'), "{listing}");
|
|
}
|
|
|
|
/// A completion offers nothing rather than a sentence, so the empty case that prints
|
|
/// prose for a reader has to stay out of the parsed path.
|
|
#[test]
|
|
fn campaign_ls_ids_says_nothing_on_a_board_with_no_campaigns() {
|
|
let temp = TempDir::new().unwrap();
|
|
setup_worklane(&temp);
|
|
|
|
let out = run(&temp, &["campaign", "ls", "--ids"]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert_eq!(stdout(&out), "");
|
|
|
|
// The decorated listing still explains itself.
|
|
assert!(stdout(&run(&temp, &["campaign", "ls"])).contains("No campaigns yet"));
|
|
}
|
|
|
|
/// The state filter, against the same three answers `Standing::state` gives: a campaign
|
|
/// with work left, one with none, and one nothing has been filed against.
|
|
#[test]
|
|
fn campaign_ls_state_lists_only_the_campaigns_in_that_state() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
// v1 holds a backlog member and v2 holds a done one, so the two are open and done.
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
run(&temp, &["assign", "v2 release", OTHER]);
|
|
run(&temp, &["campaign", "add", "--title", "Nothing filed yet"]);
|
|
|
|
let open = squeezed(&stdout(&run(&temp, &["campaign", "ls", "--state", "open"])));
|
|
assert!(open.contains("v1 release | 0/1 done [open]"), "{open}");
|
|
assert!(!open.contains("v2 release"), "a done campaign was listed as open: {open}");
|
|
assert!(!open.contains("Nothing filed yet"), "{open}");
|
|
|
|
let done = squeezed(&stdout(&run(&temp, &["campaign", "ls", "--state", "done"])));
|
|
assert!(done.contains("v2 release | 1/1 done [done]"), "{done}");
|
|
assert!(!done.contains("v1 release"), "{done}");
|
|
|
|
// The third value, which is what makes every campaign on the board reachable: a
|
|
// memberless one is neither open nor done, deliberately, and it is the one a
|
|
// grooming sweep is looking for.
|
|
let empty = squeezed(&stdout(&run(&temp, &["campaign", "ls", "--state", "empty"])));
|
|
assert!(empty.contains("Nothing filed yet | no members"), "{empty}");
|
|
assert!(!empty.contains("v1 release"), "{empty}");
|
|
assert!(!empty.contains("v2 release"), "{empty}");
|
|
|
|
// And it reaches the machine-readable listing the way `ls --ids` keeps its filters.
|
|
let ids = stdout(&run(&temp, &["campaign", "ls", "--ids", "--state", "empty"]));
|
|
assert_eq!(ids.lines().count(), 1, "{ids}");
|
|
assert!(ids.contains("Nothing filed yet"), "{ids}");
|
|
}
|
|
|
|
/// A value the enum does not hold is clap's to refuse, so nothing is read and the exit
|
|
/// code is the usage error's.
|
|
#[test]
|
|
fn campaign_ls_refuses_a_state_that_is_not_one() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
let out = run(&temp, &["campaign", "ls", "--state", "backlog"]);
|
|
assert_eq!(out.status.code(), Some(2), "{}", stderr(&out));
|
|
let said = stderr(&out);
|
|
assert!(said.contains("open"), "{said}");
|
|
assert!(said.contains("empty"), "{said}");
|
|
}
|
|
|
|
/// A filter that matches nothing says so and names what was asked for. Going silent
|
|
/// would read as the other empty case, a board with no campaigns on it, which has a
|
|
/// message of its own.
|
|
#[test]
|
|
fn campaign_ls_says_when_the_filter_matched_nothing() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
let out = run(&temp, &["campaign", "ls", "--state", "done"]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
let said = stdout(&out);
|
|
assert!(said.contains("--state done"), "the filter is not named: {said}");
|
|
assert!(!said.contains("No campaigns yet"), "the other empty case: {said}");
|
|
|
|
// The completion path stays silent, filtered or not.
|
|
assert_eq!(stdout(&run(&temp, &["campaign", "ls", "--ids", "--state", "done"])), "");
|
|
}
|
|
|
|
/// The columns line up whatever the titles are, which is what the padding is for. The
|
|
/// fixture's two titles are the same length, so this one files a third with a long title
|
|
/// and a codename: the row that pushes the column is the row that proves it moved for
|
|
/// every other row too.
|
|
#[test]
|
|
fn campaign_ls_lines_its_columns_up_whatever_the_titles_are() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"add",
|
|
"--title",
|
|
"A campaign with a much longer title than the others",
|
|
"--codename",
|
|
"beaver",
|
|
],
|
|
);
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
|
|
let listing = stdout(&run(&temp, &["campaign", "ls"]));
|
|
let rows: Vec<&str> = listing.lines().filter(|line| line.contains(" | ")).collect();
|
|
assert_eq!(rows.len(), 3, "{listing}");
|
|
|
|
for column in [" (", " | "] {
|
|
let offsets: Vec<Option<usize>> = rows.iter().map(|row| row.find(column)).collect();
|
|
assert!(
|
|
offsets.iter().all(|at| *at == offsets[0]),
|
|
"`{column}` is ragged across the rows:\n{listing}"
|
|
);
|
|
}
|
|
|
|
// The state sits at one offset too, on the rows that have one: a campaign with no
|
|
// members has nothing in brackets and pads to where the next row's bracket is.
|
|
let states: Vec<Option<usize>> = rows
|
|
.iter()
|
|
.filter(|row| row.contains('['))
|
|
.map(|row| row.find('['))
|
|
.collect();
|
|
assert!(!states.is_empty(), "no row carried a state: {listing}");
|
|
assert!(
|
|
states.iter().all(|at| *at == states[0]),
|
|
"the state column is ragged:\n{listing}"
|
|
);
|
|
}
|
|
|
|
/// The created stamp the campaign file already carries, in the form `ls` prints one in
|
|
/// rather than a second spelling of a date.
|
|
#[test]
|
|
fn campaign_ls_shows_the_created_date() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
let listing = stdout(&run(&temp, &["campaign", "ls"]));
|
|
assert!(listing.contains("26-08-21:02"), "no created stamp: {listing}");
|
|
|
|
// Not in the machine-readable listing, which is the id and the title and nothing else.
|
|
let ids = stdout(&run(&temp, &["campaign", "ls", "--ids"]));
|
|
assert!(!ids.contains("26-08-21"), "{ids}");
|
|
}
|
|
|
|
/// A campaign is done when it holds members and every one of them is done. An empty one
|
|
/// is neither, which is why it reads `no members` rather than `0/0 done`.
|
|
#[test]
|
|
fn a_campaign_whose_every_member_is_done_reads_done() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
run(&temp, &["assign", "v1 release", OTHER]);
|
|
|
|
let listing = squeezed(&stdout(&run(&temp, &["campaign", "ls"])));
|
|
assert!(listing.contains("v1 release | 1/1 done [done]"), "{listing}");
|
|
}
|
|
|
|
#[test]
|
|
fn campaign_show_prints_the_body_and_the_members_grouped_by_status() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
run(&temp, &["assign", "v1 release", OTHER]);
|
|
|
|
let out = run(&temp, &["campaign", "show", "aa11"]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
|
|
let shown = stdout(&out);
|
|
assert!(shown.contains("v1 release"), "{shown}");
|
|
assert!(shown.contains("What has to ship together."), "{shown}");
|
|
assert!(shown.contains("1/2 done"), "{shown}");
|
|
assert!(shown.contains("[BACKLOG]"), "{shown}");
|
|
assert!(shown.contains("The member"), "{shown}");
|
|
// Done members are shown here, unlike in `ls`: what is finished against what is
|
|
// left is the whole question a campaign asks.
|
|
assert!(shown.contains("[DONE]"), "{shown}");
|
|
assert!(shown.contains("The other member"), "{shown}");
|
|
// And a ticket in no campaign is not a member of this one.
|
|
assert!(!shown.contains("The loner"), "{shown}");
|
|
}
|
|
|
|
/// The members of a status are listed in that status's own order, not in the board-wide
|
|
/// one: a campaign's done list answers what just landed, for the same reason the board's
|
|
/// column does. Every fixture is a p3, so the stamp is doing all of the work.
|
|
#[test]
|
|
fn campaign_show_lists_each_status_in_its_own_order() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let stamp = |uuid: &str, day: &str| {
|
|
let path = find(&worklane, uuid);
|
|
let body = fs::read_to_string(&path).unwrap().replace(
|
|
"- **Status**: done\n",
|
|
&format!("- **Completed On**: 2026-08-0{day} 09:00:00\n- **Status**: done\n"),
|
|
);
|
|
fs::write(&path, body).unwrap();
|
|
};
|
|
|
|
// A second done member, finished after the one the fixture writes.
|
|
create_ticket(&worklane, "done", "The late member", LATE);
|
|
stamp(OTHER, "1");
|
|
stamp(LATE, "3");
|
|
|
|
run(&temp, &["assign", "v1 release", OTHER]);
|
|
run(&temp, &["assign", "v1 release", LATE]);
|
|
|
|
let shown = stdout(&run(&temp, &["campaign", "show", "aa11"]));
|
|
let at = |needle: &str| shown.find(needle).unwrap_or_else(|| panic!("{needle}: {shown}"));
|
|
|
|
assert!(at("The late member") < at("The other member"), "{shown}");
|
|
}
|
|
|
|
#[test]
|
|
fn ls_campaign_lists_only_that_campaigns_members() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
run(&temp, &["assign", "v2 release", LONER]);
|
|
|
|
let out = run(&temp, &["ls", "--campaign", "v1 release"]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
|
|
let listing = stdout(&out);
|
|
assert!(listing.contains("The member"), "{listing}");
|
|
assert!(!listing.contains("The loner"), "{listing}");
|
|
assert!(listing.contains("[BACKLOG] 1 ticket"), "{listing}");
|
|
}
|
|
|
|
#[test]
|
|
fn ls_campaign_refuses_a_campaign_that_does_not_exist() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
let out = run(&temp, &["ls", "--campaign", "v9 release"]);
|
|
|
|
assert!(!out.status.success());
|
|
assert!(stderr(&out).contains("No campaign found matching"), "{}", stderr(&out));
|
|
}
|
|
|
|
/// The stored value is a full uuid, so a campaign that has been deleted has to be
|
|
/// reported as gone rather than shown raw, the way a dangling relation target is.
|
|
#[test]
|
|
fn a_campaign_that_no_longer_exists_reads_as_missing() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
fs::remove_file(
|
|
worklane
|
|
.join("campaigns")
|
|
.join(format!("{CAMP_A}_v1-release.md")),
|
|
)
|
|
.unwrap();
|
|
|
|
let out = run(&temp, &["show", MEMBER]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
|
|
let shown = stdout(&out);
|
|
assert!(shown.contains("_missing_"), "{shown}");
|
|
// The short id survives, since it is the only thing left to go looking for.
|
|
assert!(shown.contains("(aa11bb2)"), "{shown}");
|
|
assert!(!shown.contains(CAMP_A), "the bare uuid was shown: {shown}");
|
|
}
|
|
|
|
/// The title is shown rather than the uuid the file stores: thirty-six characters of
|
|
/// hex in a metadata table say nothing about which campaign it is.
|
|
#[test]
|
|
fn a_ticket_shows_the_campaign_title_not_its_uuid() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
|
|
let shown = stdout(&run(&temp, &["show", MEMBER]));
|
|
assert!(shown.contains("(aa11bb2) v1 release"), "{shown}");
|
|
assert!(!shown.contains(CAMP_A), "{shown}");
|
|
}
|
|
|
|
// -------------------------------------------------------------- not a ticket --
|
|
|
|
/// A campaign is in no status directory, so `mv` has nothing to move. It says so rather
|
|
/// than reporting a ticket it could not find, which would send the caller hunting for a
|
|
/// typo in a name that is perfectly correct.
|
|
#[test]
|
|
fn mv_refuses_a_campaign() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let out = run(&temp, &["mv", "v1 release", "--status", "committed"]);
|
|
|
|
assert!(!out.status.success());
|
|
let message = stderr(&out);
|
|
assert!(message.contains("is a campaign, not a ticket"), "{message}");
|
|
assert!(message.contains("no status directory"), "{message}");
|
|
|
|
// And it stayed where it was: nothing was moved into a status directory.
|
|
assert!(
|
|
worklane
|
|
.join("campaigns")
|
|
.join(format!("{CAMP_A}_v1-release.md"))
|
|
.exists()
|
|
);
|
|
for status in ["backlog", "committed", "reviewing", "done"] {
|
|
let moved = fs::read_dir(worklane.join(status))
|
|
.unwrap()
|
|
.filter_map(|e| e.ok())
|
|
.any(|e| e.file_name().to_string_lossy().starts_with(CAMP_A));
|
|
assert!(!moved, "a campaign reached the {status} directory");
|
|
}
|
|
}
|
|
|
|
/// Every command that takes a ticket gives the same explanation, because the refusal is
|
|
/// in resolution rather than in `mv`.
|
|
#[test]
|
|
fn a_campaign_is_refused_wherever_a_ticket_is_expected() {
|
|
for args in [
|
|
vec!["show", "v1 release"],
|
|
vec!["comment", "v1 release", "A note."],
|
|
vec!["chown", "bob", "v1 release"],
|
|
] {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
let out = run(&temp, &args);
|
|
assert!(!out.status.success(), "{args:?}");
|
|
assert!(
|
|
stderr(&out).contains("is a campaign, not a ticket"),
|
|
"{args:?}: {}",
|
|
stderr(&out)
|
|
);
|
|
}
|
|
}
|
|
|
|
/// A search that names neither still says nothing was found, rather than complaining
|
|
/// about a directory the caller never mentioned.
|
|
#[test]
|
|
fn a_search_that_names_nothing_still_reports_no_ticket() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
let out = run(&temp, &["show", "nothing at all"]);
|
|
|
|
assert!(!out.status.success());
|
|
assert!(stderr(&out).contains("No ticket found matching"), "{}", stderr(&out));
|
|
}
|
|
|
|
/// A campaign resolves by the same tiers a ticket does, so it can be ambiguous the same
|
|
/// way, and the listing has to name campaigns rather than tickets.
|
|
#[test]
|
|
fn an_ambiguous_campaign_lists_the_candidates() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
let out = run(&temp, &["campaign", "show", "release"]);
|
|
|
|
assert!(!out.status.success());
|
|
let message = stderr(&out);
|
|
assert!(message.contains("Multiple campaigns found matching"), "{message}");
|
|
assert!(message.contains("v1 release"), "{message}");
|
|
assert!(message.contains("v2 release"), "{message}");
|
|
}
|
|
|
|
// ------------------------------------------------------------------ codenames --
|
|
|
|
/// The codename is what the board draws on every card in a campaign, since a uuid does
|
|
/// not fit there and a title is a sentence.
|
|
#[test]
|
|
fn campaign_add_writes_the_codename_under_the_id() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let out = run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"add",
|
|
"--title",
|
|
"First public release",
|
|
"--codename",
|
|
"v1",
|
|
],
|
|
);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
|
|
let name = campaigns(&worklane).remove(0);
|
|
let content = fs::read_to_string(worklane.join("campaigns").join(name)).unwrap();
|
|
|
|
assert!(content.contains("- **Codename**: v1"), "{content}");
|
|
// Under the ID, because that is what it is: a second way to say which campaign this
|
|
// is, in a word rather than in thirty-six characters.
|
|
let id = content.find("- **ID**:").expect("no id");
|
|
let codename = content.find("- **Codename**:").expect("no codename");
|
|
let owner = content.find("- **Owner**:").expect("no owner");
|
|
assert!(id < codename && codename < owner, "{content}");
|
|
}
|
|
|
|
/// A campaign filed without one carries the line unset rather than not at all, the way
|
|
/// `add` writes an unset Due on every ticket: one shape of file is one thing for the
|
|
/// parser to be right about, and the line is there to fill in by hand.
|
|
#[test]
|
|
fn a_campaign_filed_without_a_codename_carries_the_field_unset() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
run(&temp, &["campaign", "add", "--title", "No codename here"]);
|
|
|
|
let name = campaigns(&worklane).remove(0);
|
|
let content = fs::read_to_string(worklane.join("campaigns").join(name)).unwrap();
|
|
|
|
assert!(content.contains("- **Codename**: _Not set_"), "{content}");
|
|
}
|
|
|
|
/// One word, checked at parse time like `--due` and `--priority`, because the board draws
|
|
/// it as a label with a mark and no quoting: `~beaver release` on that row reads as two
|
|
/// labels and the second one is not a campaign.
|
|
#[test]
|
|
fn a_codename_of_more_than_one_word_is_a_usage_error() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let out = run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"add",
|
|
"--title",
|
|
"v1 release",
|
|
"--codename",
|
|
"beaver release",
|
|
],
|
|
);
|
|
|
|
assert_eq!(out.status.code(), Some(2), "{}", stderr(&out));
|
|
assert!(stderr(&out).contains("single word"), "{}", stderr(&out));
|
|
assert!(campaigns(&worklane).is_empty(), "a campaign was filed anyway");
|
|
}
|
|
|
|
#[test]
|
|
fn an_empty_codename_is_a_usage_error() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let out = run(&temp, &["campaign", "add", "--title", "v1 release", "--codename", ""]);
|
|
|
|
assert_eq!(out.status.code(), Some(2), "{}", stderr(&out));
|
|
assert!(campaigns(&worklane).is_empty(), "a campaign was filed anyway");
|
|
}
|
|
|
|
/// The listing is where the codename is read back, so it goes between the id and the
|
|
/// title with the mark the board draws it with: one word for one campaign, spelled the
|
|
/// same wherever it is shown.
|
|
#[test]
|
|
fn campaign_ls_names_the_codename_between_the_id_and_the_title() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
create_campaign(&worklane, "No codename here", CAMP_B);
|
|
|
|
run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"add",
|
|
"--title",
|
|
"First public release",
|
|
"-c",
|
|
"v1",
|
|
],
|
|
);
|
|
|
|
let out = run(&temp, &["campaign", "ls"]);
|
|
let listing = stdout(&out);
|
|
|
|
assert!(listing.contains("~v1 First public release"), "{listing}");
|
|
// And a campaign without one spends nothing on it, the way an untagged card spends no
|
|
// row.
|
|
assert!(listing.contains(") No codename here"), "{listing}");
|
|
assert!(!listing.contains("~No codename"), "{listing}");
|
|
let _ = worklane;
|
|
}
|
|
|
|
/// `campaign show` renders its metadata as a table, so the field is there to read without
|
|
/// anything being written twice.
|
|
#[test]
|
|
fn campaign_show_renders_the_codename_in_its_metadata() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"add",
|
|
"--title",
|
|
"First public release",
|
|
"-c",
|
|
"v1",
|
|
],
|
|
);
|
|
|
|
let out = run(&temp, &["campaign", "show", "First public"]);
|
|
assert!(stdout(&out).contains("Codename"), "{}", stdout(&out));
|
|
assert!(stdout(&out).contains("v1"), "{}", stdout(&out));
|
|
let _ = worklane;
|
|
}
|
|
|
|
/// A codename nobody can type is half a field, so it resolves a campaign the way its
|
|
/// uuid and its title do. Exact, and ahead of all three: it is a match on a field written
|
|
/// for the purpose rather than a substring that could be a coincidence.
|
|
#[test]
|
|
fn a_campaign_resolves_by_its_codename() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
// Same file, plus a codename, since `create_campaign` writes none.
|
|
let path = worklane
|
|
.join("campaigns")
|
|
.join(format!("{}_{}.md", CAMP_A, slug("v1 release")));
|
|
let content = fs::read_to_string(&path).unwrap();
|
|
fs::write(
|
|
&path,
|
|
content.replace("- **Owner**:", "- **Codename**: beaver\n- **Owner**:"),
|
|
)
|
|
.unwrap();
|
|
|
|
let out = run(&temp, &["assign", "beaver", MEMBER]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(
|
|
ticket(&worklane, MEMBER).contains(&format!("- **Campaign**: {CAMP_A}")),
|
|
"{}",
|
|
ticket(&worklane, MEMBER)
|
|
);
|
|
|
|
// And every other command that takes a campaign, since they share one resolver.
|
|
let out = run(&temp, &["campaign", "show", "beaver"]);
|
|
assert!(stdout(&out).contains("v1 release"), "{}", stdout(&out));
|
|
|
|
let out = run(&temp, &["ls", "--campaign", "beaver"]);
|
|
assert!(stdout(&out).contains("The member"), "{}", stdout(&out));
|
|
}
|
|
|
|
/// An exact codename beats a title that merely contains the search, which is the whole
|
|
/// reason it is a tier of its own: `v2` is a substring of `v2 release` and the exact
|
|
/// match has to win outright rather than be reported as ambiguous against it.
|
|
#[test]
|
|
fn an_exact_codename_beats_a_title_that_contains_the_search() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
let path = worklane
|
|
.join("campaigns")
|
|
.join(format!("{}_{}.md", CAMP_A, slug("v1 release")));
|
|
let content = fs::read_to_string(&path).unwrap();
|
|
fs::write(&path, content.replace("- **Owner**:", "- **Codename**: v2\n- **Owner**:")).unwrap();
|
|
|
|
let out = run(&temp, &["assign", "v2", MEMBER]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(
|
|
ticket(&worklane, MEMBER).contains(&format!("- **Campaign**: {CAMP_A}")),
|
|
"the title tier won: {}",
|
|
ticket(&worklane, MEMBER)
|
|
);
|
|
}
|
|
|
|
/// A ticket carries no codename, so the tier is empty for one and ticket resolution is
|
|
/// exactly what it was. Pinned because the tier lives in the shared resolver: this is the
|
|
/// half of it that must not have changed.
|
|
#[test]
|
|
fn a_ticket_search_is_unaffected_by_the_codename_tier() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
// The uuid prefix still wins over a title that quotes it, which is the precedence the
|
|
// three tiers were written for.
|
|
let out = run(&temp, &["show", "641e3d5"]);
|
|
assert!(stdout(&out).contains("The member"), "{}", stdout(&out));
|
|
let _ = worklane;
|
|
}
|
|
|
|
// ---------------------------------------------------------------- campaign set --
|
|
|
|
/// The point of the command: a campaign already on the board can be given a codename,
|
|
/// which `campaign add --codename` cannot do because `add` files a new one.
|
|
#[test]
|
|
fn campaign_set_gives_a_filed_campaign_a_codename() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let out = run(&temp, &["campaign", "set", "v1 release", "--codename", "beaver"]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(stdout(&out).contains("Updated codename"), "{}", stdout(&out));
|
|
|
|
let content = campaign_file(&worklane, CAMP_A);
|
|
assert!(content.contains("- **Codename**: beaver"), "{content}");
|
|
}
|
|
|
|
/// `create_campaign` writes no Codename line at all, which is every campaign filed before
|
|
/// the field existed, so the insertion path is the one this command is actually for.
|
|
/// It lands under the ID, where `campaign add` writes it, so a campaign given a codename
|
|
/// later is the same file as one filed with it.
|
|
#[test]
|
|
fn the_codename_is_inserted_under_the_id_when_the_line_is_absent() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
assert!(
|
|
!campaign_file(&worklane, CAMP_A).contains("Codename"),
|
|
"the fixture changed"
|
|
);
|
|
|
|
run(&temp, &["campaign", "set", "v1 release", "-c", "v1"]);
|
|
|
|
let content = campaign_file(&worklane, CAMP_A);
|
|
let id = content.find("- **ID**:").expect("no id");
|
|
let codename = content.find("- **Codename**:").expect("no codename");
|
|
let owner = content.find("- **Owner**:").expect("no owner");
|
|
assert!(id < codename && codename < owner, "{content}");
|
|
}
|
|
|
|
/// One parser, so a codename is one thing however it was written. The board draws it as a
|
|
/// label with a mark and no quoting, and that does not depend on which command wrote it.
|
|
#[test]
|
|
fn campaign_set_validates_the_codename_the_way_add_does() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
for value in ["two words", ""] {
|
|
let out = run(&temp, &["campaign", "set", "v1 release", "--codename", value]);
|
|
assert_eq!(out.status.code(), Some(2), "{value:?}: {}", stderr(&out));
|
|
assert!(
|
|
!campaign_file(&worklane, CAMP_A).contains("Codename"),
|
|
"{value:?} was written"
|
|
);
|
|
}
|
|
|
|
// And the message is the one `campaign add` gives, since the parser is the same.
|
|
let out = run(&temp, &["campaign", "set", "v1 release", "--codename", "two words"]);
|
|
assert!(stderr(&out).contains("single word"), "{}", stderr(&out));
|
|
}
|
|
|
|
/// A bare `campaign set <campaign>` is a usage error rather than a silent no-op, exactly
|
|
/// as it is for `set`.
|
|
#[test]
|
|
fn campaign_set_with_no_field_is_a_usage_error() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let out = run(&temp, &["campaign", "set", "v1 release"]);
|
|
assert_eq!(out.status.code(), Some(2), "{}", stderr(&out));
|
|
assert!(
|
|
!campaign_file(&worklane, CAMP_A).contains("Codename"),
|
|
"something was written"
|
|
);
|
|
}
|
|
|
|
/// Replacing the title renames the file, keeping the uuid, the way `set --title` does. That
|
|
/// is the reason this is a `set` rather than a flag on something narrower.
|
|
#[test]
|
|
fn campaign_set_renames_the_file_with_the_title() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
// A member first, so the rename has something to break.
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
|
|
let out = run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"set",
|
|
"v1 release",
|
|
"--title",
|
|
"First public release",
|
|
],
|
|
);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
|
|
let names = campaigns(&worklane);
|
|
assert!(
|
|
names.contains(&format!("{CAMP_A}_first-public-release.md")),
|
|
"not renamed: {names:?}"
|
|
);
|
|
assert!(
|
|
!names.contains(&format!("{CAMP_A}_v1-release.md")),
|
|
"the old file is still there: {names:?}"
|
|
);
|
|
|
|
let content = campaign_file(&worklane, CAMP_A);
|
|
assert!(content.starts_with("# First public release\n"), "{content}");
|
|
// The uuid is kept, so membership survives the rename: it is stored on the member as
|
|
// the uuid, and nothing has to be rewritten when the campaign is renamed.
|
|
assert!(content.contains(&format!("- **ID**: {CAMP_A}")), "{content}");
|
|
let out = run(&temp, &["ls", "--campaign", "First public release"]);
|
|
assert!(
|
|
stdout(&out).contains("The member"),
|
|
"membership was lost: {}",
|
|
stdout(&out)
|
|
);
|
|
}
|
|
|
|
/// Both fields in one call, since the group is `multiple`.
|
|
#[test]
|
|
fn campaign_set_takes_the_title_and_the_codename_together() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let out = run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"set",
|
|
"v1 release",
|
|
"-t",
|
|
"First public release",
|
|
"-c",
|
|
"v1",
|
|
],
|
|
);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(stdout(&out).contains("title, codename"), "{}", stdout(&out));
|
|
|
|
let content = campaign_file(&worklane, CAMP_A);
|
|
assert!(content.starts_with("# First public release\n"), "{content}");
|
|
assert!(content.contains("- **Codename**: v1"), "{content}");
|
|
}
|
|
|
|
/// The whole-file comparison `set` and `chown` use, so writing what is already there
|
|
/// writes nothing and says so.
|
|
#[test]
|
|
fn setting_the_codename_a_campaign_already_has_writes_nothing() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
run(&temp, &["campaign", "set", "v1 release", "-c", "v1"]);
|
|
|
|
let before = campaign_file(&worklane, CAMP_A);
|
|
let out = run(&temp, &["campaign", "set", "v1", "-c", "v1"]);
|
|
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(stdout(&out).contains("No changes"), "{}", stdout(&out));
|
|
assert_eq!(campaign_file(&worklane, CAMP_A), before, "the file was rewritten");
|
|
}
|
|
|
|
/// A codename set here resolves the campaign afterwards, which is the whole point of the
|
|
/// field being typable: the tier is in the shared resolver, not in `campaign add`.
|
|
#[test]
|
|
fn a_codename_set_afterwards_resolves_the_campaign() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
run(&temp, &["campaign", "set", "v1 release", "-c", "beaver"]);
|
|
|
|
let out = run(&temp, &["assign", "beaver", MEMBER]);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(
|
|
ticket(&worklane, MEMBER).contains(&format!("- **Campaign**: {CAMP_A}")),
|
|
"{}",
|
|
ticket(&worklane, MEMBER)
|
|
);
|
|
}
|
|
|
|
/// Nothing else in the file moves. A campaign carries prose and an owner this command
|
|
/// cannot reach, and a hand-written section has to survive an edit to a field.
|
|
#[test]
|
|
fn content_the_command_cannot_reach_survives_a_set() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let path = worklane
|
|
.join("campaigns")
|
|
.join(format!("{}_{}.md", CAMP_A, slug("v1 release")));
|
|
let original = fs::read_to_string(&path).unwrap();
|
|
fs::write(
|
|
&path,
|
|
original.replace("## Metadata", "## Notes\nA handwritten note.\n\n## Metadata"),
|
|
)
|
|
.unwrap();
|
|
|
|
run(&temp, &["campaign", "set", "v1 release", "-c", "v1"]);
|
|
|
|
let content = campaign_file(&worklane, CAMP_A);
|
|
assert!(content.contains("A handwritten note."), "{content}");
|
|
assert!(content.contains("What has to ship together."), "{content}");
|
|
assert!(content.contains("- **Owner**: alice"), "{content}");
|
|
assert!(!content.contains("**Status**"), "a status was invented: {content}");
|
|
}
|
|
|
|
/// A campaign that does not resolve leaves everything alone, the answer `assign` already
|
|
/// gives an unknown campaign.
|
|
#[test]
|
|
fn an_unknown_campaign_is_refused_and_nothing_is_written() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let out = run(&temp, &["campaign", "set", "nothing-by-that-name", "-c", "v1"]);
|
|
assert_eq!(out.status.code(), Some(1), "{}", stderr(&out));
|
|
assert!(stderr(&out).contains("No campaign found"), "{}", stderr(&out));
|
|
assert!(
|
|
!campaign_file(&worklane, CAMP_A).contains("Codename"),
|
|
"something was written"
|
|
);
|
|
assert!(
|
|
!campaign_file(&worklane, CAMP_B).contains("Codename"),
|
|
"something was written"
|
|
);
|
|
}
|
|
|
|
/// `--description` arrived with `campaign append`, 32e98ab, because for a prose section the
|
|
/// two are a pair. What is still deliberately absent is what this pins: no `--owner`, which
|
|
/// would settle by accident whether `chown` grows a campaign, and no `--clear`, because a
|
|
/// campaign's description has no cleared form and `Clearable`'s variants are a ticket's
|
|
/// fields.
|
|
#[test]
|
|
fn campaign_set_offers_no_owner_and_no_clear() {
|
|
let temp = TempDir::new().unwrap();
|
|
setup_worklane(&temp);
|
|
|
|
let out = run(&temp, &["campaign", "set", "--help"]);
|
|
let help = stdout(&out);
|
|
|
|
assert!(help.contains("--codename"), "{help}");
|
|
assert!(help.contains("--title"), "{help}");
|
|
assert!(help.contains("--description"), "{help}");
|
|
assert!(!help.contains("--owner"), "{help}");
|
|
assert!(!help.contains("--clear"), "{help}");
|
|
}
|
|
|
|
/// A codename is how a campaign is referred to once it has one: on every card in it and at
|
|
/// the command line. Replacing that silently is the mistake `install-skill --force` exists
|
|
/// to prevent, so it is refused and the refusal names the flag.
|
|
#[test]
|
|
fn an_existing_codename_is_not_replaced_without_force() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
run(&temp, &["campaign", "set", "v1 release", "-c", "v1"]);
|
|
let before = campaign_file(&worklane, CAMP_A);
|
|
|
|
let out = run(&temp, &["campaign", "set", "v1", "-c", "beaver"]);
|
|
|
|
assert_eq!(out.status.code(), Some(1), "{}", stderr(&out));
|
|
let said = stderr(&out);
|
|
// Both words and the flag, so the message says what is there, what was asked for and
|
|
// how to get it.
|
|
assert!(said.contains("already codenamed 'v1'"), "{said}");
|
|
assert!(said.contains("'beaver'"), "{said}");
|
|
assert!(said.contains("--force"), "{said}");
|
|
assert_eq!(campaign_file(&worklane, CAMP_A), before, "the file was written anyway");
|
|
}
|
|
|
|
#[test]
|
|
fn force_replaces_an_existing_codename() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
run(&temp, &["campaign", "set", "v1 release", "-c", "v1"]);
|
|
|
|
let out = run(&temp, &["campaign", "set", "v1", "-c", "beaver", "--force"]);
|
|
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
let content = campaign_file(&worklane, CAMP_A);
|
|
assert!(content.contains("- **Codename**: beaver"), "{content}");
|
|
// The line is replaced, not added beside the old one. Asserted on the field rather
|
|
// than on the word, since the campaign's title is "v1 release" and holds it too.
|
|
assert!(!content.contains("- **Codename**: v1"), "the old line survived: {content}");
|
|
assert_eq!(content.matches("**Codename**").count(), 1, "two codenames: {content}");
|
|
}
|
|
|
|
/// The guard is about overwriting a *different* word. A campaign with no codename has
|
|
/// nothing to overwrite, so `--force` is not the price of the first one.
|
|
#[test]
|
|
fn the_first_codename_needs_no_force() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
assert!(
|
|
!campaign_file(&worklane, CAMP_A).contains("Codename"),
|
|
"the fixture changed"
|
|
);
|
|
|
|
let out = run(&temp, &["campaign", "set", "v1 release", "-c", "v1"]);
|
|
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(campaign_file(&worklane, CAMP_A).contains("- **Codename**: v1"));
|
|
}
|
|
|
|
/// And setting the one it already has stays a no-op rather than becoming a refusal: there
|
|
/// is nothing to overwrite, which is the same answer `install-skill` gives an identical
|
|
/// document.
|
|
#[test]
|
|
fn setting_the_same_codename_again_is_a_no_op_not_a_refusal() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
run(&temp, &["campaign", "set", "v1 release", "-c", "v1"]);
|
|
|
|
let out = run(&temp, &["campaign", "set", "v1", "-c", "v1"]);
|
|
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(stdout(&out).contains("No changes"), "{}", stdout(&out));
|
|
assert!(campaign_file(&worklane, CAMP_A).contains("- **Codename**: v1"));
|
|
}
|
|
|
|
/// Refused before any edit is applied, like `SetArgs::contested`, so a call carrying both
|
|
/// fields writes neither rather than half of what was asked for.
|
|
#[test]
|
|
fn a_refused_codename_takes_the_title_down_with_it() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
run(&temp, &["campaign", "set", "v1 release", "-c", "v1"]);
|
|
let before = campaign_file(&worklane, CAMP_A);
|
|
|
|
let out = run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"set",
|
|
"v1",
|
|
"-t",
|
|
"Renamed anyway",
|
|
"-c",
|
|
"beaver",
|
|
],
|
|
);
|
|
|
|
assert_eq!(out.status.code(), Some(1), "{}", stderr(&out));
|
|
assert_eq!(campaign_file(&worklane, CAMP_A), before, "the title went through");
|
|
let names = campaigns(&worklane);
|
|
assert!(
|
|
!names.iter().any(|name| name.contains("renamed-anyway")),
|
|
"renamed: {names:?}"
|
|
);
|
|
}
|
|
|
|
/// The title needs no guard, since a campaign always has one and replacing it is what the
|
|
/// flag is for. `--force` is the codename's alone.
|
|
#[test]
|
|
fn the_title_is_replaced_without_force() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
run(&temp, &["campaign", "set", "v1 release", "-c", "v1"]);
|
|
|
|
let out = run(&temp, &["campaign", "set", "v1", "--title", "First public release"]);
|
|
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(campaign_file(&worklane, CAMP_A).starts_with("# First public release\n"));
|
|
}
|
|
|
|
// ---------------------------------------------- campaign set --description --
|
|
|
|
/// The point of 32e98ab: the description a campaign was filed with is no longer the one it
|
|
/// keeps. `create_campaign` writes prose, so this is a replacement rather than a first line.
|
|
#[test]
|
|
fn campaign_set_replaces_the_description() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let out = run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"set",
|
|
"v1 release",
|
|
"--description",
|
|
"What the tag has to hold.",
|
|
],
|
|
);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(stdout(&out).contains("Updated description"), "{}", stdout(&out));
|
|
|
|
let content = campaign_file(&worklane, CAMP_A);
|
|
assert!(content.contains("What the tag has to hold."), "{content}");
|
|
assert!(
|
|
!content.contains("What has to ship together."),
|
|
"the old description survived: {content}"
|
|
);
|
|
}
|
|
|
|
/// An empty value between two others is the paragraph break, the rule every prose argument
|
|
/// in the tool follows: `add --description`, `set --description` and `tags --annotation`.
|
|
#[test]
|
|
fn an_empty_value_is_a_paragraph_break_in_a_campaigns_description() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let out = run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"set",
|
|
"v1 release",
|
|
"-d",
|
|
"The tag itself.",
|
|
"-d",
|
|
"",
|
|
"-d",
|
|
"And what blocks it.",
|
|
],
|
|
);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
|
|
let content = campaign_file(&worklane, CAMP_A);
|
|
assert!(content.contains("The tag itself.\n\nAnd what blocks it."), "{content}");
|
|
}
|
|
|
|
/// And an all-blank value is refused rather than emptying the section. The refusal names no
|
|
/// flag, because there is none: a campaign's description has no cleared form, which is the
|
|
/// `Clearable` question 32e98ab settled rather than deferred.
|
|
#[test]
|
|
fn an_all_blank_description_is_refused_and_names_no_clear_flag() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
let before = campaign_file(&worklane, CAMP_A);
|
|
|
|
let out = run(&temp, &["campaign", "set", "v1 release", "-d", "", "-d", " "]);
|
|
|
|
assert_eq!(out.status.code(), Some(1), "{}", stderr(&out));
|
|
let said = stderr(&out);
|
|
assert!(said.contains("An empty value is a paragraph break"), "{said}");
|
|
assert!(said.contains("no cleared form"), "{said}");
|
|
assert!(!said.contains("--clear"), "it named a flag that does not exist: {said}");
|
|
assert_eq!(campaign_file(&worklane, CAMP_A), before, "the file was written");
|
|
}
|
|
|
|
/// The whole-file comparison `set`, `chown` and the codename already use, so a description
|
|
/// replaced with the one it already holds writes nothing.
|
|
#[test]
|
|
fn setting_the_description_a_campaign_already_has_writes_nothing() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
let before = campaign_file(&worklane, CAMP_A);
|
|
|
|
let out = run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"set",
|
|
"v1 release",
|
|
"-d",
|
|
"What has to ship together.",
|
|
],
|
|
);
|
|
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(stdout(&out).contains("No changes"), "{}", stdout(&out));
|
|
assert_eq!(campaign_file(&worklane, CAMP_A), before, "the file was rewritten");
|
|
}
|
|
|
|
/// Three fields in one call, since the group is `multiple` and the description is in it.
|
|
#[test]
|
|
fn campaign_set_takes_the_title_the_description_and_the_codename_together() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let out = run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"set",
|
|
"v1 release",
|
|
"-t",
|
|
"First public release",
|
|
"-d",
|
|
"What the tag has to hold.",
|
|
"-c",
|
|
"v1",
|
|
],
|
|
);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(stdout(&out).contains("title, description, codename"), "{}", stdout(&out));
|
|
|
|
let content = campaign_file(&worklane, CAMP_A);
|
|
assert!(content.starts_with("# First public release\n"), "{content}");
|
|
assert!(content.contains("What the tag has to hold."), "{content}");
|
|
assert!(content.contains("- **Codename**: v1"), "{content}");
|
|
}
|
|
|
|
/// A refused codename takes the description down with it, the way it already takes the
|
|
/// title: checked before any edit is applied, so a call writes all of what it asked for or
|
|
/// none of it.
|
|
#[test]
|
|
fn a_refused_codename_takes_the_description_down_with_it() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
run(&temp, &["campaign", "set", "v1 release", "-c", "v1"]);
|
|
let before = campaign_file(&worklane, CAMP_A);
|
|
|
|
let out = run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"set",
|
|
"v1",
|
|
"-d",
|
|
"Rewritten anyway.",
|
|
"-c",
|
|
"beaver",
|
|
],
|
|
);
|
|
|
|
assert_eq!(out.status.code(), Some(1), "{}", stderr(&out));
|
|
assert_eq!(campaign_file(&worklane, CAMP_A), before, "the description went through");
|
|
}
|
|
|
|
// ---------------------------------------------------------- campaign append --
|
|
|
|
/// The other half of the pair, and the reason `set --description` is not a flag on its own:
|
|
/// adding a line to a description must not mean retyping the rest of it.
|
|
#[test]
|
|
fn campaign_append_adds_a_paragraph_without_replacing_the_description() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let out = run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"append",
|
|
"v1 release",
|
|
"-d",
|
|
"And what is out of scope.",
|
|
],
|
|
);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(stdout(&out).contains("Appended to description"), "{}", stdout(&out));
|
|
|
|
let content = campaign_file(&worklane, CAMP_A);
|
|
// The paragraph lands after the one that was there, with the blank line between them
|
|
// that makes it a paragraph rather than a run-on.
|
|
assert!(
|
|
content.contains("What has to ship together.\n\nAnd what is out of scope.\n"),
|
|
"{content}"
|
|
);
|
|
}
|
|
|
|
/// Several values in one call are lines *within* the paragraph, not several paragraphs. The
|
|
/// same reading `append --description` gives a ticket, since it is the same section entry.
|
|
#[test]
|
|
fn the_values_of_one_append_are_lines_within_the_paragraph() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"append",
|
|
"v1 release",
|
|
"-d",
|
|
"Out of scope:",
|
|
"-d",
|
|
"the installer.",
|
|
],
|
|
);
|
|
|
|
let content = campaign_file(&worklane, CAMP_A);
|
|
assert!(content.contains("Out of scope:\nthe installer.\n"), "{content}");
|
|
}
|
|
|
|
/// A campaign filed with no description holds the placeholder, and appending replaces it
|
|
/// rather than following it: the alternative reads `_No description provided._` above the
|
|
/// description. `append_section_body`'s rule, so nothing here handles the case.
|
|
#[test]
|
|
fn appending_to_an_empty_description_replaces_the_placeholder() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
run(&temp, &["campaign", "add", "--title", "No prose yet"]);
|
|
|
|
let uuid = {
|
|
let names = campaigns(&worklane);
|
|
let name = names
|
|
.iter()
|
|
.find(|name| name.ends_with("_no-prose-yet.md"))
|
|
.expect("the campaign was not filed");
|
|
name.split('_').next().unwrap().to_string()
|
|
};
|
|
assert!(
|
|
campaign_file(&worklane, &uuid).contains("_No description provided._"),
|
|
"the placeholder is not what add writes any more"
|
|
);
|
|
|
|
let out = run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"append",
|
|
"No prose yet",
|
|
"-d",
|
|
"The first thing said.",
|
|
],
|
|
);
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
|
|
let content = campaign_file(&worklane, &uuid);
|
|
assert!(content.contains("The first thing said."), "{content}");
|
|
assert!(
|
|
!content.contains("_No description provided._"),
|
|
"the placeholder is still above the description: {content}"
|
|
);
|
|
}
|
|
|
|
/// Every value blank is refused rather than writing nothing quietly, the answer `append`
|
|
/// gives a ticket, in the same words: appending nothing was never a way to empty anything,
|
|
/// so there is no flag to name.
|
|
#[test]
|
|
fn an_all_blank_append_is_refused() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
let before = campaign_file(&worklane, CAMP_A);
|
|
|
|
let out = run(&temp, &["campaign", "append", "v1 release", "-d", " "]);
|
|
|
|
assert_eq!(out.status.code(), Some(1), "{}", stderr(&out));
|
|
assert!(stderr(&out).contains("Nothing to append"), "{}", stderr(&out));
|
|
assert_eq!(campaign_file(&worklane, CAMP_A), before, "the file was written");
|
|
}
|
|
|
|
/// A bare `campaign append <campaign>` is a usage error rather than a silent no-op, the way
|
|
/// a bare `campaign set` is. `--description` is `required` rather than a group of one.
|
|
#[test]
|
|
fn campaign_append_with_no_description_is_a_usage_error() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
let before = campaign_file(&worklane, CAMP_A);
|
|
|
|
let out = run(&temp, &["campaign", "append", "v1 release"]);
|
|
|
|
assert_eq!(out.status.code(), Some(2), "{}", stderr(&out));
|
|
assert_eq!(campaign_file(&worklane, CAMP_A), before, "something was written");
|
|
}
|
|
|
|
/// Appending to a scalar has no meaning, which is the line `append` already draws for a
|
|
/// ticket: no `--title` there and none here, and no `--codename` either.
|
|
#[test]
|
|
fn campaign_append_offers_only_the_description() {
|
|
let temp = TempDir::new().unwrap();
|
|
setup_worklane(&temp);
|
|
|
|
let out = run(&temp, &["campaign", "append", "--help"]);
|
|
let help = stdout(&out);
|
|
|
|
assert!(help.contains("--description"), "{help}");
|
|
assert!(!help.contains("--title"), "{help}");
|
|
assert!(!help.contains("--codename"), "{help}");
|
|
assert!(!help.contains("--force"), "{help}");
|
|
}
|
|
|
|
/// A campaign is addressed here by the same tiers everything else takes, codename included,
|
|
/// because it goes through `resolve_campaign` rather than a lookup of its own.
|
|
#[test]
|
|
fn campaign_append_resolves_the_campaign_by_its_codename() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
run(&temp, &["campaign", "set", "v1 release", "-c", "beaver"]);
|
|
|
|
let out = run(&temp, &["campaign", "append", "beaver", "-d", "One more thing."]);
|
|
|
|
assert!(out.status.success(), "{}", stderr(&out));
|
|
assert!(
|
|
campaign_file(&worklane, CAMP_A).contains("One more thing."),
|
|
"{}",
|
|
campaign_file(&worklane, CAMP_A)
|
|
);
|
|
}
|
|
|
|
/// An unknown campaign leaves every campaign alone, the answer `campaign set` and `assign`
|
|
/// already give.
|
|
#[test]
|
|
fn campaign_append_refuses_an_unknown_campaign() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
let before = campaign_file(&worklane, CAMP_A);
|
|
|
|
let out = run(&temp, &["campaign", "append", "nothing-by-that-name", "-d", "Text."]);
|
|
|
|
assert_eq!(out.status.code(), Some(1), "{}", stderr(&out));
|
|
assert!(stderr(&out).contains("No campaign found"), "{}", stderr(&out));
|
|
assert_eq!(campaign_file(&worklane, CAMP_A), before, "something was written");
|
|
}
|
|
|
|
// ------------------------------------------------------ the shared machinery --
|
|
|
|
/// A campaign has one section where a ticket has four, and the section table in `util.rs` is
|
|
/// what both go through. So the surgery has to land against `## Metadata`, which is the only
|
|
/// heading that follows a campaign's description, and leave everything outside the body
|
|
/// alone: a handwritten section, the owner, and the codename in its place.
|
|
#[test]
|
|
fn the_description_is_edited_in_place_in_a_file_with_one_section() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
run(&temp, &["campaign", "set", "v1 release", "-c", "v1"]);
|
|
|
|
let path = worklane
|
|
.join("campaigns")
|
|
.join(format!("{}_{}.md", CAMP_A, slug("v1 release")));
|
|
let original = fs::read_to_string(&path).unwrap();
|
|
fs::write(
|
|
&path,
|
|
original.replace("## Metadata", "## Notes\nA handwritten note.\n\n## Metadata"),
|
|
)
|
|
.unwrap();
|
|
|
|
run(&temp, &["campaign", "set", "v1", "-d", "Replaced."]);
|
|
run(&temp, &["campaign", "append", "v1", "-d", "Added."]);
|
|
|
|
let content = campaign_file(&worklane, CAMP_A);
|
|
assert!(content.contains("## Description\nReplaced.\n\nAdded.\n"), "{content}");
|
|
// Nothing outside the body moved: the section that follows it, the handwritten one
|
|
// between them, and the fields under it.
|
|
assert!(content.contains("## Notes\nA handwritten note."), "{content}");
|
|
assert!(content.contains("- **Codename**: v1"), "{content}");
|
|
assert!(content.contains("- **Owner**: alice"), "{content}");
|
|
assert!(!content.contains("**Status**"), "a status was invented: {content}");
|
|
// And no section a campaign does not have was inserted to anchor against.
|
|
assert!(!content.contains("## Acceptance Criteria"), "{content}");
|
|
assert!(!content.contains("## Implementation Plan"), "{content}");
|
|
}
|
|
|
|
/// The heading is the one in the section table, so `campaign set --description` reaches the
|
|
/// section `campaign_body` wrote and `campaign show` prints. A second spelling scoped to
|
|
/// campaigns is what this would catch.
|
|
#[test]
|
|
fn the_description_a_campaign_is_filed_with_is_the_one_set_replaces() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
run(
|
|
&temp,
|
|
&[
|
|
"campaign",
|
|
"add",
|
|
"--title",
|
|
"Filed with prose",
|
|
"--description",
|
|
"As filed.",
|
|
],
|
|
);
|
|
run(&temp, &["campaign", "set", "Filed with prose", "-d", "As replaced."]);
|
|
|
|
let out = run(&temp, &["campaign", "show", "Filed with prose"]);
|
|
let shown = stdout(&out);
|
|
assert!(shown.contains("As replaced."), "{shown}");
|
|
assert!(!shown.contains("As filed."), "{shown}");
|
|
// One Description heading in the file, not a second one written beside it.
|
|
let names = campaigns(&worklane);
|
|
let name = names
|
|
.iter()
|
|
.find(|name| name.ends_with("_filed-with-prose.md"))
|
|
.expect("not filed");
|
|
let content = fs::read_to_string(worklane.join("campaigns").join(name)).unwrap();
|
|
assert_eq!(content.matches("## Description").count(), 1, "{content}");
|
|
}
|
|
|
|
/// A campaign file with no Description heading is refused rather than given one back. Every
|
|
/// campaign the tool files carries the heading, so an insertion path here would be reachable
|
|
/// only from a hand-edited file, which is the opposite of the Relations case. The message
|
|
/// names the section and not the object, because both a ticket and a campaign reach it.
|
|
#[test]
|
|
fn a_campaign_with_no_description_section_is_refused() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = board(&temp);
|
|
|
|
let path = worklane
|
|
.join("campaigns")
|
|
.join(format!("{}_{}.md", CAMP_A, slug("v1 release")));
|
|
let original = fs::read_to_string(&path).unwrap();
|
|
fs::write(
|
|
&path,
|
|
original.replace("## Description\nWhat has to ship together.\n\n", ""),
|
|
)
|
|
.unwrap();
|
|
let before = fs::read_to_string(&path).unwrap();
|
|
|
|
for args in [
|
|
["campaign", "set", "v1 release", "-d", "Text."],
|
|
["campaign", "append", "v1 release", "-d", "Text."],
|
|
] {
|
|
let out = run(&temp, &args);
|
|
assert_eq!(out.status.code(), Some(1), "{}", stderr(&out));
|
|
let said = stderr(&out);
|
|
assert!(said.contains("no description section"), "{said}");
|
|
assert!(!said.contains("Ticket"), "a campaign was called a ticket: {said}");
|
|
assert_eq!(fs::read_to_string(&path).unwrap(), before, "the file was written");
|
|
}
|
|
}
|
|
|
|
/// A discarded member counts as finished. The work was decided out of the campaign
|
|
/// rather than left in it, and counting it as outstanding would hold the campaign open
|
|
/// forever over a ticket nobody will ever do.
|
|
#[test]
|
|
fn a_discarded_member_counts_as_finished() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
run(&temp, &["assign", "v1 release", OTHER]);
|
|
|
|
// Two members, one done and one in the backlog: open and half finished.
|
|
let listing = squeezed(&stdout(&run(&temp, &["campaign", "ls"])));
|
|
assert!(listing.contains("v1 release | 1/2 done [open]"), "{listing}");
|
|
|
|
let discarded = run(&temp, &["mv", MEMBER, "--status", "discarded"]);
|
|
assert!(discarded.status.success(), "{}", stderr(&discarded));
|
|
|
|
let listing = squeezed(&stdout(&run(&temp, &["campaign", "ls"])));
|
|
assert!(listing.contains("v1 release | 2/2 done [done]"), "{listing}");
|
|
}
|
|
|
|
/// `campaign show` groups the members by status, and a discarded one has a group to
|
|
/// land in rather than dropping out of the campaign it belongs to.
|
|
#[test]
|
|
fn campaign_show_lists_a_discarded_member() {
|
|
let temp = TempDir::new().unwrap();
|
|
let _worklane = board(&temp);
|
|
|
|
run(&temp, &["assign", "v1 release", MEMBER]);
|
|
assert!(
|
|
run(&temp, &["mv", MEMBER, "--status", "discarded"])
|
|
.status
|
|
.success()
|
|
);
|
|
|
|
let shown = stdout(&run(&temp, &["campaign", "show", "aa11"]));
|
|
assert!(shown.contains("The member"), "the discarded member is gone: {shown}");
|
|
}
|