mirror of
https://github.com/max-sixty/worktrunk.git
synced 2026-11-22 17:43:47 +08:00
## What regressed Since v0.80.0, Ctrl-C during `wt remove a b c` no longer stops the batch when the pre-remove hook catches SIGINT and exits normally, as pre-commit does (`trap '...' INT; exit 130`). Reproduced with a hook that traps INT, exits 130 and otherwise sleeps, plus a process-group SIGINT: v0.80.0 stops at `a` and keeps every worktree; current main removes `b` and `c`, branches included, and runs their hooks. `wt step prune` did the same with a hook that exits 0 after catching the key: every candidate was removed and wt exited 0. Two changes combined. #4400 moved foreground children into the caller's native job group and followed the shell's wait-and-cooperative-exit rule, so a child that handles the key keeps its own exit status. #4357 made a multi-target remove continue past a failing target. ## The rule Max chose the batch-runner convention (make, ninja, cargo) over the shell's: Ctrl-C that wt itself receives stops the current command. The terminal delivers SIGINT to the whole foreground job, so wt receives the key alongside the child. A shell waits and exits only if the child died of the signal, because the child might be an interactive program using Ctrl-C as input. A batch runner's steps aren't interactive, and the user pressing Ctrl-C means "stop the batch". For a destructive loop like remove or prune, that rule is also the one the data-safety principle asks for. The child still handles the key its own way, and wt never signals it for INT. Once the child exits, the command starts nothing more and exits interrupted (native SIGINT re-raise / 130), whatever status the child chose. Numeric exit codes such as 130 are still never read as cancellation; wt's own receipt is the evidence. ## What changes - `src/signal_forwarder.rs`: the existing per-operation cancellation (`CommandOperation`) gains a SIGINT flag beside its SIGTERM one. Foreground scopes register it, so the scope reports cancellation when its child exits, and later admissions in the same command are refused. The output drain's fresh flag, which existed to ignore keys the children had already handled, is gone. - Covered loops: hook pipelines (including Warn-strategy post-* hooks), multi-step aliases, `for-each`, multi-target `remove` and `prune`. - A command's final interactive child keeps the key as input and its own exit status: help and `config show` pagers, `--execute` programs and custom `wt-*` subcommands opt in through `Cmd::hand_off_terminal` (`TerminalInterrupt::ChildInput`). So does an alias's last serial step (`ForegroundStdin::HandOff`), since the alias is the whole command; `agent = "claude"` keeps claude's status after the user stops a turn with Ctrl-C. Otherwise pressing Ctrl-C in `less`, a REPL started by `-x` or such an alias, then quitting normally, would turn into exit 130. Earlier alias steps, concurrent groups and every hook step still cancel. - Unchanged: between children, idle SIGINT still kills wt natively. Detached background hooks, timeout-bounded captures in their own process group and the picker hold no foreground scope. A SIGINT sent only to wt is still not forwarded to the child; wt waits for it to finish, then stops. Windows is unchanged: wt installs no console Ctrl-C handler, so the default handler already ends wt and nothing more starts. - AGENTS.md "Signal Handling" and the `signal_forwarder` / `shell_exec` / `concurrent` module docs state the new rule. ## Verification - New unix integration tests, each pressing Ctrl-C (a group SIGINT) after wt has admitted a child that catches it: `remove` with a hook exiting 130 and with one exiting 0 keeps both targets; a post-start pipeline doesn't run its next step after a step exits 130; `for-each` visits one worktree when the child exits 0. All four fail on the old semantics. `test_alias_last_step_keeps_status_after_caught_ctrl_c` covers the alias handoff. The exit-0 remove case also fails if the scope stops reporting the latch and only refuses later admissions, since the current target would still be removed. - Existing tests that asserted the old rule now assert cancellation: the PTY `caught_keyboard_interrupt_cancels_following_step`, `test_alias_pid_signal_policy` (PID-only INT) and `test_alias_group_sigint_does_not_escalate`. The children still handle every key exactly once and wt never dies while they run. `test_alias_caught_sigint_preserves_successful_descendant_output` is deleted because its premise is the old rule. The pager and custom-subcommand cases in `custom_commands_and_help_pagers_preserve_native_signals` pass unchanged. - The alias signal harness moved to `tests/common` as `SignalJob` for reuse. - `cargo nextest run --all-features` (5377 passed), `cargo clippy --all-targets --all-features -- -D warnings`, pre-commit on the changed files. Manual repro of remove and prune before and after. > _This was written by Claude Code on behalf of max-sixty_ --------- Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2610 lines
81 KiB
Rust
2610 lines
81 KiB
Rust
//! Integration tests for `wt step <alias>`
|
|
|
|
use crate::common::{
|
|
TestRepo, configure_directive_file, directive_file, make_snapshot_cmd,
|
|
make_snapshot_cmd_with_global_flags, repo, repo_with_remote, setup_snapshot_settings, wt_bin,
|
|
};
|
|
// Used only by the `#[cfg(unix)]` signal tests below; gate the import to match,
|
|
// or it reads as unused on Windows under `-D warnings`.
|
|
#[cfg(unix)]
|
|
use crate::common::{SLEEP_FOR_ABSENCE_CHECK, SignalJob};
|
|
use ansi_str::AnsiStr;
|
|
use insta_cmd::assert_cmd_snapshot;
|
|
use rstest::rstest;
|
|
use std::io::Write;
|
|
use std::process::Stdio;
|
|
|
|
/// Alias from project config runs with template expansion (-y bypasses approval)
|
|
#[rstest]
|
|
fn test_step_alias_from_project_config(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
hello = "echo Hello from {{ branch }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"step",
|
|
&["hello"],
|
|
Some(&feature_path),
|
|
&["-y"],
|
|
));
|
|
}
|
|
|
|
/// `wt config alias dry-run <name>` shows the expanded command without running it
|
|
/// (no approval needed — preview never executes project commands).
|
|
#[rstest]
|
|
fn test_config_alias_dry_run(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
hello = "echo Hello from {{ branch }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "dry-run", "hello"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// Unknown alias shows error with available aliases
|
|
#[rstest]
|
|
fn test_step_alias_unknown_with_available(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
hello = "echo Hello"
|
|
deploy = "make deploy"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"step",
|
|
&["nonexistent"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// Typo in alias name suggests the closest match
|
|
#[rstest]
|
|
fn test_step_alias_did_you_mean(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "make deploy"
|
|
hello = "echo Hello"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"step",
|
|
&["deplyo"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// Unknown step command with no aliases configured
|
|
#[rstest]
|
|
fn test_step_alias_unknown_no_aliases(mut repo: TestRepo) {
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"step",
|
|
&["deploy"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// `--KEY=VALUE` binds to `{{ KEY }}` when the template references it.
|
|
#[rstest]
|
|
fn test_step_alias_binds_referenced_var(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
greet = "echo Hello {{ name }} from {{ branch }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "dry-run", "greet", "--", "--name=World"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// `--KEY VALUE` (space-separated) binds the same way `--KEY=VALUE` does
|
|
/// when KEY is referenced and VALUE doesn't look like a flag.
|
|
#[rstest]
|
|
fn test_step_alias_binds_space_separated_var(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
greet = "echo Hello {{ name }} from {{ branch }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "dry-run", "greet", "--", "--name", "World"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// `--KEY=VALUE` for a key the template doesn't reference forwards to
|
|
/// `{{ args }}` instead of binding silently.
|
|
#[rstest]
|
|
fn test_step_alias_unreferenced_key_forwards_to_args(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
run = "echo got {{ args }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"run",
|
|
&["--env=staging", "foo"],
|
|
Some(&feature_path),
|
|
&["-y"],
|
|
));
|
|
}
|
|
|
|
/// `--args=VALUE` can't bind `{{ args }}` — the alias's own positional list
|
|
/// fills that slot — so the token forwards into it rather than vanishing.
|
|
#[rstest]
|
|
fn test_step_alias_args_flag_forwards_to_args(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
run = "echo got {{ args }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let output = repo
|
|
.wt_command()
|
|
.args(["-y", "run", "--args=x", "y"])
|
|
.current_dir(&feature_path)
|
|
.output()
|
|
.unwrap();
|
|
assert!(
|
|
output.status.success(),
|
|
"alias should succeed: {}",
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
let stdout = String::from_utf8_lossy(&output.stdout);
|
|
assert!(
|
|
stdout.contains("got --args=x y"),
|
|
"--args=x should reach {{{{ args }}}}, got: {stdout}"
|
|
);
|
|
}
|
|
|
|
/// `--` is a literal-forward escape: every later token goes to `{{ args }}`,
|
|
/// so flag-shaped values that would normally bind are passed through verbatim.
|
|
#[rstest]
|
|
fn test_step_alias_double_dash_escape(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
run = "echo got {{ args }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"run",
|
|
&["--", "--env=staging", "literal"],
|
|
Some(&feature_path),
|
|
&["-y"],
|
|
));
|
|
}
|
|
|
|
/// `--KEY=VALUE` overrides built-in template variables. The user-supplied
|
|
/// value wins because `extra_refs` is applied after built-ins are seeded.
|
|
#[rstest]
|
|
fn test_step_alias_user_var_overshadows_builtin(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
show = "echo branch={{ branch }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"show",
|
|
&["--branch=override"],
|
|
Some(&feature_path),
|
|
&["-y"],
|
|
));
|
|
}
|
|
|
|
/// Multi-step pipeline: each step's `{{ KEY }}` references contribute to
|
|
/// the binding-eligible set, so a single invocation can bind both `env`
|
|
/// (referenced in step 1) and `region` (referenced in step 2).
|
|
#[rstest]
|
|
fn test_step_alias_multi_step_binds_across_pipeline(mut repo: TestRepo) {
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = [
|
|
"echo step1 env={{ env }}",
|
|
{ publish = "echo step2 region={{ region }}" },
|
|
]
|
|
"#,
|
|
);
|
|
repo.commit("initial");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
let mut cmd = make_snapshot_cmd(
|
|
&repo,
|
|
"step",
|
|
&["deploy", "--env=prod", "--region=us-east"],
|
|
Some(&feature_path),
|
|
);
|
|
cmd.env("WORKTRUNK_TEST_SERIAL_CONCURRENT", "1");
|
|
assert_cmd_snapshot!(cmd);
|
|
}
|
|
|
|
/// Alias body output is delivered on stdout so it can be piped into other
|
|
/// commands (#2478). Worktrunk's own progress/announcement messages still go
|
|
/// to stderr; only the child shell's stdout passes through.
|
|
#[rstest]
|
|
fn test_alias_body_writes_to_stdout(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
emit = "echo hello"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let output = repo
|
|
.wt_command()
|
|
.args(["-y", "emit"])
|
|
.current_dir(&feature_path)
|
|
.output()
|
|
.unwrap();
|
|
|
|
assert!(
|
|
output.status.success(),
|
|
"alias failed:\nstdout: {}\nstderr: {}",
|
|
String::from_utf8_lossy(&output.stdout),
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
let stdout = String::from_utf8_lossy(&output.stdout);
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
assert!(
|
|
stdout.lines().any(|line| line.trim() == "hello"),
|
|
"expected `hello` on stdout (so `wt <alias> | …` is usable in scripts), \
|
|
got stdout={stdout:?} stderr={stderr:?}"
|
|
);
|
|
}
|
|
|
|
/// A one-entry alias table is a single named command, not a concurrent group
|
|
/// of one: its output passes through on stdout without a `name │` prefix,
|
|
/// identical to the string and `[[aliases.x]]` spellings.
|
|
#[rstest]
|
|
fn test_alias_single_entry_table_writes_to_stdout(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases.emit]
|
|
say = "echo hello"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let output = repo
|
|
.wt_command()
|
|
.args(["-y", "emit"])
|
|
.current_dir(&feature_path)
|
|
.output()
|
|
.unwrap();
|
|
|
|
assert!(
|
|
output.status.success(),
|
|
"alias failed:\nstdout: {}\nstderr: {}",
|
|
String::from_utf8_lossy(&output.stdout),
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
let stdout = String::from_utf8_lossy(&output.stdout);
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
assert!(
|
|
stdout.lines().any(|line| line.trim() == "hello"),
|
|
"expected unprefixed `hello` on stdout, got stdout={stdout:?} stderr={stderr:?}"
|
|
);
|
|
assert!(
|
|
!stdout.contains('│') && !stderr.contains("say │"),
|
|
"single named command must not use the concurrent `name │` prefix, \
|
|
got stdout={stdout:?} stderr={stderr:?}"
|
|
);
|
|
}
|
|
|
|
/// Alias command failure propagates exit code (-y bypasses approval)
|
|
#[rstest]
|
|
fn test_step_alias_exit_code(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
fail = "exit 42"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"step",
|
|
&["fail"],
|
|
Some(&feature_path),
|
|
&["-y"],
|
|
));
|
|
}
|
|
|
|
/// An alias child killed by a signal other than INT/TERM is reported: the
|
|
/// child printed nothing about its death, and wt exits `128 + signal` rather
|
|
/// than dying by it, so no shell reports it either.
|
|
#[cfg(unix)]
|
|
#[rstest]
|
|
fn test_step_alias_killed_by_signal(repo: TestRepo) {
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
crash = "kill -KILL $$"
|
|
"#,
|
|
);
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(&repo, "step", &["crash"], None));
|
|
}
|
|
|
|
/// Alias from user config works
|
|
#[rstest]
|
|
fn test_step_alias_from_user_config(mut repo: TestRepo) {
|
|
let feature_path = repo.add_worktree("feature");
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
greet = "echo Greetings from {{ branch }}"
|
|
"#,
|
|
);
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"step",
|
|
&["greet"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// Top-level alias dispatch: `wt <name>` runs an alias when `<name>` is not
|
|
/// a built-in subcommand, with the same template-expansion and approval flow
|
|
/// as `wt step <name>`.
|
|
#[rstest]
|
|
fn test_top_level_alias_dispatch(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
hello = "echo Hello from {{ branch }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"hello",
|
|
&[],
|
|
Some(&feature_path),
|
|
&["-y"],
|
|
));
|
|
}
|
|
|
|
/// An alias whose name matches a `wt step` built-in is unreachable via
|
|
/// `wt step <name>` (the built-in always wins) but runs from the top level
|
|
/// via `wt <name>` — there's no top-level `commit` built-in.
|
|
#[rstest]
|
|
fn test_top_level_alias_with_step_builtin_name(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
commit = "echo custom-commit"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"commit",
|
|
&[],
|
|
Some(&feature_path),
|
|
&["-y"],
|
|
));
|
|
}
|
|
|
|
/// Top-level typo on an alias name suggests the alias in the `tip:` line,
|
|
/// matching `wt step <typo>`.
|
|
#[rstest]
|
|
fn test_top_level_alias_did_you_mean(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "make deploy"
|
|
hello = "echo Hello"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(&repo, "deplyo", &[], Some(&feature_path),));
|
|
}
|
|
|
|
/// Aliases shadowed by `wt step` built-ins are filtered from the typo
|
|
/// suggestion list — `wt step commit` does not suggest a (shadowed) alias
|
|
/// named `commit`, only the real built-in.
|
|
#[rstest]
|
|
fn test_step_alias_shadows_builtin(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
commit = "echo custom-commit"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"step",
|
|
&["comit"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// User config aliases merge with project config aliases
|
|
#[rstest]
|
|
fn test_step_alias_merge_user_and_project(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
project-cmd = "echo from-project"
|
|
shared = "echo project-version"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
user-cmd = "echo from-user"
|
|
shared = "echo user-version"
|
|
"#,
|
|
);
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
// User alias available
|
|
assert_cmd_snapshot!(
|
|
"user_alias",
|
|
make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "dry-run", "user-cmd"],
|
|
Some(&feature_path),
|
|
)
|
|
);
|
|
|
|
// Project alias available — dry-run never needs approval (it doesn't execute).
|
|
assert_cmd_snapshot!(
|
|
"project_alias",
|
|
make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "dry-run", "project-cmd"],
|
|
Some(&feature_path),
|
|
)
|
|
);
|
|
|
|
// Both definitions visible on collision: user first, then project (matches runtime order).
|
|
assert_cmd_snapshot!(
|
|
"user_and_project_append",
|
|
make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "dry-run", "shared"],
|
|
Some(&feature_path),
|
|
)
|
|
);
|
|
}
|
|
|
|
/// Both global and per-project user aliases execute in order on name collision.
|
|
///
|
|
/// Uses project config (`.config/wt.toml`) + user config to verify the
|
|
/// project-vs-user append, since `test_aliases_accessor_appends_on_collision`
|
|
/// already covers the user-config internal append via unit test.
|
|
#[rstest]
|
|
fn test_alias_append_executes_both(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
greet = "echo PROJECT"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
greet = "echo USER"
|
|
"#,
|
|
);
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
// Both commands execute: user first, then project (-y approves project alias)
|
|
assert_cmd_snapshot!(make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"step",
|
|
&["greet"],
|
|
Some(&feature_path),
|
|
&["-y"],
|
|
));
|
|
}
|
|
|
|
// ============================================================================
|
|
// Approval tests
|
|
// ============================================================================
|
|
|
|
/// Project-config alias prompts for approval in non-TTY (fails with hint)
|
|
#[rstest]
|
|
fn test_alias_approval_project_config_prompts(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo deploying {{ branch }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
// Without --yes, project alias triggers approval prompt (fails in non-TTY)
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"step",
|
|
&["deploy"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// Already-approved project-config alias runs without re-prompting
|
|
#[rstest]
|
|
fn test_alias_approval_already_approved(mut repo: TestRepo) {
|
|
// Remove origin so worktrunk uses directory name as project identifier
|
|
repo.run_git(&["remote", "remove", "origin"]);
|
|
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo deploying {{ branch }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
// Pre-approve the alias command
|
|
repo.write_test_approvals(&format!(
|
|
r#"[projects.'{}']
|
|
approved-commands = ["echo deploying {{{{ branch }}}}"]
|
|
"#,
|
|
repo.project_id()
|
|
));
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
// Should run without prompting
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"step",
|
|
&["deploy"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// User-config alias skips approval entirely
|
|
#[rstest]
|
|
fn test_alias_approval_user_config_skips(mut repo: TestRepo) {
|
|
let feature_path = repo.add_worktree("feature");
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo deploying from user config"
|
|
"#,
|
|
);
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
// User alias runs without approval
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"step",
|
|
&["deploy"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// User override of project alias skips approval (user is trusted)
|
|
#[rstest]
|
|
fn test_alias_approval_user_and_project_both_need_approval(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo project deploy"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo user deploy"
|
|
"#,
|
|
);
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
// Both run with -y: user first, then project (project needs approval)
|
|
assert_cmd_snapshot!(make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"step",
|
|
&["deploy"],
|
|
Some(&feature_path),
|
|
&["-y"],
|
|
));
|
|
}
|
|
|
|
/// -y bypasses approval for project-config alias without saving
|
|
#[rstest]
|
|
fn test_alias_approval_yes_bypasses(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo deploying"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
// First run with -y succeeds
|
|
assert_cmd_snapshot!(
|
|
"alias_approval_yes_first_run",
|
|
make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"step",
|
|
&["deploy"],
|
|
Some(&feature_path),
|
|
&["-y"],
|
|
)
|
|
);
|
|
|
|
// Second run without -y should still prompt (-y doesn't save approval)
|
|
assert_cmd_snapshot!(
|
|
"alias_approval_yes_second_run_prompts",
|
|
make_snapshot_cmd(&repo, "step", &["deploy"], Some(&feature_path),)
|
|
);
|
|
}
|
|
|
|
// ============================================================================
|
|
// Directive file passthrough
|
|
// ============================================================================
|
|
|
|
/// `wt step <alias>` passes the parent's `WORKTRUNK_DIRECTIVE_CD_FILE` through
|
|
/// to the alias subprocess so inner `wt switch --create` calls can land the
|
|
/// user in the new worktree.
|
|
///
|
|
/// Regression test for #2075: without the passthrough, an alias that wraps
|
|
/// `wt switch --create` prints the "shell integration not installed" hint and
|
|
/// the parent shell never `cd`s into the new worktree.
|
|
#[rstest]
|
|
fn test_alias_passes_directive_file_to_subprocess(repo: TestRepo) {
|
|
repo.commit("initial");
|
|
|
|
// Alias body invokes the test wt binary directly (PATH lookup in the
|
|
// subprocess shell wouldn't find it).
|
|
repo.write_test_config(&wt_alias_config(
|
|
"new-branch",
|
|
"switch --create alias-created",
|
|
));
|
|
|
|
let (cd_path, _guard) = directive_file();
|
|
|
|
let mut cmd = repo.wt_command();
|
|
configure_directive_file(&mut cmd, &cd_path);
|
|
cmd.args(["step", "new-branch"]);
|
|
let output = cmd.output().unwrap();
|
|
|
|
assert!(
|
|
output.status.success(),
|
|
"wt step new-branch failed: stdout={}\nstderr={}",
|
|
String::from_utf8_lossy(&output.stdout),
|
|
String::from_utf8_lossy(&output.stderr),
|
|
);
|
|
|
|
let cd_content = std::fs::read_to_string(&cd_path).unwrap_or_default();
|
|
assert!(
|
|
!cd_content.trim().is_empty(),
|
|
"alias wrapping `wt switch --create` should write a path to the \
|
|
CD directive file, got: {cd_content:?}"
|
|
);
|
|
assert!(
|
|
cd_content.contains("alias-created"),
|
|
"cd directive should target the new worktree (alias-created), got: {cd_content:?}"
|
|
);
|
|
|
|
// Stderr should NOT contain the "shell integration not installed" hint
|
|
// — that hint is what appears when the inner wt can't find the directive
|
|
// file, which is exactly the bug this test guards against.
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
assert!(
|
|
!stderr.contains("shell integration"),
|
|
"inner wt should not warn about shell integration being uninstalled, got: {stderr}",
|
|
);
|
|
}
|
|
|
|
/// Build an `[aliases]` config whose single alias body invokes the test `wt`
|
|
/// binary. Suits either config source — pass it to `write_test_config` for a
|
|
/// user alias or `write_project_config` for a project one.
|
|
///
|
|
/// The binary path has to be embedded in a TOML basic string inside a shell
|
|
/// command, so single quotes must be absent (they'd terminate the shell
|
|
/// quoting) and backslashes doubled (a Windows path like `D:\a\wt.exe` would
|
|
/// otherwise parse `\a` as a TOML escape).
|
|
fn wt_alias_config(name: &str, args: &str) -> String {
|
|
let wt = wt_bin();
|
|
let wt_str = wt.to_string_lossy();
|
|
assert!(
|
|
!wt_str.contains('\''),
|
|
"wt binary path should not contain single quotes: {wt_str}"
|
|
);
|
|
let wt_toml = wt_str.replace('\\', r"\\");
|
|
format!(
|
|
r#"
|
|
[aliases]
|
|
{name} = "'{wt_toml}' {args}"
|
|
"#
|
|
)
|
|
}
|
|
|
|
/// `wt switch` inside an alias body preserves the user's subdirectory position,
|
|
/// the same as a top-level `wt switch` does.
|
|
///
|
|
/// Regression test for #3723: alias steps run with the worktree root as their
|
|
/// working directory, so the nested `wt` used to see the root as the user's
|
|
/// cwd and land the shell at the target worktree's root instead of the
|
|
/// matching subdirectory.
|
|
#[rstest]
|
|
fn test_alias_wrapping_switch_preserves_subdir(#[from(repo_with_remote)] mut repo: TestRepo) {
|
|
let feature_wt = repo.add_worktree("feature");
|
|
|
|
// The same subdirectory exists in both worktrees.
|
|
let subdir = std::path::Path::new("apps").join("gateway");
|
|
std::fs::create_dir_all(repo.root_path().join(&subdir)).unwrap();
|
|
std::fs::create_dir_all(feature_wt.join(&subdir)).unwrap();
|
|
|
|
repo.write_test_config(&wt_alias_config("go", "switch feature"));
|
|
|
|
let (cd_path, _guard) = directive_file();
|
|
|
|
let mut cmd = repo.wt_command();
|
|
configure_directive_file(&mut cmd, &cd_path);
|
|
cmd.args(["step", "go"])
|
|
.current_dir(repo.root_path().join(&subdir));
|
|
let output = cmd.output().unwrap();
|
|
assert!(
|
|
output.status.success(),
|
|
"wt step go failed: stdout={}\nstderr={}",
|
|
String::from_utf8_lossy(&output.stdout),
|
|
String::from_utf8_lossy(&output.stderr),
|
|
);
|
|
|
|
let cd_content = std::fs::read_to_string(&cd_path).unwrap_or_default();
|
|
let expected = feature_wt.join(&subdir);
|
|
let expected_str = expected.to_string_lossy();
|
|
assert!(
|
|
cd_content.contains(&*expected_str),
|
|
"CD file should preserve the subdirectory ({expected_str}), got: {cd_content:?}"
|
|
);
|
|
}
|
|
|
|
/// `wt remove` inside an alias body preserves the user's subdirectory position.
|
|
///
|
|
/// Regression test for #3723: the reported case is a `remove`-wrapping alias
|
|
/// (`[aliases] finish = "wt remove -y"`) in a monorepo, which used to drop the
|
|
/// user at the primary worktree root instead of their sub-project.
|
|
#[rstest]
|
|
fn test_alias_wrapping_remove_preserves_subdir(#[from(repo_with_remote)] mut repo: TestRepo) {
|
|
let feature_wt = repo.add_worktree("feature");
|
|
|
|
// The same subdirectory exists in the worktree being removed (where the
|
|
// user is) and in the main worktree (where removal lands).
|
|
let subdir = std::path::Path::new("apps").join("gateway");
|
|
std::fs::create_dir_all(repo.root_path().join(&subdir)).unwrap();
|
|
std::fs::create_dir_all(feature_wt.join(&subdir)).unwrap();
|
|
|
|
repo.write_test_config(&wt_alias_config("finish", "remove -y"));
|
|
|
|
let (cd_path, _guard) = directive_file();
|
|
|
|
let mut cmd = repo.wt_command();
|
|
configure_directive_file(&mut cmd, &cd_path);
|
|
cmd.args(["step", "finish"])
|
|
.current_dir(feature_wt.join(&subdir));
|
|
let output = cmd.output().unwrap();
|
|
assert!(
|
|
output.status.success(),
|
|
"wt step finish failed: stdout={}\nstderr={}",
|
|
String::from_utf8_lossy(&output.stdout),
|
|
String::from_utf8_lossy(&output.stderr),
|
|
);
|
|
|
|
let cd_content = std::fs::read_to_string(&cd_path).unwrap_or_default();
|
|
let expected = repo.root_path().join(&subdir);
|
|
let expected_str = expected.to_string_lossy();
|
|
assert!(
|
|
cd_content.contains(&*expected_str),
|
|
"CD file should preserve the subdirectory ({expected_str}), got: {cd_content:?}"
|
|
);
|
|
}
|
|
|
|
/// A nested switch runs `--execute` directly rather than depending on a
|
|
/// directive inherited through the alias shell.
|
|
#[rstest]
|
|
fn test_alias_runs_execute_directly(repo: TestRepo) {
|
|
repo.commit("initial");
|
|
|
|
repo.write_test_config(&wt_alias_config(
|
|
"exec-passthrough",
|
|
"switch --create user-alias-target --execute echo -- from-user-alias",
|
|
));
|
|
|
|
let (cd_path, _guard) = directive_file();
|
|
|
|
let mut cmd = repo.wt_command();
|
|
configure_directive_file(&mut cmd, &cd_path);
|
|
cmd.args(["step", "exec-passthrough"]);
|
|
let output = cmd.output().unwrap();
|
|
|
|
assert!(
|
|
output.status.success(),
|
|
"wt step exec-passthrough failed: stdout={}\nstderr={}",
|
|
String::from_utf8_lossy(&output.stdout),
|
|
String::from_utf8_lossy(&output.stderr),
|
|
);
|
|
assert!(
|
|
String::from_utf8_lossy(&output.stdout).contains("from-user-alias"),
|
|
"nested --execute output missing"
|
|
);
|
|
}
|
|
|
|
/// Alias subprocesses inherit the parent's stdin so interactive children
|
|
/// (e.g. `wt switch`'s picker) keep the controlling terminal.
|
|
///
|
|
/// Regression test for #406: alias execution used to pipe the template
|
|
/// context JSON into each child's stdin, which displaced the tty and broke
|
|
/// `stdin().is_terminal()` guards in interactive commands. Hooks no longer
|
|
/// pipe JSON either, so the `"branch"` assertion below pins the rule for
|
|
/// every foreground step rather than a hooks-vs-aliases distinction.
|
|
#[rstest]
|
|
fn test_alias_inherits_stdin(repo: TestRepo) {
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
echo-stdin = "cat"
|
|
"#,
|
|
);
|
|
repo.commit("initial");
|
|
|
|
let sentinel = "INHERITED_STDIN_TOKEN";
|
|
let mut cmd = repo.wt_command();
|
|
cmd.args(["step", "echo-stdin"])
|
|
.stdin(Stdio::piped())
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::piped());
|
|
let mut child = cmd.spawn().unwrap();
|
|
{
|
|
// Drop closes the pipe so `cat` sees EOF and exits.
|
|
let mut stdin = child.stdin.take().unwrap();
|
|
stdin.write_all(sentinel.as_bytes()).unwrap();
|
|
}
|
|
let output = child.wait_with_output().unwrap();
|
|
|
|
let stdout = String::from_utf8_lossy(&output.stdout);
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
assert!(
|
|
output.status.success(),
|
|
"wt step echo-stdin failed: stdout={stdout}\nstderr={stderr}",
|
|
);
|
|
|
|
// stderr carries the "Running alias" banner; the alias body's stdout is
|
|
// redirected to stderr for deterministic ordering (see
|
|
// `execute_shell_command`). Check the combined output.
|
|
let combined = format!("{stdout}{stderr}");
|
|
assert!(
|
|
combined.contains(sentinel),
|
|
"alias body should read the parent's stdin ({sentinel} expected), \
|
|
got stdout={stdout:?} stderr={stderr:?}",
|
|
);
|
|
// The pre-fix behavior piped the context JSON (which always includes a
|
|
// "branch" key) to stdin, so `cat` would have echoed that instead.
|
|
assert!(
|
|
!combined.contains("\"branch\""),
|
|
"no foreground step should receive a JSON context on stdin, \
|
|
got stdout={stdout:?} stderr={stderr:?}",
|
|
);
|
|
}
|
|
|
|
/// Pipeline aliases announce their structure: named serial and concurrent
|
|
/// steps appear in the "Running alias" line, joined by `;` and `,`.
|
|
///
|
|
/// `WORKTRUNK_TEST_SERIAL_CONCURRENT=1` forces the concurrent step to run
|
|
/// commands sequentially (in declaration order) so the snapshot captures a
|
|
/// deterministic interleaving — analogous to how `RAYON_NUM_THREADS=1` is
|
|
/// used in `step_prune` tests.
|
|
#[rstest]
|
|
fn test_alias_pipeline_announcement(mut repo: TestRepo) {
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = [
|
|
{ install = "echo INSTALL" },
|
|
{ build = "echo BUILD", lint = "echo LINT" },
|
|
]
|
|
"#,
|
|
);
|
|
repo.commit("initial");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
let mut cmd = make_snapshot_cmd(&repo, "step", &["deploy"], Some(&feature_path));
|
|
cmd.env("WORKTRUNK_TEST_SERIAL_CONCURRENT", "1");
|
|
assert_cmd_snapshot!(cmd);
|
|
}
|
|
|
|
/// Concurrent alias steps (named table) execute all commands
|
|
#[rstest]
|
|
fn test_alias_concurrent_steps(mut repo: TestRepo) {
|
|
// Named table form: commands run concurrently within the step
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases.build]
|
|
lint = "echo LINT"
|
|
test = "echo TEST"
|
|
"#,
|
|
);
|
|
repo.commit("initial");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let mut cmd = repo.wt_command();
|
|
cmd.args(["step", "build"]).current_dir(&feature_path);
|
|
let output = cmd.output().unwrap();
|
|
|
|
assert!(
|
|
output.status.success(),
|
|
"concurrent alias failed: stderr={}",
|
|
String::from_utf8_lossy(&output.stderr),
|
|
);
|
|
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
// Both commands should have run (order may vary due to concurrency)
|
|
assert!(stderr.contains("LINT"), "expected LINT in output: {stderr}");
|
|
assert!(stderr.contains("TEST"), "expected TEST in output: {stderr}");
|
|
}
|
|
|
|
/// Concurrent alias commands have their output streamed with a per-command
|
|
/// colored prefix label (`{name} │ …`), so multiple children's lines remain
|
|
/// attributable even when they interleave.
|
|
#[rstest]
|
|
fn test_alias_concurrent_prefixes_output(mut repo: TestRepo) {
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases.build]
|
|
lint = "echo HELLO_LINT"
|
|
test = "echo HELLO_TEST"
|
|
"#,
|
|
);
|
|
repo.commit("initial");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let mut cmd = repo.wt_command();
|
|
cmd.args(["step", "build"])
|
|
.current_dir(&feature_path)
|
|
.env("NO_COLOR", "1");
|
|
let output = cmd.output().unwrap();
|
|
|
|
assert!(
|
|
output.status.success(),
|
|
"concurrent alias failed: stderr={}",
|
|
String::from_utf8_lossy(&output.stderr),
|
|
);
|
|
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
// Each command must produce a line starting with its prefixed label and
|
|
// separated by the box-drawing `│` that the executor emits. Whitespace
|
|
// between label and `│` varies with padding-to-widest-label.
|
|
for (label, body) in [("lint", "HELLO_LINT"), ("test", "HELLO_TEST")] {
|
|
let has_prefixed_line = stderr
|
|
.lines()
|
|
.any(|l| l.starts_with(label) && l.contains('│') && l.contains(body));
|
|
assert!(
|
|
has_prefixed_line,
|
|
"expected a line starting with '{label}' containing '{body}' and a '│' separator, got:\n{stderr}"
|
|
);
|
|
}
|
|
}
|
|
|
|
/// A failing concurrent step causes the alias to fail. Covers the error
|
|
/// propagation path in the `HookStep::Concurrent` join loop, complementing
|
|
/// the happy-path `test_alias_concurrent_steps` above.
|
|
#[rstest]
|
|
fn test_alias_concurrent_step_failure(repo: TestRepo) {
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases.check]
|
|
ok = "true"
|
|
fail = "exit 1"
|
|
"#,
|
|
);
|
|
repo.commit("initial");
|
|
|
|
let mut cmd = repo.wt_command();
|
|
cmd.args(["step", "check"]);
|
|
let output = cmd.output().expect("wt step check failed to spawn");
|
|
assert!(
|
|
!output.status.success(),
|
|
"wt step check should fail when a concurrent step exits non-zero"
|
|
);
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
fn signal_alias(repo: &TestRepo, concurrent: bool, caught_int: Option<bool>) -> Vec<&'static str> {
|
|
let labels = if concurrent {
|
|
vec!["one", "two"]
|
|
} else {
|
|
vec!["one"]
|
|
};
|
|
let commands: Vec<_> = labels.iter().map(|label| {
|
|
let int_trap = match caught_int {
|
|
Some(true) => format!("trap 'echo got-int >> int-{label}' INT; "),
|
|
Some(false) => "trap '' INT; ".to_owned(),
|
|
None => String::new(),
|
|
};
|
|
let body = format!("{int_trap}trap 'echo got-term > term-{label}; exit 0' TERM; echo $$ > pid-{label}; echo ready > start-{label}; while test ! -f release; do :; done");
|
|
(*label, serde_json::to_string(&body).unwrap())
|
|
}).collect();
|
|
let first = if concurrent {
|
|
format!(
|
|
"{{ {} }}",
|
|
commands
|
|
.iter()
|
|
.map(|(label, command)| format!("{label} = {command}"))
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
)
|
|
} else {
|
|
commands[0].1.clone()
|
|
};
|
|
repo.write_test_config(&format!(
|
|
"[aliases]\nsignal-test = [{first}, 'echo next > next']\n"
|
|
));
|
|
labels
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
fn ready_alias_children(repo: &TestRepo, labels: &[&str], group: nix::unistd::Pid) -> Vec<i32> {
|
|
labels
|
|
.iter()
|
|
.map(|label| {
|
|
crate::common::wait_for_file_content(&repo.root_path().join(format!("start-{label}")));
|
|
let pid =
|
|
std::fs::read_to_string(repo.root_path().join(format!("pid-{label}"))).unwrap();
|
|
let pid = nix::unistd::Pid::from_raw(pid.trim().parse().unwrap());
|
|
assert_eq!(
|
|
nix::unistd::getpgid(Some(pid)).unwrap(),
|
|
group,
|
|
"{label} left wt's native group"
|
|
);
|
|
pid.as_raw()
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// A child that crashes in its TERM handler must not let a Warn hook pipeline
|
|
/// continue after controller cancellation. The same crash alone stays ordinary.
|
|
#[rstest]
|
|
#[case::ordinary_child_death(false)]
|
|
#[case::controller_cancellation(true)]
|
|
#[cfg(unix)]
|
|
fn test_controller_cancellation_survives_child_term_handler_crash(
|
|
repo: TestRepo,
|
|
#[case] controller_cancel: bool,
|
|
) {
|
|
repo.write_project_config(r#"post-start = ["exec python3 worker.py", "printf NEXT > next"]"#);
|
|
std::fs::write(
|
|
repo.root_path().join("worker.py"),
|
|
r#"import os, signal, time
|
|
from pathlib import Path
|
|
def on_term(*_):
|
|
Path('term-handled').write_text('handled')
|
|
os.kill(os.getpid(), signal.SIGKILL)
|
|
signal.signal(signal.SIGTERM, on_term)
|
|
Path('pid-one').write_text(str(os.getpid()))
|
|
Path('start-one').write_text('ready')
|
|
while not Path('release').exists():
|
|
time.sleep(.001)
|
|
os.kill(os.getpid(), signal.SIGKILL)
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
let stderr_path = repo.root_path().join("stderr");
|
|
let mut job = SignalJob::spawn(
|
|
&repo,
|
|
&["hook", "post-start", "--yes", "--foreground"],
|
|
Stdio::from(std::fs::File::create(&stderr_path).unwrap()),
|
|
);
|
|
ready_alias_children(&repo, &["one"], job.group());
|
|
if controller_cancel {
|
|
nix::sys::signal::kill(job.pid(), nix::sys::signal::Signal::SIGTERM).unwrap();
|
|
crate::common::wait_for_file_content(&repo.root_path().join("term-handled"));
|
|
} else {
|
|
job.release();
|
|
}
|
|
let status = job.wait();
|
|
let stderr = std::fs::read_to_string(stderr_path).unwrap();
|
|
assert_eq!(
|
|
crate::common::shell_exit_code(&status),
|
|
Some(if controller_cancel { 143 } else { 0 }),
|
|
"{status:?}\n{stderr}",
|
|
);
|
|
assert_eq!(
|
|
repo.root_path().join("next").exists(),
|
|
!controller_cancel,
|
|
"{stderr}",
|
|
);
|
|
}
|
|
|
|
/// Native policy: TERM aimed at wt cancels owned work even when its
|
|
/// child handles TERM successfully. PID-only INT is never delivered to the
|
|
/// child, which runs to completion; wt's receipt still cancels the next step.
|
|
#[rstest]
|
|
#[case::single_term(false, true)]
|
|
#[case::concurrent_term(true, true)]
|
|
#[case::single_int(false, false)]
|
|
#[case::concurrent_int(true, false)]
|
|
#[cfg(unix)]
|
|
fn test_alias_pid_signal_policy(repo: TestRepo, #[case] concurrent: bool, #[case] terminate: bool) {
|
|
use nix::sys::signal::{Signal, kill};
|
|
let labels = signal_alias(&repo, concurrent, Some(true));
|
|
let stderr_path = repo.root_path().join("stderr");
|
|
let stderr = std::fs::File::create(&stderr_path).unwrap();
|
|
let mut job = SignalJob::spawn(&repo, &["-vv", "step", "signal-test"], stderr.into());
|
|
let children = ready_alias_children(&repo, &labels, job.group());
|
|
// A child can announce readiness before wt returns from spawn. This test
|
|
// sends its signal to an admitted command, not during startup cancellation.
|
|
crate::common::wait_for_foreground_admission(&repo, &children);
|
|
kill(
|
|
job.pid(),
|
|
if terminate {
|
|
Signal::SIGTERM
|
|
} else {
|
|
Signal::SIGINT
|
|
},
|
|
)
|
|
.unwrap();
|
|
if terminate {
|
|
for label in &labels {
|
|
crate::common::wait_for_file_content(&repo.root_path().join(format!("term-{label}")));
|
|
}
|
|
use std::os::unix::process::ExitStatusExt;
|
|
let status = job.wait();
|
|
assert!(
|
|
status.code() == Some(143) || status.signal() == Some(15),
|
|
"forwarded TERM must cancel after caught success: {status:?}\n{}",
|
|
std::fs::read_to_string(stderr_path).unwrap()
|
|
);
|
|
assert!(!repo.root_path().join("next").exists());
|
|
} else {
|
|
std::thread::sleep(SLEEP_FOR_ABSENCE_CHECK);
|
|
assert!(job.running(), "PID-only INT stopped the waiting caller");
|
|
for label in &labels {
|
|
assert!(
|
|
!repo.root_path().join(format!("int-{label}")).exists(),
|
|
"PID-only INT reached {label}"
|
|
);
|
|
}
|
|
job.release();
|
|
use std::os::unix::process::ExitStatusExt;
|
|
let status = job.wait();
|
|
assert!(
|
|
status.code() == Some(130) || status.signal() == Some(2),
|
|
"PID-only INT must cancel after the child's success: {status:?}\n{}",
|
|
std::fs::read_to_string(stderr_path).unwrap()
|
|
);
|
|
assert!(!repo.root_path().join("next").exists());
|
|
}
|
|
}
|
|
|
|
/// Kernel group delivery reaches both children; actual interrupted status
|
|
/// stops the following alias step.
|
|
#[rstest]
|
|
#[cfg(unix)]
|
|
fn test_alias_concurrent_receives_sigint(repo: TestRepo) {
|
|
let labels = signal_alias(&repo, true, None);
|
|
let mut job = SignalJob::spawn(&repo, &["step", "signal-test"], Stdio::null());
|
|
ready_alias_children(&repo, &labels, job.group());
|
|
nix::sys::signal::killpg(job.group(), nix::sys::signal::Signal::SIGINT).unwrap();
|
|
use std::os::unix::process::ExitStatusExt;
|
|
let status = job.wait();
|
|
assert!(
|
|
status.code() == Some(130) || status.signal() == Some(2),
|
|
"group INT should exit 130: {status:?}"
|
|
);
|
|
assert!(!repo.root_path().join("next").exists());
|
|
}
|
|
|
|
/// Repeated group interrupts retain the child's disposition and never kill wt
|
|
/// while the child runs, yet wt's receipt cancels the following step even after
|
|
/// the child succeeds. One contrast per handler/key/cardinality covers both
|
|
/// stream execution paths.
|
|
#[rstest]
|
|
#[case::single_caught_once(false, true, 1)]
|
|
#[case::concurrent_caught_twice(true, true, 2)]
|
|
#[case::single_ignored_twice(false, false, 2)]
|
|
#[case::concurrent_ignored_once(true, false, 1)]
|
|
#[cfg(unix)]
|
|
fn test_alias_group_sigint_does_not_escalate(
|
|
repo: TestRepo,
|
|
#[case] concurrent: bool,
|
|
#[case] caught: bool,
|
|
#[case] presses: usize,
|
|
) {
|
|
let labels = signal_alias(&repo, concurrent, Some(caught));
|
|
let mut job = SignalJob::spawn(&repo, &["-vv", "step", "signal-test"], Stdio::null());
|
|
let children = ready_alias_children(&repo, &labels, job.group());
|
|
crate::common::wait_for_foreground_admission(&repo, &children);
|
|
for press in 1..=presses {
|
|
nix::sys::signal::killpg(job.group(), nix::sys::signal::Signal::SIGINT).unwrap();
|
|
if caught {
|
|
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(20);
|
|
for label in &labels {
|
|
let marker = repo.root_path().join(format!("int-{label}"));
|
|
while std::fs::read_to_string(&marker)
|
|
.unwrap_or_default()
|
|
.lines()
|
|
.count()
|
|
!= press
|
|
{
|
|
assert!(
|
|
std::time::Instant::now() < deadline,
|
|
"{label} did not handle interrupt {press} exactly once"
|
|
);
|
|
std::thread::sleep(std::time::Duration::from_millis(10));
|
|
}
|
|
}
|
|
}
|
|
std::thread::sleep(SLEEP_FOR_ABSENCE_CHECK);
|
|
assert!(job.running(), "interrupt {press} killed wt before release");
|
|
ready_alias_children(&repo, &labels, job.group());
|
|
}
|
|
job.release();
|
|
use std::os::unix::process::ExitStatusExt;
|
|
let status = job.wait();
|
|
assert!(
|
|
status.code() == Some(130) || status.signal() == Some(2),
|
|
"caught/ignored interrupts must still cancel the alias: {status:?}"
|
|
);
|
|
assert!(!repo.root_path().join("next").exists());
|
|
if caught {
|
|
for label in &labels {
|
|
assert_eq!(
|
|
std::fs::read_to_string(repo.root_path().join(format!("int-{label}")))
|
|
.unwrap()
|
|
.lines()
|
|
.count(),
|
|
presses
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// An alias is the whole command, so its last serial step owns Ctrl-C as input,
|
|
/// like `--execute`: a child that handles the key and exits successfully keeps
|
|
/// that status. Earlier steps cancel instead (`test_alias_group_sigint_does_not_escalate`).
|
|
#[rstest]
|
|
#[cfg(unix)]
|
|
fn test_alias_last_step_keeps_status_after_caught_ctrl_c(repo: TestRepo) {
|
|
repo.write_test_config(
|
|
"[aliases]\nsignal-test = \"trap 'exit 0' INT; echo $$ > pid; while :; do sleep 0.1; done\"\n",
|
|
);
|
|
let mut job = SignalJob::spawn(&repo, &["-vv", "step", "signal-test"], Stdio::null());
|
|
job.interrupt_admitted_child(&repo, &repo.root_path().join("pid"));
|
|
assert!(job.wait().success());
|
|
}
|
|
|
|
/// Non-UTF-8 bytes and CRLF line endings in child output must not stall the
|
|
/// executor. Earlier code using `BufRead::lines()` returned `InvalidData` on
|
|
/// the first invalid byte and terminated the iterator, leaving the child's
|
|
/// pipe un-drained and `child.wait()` hanging forever. Also exercises the
|
|
/// `\r\n` strip path so trailing carriage returns don't render visibly.
|
|
#[rstest]
|
|
fn test_alias_concurrent_handles_non_utf8(repo: TestRepo) {
|
|
// `printf` emits a raw 0xff byte (invalid as a lone UTF-8 sequence), a
|
|
// CRLF-terminated line, then `yes` floods 50_000 more valid UTF-8 lines.
|
|
// If the reader stopped at the bad byte, the pipe would fill and the
|
|
// child would block — we'd time out. The trivial `other` command keeps
|
|
// the step a multi-command group so it routes through the concurrent
|
|
// executor (a one-command map parses as a plain `Single` step).
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases.noisy]
|
|
mixed = "sh -c 'printf \"BEFORE\\n\\xff\\nCRLF-LINE\\r\\nAFTER\\n\"; yes PAYLOAD | head -n 50000'"
|
|
other = "true"
|
|
"#,
|
|
);
|
|
repo.commit("initial");
|
|
|
|
let mut cmd = repo.wt_command();
|
|
cmd.args(["step", "noisy"]);
|
|
let output = cmd.output().expect("wt step noisy failed to spawn");
|
|
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
assert!(
|
|
output.status.success(),
|
|
"alias should succeed despite non-UTF-8 byte, got: {status:?}\nlast 500 bytes of stderr: {tail}",
|
|
status = output.status,
|
|
tail = &stderr[stderr.len().saturating_sub(500)..],
|
|
);
|
|
|
|
// All clean lines plus all 50_000 flood lines must land — proves the
|
|
// reader kept going past the invalid byte.
|
|
assert!(stderr.contains("BEFORE"), "expected BEFORE in stderr");
|
|
assert!(
|
|
stderr.contains("AFTER"),
|
|
"expected AFTER in stderr (reader stopped at the invalid byte)"
|
|
);
|
|
// CRLF line ending: the reader strips the trailing \r, so the visible
|
|
// line is `CRLF-LINE` not `CRLF-LINE\r`. Any `\r` in the output would
|
|
// indicate the strip didn't fire.
|
|
assert!(
|
|
stderr.contains("CRLF-LINE"),
|
|
"expected CRLF-LINE (with the \\r stripped) in stderr"
|
|
);
|
|
assert!(
|
|
!stderr.contains("CRLF-LINE\r"),
|
|
"trailing \\r should have been stripped before printing"
|
|
);
|
|
assert_eq!(
|
|
stderr.matches("PAYLOAD").count(),
|
|
50_000,
|
|
"expected 50000 PAYLOAD lines after the invalid byte, got {}",
|
|
stderr.matches("PAYLOAD").count(),
|
|
);
|
|
}
|
|
|
|
/// A concurrent child that produces a large volume of stdout must not
|
|
/// deadlock the executor — the reader thread has to keep draining the pipe so
|
|
/// the child can keep writing. We run two commands, each emitting ~400 KB, and
|
|
/// assert both streams land in stderr intact.
|
|
#[rstest]
|
|
fn test_alias_concurrent_large_output(repo: TestRepo) {
|
|
// yes piped through head is a portable way to generate many lines fast.
|
|
// Each command produces ~400 KB = 50_000 * ~8 bytes ("aaaa...\n" etc.).
|
|
// If the reader thread were ever to stall, the child's stdout pipe would
|
|
// fill (default ~64 KB) and the child would block forever — the test would
|
|
// time out rather than produce a misleading pass.
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases.bulk]
|
|
first = "yes 'FIRST-PAYLOAD-AAAAA' | head -n 50000"
|
|
second = "yes 'SECOND-PAYLOAD-BBBBB' | head -n 50000"
|
|
"#,
|
|
);
|
|
repo.commit("initial");
|
|
|
|
let mut cmd = repo.wt_command();
|
|
cmd.args(["step", "bulk"]);
|
|
let output = cmd.output().expect("wt step bulk failed to spawn");
|
|
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
assert!(
|
|
output.status.success(),
|
|
"concurrent alias with large output should exit 0, got: {status:?}\nlast 500 bytes of stderr: {tail}",
|
|
status = output.status,
|
|
tail = &stderr[stderr.len().saturating_sub(500)..],
|
|
);
|
|
|
|
// Count occurrences so we know both children's full output was streamed —
|
|
// not truncated by a blocked pipe. 50_000 exact matches per payload.
|
|
let first_count = stderr.matches("FIRST-PAYLOAD-AAAAA").count();
|
|
let second_count = stderr.matches("SECOND-PAYLOAD-BBBBB").count();
|
|
assert_eq!(
|
|
first_count, 50_000,
|
|
"expected 50000 occurrences of first payload in stderr, got {first_count}"
|
|
);
|
|
assert_eq!(
|
|
second_count, 50_000,
|
|
"expected 50000 occurrences of second payload in stderr, got {second_count}"
|
|
);
|
|
}
|
|
|
|
/// Ordinary success and failure both retain EOF semantics, including delayed
|
|
/// diagnostics from the failed command and output from healthy siblings.
|
|
#[rstest]
|
|
#[cfg(unix)]
|
|
fn test_alias_failure_preserves_descendant_output(repo: TestRepo) {
|
|
repo.write_test_config(
|
|
r#"[aliases.signal-test]
|
|
bad = "(sleep .6; printf 'FAILED_%s' TAIL) & exit 17"
|
|
good = "(sleep .6; printf 'LATE_%s' TAIL) & printf EARLY_"
|
|
"#,
|
|
);
|
|
let output_path = repo.root_path().join("output");
|
|
let stderr = std::fs::File::create(&output_path).unwrap();
|
|
let mut job = SignalJob::spawn(&repo, &["step", "signal-test"], stderr.into());
|
|
assert_eq!(job.wait().code(), Some(17));
|
|
let output = std::fs::read_to_string(output_path).unwrap();
|
|
assert!(
|
|
output.contains("EARLY_LATE_TAIL"),
|
|
"healthy output lost: {output}"
|
|
);
|
|
assert!(
|
|
output.contains("FAILED_TAIL"),
|
|
"failure diagnostics lost: {output}"
|
|
);
|
|
}
|
|
|
|
/// Cancellation must finish even when an unowned descendant continuously
|
|
/// refills an output pipe, retaining buffered bytes and the final diagnostic.
|
|
#[rstest]
|
|
#[cfg(all(unix, feature = "shell-integration-tests"))]
|
|
fn test_alias_cancelled_continuous_writer_flushes_partial_output(repo: TestRepo) {
|
|
std::fs::write(
|
|
repo.root_path().join("writer.py"),
|
|
r#"import os, signal, time
|
|
from pathlib import Path
|
|
signal.signal(signal.SIGTERM, lambda *_: os._exit(0))
|
|
if os.fork():
|
|
while True:
|
|
time.sleep(60)
|
|
os.write(1, b'BUFFERED_STDOUT')
|
|
os.write(2, b'FINAL_PARTIAL_DIAGNOSTIC')
|
|
Path('descendant-ready').write_text('ready')
|
|
try:
|
|
while not Path('release').exists():
|
|
os.write(1, b'x' * 8192)
|
|
except BrokenPipeError:
|
|
pass
|
|
os._exit(0)
|
|
"#,
|
|
)
|
|
.unwrap();
|
|
repo.write_test_config(
|
|
r#"[aliases.signal-test]
|
|
bad = "exec python3 writer.py"
|
|
good = "true"
|
|
"#,
|
|
);
|
|
let output_path = repo.root_path().join("output");
|
|
let stderr = std::fs::File::create(&output_path).unwrap();
|
|
let mut job = SignalJob::spawn(&repo, &["step", "signal-test"], stderr.into());
|
|
crate::common::wait_for_file_content(&repo.root_path().join("descendant-ready"));
|
|
nix::sys::signal::kill(job.pid(), nix::sys::signal::Signal::SIGTERM).unwrap();
|
|
let release = job.release.clone();
|
|
let (stop, done) = std::sync::mpsc::channel::<()>();
|
|
let (status, watchdog_fired) = std::thread::scope(|scope| {
|
|
let watchdog = scope.spawn(move || {
|
|
if matches!(
|
|
done.recv_timeout(std::time::Duration::from_secs(5)),
|
|
Err(std::sync::mpsc::RecvTimeoutError::Timeout)
|
|
) {
|
|
std::fs::write(release, "release").unwrap();
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
});
|
|
let status = job.wait();
|
|
let _ = stop.send(());
|
|
(status, watchdog.join().unwrap())
|
|
});
|
|
assert!(
|
|
!watchdog_fired,
|
|
"cancelled reader needed producer release to finish"
|
|
);
|
|
use std::os::unix::process::ExitStatusExt;
|
|
assert!(
|
|
status.signal() == Some(15) || status.code() == Some(143),
|
|
"{status:?}"
|
|
);
|
|
let output = std::fs::read_to_string(output_path).unwrap();
|
|
assert!(output.contains("BUFFERED_STDOUT"));
|
|
assert!(output.contains("FINAL_PARTIAL_DIAGNOSTIC"));
|
|
}
|
|
|
|
/// Pipeline-form aliases (list of steps) run sequentially. A later step
|
|
/// referencing `{{ vars.X }}` must see vars set by an earlier step —
|
|
/// `expand_shell_template` reads `vars.*` fresh from git config on each call.
|
|
#[rstest]
|
|
fn test_alias_pipeline_vars_across_steps(repo: TestRepo) {
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = [
|
|
"git config worktrunk.state.main.vars.target 'staging'",
|
|
{ publish = "echo target={{ vars.target }} > alias_lazy.txt" },
|
|
]
|
|
"#,
|
|
);
|
|
repo.commit("initial");
|
|
|
|
let mut cmd = repo.wt_command();
|
|
cmd.args(["step", "deploy"]);
|
|
let output = cmd.output().expect("wt step deploy failed to spawn");
|
|
assert!(
|
|
output.status.success(),
|
|
"wt step deploy failed: stdout={}\nstderr={}",
|
|
String::from_utf8_lossy(&output.stdout),
|
|
String::from_utf8_lossy(&output.stderr),
|
|
);
|
|
|
|
let marker = repo.root_path().join("alias_lazy.txt");
|
|
let content = std::fs::read_to_string(&marker)
|
|
.unwrap_or_else(|e| panic!("missing marker {marker:?}: {e}"));
|
|
assert_eq!(
|
|
content.trim(),
|
|
"target=staging",
|
|
"lazy step should see var set by prior serial step"
|
|
);
|
|
}
|
|
|
|
/// `dry-run` for a pipeline where a later step references `{{ vars.X }}` set by
|
|
/// an earlier step succeeds, mirroring the lazy execution path. The unresolved
|
|
/// `vars.*` reference is shown as the raw template since its value isn't
|
|
/// knowable until the earlier step actually runs.
|
|
#[rstest]
|
|
fn test_config_alias_dry_run_vars_across_steps(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = [
|
|
"git config worktrunk.state.main.vars.target 'prod'",
|
|
{ publish = "echo deploying to {{ vars.target }}" },
|
|
]
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
// Must succeed: dry-run must not require vars.* to be resolvable.
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "dry-run", "deploy"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// `dry-run` still catches template syntax errors (e.g., `{{ vars..foo }}`) even
|
|
/// on the lazy path where `vars.*` rendering is skipped.
|
|
#[rstest]
|
|
fn test_config_alias_dry_run_catches_syntax_error(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
broken = "echo {{ vars..target }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let output = repo
|
|
.wt_command()
|
|
.args(["config", "alias", "dry-run", "broken"])
|
|
.current_dir(&feature_path)
|
|
.output()
|
|
.unwrap();
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
assert!(
|
|
!output.status.success(),
|
|
"dry-run should fail on syntax error; stderr:\n{stderr}"
|
|
);
|
|
assert!(
|
|
stderr.contains("syntax error"),
|
|
"expected 'syntax error' in stderr, got:\n{stderr}"
|
|
);
|
|
}
|
|
|
|
/// Retired `wt <alias> --dry-run` flag produces an actionable error pointing at
|
|
/// the new subcommand. Snapshots the top-level path; the shared parser covers
|
|
/// both `wt <alias>` and `wt step <alias>` dispatch routes (unit test in
|
|
/// `commands::alias::tests::test_parse_errors` verifies the message verbatim).
|
|
#[rstest]
|
|
fn test_retired_dry_run_flag(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo hi"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"deploy",
|
|
&["--dry-run"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// Retired `--dry-run` bail also fires through `wt step <alias>` — the parser
|
|
/// is shared, but this pins the `step_alias` dispatch route specifically.
|
|
#[rstest]
|
|
fn test_retired_dry_run_flag_via_step(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo hi"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"step",
|
|
&["deploy", "--dry-run"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// `wt <alias> --help` prints guidance rather than forwarding `--help` into
|
|
/// `{{ args }}`. Aliases have no clap-style help page; the canonical
|
|
/// inspection path is `wt config alias show / dry-run`.
|
|
#[rstest]
|
|
fn test_alias_help_flag_prints_hint(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo hi {{ args }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"deploy",
|
|
&["--help"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// `wt <alias> -- --help` bypasses the intercept and forwards `--help` into
|
|
/// the alias body — the documented escape.
|
|
#[rstest]
|
|
fn test_alias_help_flag_after_double_dash_forwards(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo {{ args }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"deploy",
|
|
&["--", "--help"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// `wt config alias show <name>` prints the configured template text, source-labeled.
|
|
#[rstest]
|
|
fn test_config_alias_show_single(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "make deploy BRANCH={{ branch }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "show", "deploy"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// `wt config alias show` with no name prints every configured alias's full
|
|
/// definition — the same per-alias header + gutter block as `wt config alias
|
|
/// show <name>`, emitted for each alias in name order. Names defined in both
|
|
/// user and project config show twice (user first), and a name shadowed by a
|
|
/// top-level built-in gets the stderr warning.
|
|
#[rstest]
|
|
fn test_config_alias_show_lists_all(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo from project"
|
|
"only-project" = "echo p"
|
|
list = "echo custom list"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo from user"
|
|
greet = "echo hi {{ branch }}"
|
|
"#,
|
|
);
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "show"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// `wt config alias show` with no name and no aliases configured prints a note
|
|
/// rather than empty output.
|
|
#[rstest]
|
|
fn test_config_alias_show_lists_none(mut repo: TestRepo) {
|
|
repo.commit("Initial commit");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "show"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// Unknown alias name triggers a did-you-mean suggestion. Format mirrors
|
|
/// `wt <typo>` and `wt step <typo>`: clap-native `InvalidSubcommand` with a
|
|
/// `tip:` line — same shape at every alias-typo surface.
|
|
#[rstest]
|
|
fn test_config_alias_show_unknown_suggests(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "make deploy"
|
|
hello = "echo hi"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "show", "deplyo"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// Aliases or typos that literally contain `subcommand` must be echoed
|
|
/// verbatim — the word-substitution pass that rewrites clap's
|
|
/// "unrecognized subcommand" to "unrecognized alias" must only touch
|
|
/// clap's fixed phrases, not the user's input.
|
|
#[rstest]
|
|
fn test_config_alias_show_unknown_preserves_user_input(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
"my-subcommand" = "echo hi"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
// Typo `my-subcommond` is close enough to `my-subcommand` to suggest it —
|
|
// both the echoed typo and the suggestion must keep `subcommand` intact.
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "show", "my-subcommond"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// Single-match case: tip phrasing switches to the singular form
|
|
/// ("a similar alias exists") — mirrors clap's own singular rendering.
|
|
#[rstest]
|
|
fn test_config_alias_show_unknown_singular_suggestion(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "make deploy"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "show", "deplyo"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// `wt config alias dry-run <typo>` produces the same clap-native typo error
|
|
/// as `show` — consistent format across both introspection subcommands.
|
|
#[rstest]
|
|
fn test_config_alias_dry_run_unknown_suggests(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "make deploy"
|
|
hello = "echo hi"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "dry-run", "deplyo"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// Multi-step pipeline renders with per-step structure in the header.
|
|
#[rstest]
|
|
fn test_config_alias_show_pipeline(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[[aliases.release]]
|
|
install = "npm install"
|
|
|
|
[[aliases.release]]
|
|
build = "npm run build"
|
|
lint = "npm run lint"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "show", "release"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// Positional args via `wt config alias dry-run <name> -- foo bar` flow through as `{{ args }}`.
|
|
#[rstest]
|
|
fn test_config_alias_dry_run_positional_args(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
s = "wt switch {{ args }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "dry-run", "s", "--", "target-branch"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// `wt config alias show <name>` with the same alias defined in both user and
|
|
/// project config prints both entries in runtime order (user first).
|
|
#[rstest]
|
|
fn test_config_alias_show_user_and_project(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo from project"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo from user"
|
|
"#,
|
|
);
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "show", "deploy"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// Unknown alias name with no similar configured aliases shows a plain error
|
|
/// without a "did you mean" tail.
|
|
#[rstest]
|
|
fn test_config_alias_show_unknown_no_suggestions(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "echo hi"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
// Query name shares no meaningful prefix with any configured alias — the
|
|
// Jaro-Winkler threshold rejects it, so the error has no suggestion list.
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "show", "zzzzzzzz"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// `wt config alias show <name>` on an alias whose name is also a top-level
|
|
/// built-in subcommand warns that the alias is unreachable via `wt <name>`.
|
|
/// The alias is still configured, so the show output itself is shown — the
|
|
/// warning is an advisory on stderr.
|
|
#[rstest]
|
|
fn test_config_alias_show_warns_on_shadowed_name(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
list = "echo custom list"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "show", "list"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// `wt config alias dry-run` on a shadowed name emits the same advisory as
|
|
/// `show` — both are discovery surfaces, so both point out the shadowing.
|
|
#[rstest]
|
|
fn test_config_alias_dry_run_warns_on_shadowed_name(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
list = "echo custom list"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "dry-run", "list"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// `wt step` with no subcommand lists built-in steps plus configured aliases.
|
|
///
|
|
/// Skipped on Windows: clap renders `[experimental]` subcommand tags
|
|
/// differently (markdown escaping), same reason `tests/integration_tests/help.rs`
|
|
/// is Windows-gated.
|
|
#[cfg(not(windows))]
|
|
#[rstest]
|
|
fn test_step_list_with_aliases(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "make deploy BRANCH={{ branch }}"
|
|
port = "echo http://localhost:{{ branch | hash_port }}"
|
|
squash = "this shadows the built-in"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(&repo, "step", &[], Some(&feature_path)));
|
|
}
|
|
|
|
/// `wt step` without configured aliases still works — just prints help.
|
|
#[cfg(not(windows))]
|
|
#[rstest]
|
|
fn test_step_list_no_aliases(mut repo: TestRepo) {
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(&repo, "step", &[], Some(&feature_path)));
|
|
}
|
|
|
|
/// `wt step --help` includes the same Aliases section as bare `wt step`.
|
|
///
|
|
/// Without this, users running `--help` in the normal discovery flow would
|
|
/// see only built-in commands and miss their configured aliases.
|
|
#[cfg(not(windows))]
|
|
#[rstest]
|
|
fn test_step_help_includes_aliases(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
deploy = "make deploy BRANCH={{ branch }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"step",
|
|
&["-h"],
|
|
Some(&feature_path)
|
|
));
|
|
}
|
|
|
|
/// `wt step --help` must not emit deprecation warnings or write `.new`
|
|
/// migration files when the user config contains deprecated patterns —
|
|
/// help is a discovery surface, not an execution surface, and the user
|
|
/// will see those warnings from `wt config show` and normal commands.
|
|
#[cfg(not(windows))]
|
|
#[rstest]
|
|
fn test_step_help_silent_with_deprecated_user_config(repo: TestRepo) {
|
|
// Deprecated `main_worktree` template variable — migrated to `repo`.
|
|
repo.write_test_config(
|
|
r#"worktree-path = "../{{ main_worktree }}.{{ branch }}"
|
|
"#,
|
|
);
|
|
let migration_file = repo.test_config_path().with_extension("toml.new");
|
|
|
|
let output = repo.wt_command().args(["step", "--help"]).output().unwrap();
|
|
|
|
assert!(
|
|
output.status.success(),
|
|
"step --help should succeed: {}",
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
assert_eq!(
|
|
stderr, "",
|
|
"step --help must emit no stderr on deprecated user config"
|
|
);
|
|
assert!(
|
|
!migration_file.exists(),
|
|
"step --help must not write .new migration file at {}",
|
|
migration_file.display()
|
|
);
|
|
}
|
|
|
|
/// `wt -C <other> step --help` lists aliases from `<other>`'s project config,
|
|
/// not from the process cwd. Without applying global options before the help
|
|
/// branch, the Aliases section was rendered from the wrong repo.
|
|
#[cfg(not(windows))]
|
|
#[rstest]
|
|
fn test_step_help_honors_dash_c(repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
xyzzy = "echo nothing happens"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let repo_path = repo.root_path().to_path_buf();
|
|
|
|
// Invoke from a directory that is *not* inside the repo so the alias can
|
|
// only be discovered via -C. Using the system temp dir keeps this
|
|
// independent of the test's working directory.
|
|
let cwd = std::env::temp_dir();
|
|
let mut cmd = repo.wt_command();
|
|
cmd.current_dir(&cwd)
|
|
.args(["-C", repo_path.to_str().unwrap(), "step", "--help"]);
|
|
let output = cmd.output().expect("failed to run wt");
|
|
|
|
let stdout = String::from_utf8_lossy(&output.stdout);
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
assert!(
|
|
stdout.contains("xyzzy"),
|
|
"expected `xyzzy` alias to appear in `wt -C <repo> step --help` output\n\
|
|
stdout:\n{stdout}\nstderr:\n{stderr}"
|
|
);
|
|
}
|
|
|
|
/// Positional args after the alias name forward to `{{ args }}` in the
|
|
/// template — space-joined and shell-escaped so args with spaces, quotes,
|
|
/// or metacharacters splice safely into a command line.
|
|
#[rstest]
|
|
fn test_step_alias_forwards_positional_args(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
run = "echo got {{ args }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"run",
|
|
&["one", "two three", "four"],
|
|
Some(&feature_path),
|
|
&["-y"],
|
|
));
|
|
}
|
|
|
|
/// Templates can treat `{{ args }}` as a sequence: indexing, iteration,
|
|
/// and `length` all work because `ShellArgs` reports as `ObjectRepr::Seq`.
|
|
#[rstest]
|
|
fn test_step_alias_args_sequence_access(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
show = '''echo first={{ args[0] }}; echo count={{ args | length }}; echo each={% for a in args %} {{ a }}{% endfor %}'''
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"show",
|
|
&["alpha", "beta gamma"],
|
|
Some(&feature_path),
|
|
&["-y"],
|
|
));
|
|
}
|
|
|
|
/// With no positionals, `{{ args }}` renders empty — the rest of the line
|
|
/// stays intact and no stray whitespace is introduced.
|
|
#[rstest]
|
|
fn test_step_alias_empty_args_renders_empty(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
run = "echo [{{ args }}]"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"run",
|
|
&[],
|
|
Some(&feature_path),
|
|
&["-y"],
|
|
));
|
|
}
|
|
|
|
/// `wt s some-branch` with `s = "wt switch {{ args }}"` forwards the
|
|
/// positional into the expanded command. Verified via `wt config alias dry-run`
|
|
/// so the inner `wt switch` is not actually executed.
|
|
#[rstest]
|
|
fn test_top_level_alias_positional_expands_in_dry_run(mut repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
s = "wt switch {{ args }}"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
let _guard = settings.bind_to_scope();
|
|
|
|
assert_cmd_snapshot!(make_snapshot_cmd(
|
|
&repo,
|
|
"config",
|
|
&["alias", "dry-run", "s", "--", "target-branch"],
|
|
Some(&feature_path),
|
|
));
|
|
}
|
|
|
|
/// Under `-v`, aliases print a table of resolved template variables before
|
|
/// the announcement — symmetric with the hook-invocation verbose block, but
|
|
/// with alias-scoped vars (`args` included, no `hook_*` keys).
|
|
#[rstest]
|
|
fn test_alias_verbose_prints_variable_table(mut repo: TestRepo) {
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
greet = "echo hello {{ args }}"
|
|
"#,
|
|
);
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
settings.bind(|| {
|
|
let mut cmd = make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"greet",
|
|
&["world"],
|
|
Some(&feature_path),
|
|
&["-v"],
|
|
);
|
|
assert_cmd_snapshot!("alias_verbose_variable_table", cmd);
|
|
});
|
|
}
|
|
|
|
/// Multi-token args with whitespace render shell-escaped in the `-v` table,
|
|
/// matching what `{{ args }}` actually expands to on the line below.
|
|
#[rstest]
|
|
fn test_alias_verbose_renders_args_shell_escaped(mut repo: TestRepo) {
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
greet = "echo hello {{ args }}"
|
|
"#,
|
|
);
|
|
let feature_path = repo.add_worktree("feature");
|
|
|
|
let settings = setup_snapshot_settings(&repo);
|
|
settings.bind(|| {
|
|
let mut cmd = make_snapshot_cmd_with_global_flags(
|
|
&repo,
|
|
"greet",
|
|
&["foo", "bar baz"],
|
|
Some(&feature_path),
|
|
&["-v"],
|
|
);
|
|
assert_cmd_snapshot!("alias_verbose_args_shell_escaped", cmd);
|
|
});
|
|
}
|
|
|
|
/// Aliases keep `wt`'s inherited git-discovery context: `wt <alias>` is the
|
|
/// user's own top-level command, run where they invoked it, so the inherited
|
|
/// `GIT_DIR`/`GIT_WORK_TREE` pass through — unlike hooks and `wt step
|
|
/// for-each`, which `wt` relocates into worktrees it selects and therefore
|
|
/// scrubs (the keep side of the classification in
|
|
/// `scrub_git_discovery_env_vars`; issue #3373).
|
|
#[rstest]
|
|
#[cfg(unix)]
|
|
fn test_alias_keeps_inherited_git_discovery_vars(repo: TestRepo) {
|
|
repo.write_project_config(
|
|
r#"
|
|
[aliases]
|
|
record-git-env = "printf '[%s][%s]' \"$GIT_DIR\" \"$GIT_WORK_TREE\" > env_seen.txt"
|
|
"#,
|
|
);
|
|
repo.commit("Add alias config");
|
|
|
|
let git_dir = repo.root_path().join(".git");
|
|
let output = repo
|
|
.wt_command()
|
|
.args(["-y", "record-git-env"])
|
|
.env("GIT_DIR", &git_dir)
|
|
.env("GIT_WORK_TREE", repo.root_path())
|
|
.output()
|
|
.unwrap();
|
|
assert!(
|
|
output.status.success(),
|
|
"alias failed:\nstdout: {}\nstderr: {}",
|
|
String::from_utf8_lossy(&output.stdout),
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
|
|
let seen = std::fs::read_to_string(repo.root_path().join("env_seen.txt")).unwrap();
|
|
let expected = format!("[{}][{}]", git_dir.display(), repo.root_path().display());
|
|
assert_eq!(
|
|
seen, expected,
|
|
"alias should see wt's inherited git-discovery vars unchanged"
|
|
);
|
|
}
|
|
|
|
/// A detached worktree leaves `{{ branch }}` undefined, so `{% if branch %}`
|
|
/// guards it the way the hook docs prescribe for every optional variable.
|
|
///
|
|
/// Regression test for #4009: `branch` used to fall back to the literal
|
|
/// `HEAD`, which is a non-empty string git happily resolves as a ref — so
|
|
/// every guard written around `branch` passed and the alias ran against the
|
|
/// wrong thing (`git push origin --delete HEAD`). It also disagreed with
|
|
/// `wt list --json`, which reports `branch: null` for the same worktree.
|
|
#[rstest]
|
|
fn test_alias_branch_unset_in_detached_worktree(mut repo: TestRepo) {
|
|
repo.add_worktree("detached-test");
|
|
repo.detach_head_in_worktree("detached-test");
|
|
let detached = repo.worktree_path("detached-test").to_path_buf();
|
|
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
probe = "echo [{% if branch %}{{ branch }}{% endif %}]"
|
|
"#,
|
|
);
|
|
|
|
let output = repo
|
|
.wt_command()
|
|
.args(["-y", "probe"])
|
|
.current_dir(&detached)
|
|
.output()
|
|
.unwrap();
|
|
assert!(
|
|
output.status.success(),
|
|
"alias failed:\nstdout: {}\nstderr: {}",
|
|
String::from_utf8_lossy(&output.stdout),
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
|
|
let combined = format!(
|
|
"{}{}",
|
|
String::from_utf8_lossy(&output.stdout),
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
assert!(
|
|
combined.contains("[]"),
|
|
"`{{% if branch %}}` should not fire in a detached worktree, got: {combined}"
|
|
);
|
|
assert!(
|
|
!combined.contains("[HEAD]"),
|
|
"`branch` must not fall back to the literal `HEAD`, got: {combined}"
|
|
);
|
|
}
|
|
|
|
/// `branch` is cheap enough that `build_hook_context` computes it whatever the
|
|
/// scope, so its absence in a detached worktree is `(unset)` — a fact about the
|
|
/// worktree — even in an alias body that never names it. `(unused)` is reserved
|
|
/// for a var the scope gate actually skipped computing.
|
|
#[rstest]
|
|
fn test_verbose_variables_table_marks_detached_branch_unset(mut repo: TestRepo) {
|
|
repo.add_worktree("detached-vars");
|
|
repo.detach_head_in_worktree("detached-vars");
|
|
let detached = repo.worktree_path("detached-vars").to_path_buf();
|
|
|
|
// The body references neither `branch` nor `upstream`, so the scope gate
|
|
// skips only the latter — an expensive var behind a git-config read.
|
|
repo.write_test_config(
|
|
r#"
|
|
[aliases]
|
|
probe = "echo hello"
|
|
"#,
|
|
);
|
|
|
|
let output = repo
|
|
.wt_command()
|
|
.args(["-v", "-y", "probe"])
|
|
.current_dir(&detached)
|
|
.output()
|
|
.unwrap();
|
|
let raw_stderr = String::from_utf8_lossy(&output.stderr);
|
|
let stderr = raw_stderr.ansi_strip();
|
|
|
|
let branch_row = stderr
|
|
.lines()
|
|
.map(str::trim)
|
|
.find(|line| line.starts_with("branch "))
|
|
.unwrap_or_else(|| panic!("no `branch` row in the variables table:\n{stderr}"));
|
|
assert!(
|
|
branch_row.ends_with("= (unset)"),
|
|
"detached `branch` should read `(unset)`, not `(unused)`, got: {branch_row}"
|
|
);
|
|
}
|
|
|
|
/// The first alias step moves its worktree, so the next child's cwd is absent.
|
|
#[rstest]
|
|
#[cfg(unix)]
|
|
#[case::serial(false)]
|
|
#[case::concurrent(true)]
|
|
fn test_alias_spawn_failure_has_one_source_detail(repo: TestRepo, #[case] concurrent: bool) {
|
|
repo.write_test_config(
|
|
if concurrent {
|
|
r#"[aliases]
|
|
move-away = ["mv {{ worktree_path }} {{ worktree_path }}.moved", { check = "true", sibling = "true" }]
|
|
"#
|
|
} else {
|
|
r#"[aliases]
|
|
move-away = ["mv {{ worktree_path }} {{ worktree_path }}.moved", "true"]
|
|
"#
|
|
}
|
|
);
|
|
let output = repo.wt_command().arg("move-away").output().unwrap();
|
|
assert_eq!(output.status.code(), Some(1));
|
|
assert!(!repo.root_path().exists());
|
|
assert!(repo.root_path().with_file_name("repo.moved").exists());
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
assert_eq!(stderr.matches("Failed to execute").count(), 1, "{stderr}");
|
|
assert_eq!(stderr.matches("os error 2").count(), 1, "{stderr}");
|
|
if concurrent {
|
|
assert!(stderr.contains("command 'check'"), "{stderr}");
|
|
}
|
|
setup_snapshot_settings(&repo).bind(|| {
|
|
insta::assert_snapshot!(
|
|
if concurrent {
|
|
"alias_concurrent_spawn_failure_has_one_source_detail"
|
|
} else {
|
|
"alias_spawn_failure_has_one_source_detail"
|
|
},
|
|
stderr
|
|
);
|
|
});
|
|
}
|