The comments directory was already an append-only log with one event kind. It is now .worklane/history/<uuid>/, with the kind in the entry and in the filename after the stamp, so a ticket says how it got where it is and not only what was said about it. mv, chown and set --tags each write an entry after their own save and behind their own no-change return, so a refused or no-op edit records nothing. --actor is on all four writers now. An old comments directory is adopted on first access and a file with no marker reads as the comment it is, so nothing is migrated or rewritten. The log moves to src/history.rs, out of util.rs and handlers.rs, and the card's counter counts comments only: a ticket that has moved three times has not been talked about. 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", "history"].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)]);
|
|
}
|