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>
362 lines
12 KiB
Rust
362 lines
12 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");
|
|
const UUID: &str = "641e3d5c-1b0e-4d2f-9a7e-3c8b5f0a2d61";
|
|
|
|
fn setup_worklane(temp: &TempDir) -> 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()
|
|
}
|
|
|
|
/// A fully populated ticket, with one criterion already ticked and a section the tool
|
|
/// knows nothing about, so every test can check both survive.
|
|
fn create_ticket(worklane: &Path) {
|
|
fs::write(
|
|
worklane
|
|
.join("backlog")
|
|
.join(format!("{}_original-title.md", UUID)),
|
|
format!(
|
|
"# Original title\n\
|
|
\n\
|
|
## Description\n\
|
|
The **Owner**: line quoted here is prose, not metadata.\n\
|
|
\n\
|
|
## Acceptance Criteria\n\
|
|
- [x] Crit one\n\
|
|
- [ ] Crit two\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**: {}\n\
|
|
- **Priority**: 3\n\
|
|
- **Tags**: alpha\n\
|
|
- **Due**: 2026-09-01\n\
|
|
- **Owner**: alice\n\
|
|
- **Created At**: 2026-08-21 02:10:17\n\
|
|
- **Status**: backlog\n",
|
|
UUID
|
|
),
|
|
)
|
|
.unwrap();
|
|
}
|
|
|
|
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 ticket(worklane: &Path) -> String {
|
|
let entry = fs::read_dir(worklane.join("backlog"))
|
|
.unwrap()
|
|
.filter_map(|e| e.ok())
|
|
.find(|e| e.file_name().to_string_lossy().ends_with(".md"))
|
|
.expect("no ticket file");
|
|
fs::read_to_string(entry.path()).unwrap()
|
|
}
|
|
|
|
fn stray_files(worklane: &Path) -> Vec<String> {
|
|
fs::read_dir(worklane)
|
|
.unwrap()
|
|
.filter_map(|e| e.ok())
|
|
.map(|e| e.file_name().into_string().unwrap())
|
|
.filter(|name| {
|
|
!["backlog", "committed", "reviewing", "done", "comments"].contains(&name.as_str())
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
#[test]
|
|
fn chown_sets_the_owner() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
create_ticket(&worklane);
|
|
|
|
let out = run(&temp, &["chown", "bob", UUID]);
|
|
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
|
assert!(
|
|
String::from_utf8_lossy(&out.stdout).contains("owner"),
|
|
"{:?}",
|
|
String::from_utf8_lossy(&out.stdout)
|
|
);
|
|
|
|
let content = ticket(&worklane);
|
|
assert!(content.contains("- **Owner**: bob"), "{content}");
|
|
|
|
// Every other field is left as it was
|
|
assert!(content.contains("- **Priority**: 3"), "{content}");
|
|
assert!(content.contains("- **Tags**: alpha"), "{content}");
|
|
assert!(content.contains("- **Due**: 2026-09-01"), "{content}");
|
|
assert!(content.contains("- **Status**: backlog"), "{content}");
|
|
}
|
|
|
|
/// The value is free text, matching `add --owner`, and is checked against nothing:
|
|
/// not git, not a list of users.
|
|
#[test]
|
|
fn chown_accepts_any_user_without_validating_it() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
create_ticket(&worklane);
|
|
|
|
run(&temp, &["chown", "Nobody At All", UUID]);
|
|
|
|
assert!(
|
|
ticket(&worklane).contains("- **Owner**: Nobody At All"),
|
|
"{}",
|
|
ticket(&worklane)
|
|
);
|
|
}
|
|
|
|
/// The tick and the unknown section are what a regenerated file would lose, and the
|
|
/// quoted `**Owner**:` line in the description is what an unscoped rewrite would take
|
|
/// instead of the real field.
|
|
#[test]
|
|
fn chown_leaves_everything_it_was_not_asked_about_alone() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
create_ticket(&worklane);
|
|
|
|
run(&temp, &["chown", "bob", UUID]);
|
|
|
|
let content = ticket(&worklane);
|
|
assert!(content.contains("- [x] Crit one"), "the tick was lost: {content}");
|
|
assert!(
|
|
content.contains("## Notes\nA handwritten note the tool knows nothing about.\n"),
|
|
"the unknown section was lost: {content}"
|
|
);
|
|
assert!(
|
|
content.contains("The **Owner**: line quoted here is prose, not metadata.\n"),
|
|
"the prose was rewritten as metadata: {content}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn chown_reports_no_change_and_leaves_the_file_alone() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
create_ticket(&worklane);
|
|
let before = ticket(&worklane);
|
|
|
|
let out = run(&temp, &["chown", "alice", UUID]);
|
|
assert!(out.status.success());
|
|
assert!(
|
|
String::from_utf8_lossy(&out.stdout).contains("No changes"),
|
|
"{:?}",
|
|
String::from_utf8_lossy(&out.stdout)
|
|
);
|
|
assert_eq!(ticket(&worklane), before, "the file was rewritten anyway");
|
|
}
|
|
|
|
/// Resolution is `resolve_ticket`, the same as `mv` and `comment`, so all three tiers
|
|
/// reach the ticket. The filename search reaches the middle of the uuid, which the
|
|
/// prefix tier cannot.
|
|
#[test]
|
|
fn chown_resolves_a_uuid_prefix_a_title_or_a_filename() {
|
|
for search in ["641e", "Original", "4d2f"] {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
create_ticket(&worklane);
|
|
|
|
let out = run(&temp, &["chown", "bob", search]);
|
|
assert!(
|
|
out.status.success(),
|
|
"{search} did not resolve: {:?}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
assert!(
|
|
ticket(&worklane).contains("- **Owner**: bob"),
|
|
"{search}: {}",
|
|
ticket(&worklane)
|
|
);
|
|
}
|
|
}
|
|
|
|
/// The swap is left to resolution rather than checked for: the username has to resolve
|
|
/// as a ticket, and a bare one does not.
|
|
#[test]
|
|
fn chown_refuses_a_swapped_call() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
create_ticket(&worklane);
|
|
let before = ticket(&worklane);
|
|
|
|
let out = run(&temp, &["chown", UUID, "bob"]);
|
|
assert_eq!(out.status.code(), Some(1));
|
|
assert!(
|
|
String::from_utf8_lossy(&out.stderr).contains("No ticket found matching 'bob'"),
|
|
"{:?}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
assert_eq!(ticket(&worklane), before);
|
|
}
|
|
|
|
/// An empty user is still a usage error, and now points at the flag that does take the
|
|
/// owner away.
|
|
#[test]
|
|
fn chown_refuses_an_empty_user_as_a_usage_error() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
create_ticket(&worklane);
|
|
let before = ticket(&worklane);
|
|
|
|
let out = run(&temp, &["chown", "", UUID]);
|
|
assert_eq!(out.status.code(), Some(2));
|
|
let stderr = String::from_utf8_lossy(&out.stderr);
|
|
assert!(stderr.contains("use --clear"), "{stderr:?}");
|
|
assert!(!stderr.contains("not supported"), "{stderr:?}");
|
|
assert_eq!(ticket(&worklane), before);
|
|
}
|
|
|
|
/// The owner goes back to the sentinel, not to the git user: an owner taken away says
|
|
/// nobody owns this.
|
|
#[test]
|
|
fn chown_clear_returns_the_owner_to_unset() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
create_ticket(&worklane);
|
|
|
|
let out = run(&temp, &["chown", "--clear", UUID]);
|
|
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
|
assert!(
|
|
String::from_utf8_lossy(&out.stdout).contains("Cleared owner"),
|
|
"{:?}",
|
|
String::from_utf8_lossy(&out.stdout)
|
|
);
|
|
|
|
let content = ticket(&worklane);
|
|
assert!(content.contains("- **Owner**: _Not set_"), "{content}");
|
|
// Nothing else on the way past.
|
|
assert!(content.contains("- **Status**: backlog"), "{content}");
|
|
}
|
|
|
|
/// The ticket is still resolved the three usual ways when it arrives in the flag.
|
|
#[test]
|
|
fn chown_clear_resolves_the_ticket_it_is_given() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
create_ticket(&worklane);
|
|
|
|
let out = run(&temp, &["chown", "--clear", "Original"]);
|
|
assert!(out.status.success(), "{:?}", String::from_utf8_lossy(&out.stderr));
|
|
assert!(ticket(&worklane).contains("- **Owner**: _Not set_"));
|
|
}
|
|
|
|
#[test]
|
|
fn chown_clear_on_an_unowned_ticket_is_no_change() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
create_ticket(&worklane);
|
|
|
|
run(&temp, &["chown", "--clear", UUID]);
|
|
let before = ticket(&worklane);
|
|
|
|
let out = run(&temp, &["chown", "--clear", UUID]);
|
|
assert!(out.status.success());
|
|
assert!(
|
|
String::from_utf8_lossy(&out.stdout).contains("No changes"),
|
|
"{:?}",
|
|
String::from_utf8_lossy(&out.stdout)
|
|
);
|
|
assert_eq!(ticket(&worklane), before, "the file was rewritten anyway");
|
|
}
|
|
|
|
/// Setting an owner and clearing it are the two forms of the command, and clap keeps
|
|
/// them apart rather than the handler picking one.
|
|
#[test]
|
|
fn chown_refuses_a_user_and_a_clear_together() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
create_ticket(&worklane);
|
|
let before = ticket(&worklane);
|
|
|
|
for args in [
|
|
vec!["chown", "bob", "--clear", UUID],
|
|
vec!["chown", "bob", UUID, "--clear", UUID],
|
|
] {
|
|
let out = run(&temp, &args);
|
|
assert_eq!(out.status.code(), Some(2), "{args:?} was accepted");
|
|
assert!(
|
|
String::from_utf8_lossy(&out.stderr).contains("cannot be used with"),
|
|
"{:?}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
}
|
|
|
|
// And a bare --clear still needs the ticket it is meant to name.
|
|
let out = run(&temp, &["chown", "--clear"]);
|
|
assert_eq!(out.status.code(), Some(2));
|
|
assert!(
|
|
String::from_utf8_lossy(&out.stderr).contains("a value is required"),
|
|
"{:?}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
|
|
assert_eq!(ticket(&worklane), before);
|
|
}
|
|
|
|
/// A hand-made ticket without the field is refused rather than guessed at, the same
|
|
/// as every other metadata field.
|
|
#[test]
|
|
fn chown_refuses_a_ticket_with_no_owner_field() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
fs::write(
|
|
worklane.join("backlog").join(format!("{}_bare.md", UUID)),
|
|
format!("# Bare\n\n## Metadata\n\n- **ID**: {}\n", UUID),
|
|
)
|
|
.unwrap();
|
|
|
|
let out = run(&temp, &["chown", "bob", UUID]);
|
|
assert_eq!(out.status.code(), Some(1));
|
|
assert!(
|
|
String::from_utf8_lossy(&out.stderr).contains("has no Owner field"),
|
|
"{:?}",
|
|
String::from_utf8_lossy(&out.stderr)
|
|
);
|
|
}
|
|
|
|
/// The staged temp file is renamed into place, so a completed write leaves nothing to
|
|
/// be read as a stray ticket.
|
|
#[test]
|
|
fn chown_leaves_nothing_behind() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
create_ticket(&worklane);
|
|
|
|
run(&temp, &["chown", "bob", UUID]);
|
|
assert_eq!(stray_files(&worklane), Vec::<String>::new());
|
|
}
|
|
|
|
/// The file keeps its name: the slug follows the title, and the owner is not in it.
|
|
#[test]
|
|
fn chown_does_not_rename_the_file() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
create_ticket(&worklane);
|
|
|
|
run(&temp, &["chown", "bob", UUID]);
|
|
|
|
let names: Vec<String> = fs::read_dir(worklane.join("backlog"))
|
|
.unwrap()
|
|
.filter_map(|e| e.ok())
|
|
.map(|e| e.file_name().into_string().unwrap())
|
|
.collect();
|
|
assert_eq!(names, vec![format!("{}_original-title.md", UUID)]);
|
|
}
|