Nothing could change a ticket after it was created. mv wrote status, comment appended a file, and that was the whole set of mutations, so correcting a typo or adding a criterion meant hand editing the markdown. Two commands rather than the one vague "edit" the ticket described. set replaces a field, append adds to a section, so the verb carries the meaning instead of a prefix on seven flag names, and append only offers the three sections that hold multiple lines. Owner is absent from both, it belongs to the chown command filed alongside this, and status stays mv's. One field, one writer. Sections are a table, DESCRIPTION, ACCEPTANCE and PLAN, each carrying a heading, a label, the placeholder add writes when empty, and a kind. Both commands walk it, so a section added later is one entry rather than edits in two places. Everything is targeted line surgery and never a regenerated file, which is what keeps a ticked criterion ticked and a handwritten section intact when an unrelated field changes. Appending to a numbered section continues from the count already there rather than renumbering above it, so a handwritten line survives exactly as written. Appending to an empty section replaces the placeholder instead of following it. An empty value is a paragraph break for a section and a usage error for a scalar, since it looks like a way to clear a field and clearing is not supported yet. No-op detection compares the whole file before and after each edit, so a field set to the value it already holds is reported unchanged and nothing is written. Two things came out of building it. move_ticket_file's staged write is extracted as write_then_replace, now the only way any ticket file is written. And the file is located by uuid rather than by title: titles are not unique, add allows duplicates on purpose, and the old title scan meant mv <uuid-of-second> moved the first ticket sharing its title. Reproduced, fixed, and pinned by a test. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
643 lines
18 KiB
Rust
643 lines
18 KiB
Rust
use assert_cmd::Command;
|
|
use assert_fs::TempDir;
|
|
use assert_fs::fixture::{PathChild, PathCreateDir};
|
|
use std::fs;
|
|
use std::path::PathBuf;
|
|
|
|
const BIN_NAME: &str = env!("CARGO_BIN_EXE_worklane");
|
|
|
|
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 create_ticket(
|
|
worklane_dir: &PathBuf,
|
|
status: &str,
|
|
title: &str,
|
|
description: &str,
|
|
id: &str,
|
|
owner: &str,
|
|
due: &str,
|
|
tags: &str,
|
|
) -> String {
|
|
let slug = title
|
|
.to_lowercase()
|
|
.chars()
|
|
.filter(|c| c.is_alphanumeric() || *c == ' ' || *c == '-' || *c == '_')
|
|
.map(|c| if c == ' ' { '-' } else { c })
|
|
.collect::<String>();
|
|
let filename = format!("{}_{}.md", id, slug);
|
|
let ticket_body = format!(
|
|
"# {}\n\
|
|
\n\
|
|
## Description\n\
|
|
{}\n\
|
|
\n\
|
|
## Acceptance Criteria\n\
|
|
- [ ] test\n\
|
|
\n\
|
|
## Implementation Plan\n\
|
|
- test\n\
|
|
\n\
|
|
## Metadata\n\
|
|
\n\
|
|
- **ID**: {}\n\
|
|
- **Tags**: {}\n\
|
|
- **Due**: {}\n\
|
|
- **Owner**: {}\n\
|
|
- **Status**: {}\n\
|
|
",
|
|
title, description, id, tags, due, owner, status
|
|
);
|
|
let path = worklane_dir.join(status).join(&filename);
|
|
fs::write(&path, ticket_body).unwrap();
|
|
filename
|
|
}
|
|
|
|
fn get_stdout(cmd: &mut Command) -> String {
|
|
let assert = cmd.assert();
|
|
String::from_utf8(assert.get_output().stdout.clone()).unwrap()
|
|
}
|
|
|
|
fn get_stderr(cmd: &mut Command) -> String {
|
|
let assert = cmd.assert();
|
|
String::from_utf8(assert.get_output().stderr.clone()).unwrap()
|
|
}
|
|
|
|
#[test]
|
|
fn mv_forwards_from_backlog_to_committed() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let id = "abc123def456789012345678901234567890";
|
|
let filename = create_ticket(
|
|
&worklane,
|
|
"backlog",
|
|
"Task One",
|
|
"Move this ticket.",
|
|
id,
|
|
"alice",
|
|
"2026-12-31",
|
|
"test",
|
|
);
|
|
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(&temp.path())
|
|
.arg("mv")
|
|
.arg("abc123def4567")
|
|
.arg("--status")
|
|
.arg("committed");
|
|
|
|
let assert = cmd.assert();
|
|
let stdout = String::from_utf8(assert.get_output().stdout.clone()).unwrap();
|
|
assert.success();
|
|
|
|
assert!(stdout.contains("Task One"));
|
|
assert!(stdout.contains("backlog"));
|
|
assert!(stdout.contains("committed"));
|
|
|
|
// Verify file moved
|
|
assert!(!worklane.join("backlog").join(&filename).exists());
|
|
assert!(worklane.join("committed").join(&filename).exists());
|
|
|
|
// Verify status updated
|
|
let content = fs::read_to_string(worklane.join("committed").join(&filename)).unwrap();
|
|
assert!(content.contains("- **Status**: committed"));
|
|
|
|
// No stray blank line inserted after the rewritten field
|
|
assert!(content.ends_with("- **Status**: committed\n"));
|
|
}
|
|
|
|
#[test]
|
|
fn mv_blocks_backward_move() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let id = "abc123def456789012345678901234567890";
|
|
create_ticket(
|
|
&worklane,
|
|
"committed",
|
|
"Committed Task",
|
|
"Should stay committed.",
|
|
id,
|
|
"bob",
|
|
"2026-11-15",
|
|
"test",
|
|
);
|
|
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(&temp.path())
|
|
.arg("mv")
|
|
.arg("abc123def4567")
|
|
.arg("--status")
|
|
.arg("backlog")
|
|
.assert()
|
|
.failure();
|
|
|
|
let stderr = get_stderr(&mut cmd);
|
|
assert!(stderr.contains("Cannot move backward"));
|
|
}
|
|
|
|
#[test]
|
|
fn mv_allows_backward_move_with_force() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let id = "abc123def456789012345678901234567890";
|
|
let filename = create_ticket(
|
|
&worklane,
|
|
"committed",
|
|
"Backward Move",
|
|
"Force backward.",
|
|
id,
|
|
"charlie",
|
|
"2026-10-01",
|
|
"test",
|
|
);
|
|
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(&temp.path())
|
|
.arg("mv")
|
|
.arg("abc123def4567")
|
|
.arg("--status")
|
|
.arg("backlog")
|
|
.arg("-f");
|
|
|
|
let assert = cmd.assert();
|
|
let stdout = String::from_utf8(assert.get_output().stdout.clone()).unwrap();
|
|
assert.success();
|
|
|
|
assert!(stdout.contains("Backward Move"));
|
|
assert!(stdout.contains("backlog"));
|
|
assert!(worklane.join("backlog").join(&filename).exists());
|
|
}
|
|
|
|
#[test]
|
|
fn mv_blocks_nonsequential_forward_move() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let id = "abc123def456789012345678901234567890";
|
|
create_ticket(
|
|
&worklane,
|
|
"backlog",
|
|
"Jump Task",
|
|
"Should not skip.",
|
|
id,
|
|
"dave",
|
|
"2026-09-01",
|
|
"test",
|
|
);
|
|
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(&temp.path())
|
|
.arg("mv")
|
|
.arg("abc123def4567")
|
|
.arg("--status")
|
|
.arg("done")
|
|
.assert()
|
|
.failure();
|
|
|
|
let stderr = get_stderr(&mut cmd);
|
|
assert!(stderr.contains("one stage forward"));
|
|
}
|
|
|
|
#[test]
|
|
fn mv_allows_skipping_stages_with_force() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let id = "abc123def456789012345678901234567890";
|
|
let filename = create_ticket(
|
|
&worklane,
|
|
"backlog",
|
|
"Skip Task",
|
|
"Force jump.",
|
|
id,
|
|
"eve",
|
|
"2026-08-01",
|
|
"test",
|
|
);
|
|
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(&temp.path())
|
|
.arg("mv")
|
|
.arg("abc123def4567")
|
|
.arg("--status")
|
|
.arg("done")
|
|
.arg("-f")
|
|
.assert()
|
|
.success();
|
|
|
|
assert!(worklane.join("done").join(&filename).exists());
|
|
let content = fs::read_to_string(worklane.join("done").join(&filename)).unwrap();
|
|
assert!(content.contains("- **Status**: done"));
|
|
}
|
|
|
|
#[test]
|
|
fn mv_ignores_already_in_same_status() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let id = "abc123def456789012345678901234567890";
|
|
let filename = create_ticket(
|
|
&worklane,
|
|
"reviewing",
|
|
"Same Status",
|
|
"Already there.",
|
|
id,
|
|
"frank",
|
|
"2026-07-01",
|
|
"test",
|
|
);
|
|
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(&temp.path())
|
|
.arg("mv")
|
|
.arg("abc123def4567")
|
|
.arg("--status")
|
|
.arg("reviewing")
|
|
.assert()
|
|
.success();
|
|
|
|
let stdout = get_stdout(&mut cmd);
|
|
assert!(stdout.contains("already in"));
|
|
assert!(worklane.join("reviewing").join(&filename).exists());
|
|
}
|
|
|
|
#[test]
|
|
fn mv_rejects_invalid_status() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let id = "abc123def456789012345678901234567890";
|
|
let _filename = create_ticket(
|
|
&worklane,
|
|
"backlog",
|
|
"Invalid Target",
|
|
"Bad status.",
|
|
id,
|
|
"grace",
|
|
"2026-06-01",
|
|
"test",
|
|
);
|
|
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(&temp.path())
|
|
.arg("mv")
|
|
.arg("abc123def4567")
|
|
.arg("--status")
|
|
.arg("invalid")
|
|
.assert()
|
|
.failure();
|
|
|
|
let stderr = get_stderr(&mut cmd);
|
|
assert!(stderr.contains("Invalid target status"));
|
|
}
|
|
|
|
#[test]
|
|
fn mv_uses_ticket_id_for_resolution() {
|
|
let temp = TempDir::new().unwrap();
|
|
let wl = setup_worklane(&temp);
|
|
|
|
let id = "abc123def456789012345678901234567890";
|
|
let filename = create_ticket(
|
|
&wl,
|
|
"backlog",
|
|
"ID Resolution",
|
|
"Use ID to find.",
|
|
id,
|
|
"hank",
|
|
"2026-05-01",
|
|
"test",
|
|
);
|
|
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(&temp.path())
|
|
.arg("mv")
|
|
.arg("abc123def4567")
|
|
.arg("--status")
|
|
.arg("committed");
|
|
|
|
let assert = cmd.assert();
|
|
let stdout = String::from_utf8(assert.get_output().stdout.clone()).unwrap();
|
|
assert.success();
|
|
|
|
assert!(stdout.contains("ID Resolution"));
|
|
assert!(wl.join("committed").join(&filename).exists());
|
|
}
|
|
|
|
#[test]
|
|
fn mv_keeps_status_in_sync_across_consecutive_moves() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let id = "abc123def456789012345678901234567890";
|
|
let filename = create_ticket(
|
|
&worklane,
|
|
"backlog",
|
|
"Two Hop",
|
|
"Moved twice.",
|
|
id,
|
|
"ida",
|
|
"2026-04-01",
|
|
"test",
|
|
);
|
|
|
|
for target in ["committed", "reviewing"] {
|
|
Command::cargo_bin(BIN_NAME)
|
|
.unwrap()
|
|
.current_dir(&temp.path())
|
|
.arg("mv")
|
|
.arg("abc123def4567")
|
|
.arg("--status")
|
|
.arg(target)
|
|
.assert()
|
|
.success();
|
|
}
|
|
|
|
assert!(worklane.join("reviewing").join(&filename).exists());
|
|
|
|
// The second move must update the field too, not silently skip it
|
|
let content = fs::read_to_string(worklane.join("reviewing").join(&filename)).unwrap();
|
|
assert!(content.contains("- **Status**: reviewing"));
|
|
assert!(!content.contains("-Status"));
|
|
assert!(!content.contains("committed"));
|
|
}
|
|
|
|
#[test]
|
|
fn mv_repairs_legacy_status_field() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let filename = "abc123def456789012345678901234567890_legacy.md";
|
|
let path = worklane.join("committed").join(filename);
|
|
fs::write(
|
|
&path,
|
|
"# Legacy Ticket\n\
|
|
\n\
|
|
## Metadata\n\
|
|
\n\
|
|
- **ID**: abc123def456789012345678901234567890\n\
|
|
- **-Status**: committed\n",
|
|
)
|
|
.unwrap();
|
|
|
|
Command::cargo_bin(BIN_NAME)
|
|
.unwrap()
|
|
.current_dir(&temp.path())
|
|
.arg("mv")
|
|
.arg("abc123def4567")
|
|
.arg("--status")
|
|
.arg("reviewing")
|
|
.assert()
|
|
.success();
|
|
|
|
let content = fs::read_to_string(worklane.join("reviewing").join(filename)).unwrap();
|
|
assert!(content.contains("- **Status**: reviewing"));
|
|
assert!(!content.contains("-Status"));
|
|
}
|
|
|
|
#[test]
|
|
fn mv_fails_when_status_field_is_missing() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let filename = "abc123def456789012345678901234567890_no-status.md";
|
|
let path = worklane.join("backlog").join(filename);
|
|
fs::write(&path, "# No Status\n\n## Metadata\n\n- **Owner**: jack\n").unwrap();
|
|
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(&temp.path())
|
|
.arg("mv")
|
|
.arg("abc123def4567")
|
|
.arg("--status")
|
|
.arg("committed")
|
|
.assert()
|
|
.failure();
|
|
|
|
let stderr = get_stderr(&mut cmd);
|
|
assert!(stderr.contains("No Status"));
|
|
assert!(stderr.contains("has no Status field"));
|
|
|
|
// The ticket must not be half-moved
|
|
assert!(worklane.join("backlog").join(filename).exists());
|
|
assert!(!worklane.join("committed").join(filename).exists());
|
|
}
|
|
|
|
use std::os::unix::fs::PermissionsExt;
|
|
|
|
fn chmod(path: &std::path::Path, mode: u32) {
|
|
let mut perms = fs::metadata(path).unwrap().permissions();
|
|
perms.set_mode(mode);
|
|
fs::set_permissions(path, perms).unwrap();
|
|
}
|
|
|
|
fn md_files(dir: &std::path::Path) -> Vec<String> {
|
|
match fs::read_dir(dir) {
|
|
Ok(entries) => entries
|
|
.filter_map(|e| e.ok())
|
|
.map(|e| e.file_name().into_string().unwrap())
|
|
.filter(|name| name.ends_with(".md"))
|
|
.collect(),
|
|
Err(_) => vec![],
|
|
}
|
|
}
|
|
|
|
/// Nothing is staged in a status directory, so nothing can be left behind that the
|
|
/// listing would read as a ticket.
|
|
fn stray_files(worklane: &std::path::Path) -> Vec<String> {
|
|
let mut stray: 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();
|
|
|
|
for dir in ["backlog", "committed", "reviewing", "done"] {
|
|
stray.extend(
|
|
fs::read_dir(worklane.join(dir))
|
|
.into_iter()
|
|
.flatten()
|
|
.filter_map(|e| e.ok())
|
|
.map(|e| e.file_name().into_string().unwrap())
|
|
.filter(|name| !name.ends_with(".md")),
|
|
);
|
|
}
|
|
|
|
stray
|
|
}
|
|
|
|
/// The bug this fixes. The old order renamed first and wrote second, so a write
|
|
/// that failed left the ticket in its new directory still claiming the old status.
|
|
/// A read-only ticket file is the cheapest way to make the write fail.
|
|
#[test]
|
|
fn mv_never_leaves_stale_content_in_the_target_directory() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let filename = create_ticket(
|
|
&worklane,
|
|
"backlog",
|
|
"Read Only",
|
|
"A description.",
|
|
"abc123def456789012345678901234567890",
|
|
"alice",
|
|
"2026-12-31",
|
|
"test",
|
|
);
|
|
|
|
let source = worklane.join("backlog").join(&filename);
|
|
chmod(&source, 0o444);
|
|
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(&temp.path())
|
|
.args(["mv", "abc123def4567", "--status", "committed"])
|
|
.assert()
|
|
.success();
|
|
|
|
// Wherever it ended up, its Status must agree with the directory it is in
|
|
let moved = worklane.join("committed").join(&filename);
|
|
assert!(moved.exists(), "ticket did not move");
|
|
let content = fs::read_to_string(&moved).unwrap();
|
|
assert!(
|
|
content.contains("- **Status**: committed"),
|
|
"stale status: {content:?}"
|
|
);
|
|
assert!(!content.contains("- **Status**: backlog"), "{content:?}");
|
|
|
|
assert_eq!(md_files(&worklane.join("backlog")).len(), 0);
|
|
assert_eq!(stray_files(&worklane), Vec::<String>::new());
|
|
}
|
|
|
|
/// The other criterion: one directory or the other, never both. An unwritable
|
|
/// target directory fails the move at the last step, which is the step that would
|
|
/// have to be reordered to break this.
|
|
#[test]
|
|
fn mv_leaves_the_ticket_in_one_place_when_the_move_fails() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
let filename = create_ticket(
|
|
&worklane,
|
|
"backlog",
|
|
"Blocked Move",
|
|
"A description.",
|
|
"abc123def456789012345678901234567890",
|
|
"alice",
|
|
"2026-12-31",
|
|
"test",
|
|
);
|
|
|
|
let target = worklane.join("committed");
|
|
chmod(&target, 0o555);
|
|
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
let assert = cmd
|
|
.current_dir(&temp.path())
|
|
.args(["mv", "abc123def4567", "--status", "committed"])
|
|
.assert()
|
|
.failure();
|
|
|
|
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
|
|
// Named, not a bare io error
|
|
assert!(stderr.contains("Blocked Move"), "{stderr}");
|
|
|
|
assert_eq!(
|
|
md_files(&worklane.join("backlog")),
|
|
vec![filename.clone()],
|
|
"the ticket left its own directory"
|
|
);
|
|
assert_eq!(md_files(&target).len(), 0, "the ticket is in both places");
|
|
assert_eq!(stray_files(&worklane), Vec::<String>::new());
|
|
|
|
// The documented worst case: still in its old directory, carrying a Status one
|
|
// move ahead because the content was written before the move was attempted.
|
|
let left = fs::read_to_string(worklane.join("backlog").join(&filename)).unwrap();
|
|
assert!(left.contains("- **Status**: committed"), "{left:?}");
|
|
|
|
// And the state is recoverable, because the directory is what decides the
|
|
// current status, so a retry moves it rather than refusing.
|
|
chmod(&target, 0o755);
|
|
|
|
let mut retry = Command::cargo_bin(BIN_NAME).unwrap();
|
|
retry
|
|
.current_dir(&temp.path())
|
|
.args(["mv", "abc123def4567", "--status", "committed"])
|
|
.assert()
|
|
.success();
|
|
|
|
assert_eq!(md_files(&target), vec![filename]);
|
|
assert_eq!(md_files(&worklane.join("backlog")).len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn mv_leaves_nothing_behind_on_success() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
create_ticket(
|
|
&worklane,
|
|
"backlog",
|
|
"Clean Move",
|
|
"A description.",
|
|
"abc123def456789012345678901234567890",
|
|
"alice",
|
|
"2026-12-31",
|
|
"test",
|
|
);
|
|
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(&temp.path())
|
|
.args(["mv", "abc123def4567", "--status", "committed"])
|
|
.assert()
|
|
.success();
|
|
|
|
assert_eq!(stray_files(&worklane), Vec::<String>::new());
|
|
}
|
|
|
|
/// Duplicate titles are allowed, so the file cannot be located by title. It used to be,
|
|
/// and `mv <uuid-of-second>` moved the first ticket that shared its title.
|
|
#[test]
|
|
fn mv_moves_the_resolved_ticket_when_two_share_a_title() {
|
|
let temp = TempDir::new().unwrap();
|
|
let worklane = setup_worklane(&temp);
|
|
|
|
for uuid in [
|
|
"11111111-aaaa-bbbb-cccc-dddddddddddd",
|
|
"22222222-aaaa-bbbb-cccc-dddddddddddd",
|
|
] {
|
|
fs::write(
|
|
worklane.join("backlog").join(format!("{}_foo.md", uuid)),
|
|
format!(
|
|
"# Foo\n\n## Metadata\n\n- **ID**: {}\n- **Status**: backlog\n",
|
|
uuid
|
|
),
|
|
)
|
|
.unwrap();
|
|
}
|
|
|
|
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
|
cmd.current_dir(&temp.path())
|
|
.args(["mv", "22222222", "--status", "committed"])
|
|
.assert()
|
|
.success();
|
|
|
|
assert_eq!(
|
|
md_files(&worklane.join("committed")),
|
|
vec!["22222222-aaaa-bbbb-cccc-dddddddddddd_foo.md".to_string()],
|
|
"the wrong ticket moved"
|
|
);
|
|
assert_eq!(
|
|
md_files(&worklane.join("backlog")),
|
|
vec!["11111111-aaaa-bbbb-cccc-dddddddddddd_foo.md".to_string()]
|
|
);
|
|
}
|