(4179958) Add a Relations section for blocked by, regression of and relates to, and bump to 0.11.0
`relate` is the only writer of the section, the way `chown` is the only writer of Owner: a relation names a target that has to be resolved to a uuid first, so `set` and `append` are deliberately kept out of it. One flag per kind, so an unknown kind is a usage error rather than a line refused on the way back out. One direction is stored and the inverse is derived by a scan. `blocked by` goes on the gated ticket, whose move `mv` now refuses while the target is not done, naming every open blocker; `-f` bypasses it beside the backward and skipping moves. A target that is not on the board warns and allows the move. The rendered block is built outside `content_trim` and passed in, since half of it comes from other tickets. The section is created on demand rather than by `add`, so a ticket written before it existed gains it without being regenerated. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude Opus 5
parent
b56b31d2d9
commit
3085b0226f
+233
@@ -645,3 +645,236 @@ fn mv_moves_the_resolved_ticket_when_two_share_a_title() {
|
||||
vec!["11111111-aaaa-bbbb-cccc-dddddddddddd_foo.md".to_string()]
|
||||
);
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------- blocked by --
|
||||
|
||||
/// A ticket waiting on another, and a second one for it to wait on. Returns the
|
||||
/// filename of the gated ticket, whose relations the moves are then checked against.
|
||||
fn create_gated_pair(worklane: &std::path::Path, temp: &TempDir, status: &str) -> String {
|
||||
let filename = create_ticket(
|
||||
worklane,
|
||||
status,
|
||||
"Gated Task",
|
||||
"Waits on the blocker.",
|
||||
"aaaa1111aaaa1111aaaa1111aaaa1111aaaa",
|
||||
"alice",
|
||||
"_Not set_",
|
||||
"test",
|
||||
);
|
||||
create_ticket(
|
||||
worklane,
|
||||
"backlog",
|
||||
"The Blocker",
|
||||
"Nothing waits on this.",
|
||||
"bbbb2222bbbb2222bbbb2222bbbb2222bbbb",
|
||||
"bob",
|
||||
"_Not set_",
|
||||
"test",
|
||||
);
|
||||
|
||||
// Through the command, so the fixture cannot store a relation in a shape the tool
|
||||
// does not actually write.
|
||||
Command::cargo_bin(BIN_NAME)
|
||||
.unwrap()
|
||||
.current_dir(temp.path())
|
||||
.args(["relate", "aaaa1111", "--blocked-by", "bbbb2222"])
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
filename
|
||||
}
|
||||
|
||||
fn move_ticket(temp: &TempDir, ticket: &str, status: &str, force: bool) -> std::process::Output {
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(temp.path())
|
||||
.args(["mv", ticket, "--status", status]);
|
||||
if force {
|
||||
cmd.arg("-f");
|
||||
}
|
||||
|
||||
cmd.assert().get_output().clone()
|
||||
}
|
||||
|
||||
/// Refused, and nothing written: not the rename, not the Status field, not a stray
|
||||
/// temp file. The blocker is named with its status, since that is what has to change.
|
||||
#[test]
|
||||
fn mv_refuses_a_move_while_a_blocker_is_open() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = create_gated_pair(&worklane, &temp, "backlog");
|
||||
let before = fs::read_to_string(worklane.join("backlog").join(&filename)).unwrap();
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "committed", false);
|
||||
assert!(!out.status.success());
|
||||
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains("blocked by"), "{stderr}");
|
||||
assert!(stderr.contains("The Blocker"), "{stderr}");
|
||||
assert!(stderr.contains("backlog"), "{stderr}");
|
||||
assert!(stderr.contains("--force"), "{stderr}");
|
||||
|
||||
assert!(worklane.join("backlog").join(&filename).exists());
|
||||
assert_eq!(md_files(&worklane.join("committed")).len(), 0);
|
||||
assert_eq!(
|
||||
fs::read_to_string(worklane.join("backlog").join(&filename)).unwrap(),
|
||||
before,
|
||||
"a refused move rewrote the ticket"
|
||||
);
|
||||
assert_eq!(stray_files(&worklane), Vec::<String>::new());
|
||||
}
|
||||
|
||||
/// Every open blocker, not the first: clearing the one the message happened to name
|
||||
/// would leave the ticket blocked and the reader surprised.
|
||||
#[test]
|
||||
fn mv_names_every_open_blocker() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_gated_pair(&worklane, &temp, "backlog");
|
||||
create_ticket(
|
||||
&worklane,
|
||||
"reviewing",
|
||||
"The Second Blocker",
|
||||
"Also not done.",
|
||||
"cccc3333cccc3333cccc3333cccc3333cccc",
|
||||
"bob",
|
||||
"_Not set_",
|
||||
"test",
|
||||
);
|
||||
|
||||
Command::cargo_bin(BIN_NAME)
|
||||
.unwrap()
|
||||
.current_dir(temp.path())
|
||||
.args(["relate", "aaaa1111", "--blocked-by", "cccc3333"])
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "committed", false);
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains("The Blocker"), "{stderr}");
|
||||
assert!(stderr.contains("The Second Blocker"), "{stderr}");
|
||||
}
|
||||
|
||||
/// `-f` is where the deliberate overrides live, beside the backward and skipping moves.
|
||||
#[test]
|
||||
fn mv_moves_a_blocked_ticket_with_force() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = create_gated_pair(&worklane, &temp, "backlog");
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "committed", true);
|
||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(worklane.join("committed").join(&filename).exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mv_allows_the_move_once_the_blocker_is_done() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = create_gated_pair(&worklane, &temp, "backlog");
|
||||
|
||||
for status in ["committed", "reviewing", "done"] {
|
||||
assert!(
|
||||
move_ticket(&temp, "bbbb2222", status, false).status.success(),
|
||||
"the blocker itself could not be moved to {status}"
|
||||
);
|
||||
}
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "committed", false);
|
||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(worklane.join("committed").join(&filename).exists());
|
||||
}
|
||||
|
||||
/// Every move, not only the one into committed. An open blocker is a reason not to
|
||||
/// finish as much as a reason not to start.
|
||||
#[test]
|
||||
fn mv_checks_the_blockers_on_every_move() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = create_gated_pair(&worklane, &temp, "reviewing");
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "done", false);
|
||||
assert!(!out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(worklane.join("reviewing").join(&filename).exists());
|
||||
}
|
||||
|
||||
/// A move to the status the ticket is already in is not a move, so it is reported the
|
||||
/// way it always was rather than refused.
|
||||
#[test]
|
||||
fn mv_does_not_check_the_blockers_on_a_no_op() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
create_gated_pair(&worklane, &temp, "backlog");
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "backlog", false);
|
||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(String::from_utf8_lossy(&out.stdout).contains("already in"));
|
||||
}
|
||||
|
||||
/// A dangling target is a bookkeeping fault, not a dependency. Refusing there would
|
||||
/// wedge the ticket with no way out but `--force`.
|
||||
#[test]
|
||||
fn mv_warns_and_allows_when_a_blocker_is_not_on_the_board() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = create_gated_pair(&worklane, &temp, "backlog");
|
||||
fs::remove_file(
|
||||
worklane
|
||||
.join("backlog")
|
||||
.join("bbbb2222bbbb2222bbbb2222bbbb2222bbbb_the-blocker.md"),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "committed", false);
|
||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("not on the board"),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert!(worklane.join("committed").join(&filename).exists());
|
||||
}
|
||||
|
||||
/// Only `blocked by` gates a move. The other two kinds are reference data.
|
||||
#[test]
|
||||
fn mv_ignores_the_kinds_that_are_not_blockers() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = setup_worklane(&temp);
|
||||
let filename = create_ticket(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"Related Task",
|
||||
"Points at an open ticket.",
|
||||
"aaaa1111aaaa1111aaaa1111aaaa1111aaaa",
|
||||
"alice",
|
||||
"_Not set_",
|
||||
"test",
|
||||
);
|
||||
create_ticket(
|
||||
&worklane,
|
||||
"backlog",
|
||||
"The Other",
|
||||
"Still open.",
|
||||
"bbbb2222bbbb2222bbbb2222bbbb2222bbbb",
|
||||
"bob",
|
||||
"_Not set_",
|
||||
"test",
|
||||
);
|
||||
|
||||
Command::cargo_bin(BIN_NAME)
|
||||
.unwrap()
|
||||
.current_dir(temp.path())
|
||||
.args([
|
||||
"relate",
|
||||
"aaaa1111",
|
||||
"--regression-of",
|
||||
"bbbb2222",
|
||||
"--relates-to",
|
||||
"bbbb2222",
|
||||
])
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
let out = move_ticket(&temp, "aaaa1111", "committed", false);
|
||||
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
assert!(worklane.join("committed").join(&filename).exists());
|
||||
}
|
||||
|
||||
@@ -0,0 +1,358 @@
|
||||
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");
|
||||
|
||||
/// The ticket under edit, the one it points at, and one that is already done.
|
||||
const GATED: &str = "641e3d5c-1b0e-4d2f-9a7e-3c8b5f0a2d61";
|
||||
const BLOCKER: &str = "b1b2c3d4-5e6f-4a7b-8c9d-0e1f2a3b4c5d";
|
||||
const FIXED: &str = "f1f2f3f4-5a6b-4c7d-8e9f-0a1b2c3d4e5f";
|
||||
|
||||
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()
|
||||
}
|
||||
|
||||
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 and a section the tool knows nothing about, so
|
||||
/// every test can check that recording a relation leaves both exactly as they were.
|
||||
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!(
|
||||
"# {}\n\
|
||||
\n\
|
||||
## Description\n\
|
||||
Prose.\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**: {}\n\
|
||||
- **Priority**: 3\n\
|
||||
- **Tags**: alpha\n\
|
||||
- **Due**: _Not set_\n\
|
||||
- **Owner**: alice\n\
|
||||
- **Created At**: 2026-08-21 02:10:17\n\
|
||||
- **Status**: {}\n",
|
||||
title, uuid, status
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
path
|
||||
}
|
||||
|
||||
/// The three tickets every test starts from: the one being edited, one it can wait on,
|
||||
/// and one in done.
|
||||
fn board(temp: &TempDir) -> PathBuf {
|
||||
let worklane = setup_worklane(temp);
|
||||
create_ticket(&worklane, "backlog", "The gated one", GATED);
|
||||
create_ticket(&worklane, "backlog", "The blocker", BLOCKER);
|
||||
create_ticket(&worklane, "done", "The old fix", FIXED);
|
||||
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 find(worklane: &Path, uuid: &str) -> PathBuf {
|
||||
for status in ["backlog", "committed", "reviewing", "done"] {
|
||||
let dir = worklane.join(status);
|
||||
for entry in fs::read_dir(&dir).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}");
|
||||
}
|
||||
|
||||
fn ticket(worklane: &Path, uuid: &str) -> String {
|
||||
fs::read_to_string(find(worklane, uuid)).unwrap()
|
||||
}
|
||||
|
||||
/// All three tiers, since the target is a ticket argument like any other: a uuid
|
||||
/// prefix, a title substring, and a substring reaching the middle of the filename.
|
||||
#[test]
|
||||
fn a_target_resolves_by_uuid_prefix_title_or_filename() {
|
||||
for search in ["b1b2", "blocker", "4a7b"] {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
let out = run(&temp, &["relate", GATED, "--blocked-by", search]);
|
||||
assert!(
|
||||
out.status.success(),
|
||||
"{search}: {}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert!(
|
||||
ticket(&worklane, GATED).contains(&format!("- blocked by {}", BLOCKER)),
|
||||
"{search}: {}",
|
||||
ticket(&worklane, GATED)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_kind_is_recorded_under_its_own_label() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
let out = run(
|
||||
&temp,
|
||||
&[
|
||||
"relate",
|
||||
GATED,
|
||||
"--blocked-by",
|
||||
BLOCKER,
|
||||
"--regression-of",
|
||||
FIXED,
|
||||
"--relates-to",
|
||||
"old fix",
|
||||
],
|
||||
);
|
||||
assert!(out.status.success());
|
||||
|
||||
let content = ticket(&worklane, GATED);
|
||||
assert!(content.contains(&format!("- blocked by {}", BLOCKER)), "{content}");
|
||||
assert!(content.contains(&format!("- regression of {}", FIXED)), "{content}");
|
||||
assert!(content.contains(&format!("- relates to {}", FIXED)), "{content}");
|
||||
|
||||
// Each kind named once in the report, whatever the order of the flags.
|
||||
let reported = stdout(&out);
|
||||
for kind in ["blocked by", "regression of", "relates to"] {
|
||||
assert!(reported.contains(kind), "{reported}");
|
||||
}
|
||||
}
|
||||
|
||||
/// The kinds are flags, so anything else never reaches the file: clap refuses it with
|
||||
/// a usage error, exit code 2, and nothing is written.
|
||||
#[test]
|
||||
fn an_unknown_kind_is_a_usage_error() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
let before = ticket(&worklane, GATED);
|
||||
|
||||
let out = run(&temp, &["relate", GATED, "--depends-on", BLOCKER]);
|
||||
assert_eq!(out.status.code(), Some(2), "{}", stdout(&out));
|
||||
assert_eq!(ticket(&worklane, GATED), before);
|
||||
}
|
||||
|
||||
/// A bare `relate <ticket>` is a usage error too, not a silent no-op, the same way a
|
||||
/// bare `set` and a bare `append` are.
|
||||
#[test]
|
||||
fn a_relate_with_no_kind_is_a_usage_error() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
board(&temp);
|
||||
|
||||
assert_eq!(run(&temp, &["relate", GATED]).status.code(), Some(2));
|
||||
}
|
||||
|
||||
/// Between the plan and the metadata, created for a ticket written before the section
|
||||
/// existed, and behind a handwritten section rather than in front of it.
|
||||
#[test]
|
||||
fn the_section_is_created_in_its_place() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
|
||||
let content = ticket(&worklane, GATED);
|
||||
let at = |heading: &str| content.find(heading).unwrap_or_else(|| panic!("{heading}"));
|
||||
assert!(at("## Implementation Plan") < at("## Relations"), "{content}");
|
||||
assert!(at("## Notes") < at("## Relations"), "{content}");
|
||||
assert!(at("## Relations") < at("## Metadata"), "{content}");
|
||||
}
|
||||
|
||||
/// The full uuid, not the seven characters `ls` prints, which is what makes the link
|
||||
/// survive a rename of the target and stay unambiguous as the board grows.
|
||||
#[test]
|
||||
fn the_stored_target_is_the_full_uuid() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
assert!(
|
||||
ticket(&worklane, GATED).contains(&format!("- blocked by {}\n", BLOCKER)),
|
||||
"{}",
|
||||
ticket(&worklane, GATED)
|
||||
);
|
||||
|
||||
run(&temp, &["set", BLOCKER, "--title", "Renamed entirely"]);
|
||||
|
||||
let shown = stdout(&run(&temp, &["show", GATED]));
|
||||
assert!(shown.contains("Renamed entirely"), "{shown}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_ticket_cannot_relate_to_itself() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
let before = ticket(&worklane, GATED);
|
||||
|
||||
let out = run(&temp, &["relate", GATED, "--relates-to", "gated"]);
|
||||
assert!(!out.status.success());
|
||||
assert!(
|
||||
String::from_utf8_lossy(&out.stderr).contains("cannot relate to itself"),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&out.stderr)
|
||||
);
|
||||
assert_eq!(ticket(&worklane, GATED), before);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_relation_already_held_reports_no_change_and_writes_nothing() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
let before = ticket(&worklane, GATED);
|
||||
|
||||
let out = run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
assert!(out.status.success());
|
||||
assert!(stdout(&out).contains("No changes"), "{}", stdout(&out));
|
||||
assert_eq!(
|
||||
ticket(&worklane, GATED),
|
||||
before,
|
||||
"the relation was recorded twice"
|
||||
);
|
||||
}
|
||||
|
||||
/// One direction is stored. The inverse is derived by a scan, so the ticket at the
|
||||
/// other end is not touched at all.
|
||||
#[test]
|
||||
fn only_the_ticket_named_is_written() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
let before = ticket(&worklane, BLOCKER);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
|
||||
assert_eq!(ticket(&worklane, BLOCKER), before);
|
||||
assert!(!ticket(&worklane, BLOCKER).contains("Relations"));
|
||||
}
|
||||
|
||||
/// The tick, the handwritten section and the prose are what a regenerated file would
|
||||
/// lose, and the section is spliced in rather than rewritten around them.
|
||||
#[test]
|
||||
fn relate_leaves_everything_it_was_not_asked_about_alone() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
|
||||
let content = ticket(&worklane, GATED);
|
||||
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("1. Step one"), "{content}");
|
||||
assert!(content.contains("- **Owner**: alice"), "{content}");
|
||||
}
|
||||
|
||||
/// The kind, the short id and the title, so the section reads without a second lookup.
|
||||
#[test]
|
||||
fn show_renders_the_kind_the_short_id_and_the_title() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
board(&temp);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
|
||||
let shown = stdout(&run(&temp, &["show", GATED]));
|
||||
assert!(shown.contains("Relations"), "{shown}");
|
||||
assert!(shown.contains("blocked by (b1b2c3d) The blocker"), "{shown}");
|
||||
// Never the stored line: a bare uuid says nothing about what it points at.
|
||||
assert!(!shown.contains(BLOCKER), "{shown}");
|
||||
}
|
||||
|
||||
/// Derived by scanning, since the file at this end holds nothing at all.
|
||||
#[test]
|
||||
fn show_lists_the_relation_the_other_ticket_holds() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
run(&temp, &["relate", GATED, "--relates-to", FIXED]);
|
||||
|
||||
let shown = stdout(&run(&temp, &["show", BLOCKER]));
|
||||
assert!(shown.contains("blocks (641e3d5) The gated one"), "{shown}");
|
||||
assert!(!ticket(&worklane, BLOCKER).contains("Relations"));
|
||||
|
||||
// `relates to` is symmetric, so it reads the same way from either end.
|
||||
let shown = stdout(&run(&temp, &["show", FIXED]));
|
||||
assert!(shown.contains("relates to (641e3d5) The gated one"), "{shown}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_target_that_no_longer_exists_renders_as_missing() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
run(&temp, &["relate", GATED, "--blocked-by", BLOCKER]);
|
||||
fs::remove_file(find(&worklane, BLOCKER)).unwrap();
|
||||
|
||||
let shown = stdout(&run(&temp, &["show", GATED]));
|
||||
assert!(shown.contains("blocked by (b1b2c3d) _missing_"), "{shown}");
|
||||
}
|
||||
|
||||
/// The section is the one part of a ticket read back by machine, so a line nobody can
|
||||
/// parse is an error naming the ticket rather than a line quietly skipped.
|
||||
#[test]
|
||||
fn a_line_that_is_not_a_relation_is_an_error() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let worklane = board(&temp);
|
||||
|
||||
let path = find(&worklane, GATED);
|
||||
let content = fs::read_to_string(&path)
|
||||
.unwrap()
|
||||
.replace(
|
||||
"## Metadata",
|
||||
&format!("## Relations\n- depends on {}\n\n## Metadata", BLOCKER),
|
||||
);
|
||||
fs::write(&path, content).unwrap();
|
||||
|
||||
let out = run(&temp, &["show", GATED]);
|
||||
assert!(!out.status.success());
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains("is not a relation"), "{stderr}");
|
||||
assert!(stderr.contains("The gated one"), "{stderr}");
|
||||
}
|
||||
Reference in New Issue
Block a user