(c6a61b4) Resolve a board through a pointer file and a shared boards repo, and bump to 0.33.0
This commit is contained in:
+11
-1
@@ -247,7 +247,17 @@ fn nothing_is_created_without_a_title() {
|
||||
fn init_creates_the_campaigns_directory() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
|
||||
let out = run(&temp, &["init"]);
|
||||
// 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());
|
||||
|
||||
@@ -75,7 +75,15 @@ fn fish_is_offered_every_status() {
|
||||
fn board() -> (assert_fs::TempDir, String, String) {
|
||||
let temp = assert_fs::TempDir::new().unwrap();
|
||||
let mut init = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
init.current_dir(temp.path()).arg("init").assert().success();
|
||||
// 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.
|
||||
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")
|
||||
.assert()
|
||||
.success();
|
||||
|
||||
let mut add = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
add.current_dir(temp.path())
|
||||
|
||||
@@ -0,0 +1,359 @@
|
||||
//! `worklane init` and the shared-board decision table (c6a61b4).
|
||||
//!
|
||||
//! A project is on one of two layouts: the local `.worklane` directory every project
|
||||
//! always had, or the shared one where the project carries a committed `.worklane.toml`,
|
||||
//! the board lives in a machine-level boards directory, and `.worklane` is a symlink
|
||||
//! into it. The machine config decides the default, and the pointer decides where the
|
||||
//! project already is. The tests below walk the whole table: one per row, the three
|
||||
//! symlink states, and the standalone path.
|
||||
//!
|
||||
//! Every test runs on an isolated machine: `HOME` and the XDG variables point into the
|
||||
//! temp directory, so the suite can never read or write a real config or boards
|
||||
//! directory, and a `find_worklane_dir` walk from the project can never climb into one.
|
||||
|
||||
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");
|
||||
|
||||
/// A project with no pointer and no board, ready for `init` to decide on.
|
||||
fn project(temp: &TempDir) -> PathBuf {
|
||||
temp.child("project").create_dir_all().unwrap();
|
||||
temp.child("project").path().to_path_buf()
|
||||
}
|
||||
|
||||
fn run(project: &Path, machine: &TempDir, args: &[&str]) -> std::process::Output {
|
||||
let mut cmd = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
cmd.current_dir(project)
|
||||
.env("HOME", machine.path())
|
||||
.env("XDG_CONFIG_HOME", machine.path().join(".config"))
|
||||
.env("XDG_DATA_HOME", machine.path().join(".local/share"))
|
||||
.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()
|
||||
}
|
||||
|
||||
/// The boards directory of a machine, under its data dir.
|
||||
fn boards_dir(machine: &TempDir) -> PathBuf {
|
||||
machine.path().join(".local/share/worklane/boards")
|
||||
}
|
||||
|
||||
/// The board a pointer names when the machine holds it.
|
||||
fn board_path(machine: &TempDir, uuid: &str, slug: &str) -> PathBuf {
|
||||
boards_dir(machine).join(format!("{uuid}_{slug}"))
|
||||
}
|
||||
|
||||
/// The machine config, without which a no-pointer project stays on the local layout.
|
||||
///
|
||||
/// Carries only the boards repo url; the boards directory defaults under the machine's
|
||||
/// data dir, which is where these tests put it.
|
||||
fn with_boards_config(machine: &TempDir) {
|
||||
let config = machine.path().join(".config/worklane/config.toml");
|
||||
fs::create_dir_all(config.parent().unwrap()).unwrap();
|
||||
fs::write(config, "[boards]\nurl = \"git@example:worklane/boards\"\n").unwrap();
|
||||
}
|
||||
|
||||
/// The committed pointer naming a board by uuid. This is the only thing that puts a
|
||||
/// project on the shared layout.
|
||||
fn write_pointer(project: &Path, uuid: &str) {
|
||||
fs::write(project.join(".worklane.toml"), format!("[worklane]\nboard = \"{uuid}\"\n")).unwrap();
|
||||
}
|
||||
|
||||
/// A board directory in the machine's boards repo, named `<uuid>_<slug>`.
|
||||
fn with_board(machine: &TempDir, uuid: &str, slug: &str) -> PathBuf {
|
||||
let board = board_path(machine, uuid, slug);
|
||||
fs::create_dir_all(&board).unwrap();
|
||||
board
|
||||
}
|
||||
|
||||
/// The relative spelling init gives a `.worklane` symlink, used to build the states a
|
||||
/// project can already be in.
|
||||
fn link_target(project: &Path, board: &Path) -> String {
|
||||
let base = project;
|
||||
let common = base
|
||||
.components()
|
||||
.zip(board.components())
|
||||
.take_while(|(a, b)| a == b)
|
||||
.count();
|
||||
let mut up = String::new();
|
||||
for _ in common..base.components().count() {
|
||||
up.push_str("../");
|
||||
}
|
||||
let mut rest = String::new();
|
||||
for component in board.components().skip(common) {
|
||||
rest.push_str(&component.as_os_str().to_string_lossy());
|
||||
rest.push('/');
|
||||
}
|
||||
format!("{up}{rest}").trim_end_matches('/').to_string()
|
||||
}
|
||||
|
||||
fn symlink_to(project: &Path, target: &str) {
|
||||
std::os::unix::fs::symlink(target, project.join(".worklane")).unwrap();
|
||||
}
|
||||
|
||||
fn boards_of(machine: &TempDir) -> Vec<PathBuf> {
|
||||
fs::read_dir(boards_dir(machine))
|
||||
.unwrap()
|
||||
.map(|entry| entry.unwrap().path())
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The standalone path, and the reason it has to stay: every project written before the
|
||||
/// shared layout existed, and every project whose machine has no boards config, must
|
||||
/// still get exactly the board `init` always made.
|
||||
#[test]
|
||||
fn no_pointer_no_config_and_no_boards_repo_makes_a_local_board() {
|
||||
let machine = TempDir::new().unwrap();
|
||||
let project = project(&machine);
|
||||
|
||||
let out = run(&project, &machine, &["init"]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
assert_eq!(
|
||||
stdout(&out),
|
||||
format!("Initialized worklane in: {}\n", project.join(".worklane").display())
|
||||
);
|
||||
|
||||
assert!(
|
||||
fs::symlink_metadata(project.join(".worklane")).unwrap().is_dir(),
|
||||
".worklane must be a real directory"
|
||||
);
|
||||
assert!(!project.join(".worklane.toml").exists(), "no pointer on a local board");
|
||||
for dir in [
|
||||
"backlog",
|
||||
"committed",
|
||||
"reviewing",
|
||||
"done",
|
||||
"discarded",
|
||||
"campaigns",
|
||||
] {
|
||||
assert!(project.join(".worklane").join(dir).is_dir(), "local board missing {dir}");
|
||||
}
|
||||
}
|
||||
|
||||
/// The pointer is committed and carries only the board by uuid, nowhere for a home
|
||||
/// directory or a server address to hide.
|
||||
#[test]
|
||||
fn a_shared_init_commits_a_pointer_carrying_only_the_uuid() {
|
||||
let machine = TempDir::new().unwrap();
|
||||
let project = project(&machine);
|
||||
with_boards_config(&machine);
|
||||
|
||||
let out = run(&project, &machine, &["init"]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
let output = stdout(&out);
|
||||
assert!(output.contains("Initialized shared worklane in: "), "{output}");
|
||||
assert!(output.contains("Board pointer: "), "{output}");
|
||||
assert!(
|
||||
output.contains(&format!("Linked {} to it", project.join(".worklane").display())),
|
||||
"{output}"
|
||||
);
|
||||
|
||||
let board = output
|
||||
.lines()
|
||||
.next()
|
||||
.unwrap()
|
||||
.trim_start_matches("Initialized shared worklane in: ")
|
||||
.to_string();
|
||||
let uuid = Path::new(&board)
|
||||
.file_name()
|
||||
.unwrap()
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.split('_')
|
||||
.next()
|
||||
.unwrap();
|
||||
let pointer = fs::read_to_string(project.join(".worklane.toml")).unwrap();
|
||||
assert_eq!(pointer, format!("[worklane]\nboard = \"{uuid}\"\n"));
|
||||
assert!(
|
||||
!pointer.contains(machine.path().to_str().unwrap()),
|
||||
"no home path in the pointer"
|
||||
);
|
||||
assert!(!pointer.contains("git@"), "no server address in the pointer");
|
||||
}
|
||||
|
||||
/// A pointer whose board is present is the state a fresh clone is in: `.worklane` is
|
||||
/// missing and nothing else is. init links it and creates nothing.
|
||||
#[test]
|
||||
fn pointer_with_the_board_present_symlinks_it_and_creates_nothing() {
|
||||
let machine = TempDir::new().unwrap();
|
||||
let project = project(&machine);
|
||||
with_boards_config(&machine);
|
||||
write_pointer(&project, "12345678-1234-1234-1234-1234567890ab");
|
||||
let board = with_board(&machine, "12345678-1234-1234-1234-1234567890ab", "project");
|
||||
|
||||
let before = fs::read_to_string(project.join(".worklane.toml")).unwrap();
|
||||
let out = run(&project, &machine, &["init"]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
assert!(
|
||||
stdout(&out).contains(&format!("Linked {} to it", project.join(".worklane").display()))
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
fs::canonicalize(project.join(".worklane")).unwrap(),
|
||||
fs::canonicalize(&board).unwrap()
|
||||
);
|
||||
assert_eq!(fs::read_to_string(project.join(".worklane.toml")).unwrap(), before);
|
||||
assert_eq!(boards_of(&machine).len(), 1, "no second board was created");
|
||||
}
|
||||
|
||||
/// A pointer whose board is absent is an unsynced machine, and creating a second board
|
||||
/// there is the worst outcome in the design. init refuses, and `--create` is the only
|
||||
/// way to make one.
|
||||
#[test]
|
||||
fn pointer_with_the_board_absent_refuses_and_create_is_the_only_way() {
|
||||
let machine = TempDir::new().unwrap();
|
||||
let project = project(&machine);
|
||||
with_boards_config(&machine);
|
||||
write_pointer(&project, "abcd5678-abcd-4bcd-abcd-abcdabcdabcd");
|
||||
with_board(&machine, "12345678-1234-1234-1234-1234567890ab", "other");
|
||||
|
||||
let out = run(&project, &machine, &["init"]);
|
||||
assert!(!out.status.success());
|
||||
let err = stderr(&out);
|
||||
assert!(
|
||||
err.contains("holds no board for abcd5678-abcd-4bcd-abcd-abcdabcdabcd."),
|
||||
"{err}"
|
||||
);
|
||||
assert!(err.contains("`worklane init --create`"), "{err}");
|
||||
assert!(!project.join(".worklane").exists(), "nothing was linked");
|
||||
assert_eq!(boards_of(&machine).len(), 1, "no board was created");
|
||||
|
||||
let out = run(&project, &machine, &["init", "--create"]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
assert_eq!(
|
||||
fs::canonicalize(project.join(".worklane")).unwrap(),
|
||||
fs::canonicalize(board_path(&machine, "abcd5678-abcd-4bcd-abcd-abcdabcdabcd", "project"))
|
||||
.unwrap()
|
||||
);
|
||||
}
|
||||
|
||||
/// The boards directory itself is gone: that is an uncloned boards repo, not a missing
|
||||
/// board, and the two must be told apart.
|
||||
#[test]
|
||||
fn boards_repo_missing_is_said_as_such() {
|
||||
let machine = TempDir::new().unwrap();
|
||||
let project = project(&machine);
|
||||
with_boards_config(&machine);
|
||||
write_pointer(&project, "12345678-1234-1234-1234-1234567890ab");
|
||||
|
||||
let out = run(&project, &machine, &["init"]);
|
||||
assert!(!out.status.success());
|
||||
let err = stderr(&out);
|
||||
assert!(err.contains("does not exist"), "{err}");
|
||||
assert!(err.contains("boards repo that is not cloned here"), "{err}");
|
||||
}
|
||||
|
||||
/// The correct symlink in place is the layout already there: init reports no change and
|
||||
/// writes nothing.
|
||||
#[test]
|
||||
fn correct_symlink_already_in_place_reports_no_change() {
|
||||
let machine = TempDir::new().unwrap();
|
||||
let project = project(&machine);
|
||||
with_boards_config(&machine);
|
||||
let board = with_board(&machine, "12345678-1234-1234-1234-1234567890ab", "project");
|
||||
write_pointer(&project, "12345678-1234-1234-1234-1234567890ab");
|
||||
symlink_to(&project, &link_target(&project, &board));
|
||||
|
||||
let before = fs::read_to_string(project.join(".worklane.toml")).unwrap();
|
||||
let out = run(&project, &machine, &["init"]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
assert!(stdout(&out).starts_with("worklane already initialized in: "));
|
||||
assert_eq!(fs::read_to_string(project.join(".worklane.toml")).unwrap(), before);
|
||||
assert_eq!(boards_of(&machine).len(), 1, "nothing was written");
|
||||
}
|
||||
|
||||
/// A symlink pointing at a different board is a project on the wrong board, and changing
|
||||
/// what a project is on without asking is how two machines disagree about the work.
|
||||
#[test]
|
||||
fn symlink_to_a_different_board_refuses_rather_than_repointing() {
|
||||
let machine = TempDir::new().unwrap();
|
||||
let project = project(&machine);
|
||||
with_boards_config(&machine);
|
||||
with_board(&machine, "12345678-1234-1234-1234-1234567890ab", "project");
|
||||
let other = with_board(&machine, "99999999-9999-4999-8999-999999999999", "other");
|
||||
write_pointer(&project, "12345678-1234-1234-1234-1234567890ab");
|
||||
let other_target = link_target(&project, &other);
|
||||
symlink_to(&project, &other_target);
|
||||
|
||||
let out = run(&project, &machine, &["init"]);
|
||||
assert!(!out.status.success());
|
||||
let err = stderr(&out);
|
||||
assert!(err.contains("already links to"), "{err}");
|
||||
assert!(err.contains("not to the board"), "{err}");
|
||||
assert_eq!(
|
||||
fs::read_link(project.join(".worklane")).unwrap(),
|
||||
PathBuf::from(&other_target)
|
||||
);
|
||||
}
|
||||
|
||||
/// A symlink that resolves to nothing is neither the layout init places nor a board: it
|
||||
/// is not replaced without asking.
|
||||
#[test]
|
||||
fn symlink_that_dangles_is_not_replaced() {
|
||||
let machine = TempDir::new().unwrap();
|
||||
let project = project(&machine);
|
||||
with_boards_config(&machine);
|
||||
with_board(&machine, "12345678-1234-1234-1234-1234567890ab", "project");
|
||||
write_pointer(&project, "12345678-1234-1234-1234-1234567890ab");
|
||||
symlink_to(&project, "nowhere-anyone-knows");
|
||||
|
||||
let out = run(&project, &machine, &["init"]);
|
||||
assert!(!out.status.success());
|
||||
let err = stderr(&out);
|
||||
assert!(err.contains("nowhere-anyone-knows, which does not exist"), "{err}");
|
||||
assert_eq!(
|
||||
fs::read_link(project.join(".worklane")).unwrap(),
|
||||
PathBuf::from("nowhere-anyone-knows")
|
||||
);
|
||||
}
|
||||
|
||||
/// A real `.worklane` directory under a pointer is a board from before the shared
|
||||
/// layout, and it is never walked over; the refusal names the adopt path.
|
||||
#[test]
|
||||
fn real_worklane_directory_under_a_pointer_refuses_and_names_the_adopt_path() {
|
||||
let machine = TempDir::new().unwrap();
|
||||
let project = project(&machine);
|
||||
with_boards_config(&machine);
|
||||
write_pointer(&project, "12345678-1234-1234-1234-1234567890ab");
|
||||
with_board(&machine, "12345678-1234-1234-1234-1234567890ab", "project");
|
||||
fs::create_dir_all(project.join(".worklane").join("backlog")).unwrap();
|
||||
fs::write(project.join(".worklane").join("backlog").join("b.md"), "# anything\n").unwrap();
|
||||
|
||||
let out = run(&project, &machine, &["init"]);
|
||||
assert!(!out.status.success());
|
||||
let err = stderr(&out);
|
||||
assert!(err.contains("is a real directory"), "{err}");
|
||||
assert!(err.contains("adopt"), "{err}");
|
||||
assert!(
|
||||
project.join(".worklane").join("backlog").join("b.md").is_file(),
|
||||
"the pre-existing board was left intact"
|
||||
);
|
||||
}
|
||||
|
||||
/// The slug, and only the slug, may change: resolution is a uuid prefix match, so
|
||||
/// renaming a board breaks no committed pointer.
|
||||
#[test]
|
||||
fn renaming_a_board_slug_breaks_no_pointer() {
|
||||
let machine = TempDir::new().unwrap();
|
||||
let project = project(&machine);
|
||||
with_boards_config(&machine);
|
||||
write_pointer(&project, "12345678-1234-1234-1234-1234567890ab");
|
||||
let renamed = with_board(&machine, "12345678-1234-1234-1234-1234567890ab", "new-name");
|
||||
|
||||
let out = run(&project, &machine, &["init"]);
|
||||
assert!(out.status.success(), "{}", stderr(&out));
|
||||
assert_eq!(
|
||||
fs::canonicalize(project.join(".worklane")).unwrap(),
|
||||
fs::canonicalize(&renamed).unwrap()
|
||||
);
|
||||
}
|
||||
+11
-1
@@ -397,7 +397,17 @@ fn the_file_is_created_on_a_board_that_predates_it() {
|
||||
#[test]
|
||||
fn init_writes_the_vocabulary_beside_the_status_directories() {
|
||||
let temp = TempDir::new().unwrap();
|
||||
let out = run(&temp, &["init"]);
|
||||
// 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 out = Command::cargo_bin(BIN_NAME).unwrap();
|
||||
let out = out
|
||||
.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(), "{}", String::from_utf8_lossy(&out.stderr));
|
||||
|
||||
let file = vocabulary(&temp);
|
||||
|
||||
Reference in New Issue
Block a user