//! Shell wrapper integration tests //! //! Tests that verify the complete shell integration path - commands executed through //! the actual shell wrapper (wt_exec in bash/zsh/fish). //! //! These tests ensure that: //! - Directives are never leaked to users //! - Output is properly formatted for humans //! - Shell integration works end-to-end as users experience it //! //! ## Why Manual PTY Execution + File Snapshots (Not insta_cmd)? //! //! These tests use PTY execution because testing shell wrappers requires real TTY behavior //! (streaming output, ANSI codes, signal handling). `insta_cmd` uses `std::process::Command` //! which doesn't provide a TTY to child processes. //! //! Output normalization uses insta's `add_filter()` API via `shell_wrapper_settings()`, //! which is consistent with how other tests in the codebase handle path and hash //! normalization. The filters handle: //! - PTY-specific artifacts (CRLF, ^D control sequences, ANSI resets) //! - Temporary directory paths //! - Commit hashes (non-deterministic in PTY tests due to timing/environment) //! - Project root paths // All shell integration tests and infrastructure gated by feature flag // Supports both Unix (bash/zsh/fish) and Windows (PowerShell) #![cfg(feature = "shell-integration-tests")] // ============================================================================= // Imports // ============================================================================= // Shared imports (both platforms) use crate::common::{TestRepo, shell::shell_binary, wt_bin}; use std::process::Command; use worktrunk::shell; // Unix-only imports #[cfg(unix)] use { crate::common::{add_pty_filters, canonicalize, wait_for_file_content}, insta::assert_snapshot, std::{fs, path::PathBuf, sync::LazyLock}, }; /// Output from executing a command through a shell wrapper #[derive(Debug)] struct ShellOutput { /// Combined stdout and stderr as user would see combined: String, /// Exit code from the command exit_code: i32, } /// Regex for detecting bash job control messages /// Matches patterns like "[1] 12345" (job start) and "[1]+ Done" (job completion) #[cfg(unix)] static JOB_CONTROL_REGEX: LazyLock = LazyLock::new(|| regex::Regex::new(r"\[\d+\][+-]?\s+(Done|\d+)").unwrap()); impl ShellOutput { /// Check if output contains no directive leaks fn assert_no_directive_leaks(&self) { assert!( !self.combined.contains("__WORKTRUNK_CD__"), "Output contains leaked __WORKTRUNK_CD__ directive:\n{}", self.combined ); assert!( !self.combined.contains("__WORKTRUNK_EXEC__"), "Output contains leaked __WORKTRUNK_EXEC__ directive:\n{}", self.combined ); } /// Check if output contains no bash job control messages /// /// Job control messages like "[1] 12345" (job start) and "[1]+ Done ..." (job completion) /// should not appear in user-facing output. These are internal shell artifacts from /// background process management that leak implementation details. #[cfg(unix)] fn assert_no_job_control_messages(&self) { assert!( !JOB_CONTROL_REGEX.is_match(&self.combined), "Output contains job control messages (e.g., '[1] 12345' or '[1]+ Done'):\n{}", self.combined ); } /// Assert command exited successfully (exit code 0) #[cfg(unix)] fn assert_success(&self) { assert_eq!( self.exit_code, 0, "Expected exit code 0, got {}.\nOutput:\n{}", self.exit_code, self.combined ); } } /// Insta settings for shell wrapper tests. /// /// Inherits snapshot_path and path filters from TestRepo (bound to scope), /// then adds PTY-specific filters for cross-platform consistency. #[cfg(unix)] fn shell_wrapper_settings() -> insta::Settings { let mut settings = insta::Settings::clone_current(); add_pty_filters(&mut settings); settings } /// Generate a shell wrapper script using the actual `wt config shell init` command fn generate_wrapper(repo: &TestRepo, shell: &str) -> String { let wt_bin = wt_bin(); let mut cmd = Command::new(&wt_bin); cmd.arg("config").arg("shell").arg("init").arg(shell); // Configure environment repo.configure_wt_cmd(&mut cmd); let output = cmd.output().unwrap_or_else(|e| { panic!( "Failed to run wt config shell init {}: {} (binary: {})", shell, e, wt_bin.display() ) }); if !output.status.success() { panic!( "wt config shell init {} failed with exit code: {:?}\nOutput:\n{}", shell, output.status.code(), String::from_utf8_lossy(&output.stderr) ); } String::from_utf8(output.stdout) .unwrap_or_else(|_| panic!("wt config shell init {} produced invalid UTF-8", shell)) } /// Generate shell completions script for the given shell /// /// Note: Fish completions are custom (use $WORKTRUNK_BIN to bypass shell wrapper). /// Bash and Zsh use inline lazy loading in the init script. #[cfg(unix)] fn generate_completions(_repo: &TestRepo, shell: &str) -> String { match shell { "fish" => { // Fish uses a custom completion that bypasses the shell wrapper r#"# worktrunk completions for fish - uses $WORKTRUNK_BIN to bypass shell wrapper complete --keep-order --exclusive --command wt --arguments "(COMPLETE=fish \$WORKTRUNK_BIN -- (commandline --current-process --tokenize --cut-at-cursor) (commandline --current-token))" "#.to_string() } _ => { // Bash and Zsh use inline lazy loading in the init script String::new() } } } /// Quote a shell argument if it contains special characters fn quote_arg(arg: &str) -> String { if arg.is_empty() || arg.contains(' ') || arg.contains(';') || arg.contains('\'') { shell_quote(arg) } else { arg.to_string() } } /// Always quote a string for shell use, properly escaping single quotes. /// Handles paths like `/path/to/worktrunk.'∅'/target/debug/wt` fn shell_quote(s: &str) -> String { format!("'{}'", s.replace('\'', r"'\''")) } /// Always quote a Nushell string. Nushell does not support the POSIX `\''` /// concatenation idiom, while ordinary double-quoted strings accept `\\` and /// `\"` escapes without interpolation (`$"…"` is the interpolation form). fn nushell_quote(s: &str) -> String { format!("\"{}\"", s.replace('\\', r"\\").replace('"', r#"\""#)) } /// Quote a path for PowerShell (escape backticks and single quotes) fn powershell_quote(s: &str) -> String { // PowerShell string escaping: use single quotes and escape embedded single quotes by doubling format!("'{}'", s.replace('\'', "''")) } fn wrapper_shell(shell_name: &str) -> shell::Shell { match shell_name { "bash" => shell::Shell::Bash, "fish" => shell::Shell::Fish, "nu" | "nushell" => shell::Shell::Nushell, "zsh" => shell::Shell::Zsh, "powershell" | "pwsh" => shell::Shell::PowerShell, other => panic!("Unsupported shell wrapper test shell: {other}"), } } fn wrapper_env_vars(shell: shell::Shell, repo: &TestRepo) -> Vec<(&'static str, String)> { let quote = |value: &str| match shell { shell::Shell::PowerShell => powershell_quote(value), _ => shell_quote(value), }; vec![ ("WORKTRUNK_BIN", quote(&wt_bin().display().to_string())), ( "WORKTRUNK_CONFIG_PATH", quote(&repo.test_config_path().display().to_string()), ), ( "WORKTRUNK_APPROVALS_PATH", quote(&repo.test_approvals_path().display().to_string()), ), ( "CLICOLOR_FORCE", match shell { shell::Shell::Nushell | shell::Shell::PowerShell => "'1'".to_string(), _ => "1".to_string(), }, ), ] } fn append_shell_env_exports(script: &mut String, shell: shell::Shell, vars: &[(&str, String)]) { if matches!(shell, shell::Shell::Zsh) { script.push_str("autoload -Uz compinit && compinit -i 2>/dev/null\n"); } for (key, value) in vars { match shell { shell::Shell::Fish => script.push_str(&format!("set -x {key} {value}\n")), shell::Shell::Nushell => script.push_str(&format!("$env.{key} = {value}\n")), shell::Shell::PowerShell => script.push_str(&format!("$env:{key} = {value}\n")), shell::Shell::Bash | shell::Shell::Zsh => { script.push_str(&format!("export {key}={value}\n")) } } } } fn append_wrapper_setup(script: &mut String, shell_name: &str, repo: &TestRepo) { let shell = wrapper_shell(shell_name); let env_vars = wrapper_env_vars(shell, repo); append_shell_env_exports(script, shell, &env_vars); script.push_str(&generate_wrapper(repo, shell_name)); script.push('\n'); } /// Build a shell script that sources the wrapper and runs a command fn build_shell_script(shell: &str, repo: &TestRepo, subcommand: &str, args: &[&str]) -> String { let mut script = String::new(); append_wrapper_setup(&mut script, shell, repo); // Build the command script.push_str("wt "); script.push_str(subcommand); for arg in args { script.push(' '); match shell { "powershell" | "pwsh" => { // PowerShell argument quoting // Note: -- is special in PowerShell (stop-parsing token), so we must quote it if arg.contains(' ') || arg.contains(';') || arg.contains('\'') || *arg == "--" { script.push_str(&powershell_quote(arg)); } else { script.push_str(arg); } } "nu" | "nushell" => { if arg.is_empty() || arg .chars() .any(|c| c.is_whitespace() || matches!(c, ';' | '\'' | '"' | '$' | '\\')) { script.push_str(&nushell_quote(arg)); } else { script.push_str(arg); } } _ => { script.push_str("e_arg(arg)); } } } script.push('\n'); // Merge stderr to stdout to simulate real terminal behavior // In a real terminal, both streams interleave naturally by the OS. // The .output() method captures them separately, so we merge them here // to preserve temporal locality (output appears when operations complete, not batched at the end) match shell { "fish" => { // Fish uses begin...end for grouping // Note: This exposes a Fish wrapper buffering bug where child output appears out of order // (see templates/fish.fish - psub causes buffering). Tests document current behavior. format!("begin\n{}\nend 2>&1", script) } "nu" => { // Nushell doesn't need explicit stderr redirect - PTY captures both streams // The script is executed directly script } "bash" => { // For bash, we don't use a subshell wrapper because it would isolate job control messages. // Instead, we use exec to redirect stderr to stdout, then run the script. // This ensures job control messages (like "[1] 12345" and "[1]+ Done") are captured, // allowing tests to catch these leaks. format!("exec 2>&1\n{}", script) } "powershell" | "pwsh" => { // PowerShell: run script directly, redirect stderr to stdout for the wt call // The & { } wrapper was causing output to be lost in ConPTY. // Instead, we run the script directly - stderr naturally appears in the PTY. // Exit with LASTEXITCODE to propagate the wt function's exit code to the calling process. format!("{}\nexit $LASTEXITCODE", script) } _ => { // zsh uses parentheses for subshell grouping format!("( {} ) 2>&1", script) } } } /// Execute a command in a PTY with interactive input support. /// /// The PTY will automatically echo the input (like a real terminal), so you'll /// see both the prompts and the input in the captured output. /// /// # Arguments /// * `shell` - The shell to use (e.g., "bash", "zsh") /// * `script` - The script to execute /// * `working_dir` - Working directory for the command /// * `env_vars` - Environment variables to set /// * `inputs` - A slice of strings to send as input (e.g., `&["y\n", "feature\n"]`) /// /// # Example /// ```no_run /// let (output, exit_code) = exec_in_pty_interactive( /// "bash", /// "wt switch --create", /// repo.root_path(), /// &[("CLICOLOR_FORCE", "1")], /// &["y\n"], // Send 'y' and newline when prompted /// ); /// // The output will show: "Allow? [y/N] y" /// ``` #[cfg(test)] fn exec_in_pty_interactive( shell: &str, script: &str, working_dir: &std::path::Path, env_vars: &[(&str, &str)], inputs: &[&str], ) -> (String, i32) { exec_in_pty_shell(shell, script, working_dir, env_vars, inputs, true) } /// Like [`exec_in_pty_interactive`] but lets the caller choose whether `bash` / /// `zsh` run interactively (`-i`). /// /// An interactive shell does job-control initialization at startup: if it /// decides it isn't the PTY's foreground process group it sends its own process /// group `SIGTTIN` and stops — producing no output and never exiting. Under /// parallel load that occasionally wedged `test_source_flag_forwards_errors` /// until the 180s harness timeout. A non-interactive shell skips job control /// entirely, so the wedge can't happen; pass `interactive = false` for tests /// that don't assert on job-control output. Tests that *do* (e.g. /// `test_zsh_no_job_control`) pass `interactive = true`. #[cfg(test)] fn exec_in_pty_shell( shell: &str, script: &str, working_dir: &std::path::Path, env_vars: &[(&str, &str)], inputs: &[&str], interactive: bool, ) -> (String, i32) { use portable_pty::CommandBuilder; use std::io::Write; let pair = crate::common::open_pty(); let shell_binary = shell_binary(shell); let mut cmd = CommandBuilder::new(shell_binary); // Isolated environment (env_clear, HOME, PATH, determinism baselines, coverage) crate::common::configure_pty_command(&mut cmd); cmd.env("USER", "testuser"); cmd.env("SHELL", shell_binary); // Interactive shells (`-i`) enable job control, so tests can catch // job-control message leaks like "[1] 12345" and "[1]+ Done". Callers that // don't assert on job control pass `interactive = false` to skip `-i` and // avoid the startup job-control wedge (see `exec_in_pty_shell`). match shell { "zsh" => { // Isolate from user rc files cmd.env("ZDOTDIR", "/dev/null"); if interactive { cmd.arg("-i"); } cmd.arg("--no-rcs"); cmd.arg("-o"); cmd.arg("NO_GLOBAL_RCS"); cmd.arg("-o"); cmd.arg("NO_RCS"); cmd.arg("-c"); cmd.arg(script); } "bash" => { // Isolate from user rc/profile files, mirroring the zsh arm and // `exec_bash_truly_interactive`. A no-op for non-interactive // `bash -c`, but it keeps interactive (`-i`) startup from sourcing // the host's ~/.bashrc and leaking host-specific output. cmd.arg("--norc"); cmd.arg("--noprofile"); if interactive { cmd.arg("-i"); } cmd.arg("-c"); cmd.arg(script); } "powershell" | "pwsh" => { // PowerShell: write script to temp file and execute via -File // Using -Command with long scripts can cause issues with ConPTY let temp_dir = std::env::temp_dir(); let script_path = temp_dir.join(format!("wt_test_{}.ps1", std::process::id())); std::fs::write(&script_path, script).expect("Failed to write temp script"); cmd.arg("-NoProfile"); cmd.arg("-ExecutionPolicy"); cmd.arg("Bypass"); cmd.arg("-File"); cmd.arg(script_path.to_string_lossy().to_string()); } "nu" => { // Nushell: isolate from user config cmd.arg("--no-config-file"); cmd.arg("-c"); cmd.arg(script); } "fish" => { cmd.arg("--no-config"); cmd.arg("-c"); cmd.arg(script); } _ => { cmd.arg("-c"); cmd.arg(script); } } cmd.cwd(working_dir); // Add test-specific environment variables (convert &str tuples to String tuples) for (key, value) in env_vars { cmd.env(key, value); } // Pass through LLVM coverage env vars for subprocess coverage collection crate::common::pass_coverage_env_to_pty_cmd(&mut cmd); let mut child = pair.slave.spawn_command(cmd).unwrap(); drop(pair.slave); // Close slave in parent // Get reader and writer for the PTY master let reader = pair.master.try_clone_reader().unwrap(); let mut writer = pair.master.take_writer().unwrap(); // Write input synchronously if we have any (matches approval_pty.rs approach) for input in inputs { writer.write_all(input.as_bytes()).unwrap(); writer.flush().unwrap(); } // Read output and wait for exit using platform-aware handling // On Windows ConPTY, this handles cursor queries and proper pipe closure let (buf, exit_code) = crate::common::pty::read_pty_output(reader, writer, pair.master, &mut child); // Normalize CRLF to LF (PTYs use CRLF on some platforms) let normalized = buf.replace("\r\n", "\n"); (normalized, exit_code) } /// Execute bash in true interactive mode by writing commands to the PTY /// /// Unlike `exec_in_pty_interactive` which uses `bash -i -c "script"`, this function /// starts bash without `-c` and writes commands directly to the PTY. This captures /// job control notifications (`[1]+ Done`) that only appear at prompt-time in bash. /// /// The setup_script is written to a temp file and sourced. Then final_cmd is run /// directly at the prompt (where job notifications appear). /// /// `success_marker` is a substring the command is expected to print; the helper /// polls for it to know the command finished, instead of sleeping a fixed guess. #[cfg(all(test, unix))] fn exec_bash_truly_interactive( setup_script: &str, final_cmd: &str, success_marker: &str, working_dir: &std::path::Path, env_vars: &[(&str, &str)], ) -> (String, i32) { use portable_pty::CommandBuilder; use std::io::{Read, Write}; use std::sync::mpsc; use std::thread; use std::time::{Duration, Instant}; // Write setup script to a temp file let tmp_dir = tempfile::tempdir().unwrap(); let script_path = tmp_dir.path().join("setup.sh"); fs::write(&script_path, setup_script).unwrap(); let pair = crate::common::open_pty(); // Spawn bash in true interactive mode using env to pass flags // (portable_pty's CommandBuilder can have issues with flag parsing) let mut cmd = CommandBuilder::new("env"); cmd.arg("bash"); cmd.arg("--norc"); cmd.arg("--noprofile"); cmd.arg("-i"); // Isolated environment (env_clear, HOME, PATH, determinism baselines, coverage) crate::common::configure_pty_command(&mut cmd); cmd.env("USER", "testuser"); cmd.env("SHELL", "bash"); // Simple prompt to make output cleaner ($ followed by space) cmd.env("PS1", "$ "); cmd.cwd(working_dir); // Add test-specific environment variables for (key, value) in env_vars { cmd.env(key, value); } let mut child = pair.slave.spawn_command(cmd).unwrap(); drop(pair.slave); // Close slave in parent let reader = pair.master.try_clone_reader().unwrap(); let mut writer = pair.master.take_writer().unwrap(); // Stream PTY output over a channel so the main thread can poll for prompts and // command output as they arrive, rather than reading only after `exit`. This is // what lets the blind startup/command sleeps become waits on real output. let (tx, rx) = mpsc::channel::>(); let reader_thread = thread::spawn(move || { let mut reader = reader; let mut buf = [0u8; 4096]; loop { match reader.read(&mut buf) { Ok(0) => break, Ok(n) => { if tx.send(buf[..n].to_vec()).is_err() { break; } } Err(_) => break, } } }); let mut accumulated: Vec = Vec::new(); let poll = Duration::from_millis(10); // Drain pending chunks, then poll until `needle` appears or the timeout elapses. // This is the presence half: wait on the output that the command must produce. let mut wait_for = |needle: &[u8], timeout: Duration, what: &str| { let start = Instant::now(); loop { while let Ok(chunk) = rx.try_recv() { accumulated.extend_from_slice(&chunk); } if accumulated.windows(needle.len()).any(|w| w == needle) { return; } if start.elapsed() > timeout { panic!( "Timed out waiting for {} ({:?}). Output so far:\n{}", what, String::from_utf8_lossy(needle), String::from_utf8_lossy(&accumulated) ); } thread::sleep(poll); } }; // Wait for bash's first prompt instead of guessing a startup delay. wait_for(b"$ ", Duration::from_secs(10), "bash startup prompt"); // Write setup and command (but not exit yet). let commands = format!("source '{}'\n{}\n", script_path.display(), final_cmd); writer.write_all(commands.as_bytes()).unwrap(); writer.flush().unwrap(); // Wait for the command's success output, confirming it ran to completion. wait_for( success_marker.as_bytes(), Duration::from_secs(30), "command output", ); // Absence window: a leaked `[1]+ Done` surfaces at prompt-time after the // backgrounded post-start hook finishes. Hold a fixed window so a leak has time // to appear. The assertion is that it does not, so there is no event to poll for. thread::sleep(crate::common::SLEEP_FOR_ABSENCE_CHECK); // Now send exit. writer.write_all(b"exit\n").unwrap(); writer.flush().unwrap(); drop(writer); // Drain the remaining output once bash has exited. let status = child.wait().unwrap(); reader_thread.join().unwrap(); while let Ok(chunk) = rx.try_recv() { accumulated.extend_from_slice(&chunk); } // Normalize CRLF to LF (same as exec_in_pty_interactive). let normalized = String::from_utf8_lossy(&accumulated).replace("\r\n", "\n"); (normalized, status.exit_code() as i32) } /// Execute a command through a shell wrapper /// /// This simulates what actually happens when users run `wt switch`, etc. in their shell: /// 1. The `wt` function is defined (from shell integration) /// 2. It sets WORKTRUNK_DIRECTIVE_CD_FILE /// 3. The wrapper reads the cd path after wt exits /// 4. Users see stdout/stderr output in real-time /// /// Now uses PTY interactive mode for consistent behavior and potential input echoing. /// /// Returns ShellOutput with combined output and exit code fn exec_through_wrapper( shell: &str, repo: &TestRepo, subcommand: &str, args: &[&str], ) -> ShellOutput { exec_through_wrapper_from(shell, repo, subcommand, args, repo.root_path()) } fn exec_through_wrapper_from( shell: &str, repo: &TestRepo, subcommand: &str, args: &[&str], working_dir: &std::path::Path, ) -> ShellOutput { // Delegate to interactive version with no input // This provides consistent PTY behavior across all tests exec_through_wrapper_interactive(shell, repo, subcommand, args, working_dir, &[]) } /// Execute a command through a shell wrapper with interactive input support /// /// This is similar to `exec_through_wrapper_from` but allows sending input during execution /// (e.g., approval responses). The PTY will automatically echo the input, so you'll see /// both the prompts and the responses in the captured output. /// /// # Arguments /// * `shell` - The shell to use (e.g., "bash", "zsh", "fish") /// * `repo` - The test repository /// * `subcommand` - The wt subcommand (e.g., "merge", "switch") /// * `args` - Arguments to the subcommand (without --yes) /// * `working_dir` - Working directory for the command /// * `inputs` - Input strings to send (e.g., `&["y\n"]` for approval prompts) /// /// # Example /// ```no_run /// // Test merge with approval prompt visible in output /// let output = exec_through_wrapper_interactive( /// "bash", /// &repo, /// "merge", /// &["main"], /// repo.root_path(), /// &["y\n"], // Approve the merge /// ); /// // Output will show: "❓ Allow and remember? [y/N] y" /// ``` #[cfg(test)] fn exec_through_wrapper_interactive( shell: &str, repo: &TestRepo, subcommand: &str, args: &[&str], working_dir: &std::path::Path, inputs: &[&str], ) -> ShellOutput { exec_through_wrapper_with_env(shell, repo, subcommand, args, working_dir, inputs, &[]) } /// Execute a command through a shell wrapper with custom environment variables /// /// Like `exec_through_wrapper_interactive` but allows additional env vars to be set. /// Useful for tests that need custom PATH (e.g., for mock binaries). #[cfg(test)] fn exec_through_wrapper_with_env( shell: &str, repo: &TestRepo, subcommand: &str, args: &[&str], working_dir: &std::path::Path, inputs: &[&str], extra_env: &[(&str, &str)], ) -> ShellOutput { let script = build_shell_script(shell, repo, subcommand, args); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let mut env_vars = build_test_env_vars(&config_path, &approvals_path); // Add extra env vars (these can override defaults if needed) env_vars.extend(extra_env.iter().copied()); let (combined, exit_code) = exec_in_pty_interactive(shell, &script, working_dir, &env_vars, inputs); ShellOutput { combined, exit_code, } } /// Build the per-test half of a shell-wrapper PTY environment. /// /// The determinism baselines come from [`crate::common::configure_pty_command`], /// which `exec_in_pty_shell` applies first; these are what it can't supply — /// the paths pointing wt at this test's fixture, a git identity for the /// commits the scripts make, and a `TERM` with real terminfo. The caller must /// keep both path strings alive for the duration of the returned Vec's use. #[cfg(test)] fn build_test_env_vars<'a>( config_path: &'a str, approvals_path: &'a str, ) -> Vec<(&'a str, &'a str)> { vec![ ("WORKTRUNK_CONFIG_PATH", config_path), ("WORKTRUNK_APPROVALS_PATH", approvals_path), ("TERM", "xterm"), ("GIT_AUTHOR_NAME", "Test User"), ("GIT_AUTHOR_EMAIL", "test@example.com"), ("GIT_COMMITTER_NAME", "Test User"), ("GIT_COMMITTER_EMAIL", "test@example.com"), ("GIT_AUTHOR_DATE", "2025-01-01T00:00:00Z"), ("GIT_COMMITTER_DATE", "2025-01-01T00:00:00Z"), ] } // ============================================================================= // Unix Shell Tests (bash/zsh/fish) // ============================================================================= // // All Unix shell integration tests are in this module, gated by #[cfg(unix)]. // This includes tests for bash, zsh, and fish shells. // // Shared infrastructure (exec_through_wrapper, ShellOutput, etc.) is defined // above and works on both platforms. #[cfg(unix)] mod unix_tests { use super::*; use crate::common::repo; use rstest::rstest; /// Errexit must wait for cleanup, and a failed CD must retain child failure. #[rstest] #[case("bash", "/bin/bash")] #[case("bash", "bash")] #[case("zsh", "zsh")] fn wrapper_errexit_preserves_status_and_cleanup( repo: TestRepo, #[case] shell: &str, #[case] executable: &str, ) { use std::os::unix::fs::PermissionsExt; let temporary = repo.root_path().join("wrapper-temps"); fs::create_dir(&temporary).unwrap(); let child = repo.root_path().join("failing-child"); fs::write( &child, "#!/bin/sh\nprintf '%s' \"$WORKTRUNK_TEST_WRAPPER_MISSING\" > \"$WORKTRUNK_DIRECTIVE_CD_FILE\"\nexit 3\n", ) .unwrap(); fs::set_permissions(&child, fs::Permissions::from_mode(0o755)).unwrap(); // An explicit template keeps mktemp inside the fixture on every OS. let script = format!( "{}\nmktemp() {{ command mktemp \"$WORKTRUNK_TEST_WRAPPER_TEMP/XXXXXX\"; }}\nset -e\nwt\nprintf UNREACHABLE\n", generate_wrapper(&repo, shell) ); let mut command = Command::new(executable); repo.configure_wt_cmd(&mut command); let output = command .args(["-c", &script]) .env("WORKTRUNK_BIN", &child) .env("WORKTRUNK_TEST_WRAPPER_TEMP", &temporary) .env( "WORKTRUNK_TEST_WRAPPER_MISSING", repo.root_path().join("missing"), ) .output() .unwrap(); assert_eq!(output.status.code(), Some(3), "{output:?}"); assert!(!String::from_utf8_lossy(&output.stdout).contains("UNREACHABLE")); assert_eq!(fs::read_dir(temporary).unwrap().count(), 0); } // ======================================================================== // Cross-Shell Error Handling Tests // ======================================================================== // // These tests use parametrized testing to verify consistent behavior // across all supported shells (bash, zsh, fish). // // Note: Zsh tests run in isolated mode (--no-rcs, ZDOTDIR=/dev/null) to prevent // user startup files from touching /dev/tty, which would cause SIGTTIN/TTOU/TSTP // signals. This isolation ensures tests are deterministic across all environments. // // SNAPSHOT CONSOLIDATION: // Tests use `insta::allow_duplicates!` to share a single snapshot across all shells // when output is deterministic and identical. This reduces snapshot count from 3×N to N. // // Trade-off: If future changes introduce shell-specific output differences, all three // shells will fail with "doesn't match snapshot" rather than showing which specific // shell differs. For tests with non-deterministic output (PTY buffering causes varying // order), we keep shell-specific snapshots. // // TODO: Consider adding a test assertion that compares bash/zsh/fish outputs are // byte-identical before the snapshot check, so we can identify which shell diverged. #[rstest] #[case("bash")] #[case("zsh")] #[case("fish")] #[case("nu")] fn test_wrapper_handles_command_failure(#[case] shell: &str, mut repo: TestRepo) { // Create a worktree that already exists repo.add_worktree("existing"); // Try to create it again - should fail let output = exec_through_wrapper(shell, &repo, "switch", &["--create", "existing"]); // Shell-agnostic assertions: these must be true for ALL shells assert_eq!( output.exit_code, 1, "{}: Command should fail with exit code 1", shell ); output.assert_no_directive_leaks(); assert!( output.combined.contains("already exists"), "{}: Error message should mention 'already exists'.\nOutput:\n{}", shell, output.combined ); // Consolidated snapshot - output should be identical across all shells shell_wrapper_settings().bind(|| { insta::allow_duplicates! { assert_snapshot!("command_failure", &output.combined); } }); } /// The nushell wrapper reports a failing `wt` without spawning a POSIX shell. /// /// `Shell::Nushell` is not platform-gated — `wt config shell install` writes /// this wrapper on Windows whenever `nu` is on PATH, and stock Windows has no /// `sh`. Exit-code propagation runs on *every* failing `wt` command, so a `sh` /// dependency there appended a ``Command `sh` not found`` trace (printing the /// wrapper's own source) to each one and flattened the real exit code to 1 /// (#3944). /// /// Restricting PATH to `nu` and `git` reproduces the only property of Windows /// that this path depends on — no POSIX shell to spawn — so the regression is /// covered on the Unix runners where the nushell wrapper is actually tested. #[rstest] fn test_nushell_wrapper_needs_no_posix_shell(mut repo: TestRepo) { repo.add_worktree("existing"); // A PATH with no `sh`/`bash`/`dash`: just nushell, git, the command run // by `--execute`, and the `rm` used by the wrapper's Unix cleanup branch. // Dropping `rm` would leak every // `mktemp` file, silently — the branch is wrapped in `try` — and would // also make the test less faithful to the platform it stands in for: // Windows takes the `$nu.os-info.family` branch, where cleanup uses the // nushell builtin and does run. let bin_dir = tempfile::tempdir().unwrap(); for tool in ["nu", "git", "rm", "printf"] { let resolved = which::which(tool) .unwrap_or_else(|e| panic!("{tool} must be installed to run tests: {e}")); std::os::unix::fs::symlink(resolved, bin_dir.path().join(tool)).unwrap(); } let sanitized_path = bin_dir.path().display().to_string(); // Re-creating an existing branch fails, so the wrapper takes its // exit-code propagation branch. let output = exec_through_wrapper_with_env( "nu", &repo, "switch", &["--create", "existing"], repo.root_path(), &[], &[("PATH", &sanitized_path)], ); assert_eq!( output.exit_code, 1, "failure should propagate as exit 1.\nOutput:\n{}", output.combined ); assert!( output.combined.contains("already exists"), "wt's own error should still reach the terminal.\nOutput:\n{}", output.combined ); // The shape the bug produced: nushell rendering a spawn failure for the // wrapper's internals on top of wt's error. assert!( !output.combined.contains("External command failed") && !output.combined.contains("not found"), "wrapper leaked a nushell external-command error.\nOutput:\n{}", output.combined ); // The other half of the bug: a failed spawn flattens every exit code to // 1, so an exit-1 command can't tell the two templates apart. `wt config // alias show ` exits 2 entirely inside wt (`unknown_alias_error` // in `src/commands/config/alias.rs`), so the code only survives if the // wrapper's propagation command actually ran. let output = exec_through_wrapper_with_env( "nu", &repo, "config", &["alias", "show", "no-such-alias"], repo.root_path(), &[], &[("PATH", &sanitized_path)], ); assert_eq!( output.exit_code, 2, "wt's exit code should propagate unchanged, not flatten to 1.\nOutput:\n{}", output.combined ); assert!( !output.combined.contains("External command failed") && !output.combined.contains("not found"), "wrapper leaked a nushell external-command error.\nOutput:\n{}", output.combined ); // `--execute` uses the same shell-free path. let output = exec_through_wrapper_with_env( "nu", &repo, "switch", &[ "--create", "nu-exec-no-sh", "--execute", "printf", "--", "NU_EXEC_OK", ], repo.root_path(), &[], &[("PATH", &sanitized_path)], ); assert_eq!(output.exit_code, 0, "Output:\n{}", output.combined); assert!( output.combined.contains("NU_EXEC_OK"), "directly executed program output is missing.\nOutput:\n{}", output.combined ); assert!( !output.combined.contains("Command `sh` not found"), "wrapper tried to introduce an implicit POSIX shell.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); } #[rstest] #[case("bash")] #[case("zsh")] #[case("fish")] #[case("nu")] fn test_wrapper_switch_create(#[case] shell: &str, repo: TestRepo) { let branch = "feature/with-dashes_and_underscores"; let output = exec_through_wrapper(shell, &repo, "switch", &["--create", branch]); // Shell-agnostic assertions assert_eq!(output.exit_code, 0, "{}: Command should succeed", shell); output.assert_no_directive_leaks(); output.assert_no_job_control_messages(); assert!( output.combined.contains("Created branch") && output.combined.contains(branch) && output.combined.contains("and worktree"), "{shell}: Should create the exact branch passed through the wrapper" ); // Consolidated snapshot - output should be identical across all shells shell_wrapper_settings().bind(|| { insta::allow_duplicates! { assert_snapshot!("switch_create", &output.combined); } }); } /// A user's `alias rm = ...` must not intercept the nushell wrapper's /// temp-file cleanup. /// /// Nushell resolves aliases at parse time, and `config.nu` runs before the /// vendor autoload dir the wrapper is installed into — so an alias declared /// there is already in scope when the wrapper's `def` is parsed. Before the /// fix, an alias that exits non-zero raised a ShellError mid-cleanup that /// aborted the wrapper before it returned the command's stdout, and left /// every temp file behind. `^false` stands in for the realistic aliases /// (`trash`, a wrapper that prompts, one that isn't installed on this box). /// /// The POSIX wrappers use `command rm` for the same reason; nushell has no /// `command` builtin, so the template branches on `$nu.os-info.family`. #[rstest] fn test_nu_wrapper_cleanup_survives_rm_alias(repo: TestRepo) { // A dedicated TMPDIR so the wrapper's `mktemp` files are the only // occupants, and a leak is directly observable. let tmp = tempfile::tempdir().unwrap(); let tmp_path = tmp.path().to_string_lossy().to_string(); let mut script = String::new(); // Must precede the wrapper's `def`: alias resolution is parse-time. script.push_str("alias rm = ^false\n"); append_wrapper_setup(&mut script, "nu", &repo); // `config show` writes to stdout, which the wrapper returns as the // function's value — the part a mid-cleanup abort swallows. `switch` // wouldn't show it: its output is on stderr, which streams to the // terminal before cleanup runs either way. script.push_str("let out = (wt config show)\n"); script.push_str("print $\"WRAPPER_STDOUT_EMPTY:($out | is-empty)\"\n"); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let mut env_vars = build_test_env_vars(&config_path, &approvals_path); env_vars.push(("TMPDIR", &tmp_path)); let (combined, exit_code) = exec_in_pty_interactive("nu", &script, repo.root_path(), &env_vars, &[]); assert!( combined.contains("WRAPPER_STDOUT_EMPTY:false"), "wrapper returned no stdout — the marker is missing entirely when cleanup \ aborted the wrapper, and reads `true` when it returned an empty value.\nOutput:\n{combined}" ); assert_eq!(exit_code, 0, "Output:\n{combined}"); let leftover: Vec<_> = fs::read_dir(tmp.path()) .unwrap() .map(|e| e.unwrap().file_name()) .collect(); assert!( leftover.is_empty(), "wrapper leaked temp files past cleanup: {leftover:?}" ); } #[rstest] fn test_nu_wrapper_ignores_execute_flags_after_argument_boundary(repo: TestRepo) { let mut script = String::new(); append_wrapper_setup(&mut script, "nu", &repo); // Nu 0.113 passes unquoted wrapped words as glob values. Keep that // native argument type explicit on newer Nu versions too. script.push_str( "let subcommand = (\"step\" | into glob)\n\ let out = (wt $subcommand for-each --format=json -- printf -- -x)\n\ print $\"PIPELINE_CAPTURED:(not ($out | is-empty))\"\n", ); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let env_vars = build_test_env_vars(&config_path, &approvals_path); let (combined, exit_code) = exec_in_pty_interactive("nu", &script, repo.root_path(), &env_vars, &[]); assert_eq!(exit_code, 0, "Output:\n{combined}"); assert!( combined.contains("PIPELINE_CAPTURED:true"), "-x after -- should not disable Nushell pipeline capture.\nOutput:\n{combined}" ); } #[rstest] #[case("bash")] #[case("zsh")] #[case("fish")] #[case("nu")] fn test_wrapper_switch_with_execute(#[case] shell: &str, repo: TestRepo) { let args = if shell == "nu" { vec![ "-cx", "sh", "test-exec", "--yes", "--", "-c", "test -t 1 && printf 'EXEC_STDOUT_TTY:true\\n'", ] } else { vec![ "--create", "test-exec", "--yes", "--execute", "sh", "--", "-c", "test -t 1 && printf 'EXEC_STDOUT_TTY:true\\n'", ] }; // The child must inherit a real terminal, including through Nushell's // normally-buffered wrapper path. Its case uses the valid `-cx` // cluster so execute detection follows clap's short-option parsing. let output = exec_through_wrapper_with_env( shell, &repo, "switch", &args, repo.root_path(), &[], &[("WORKTRUNK_DIRECTIVE_EXEC_FILE", "retired")], ); // Shell-agnostic assertions assert_eq!( output.exit_code, 0, "{}: Command should succeed\nOutput:\n{}", shell, output.combined ); output.assert_no_directive_leaks(); assert!( output.combined.contains("EXEC_STDOUT_TTY:true"), "{}: execute child did not inherit terminal stdout", shell ); assert!( !output.combined.contains("Shell wrapper is out of date"), "{shell}: a stale wrapper with terminal stdout should not warn" ); // Keep one snapshot per wrapper implementation: all consume the same // argv protocol, but their PTY echo can still differ. shell_wrapper_settings().bind(|| { assert_snapshot!(format!("switch_with_execute_{shell}"), &output.combined); }); } /// Test that --execute command exit codes are propagated /// Verifies that when wt succeeds but the --execute command fails, /// the wrapper returns the command's exit code, not wt's. #[rstest] #[case("bash")] #[case("zsh")] #[case("fish")] #[case("nu")] fn test_wrapper_execute_exit_code_propagation(#[case] shell: &str, repo: TestRepo) { // Use --yes to skip approval prompt in tests // wt should succeed (creates worktree), but the execute command should fail with exit 42 let output = exec_through_wrapper( shell, &repo, "switch", &[ "--create", "test-exit-code", "--yes", "--execute", "sh", "--", "-c", "exit 42", ], ); // Shell-agnostic assertions assert_eq!( output.exit_code, 42, "{}: Should propagate execute command's exit code (42), not wt's (0)", shell ); output.assert_no_directive_leaks(); // Should still show wt's success message (worktree was created) assert!( output.combined.contains("Created branch") && output.combined.contains("and worktree"), "{}: Should show wt's success message even though execute command failed", shell ); } /// A failing `--execute` body must not abort the nushell wrapper before its /// cleanup runs. /// /// Nushell 0.98+ raises a `ShellError` on a non-zero external exit, so a /// failing program can unwind the whole `def` unless the wrapper catches /// it before cleanup — the temp files leaked and the stdout the function still had to return was /// discarded. `test_wrapper_execute_exit_code_propagation` covers the same /// command and passes either way: the unwind *happens* to carry exit 42 out /// to the shell, which is all that test asserts. So the leak sat on a path /// with coverage, and the assertion that distinguishes the two is whether the /// wrapper reached its own end — observable here as an empty `TMPDIR`. /// /// The wrapper's terminal `^$nu.current-exe -c $"exit ($exit_code)"` is /// *meant* to abort the caller, since that's how the code propagates; the /// driving script wraps the call in nushell's own `try` so that intended /// propagation doesn't hide whether cleanup ran first. #[rstest] fn test_nu_wrapper_execute_failure_runs_cleanup(repo: TestRepo) { // A dedicated TMPDIR so the wrapper's `mktemp` files are the only // occupants and a leak is directly observable. let tmp = tempfile::tempdir().unwrap(); let tmp_path = tmp.path().to_string_lossy().to_string(); let mut script = String::new(); append_wrapper_setup(&mut script, "nu", &repo); script.push_str( "let code = (try { wt switch --create exec-abort --yes --execute sh -- -c \"exit 42\"; 0 } catch { $env.LAST_EXIT_CODE })\n", ); script.push_str("print $\"WT_EXIT:($code)\"\n"); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let mut env_vars = build_test_env_vars(&config_path, &approvals_path); env_vars.push(("TMPDIR", &tmp_path)); let (combined, _) = exec_in_pty_interactive("nu", &script, repo.root_path(), &env_vars, &[]); // The body's exit code still reaches the caller — the contract // `test_wrapper_execute_exit_code_propagation` pins, now carried by the // wrapper's own propagation rather than by the unwind. assert!( combined.contains("WT_EXIT:42"), "wrapper should propagate the --execute body's exit code (42).\nOutput:\n{combined}" ); let leftover: Vec<_> = fs::read_dir(tmp.path()) .unwrap() .map(|e| e.unwrap().file_name()) .collect(); assert!( leftover.is_empty(), "wrapper aborted before cleanup and leaked temp files: {leftover:?}\nOutput:\n{combined}" ); } /// A failed directive must still release both wrapper temp files. #[rstest] fn test_nu_wrapper_cd_failure_runs_cleanup(repo: TestRepo) { use std::os::unix::fs::PermissionsExt; let tmp = tempfile::tempdir().unwrap(); let executable = repo.root_path().join("invalid-directive"); fs::write( &executable, "#!/bin/sh\nprintf '%s' \"$PWD/missing-directory\" > \"$WORKTRUNK_DIRECTIVE_CD_FILE\"\n", ) .unwrap(); fs::set_permissions(&executable, fs::Permissions::from_mode(0o755)).unwrap(); let mut script = String::new(); append_wrapper_setup(&mut script, "nu", &repo); script.push_str(&format!( "$env.WORKTRUNK_BIN = {}\nwt config show\n", nushell_quote(&executable.to_string_lossy()), )); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let tmp_path = tmp.path().to_string_lossy().to_string(); let mut env_vars = build_test_env_vars(&config_path, &approvals_path); env_vars.push(("TMPDIR", &tmp_path)); let (combined, exit_code) = exec_in_pty_interactive("nu", &script, repo.root_path(), &env_vars, &[]); assert_ne!(exit_code, 0, "invalid directive should fail: {combined}"); assert!(combined.contains("missing-directory"), "{combined}"); assert_eq!(fs::read_dir(tmp.path()).unwrap().count(), 0, "{combined}"); } /// Redirecting the wrapper's stdout must not abort it when the command /// prints nothing there. Under `o>`, Nushell fails to convert a /// `try … finally` that evaluates to nothing, and the script stopped /// after the directory change was lost. #[rstest] fn test_nu_wrapper_redirected_stdout_applies_cd(mut repo: TestRepo) { repo.add_worktree("nu-redirect"); let target = canonicalize(repo.worktree_path("nu-redirect")).unwrap(); let mut script = String::new(); append_wrapper_setup(&mut script, "nu", &repo); script.push_str(&format!( "wt switch nu-redirect o> /dev/null\nprint $\"WT_CD:($env.PWD == {})\"\n", nushell_quote(&target.to_string_lossy()), )); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let env_vars = build_test_env_vars(&config_path, &approvals_path); let (combined, exit_code) = exec_in_pty_interactive("nu", &script, repo.root_path(), &env_vars, &[]); assert_eq!(exit_code, 0, "Output:\n{combined}"); assert!(combined.contains("WT_CD:true"), "Output:\n{combined}"); } /// Native signal deaths must cross Nushell's negative-status boundary /// before the wrapper propagates the status, after applying CD and cleanup. #[rstest] fn test_nu_wrapper_signal_status_runs_cleanup(mut repo: TestRepo) { repo.add_worktree("nu-signal"); let target = canonicalize(repo.worktree_path("nu-signal")).unwrap(); let tmp = tempfile::tempdir().unwrap(); let tmp_path = tmp.path().to_string_lossy().to_string(); let mut script = String::new(); append_wrapper_setup(&mut script, "nu", &repo); for (body, expected) in [ ("kill -INT $$", 130), ("kill -TERM $$", 143), ("exit 130", 130), ("exit 143", 143), ] { script.push_str(&format!( "let code = (try {{ wt switch nu-signal --yes --execute sh -- -c {}; 0 }} catch {{ $env.LAST_EXIT_CODE }})\nprint $\"WT_EXIT:($code)\"\nprint $\"WT_CD:($env.PWD == {})\"\n", nushell_quote(body), nushell_quote(&target.to_string_lossy()), )); // Each iteration starts outside the destination, so every call // must apply the directive before propagating its failure. script.push_str(&format!( "cd {}\n", nushell_quote(&repo.root_path().to_string_lossy()) )); script.push_str(&format!( "if $code != {expected} {{ error make {{ msg: $\"unexpected wrapper status: ($code)\" }} }}\n" )); } let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let mut env_vars = build_test_env_vars(&config_path, &approvals_path); env_vars.push(("TMPDIR", &tmp_path)); let (combined, exit_code) = exec_in_pty_interactive("nu", &script, repo.root_path(), &env_vars, &[]); assert_eq!(exit_code, 0, "Output:\n{combined}"); assert_eq!(combined.matches("WT_CD:true").count(), 4, "{combined}"); assert_eq!(combined.matches("WT_EXIT:130").count(), 2, "{combined}"); assert_eq!(combined.matches("WT_EXIT:143").count(), 2, "{combined}"); assert_eq!(fs::read_dir(tmp.path()).unwrap().count(), 0, "{combined}"); } /// Test switch --create with pre-start (blocking) and post-start (background) /// Note: bash and fish disabled due to flaky PTY buffering race conditions /// /// TODO: Fix timing/race condition in bash where "Building project..." output appears /// before the command display, causing snapshot mismatch (appears on line 7 instead of line 9). /// This is a non-deterministic PTY output ordering issue. #[rstest] // #[case("bash")] // TODO: Flaky PTY output ordering - command output appears before command display #[case("zsh")] // #[case("fish")] // TODO: Fish shell has non-deterministic PTY output ordering fn test_wrapper_switch_with_hooks(#[case] shell: &str, repo: TestRepo) { // Create project config with both pre-start and post-start hooks let config_dir = repo.root_path().join(".config"); fs::create_dir_all(&config_dir).unwrap(); fs::write( config_dir.join("wt.toml"), r#"# Blocking commands that run before worktree is ready pre-start = [ {install = "echo 'Installing dependencies...'"}, {build = "echo 'Building project...'"}, ] # Background commands that run in parallel [post-start] server = "echo 'Starting dev server on port 3000'" watch = "echo 'Watching for file changes'" "#, ) .unwrap(); repo.commit("Add hooks"); // Pre-approve the commands repo.write_test_approvals( r#"[projects."../origin"] approved-commands = [ "echo 'Installing dependencies...'", "echo 'Building project...'", "echo 'Starting dev server on port 3000'", "echo 'Watching for file changes'", ] "#, ); let output = exec_through_wrapper(shell, &repo, "switch", &["--create", "feature-hooks"]); assert_eq!(output.exit_code, 0, "{}: Command should succeed", shell); output.assert_no_directive_leaks(); // Shell-specific snapshot - output ordering varies due to PTY buffering shell_wrapper_settings().bind(|| { assert_snapshot!(format!("switch_with_hooks_{}", shell), &output.combined); }); } /// Test merge with successful pre-merge validation /// Note: fish disabled due to flaky PTY buffering race conditions /// TODO: bash variant occasionally fails on Ubuntu CI with snapshot mismatches due to PTY timing #[rstest] #[case("bash")] #[case("zsh")] // #[case("fish")] // TODO: Fish shell has non-deterministic PTY output ordering fn test_wrapper_merge_with_pre_merge_success(#[case] shell: &str, mut repo: TestRepo) { // Create project config with pre-merge validation let config_dir = repo.root_path().join(".config"); fs::create_dir_all(&config_dir).unwrap(); fs::write( config_dir.join("wt.toml"), r#"pre-merge = [ {format = "echo '✓ Code formatting check passed'"}, {lint = "echo '✓ Linting passed - no warnings'"}, {test = "echo '✓ All 47 tests passed in 2.3s'"}, ] "#, ) .unwrap(); repo.commit("Add pre-merge validation"); let feature_wt = repo.add_feature(); // Suppress commit generation prompt (fires in PTY when claude is on PATH) repo.write_test_config(""); // Pre-approve commands repo.write_test_approvals( r#"[projects."../origin"] approved-commands = [ "echo '✓ Code formatting check passed'", "echo '✓ Linting passed - no warnings'", "echo '✓ All 47 tests passed in 2.3s'", ] "#, ); // Run merge from the feature worktree let output = exec_through_wrapper_from(shell, &repo, "merge", &["main", "--yes"], &feature_wt); assert_eq!(output.exit_code, 0, "{}: Merge should succeed", shell); output.assert_no_directive_leaks(); // Shell-specific snapshot - output ordering varies due to PTY buffering shell_wrapper_settings().bind(|| { assert_snapshot!( format!("merge_with_pre_merge_success_{}", shell), &output.combined ); }); } /// Test merge with failing pre-merge that aborts the merge /// Note: fish disabled due to flaky PTY buffering race conditions #[rstest] #[case("bash")] #[case("zsh")] // #[case("fish")] // TODO: Fish shell has non-deterministic PTY output ordering fn test_wrapper_merge_with_pre_merge_failure(#[case] shell: &str, mut repo: TestRepo) { // Create project config with failing pre-merge validation let config_dir = repo.root_path().join(".config"); fs::create_dir_all(&config_dir).unwrap(); fs::write( config_dir.join("wt.toml"), r#"pre-merge = [ {format = "echo '✓ Code formatting check passed'"}, {test = "echo '✗ Test suite failed: 3 tests failing' && exit 1"}, ] "#, ) .unwrap(); repo.commit("Add failing pre-merge validation"); // Suppress commit generation prompt (fires in PTY when claude is on PATH) repo.write_test_config(""); // Create feature worktree with a commit let feature_wt = repo.add_worktree_with_commit( "feature-fail", "feature.txt", "feature content", "Add feature", ); // Pre-approve the commands repo.write_test_approvals( r#"[projects."../origin"] approved-commands = [ "echo '✓ Code formatting check passed'", "echo '✗ Test suite failed: 3 tests failing' && exit 1", ] "#, ); // Run merge from the feature worktree let output = exec_through_wrapper_from(shell, &repo, "merge", &["main", "--yes"], &feature_wt); output.assert_no_directive_leaks(); // Shell-specific snapshot - output ordering varies due to PTY buffering shell_wrapper_settings().bind(|| { assert_snapshot!( format!("merge_with_pre_merge_failure_{}", shell), &output.combined ); }); } /// Test merge with pre-merge commands that output to both stdout and stderr /// Verifies that interleaved stdout/stderr appears in correct temporal order /// Note: fish disabled due to flaky PTY buffering race conditions #[rstest] #[case("bash")] #[case("zsh")] // #[case("fish")] // TODO: Fish shell has non-deterministic PTY output ordering fn test_wrapper_merge_with_mixed_stdout_stderr(#[case] shell: &str, mut repo: TestRepo) { // Copy the fixture script to the test repo to avoid path issues with special characters // (CARGO_MANIFEST_DIR may contain single quotes like worktrunk.'∅' which break shell parsing) let fixtures_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures"); let script_content = fs::read(fixtures_dir.join("mixed-output.sh")).unwrap(); let script_path = repo.root_path().join("mixed-output.sh"); fs::write(&script_path, &script_content).unwrap(); // Make the script executable #[cfg(unix)] { use std::os::unix::fs::PermissionsExt; fs::set_permissions(&script_path, fs::Permissions::from_mode(0o755)).unwrap(); } // Create project config with pre-merge commands that output to both stdout and stderr. // Use relative path (./mixed-output.sh) instead of absolute temp path to avoid flaky // snapshot matching on macOS where _REPO_ filter can intermittently fail to match // absolute paths inside syntax-highlighted format_bash_with_gutter output, causing // the broader [PROJECT_ID] catch-all to consume the entire path. let config_dir = repo.root_path().join(".config"); fs::create_dir_all(&config_dir).unwrap(); fs::write( config_dir.join("wt.toml"), r#"pre-merge = [ {check1 = "./mixed-output.sh check1 3"}, {check2 = "./mixed-output.sh check2 3"}, ] "#, ) .unwrap(); repo.commit("Add pre-merge validation with mixed output"); let feature_wt = repo.add_feature(); repo.write_test_config(r#"worktree-path = "../{{ repo }}.{{ branch }}""#); // Pre-approve commands repo.write_test_approvals( r#"[projects."../origin"] approved-commands = [ "./mixed-output.sh check1 3", "./mixed-output.sh check2 3", ] "#, ); // Run merge from the feature worktree let output = exec_through_wrapper_from(shell, &repo, "merge", &["main", "--yes"], &feature_wt); assert_eq!(output.exit_code, 0, "{}: Merge should succeed", shell); output.assert_no_directive_leaks(); // Verify output shows proper temporal ordering: // header1 → all check1 output (interleaved stdout/stderr) → header2 → all check2 output // This ensures that stdout/stderr from child processes properly stream through // to the terminal in real-time, maintaining correct ordering shell_wrapper_settings().bind(|| { assert_snapshot!( format!("merge_with_mixed_stdout_stderr_{}", shell), &output.combined ); }); } // ======================================================================== // Bash Shell Wrapper Tests // ======================================================================== #[rstest] fn test_switch_with_post_start_command_no_directive_leak(repo: TestRepo) { // Configure a post-start command in the project config (this is where the bug manifests) // The println! in handle_post_start_commands causes directive leaks let config_dir = repo.root_path().join(".config"); fs::create_dir_all(&config_dir).unwrap(); fs::write( config_dir.join("wt.toml"), r#"post-start = "echo 'test command executed'""#, ) .unwrap(); repo.commit("Add post-start command"); // Pre-approve the command repo.write_test_approvals( r#"[projects."../origin"] approved-commands = ["echo 'test command executed'"] "#, ); let output = exec_through_wrapper("bash", &repo, "switch", &["--create", "feature-with-hooks"]); // The critical assertion: directives must never appear in user-facing output // This is where the bug occurs - "🔄 Starting (background):" is printed with println! // which causes it to concatenate with the directive output.assert_no_directive_leaks(); output.assert_no_job_control_messages(); output.assert_success(); // Normalize paths in output for snapshot testing // Snapshot the output shell_wrapper_settings().bind(|| assert_snapshot!(&output.combined)); } #[rstest] fn test_switch_with_execute_through_wrapper(repo: TestRepo) { // Use --yes to skip approval prompt in tests let output = exec_through_wrapper( "bash", &repo, "switch", &[ "--create", "test-exec", "--yes", "--execute", "echo", "--", "executed", ], ); // No directives should leak output.assert_no_directive_leaks(); output.assert_success(); // The executed command output should appear assert!( output.combined.contains("executed"), "Execute command output missing" ); // Normalize paths in output for snapshot testing // Snapshot the output shell_wrapper_settings().bind(|| assert_snapshot!(&output.combined)); } #[rstest] fn test_bash_shell_integration_hint_suppressed(repo: TestRepo) { // When running through the shell wrapper, the "To enable automatic cd" hint // should NOT appear because the user already has shell integration let output = exec_through_wrapper("bash", &repo, "switch", &["--create", "bash-test"]); // Critical: shell integration hint must be suppressed when shell integration is active assert!( !output.combined.contains("To enable automatic cd"), "Shell integration hint should not appear when running through wrapper. Output:\n{}", output.combined ); // Should still have the success message assert!( output.combined.contains("Created branch") && output.combined.contains("and worktree"), "Success message missing" ); shell_wrapper_settings().bind(|| assert_snapshot!(&output.combined)); } #[rstest] fn test_readme_example_simple_switch(repo: TestRepo) { // Create worktree through shell wrapper (suppresses hint) let output = exec_through_wrapper("bash", &repo, "switch", &["--create", "fix-auth"]); assert!( !output.combined.contains("To enable automatic cd"), "Shell integration hint should be suppressed" ); shell_wrapper_settings().bind(|| assert_snapshot!(&output.combined)); } #[rstest] fn test_readme_example_switch_back(repo: TestRepo) { // Create worktrees (fix-auth is where we are after step 2, feature-api exists from earlier) exec_through_wrapper("bash", &repo, "switch", &["--create", "fix-auth"]); // Create feature-api from main (simulating it already existed) exec_through_wrapper("bash", &repo, "switch", &["--create", "feature-api"]); // Switch to feature-api from fix-auth (showing navigation between worktrees) let fix_auth_path = repo.root_path().parent().unwrap().join("repo.fix-auth"); let output = exec_through_wrapper_from("bash", &repo, "switch", &["feature-api"], &fix_auth_path); assert!( !output.combined.contains("To enable automatic cd"), "Shell integration hint should be suppressed" ); shell_wrapper_settings().bind(|| assert_snapshot!(&output.combined)); } #[rstest] fn test_readme_example_remove(repo: TestRepo) { // Create worktrees exec_through_wrapper("bash", &repo, "switch", &["--create", "fix-auth"]); exec_through_wrapper("bash", &repo, "switch", &["--create", "feature-api"]); // Remove feature-api from within it (current worktree removal) let feature_api_path = repo.root_path().parent().unwrap().join("repo.feature-api"); let output = exec_through_wrapper_from("bash", &repo, "remove", &[], &feature_api_path); assert!( !output.combined.contains("To enable automatic cd"), "Shell integration hint should be suppressed" ); shell_wrapper_settings().bind(|| assert_snapshot!(&output.combined)); } #[rstest] fn test_wrapper_preserves_progress_messages(repo: TestRepo) { // Configure a post-start background command that will trigger progress output let config_dir = repo.root_path().join(".config"); fs::create_dir_all(&config_dir).unwrap(); fs::write( config_dir.join("wt.toml"), r#"post-start = "echo 'background task'""#, ) .unwrap(); repo.commit("Add post-start command"); // Pre-approve the command repo.write_test_approvals( r#"[projects."../origin"] approved-commands = ["echo 'background task'"] "#, ); let output = exec_through_wrapper("bash", &repo, "switch", &["--create", "feature-bg"]); // No directives should leak output.assert_no_directive_leaks(); output.assert_success(); // Snapshot verifies progress messages appear to users // (catches the bug where progress() was incorrectly suppressed) shell_wrapper_settings().bind(|| assert_snapshot!(&output.combined)); } // ============================================================================ // Fish Shell Wrapper Tests // ============================================================================ // // These tests verify that the Fish shell wrapper correctly: // 1. Captures stdout (shell script) via command substitution and evals it // 2. Streams stderr (progress, success, hints) to terminal in real-time // 3. Never leaks shell script commands to users // 4. Preserves exit codes from both wt and executed commands // // Fish uses `string collect` to join command substitution output into // a single string before eval (fish splits on newlines by default). #[rstest] fn test_fish_wrapper_preserves_progress_messages(repo: TestRepo) { // Configure a post-start background command that will trigger progress output let config_dir = repo.root_path().join(".config"); fs::create_dir_all(&config_dir).unwrap(); fs::write( config_dir.join("wt.toml"), r#"post-start = "echo 'fish background task'""#, ) .unwrap(); repo.commit("Add post-start command"); // Pre-approve the command repo.write_test_approvals( r#"[projects."../origin"] approved-commands = ["echo 'fish background task'"] "#, ); let output = exec_through_wrapper("fish", &repo, "switch", &["--create", "fish-bg"]); // No directives should leak output.assert_no_directive_leaks(); output.assert_success(); // Snapshot verifies progress messages appear to users through Fish wrapper shell_wrapper_settings().bind(|| assert_snapshot!(&output.combined)); } #[rstest] fn test_fish_multiline_command_execution(repo: TestRepo) { // Shell behavior remains available when requested explicitly. let multiline_cmd = "echo 'line 1'; echo 'line 2'; echo 'line 3'"; // Use --yes to skip approval prompt in tests let output = exec_through_wrapper( "fish", &repo, "switch", &[ "--create", "fish-multiline", "--yes", "--execute", "fish", "--", "-c", multiline_cmd, ], ); // No directives should leak output.assert_no_directive_leaks(); output.assert_success(); // All three lines should be executed and visible assert!(output.combined.contains("line 1"), "First line missing"); assert!(output.combined.contains("line 2"), "Second line missing"); assert!(output.combined.contains("line 3"), "Third line missing"); // Normalize paths in output for snapshot testing shell_wrapper_settings().bind(|| assert_snapshot!(&output.combined)); } #[rstest] fn test_fish_wrapper_handles_empty_chunks(repo: TestRepo) { // Test edge case: command that produces minimal output // This verifies Fish's `test -n "$chunk"` check works correctly let output = exec_through_wrapper("fish", &repo, "switch", &["--create", "fish-minimal"]); // No directives should leak even with minimal output output.assert_no_directive_leaks(); output.assert_success(); // Should still show success message assert!( output.combined.contains("Created branch") && output.combined.contains("and worktree"), "Success message missing from minimal output" ); // Normalize paths in output for snapshot testing shell_wrapper_settings().bind(|| assert_snapshot!(&output.combined)); } // ======================================================================== // --source Flag Error Passthrough Tests // ======================================================================== // // These tests verify that actual error messages pass through correctly // when using the --source flag (instead of being hidden with generic // wrapper error messages like "Error: cargo build failed"). // Note: Nushell not included - this test builds custom scripts with bash syntax #[rstest] #[case("bash")] #[case("fish")] fn test_source_flag_forwards_errors(#[case] shell: &str, repo: TestRepo) { use std::env; use std::os::unix::fs::PermissionsExt; // Stub `cargo` instead of invoking the real one. The wrapper's // `--source` branch shells out to `cargo run --bin wt --quiet -- // `. Real cargo unlinks and re-links `target/debug/wt` on every // invocation (~4% non-existence window measured locally), which // races concurrent tests that `spawn(target/debug/wt)` and produces // ENOENT flakes on Linux CI. The stub strips the cargo args and // execs the existing wt binary directly — same end-to-end coverage // of error pass-through through the `--source` branch, no race. let stub_dir = repo.root_path().join("stub-bin"); fs::create_dir_all(&stub_dir).unwrap(); let stub_cargo = stub_dir.join("cargo"); let stub_marker = repo.root_path().join("cargo-stub-ran"); fs::write( &stub_cargo, "#!/bin/sh\nprintf invoked > \"$WORKTRUNK_TEST_CARGO_STUB_MARKER\"\nshift 5\nexec \"$WORKTRUNK_BIN\" \"$@\"\n", ) .unwrap(); fs::set_permissions(&stub_cargo, fs::Permissions::from_mode(0o755)).unwrap(); let stub_path = format!( "{}:{}", stub_dir.display(), env::var("PATH").unwrap_or_default() ); // Fish startup configuration can prepend PATH and displace the cargo // stub. Shell tests must bypass it, just as bash bypasses ~/.bashrc. let startup_bin = repo.home_path().join("startup-bin"); fs::create_dir_all(&startup_bin).unwrap(); let startup_cargo = startup_bin.join("cargo"); fs::write( &startup_cargo, "#!/bin/sh\necho 'unexpected startup cargo' >&2\nexit 23\n", ) .unwrap(); fs::set_permissions(&startup_cargo, fs::Permissions::from_mode(0o755)).unwrap(); let fish_config = repo.home_path().join(".config/fish"); fs::create_dir_all(&fish_config).unwrap(); fs::write( fish_config.join("config.fish"), format!( "fish_add_path {}\n", shell_quote(&startup_bin.to_string_lossy()) ), ) .unwrap(); // Get the worktrunk source directory (where this test is running from) // This is the directory that contains Cargo.toml with the workspace let worktrunk_source = canonicalize(&env::current_dir().unwrap()).unwrap(); // Build a shell script that runs from the worktrunk source directory let mut script = String::new(); append_wrapper_setup(&mut script, shell, &repo); // Try to run wt --source with an invalid subcommand. The wrapper // routes this through the stub `cargo`, which execs the real wt; // wt then fails with clap's "unrecognized subcommand" error. script.push_str("wt --source foo\n"); // Wrap in subshell to merge stderr let final_script = match shell { "fish" => format!("begin\n{}\nend 2>&1", script), _ => format!("( {} ) 2>&1", script), }; let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let stub_marker_path = stub_marker.to_string_lossy().to_string(); let fixture_home = repo.home_path().to_string_lossy().to_string(); let xdg_config = repo .home_path() .join(".config") .to_string_lossy() .to_string(); let env_vars: Vec<(&str, &str)> = vec![ ("HOME", &fixture_home), ("XDG_CONFIG_HOME", &xdg_config), ("PATH", &stub_path), ("WORKTRUNK_TEST_CARGO_STUB_MARKER", &stub_marker_path), ("CLICOLOR_FORCE", "1"), ("WORKTRUNK_CONFIG_PATH", &config_path), ("WORKTRUNK_APPROVALS_PATH", &approvals_path), ("TERM", "xterm"), ("GIT_AUTHOR_NAME", "Test User"), ("GIT_AUTHOR_EMAIL", "test@example.com"), ("GIT_COMMITTER_NAME", "Test User"), ("GIT_COMMITTER_EMAIL", "test@example.com"), ("GIT_AUTHOR_DATE", "2025-01-01T00:00:00Z"), ("GIT_COMMITTER_DATE", "2025-01-01T00:00:00Z"), ("LANG", "C"), ("LC_ALL", "C"), ("WORKTRUNK_TEST_EPOCH", "1735776000"), ]; // Run non-interactively: this test only checks that the `--source` // branch forwards wt's error, never job-control output. Skipping `-i` // avoids the interactive-shell startup wedge that flaked this test. let (combined, exit_code) = exec_in_pty_shell( shell, &final_script, &worktrunk_source, &env_vars, &[], false, ); let output = ShellOutput { combined, exit_code, }; assert!( stub_marker.exists(), "{shell}: --source must execute the cargo stub, not compile live source" ); // Shell-agnostic assertions assert_ne!(output.exit_code, 0, "{}: Command should fail", shell); // CRITICAL: Should see wt's actual error message about an unknown subcommand assert!( output.combined.contains("unrecognized subcommand"), "{}: Should show clap's 'unrecognized subcommand' error.\nOutput:\n{}", shell, output.combined ); // CRITICAL: Should NOT see the old generic wrapper error message assert!( !output.combined.contains("Error: cargo build failed"), "{}: Should not contain old generic error message", shell ); // Consolidated snapshot - output should be identical across shells // (wt error messages are deterministic) shell_wrapper_settings().bind(|| { insta::allow_duplicates! { assert_snapshot!("source_flag_error_passthrough", &output.combined); } }); } // ======================================================================== // Job Control Notification Tests // ======================================================================== // // These tests verify that job control notifications ([1] 12345, [1] + done) // don't leak into user output. Zsh suppresses these with NO_MONITOR, // bash shows them at the next prompt (less intrusive). /// Test that zsh doesn't show job control notifications inline /// The NO_MONITOR option should suppress [1] 12345 and [1] + done messages #[rstest] fn test_zsh_no_job_control_notifications(repo: TestRepo) { // Configure a post-start command that will trigger background job let config_dir = repo.root_path().join(".config"); fs::create_dir_all(&config_dir).unwrap(); fs::write( config_dir.join("wt.toml"), r#"post-start = "echo 'background job'""#, ) .unwrap(); repo.commit("Add post-start command"); // Pre-approve the command repo.write_test_approvals( r#"[projects."../origin"] approved-commands = ["echo 'background job'"] "#, ); let output = exec_through_wrapper("zsh", &repo, "switch", &["--create", "zsh-job-test"]); output.assert_success(); output.assert_no_directive_leaks(); // Critical: zsh should NOT show job control notifications // These patterns indicate job control messages leaked through assert!( !output.combined.contains("[1]"), "Zsh should suppress job control notifications with NO_MONITOR.\nOutput:\n{}", output.combined ); assert!( !output.combined.contains("+ done"), "Zsh should suppress job completion notifications.\nOutput:\n{}", output.combined ); } /// Test that bash job control messages are suppressed in true interactive mode /// /// Bash shows `[1]+ Done` notifications at prompt-time, not during script execution. /// To detect if they leak, we use `exec_bash_truly_interactive` which runs bash without /// `-c` and writes commands to the PTY, triggering prompts where notifications appear. /// /// The shell wrapper suppresses these via two mechanisms (see bash.sh/zsh.zsh templates): /// - START notifications (`[1] 12345`): stderr redirection around `&` /// - DONE notifications (`[1]+ Done`): `set +m` before backgrounding #[rstest] fn test_bash_job_control_suppression(repo: TestRepo) { // Configure a post-start command that will trigger background job let config_dir = repo.root_path().join(".config"); fs::create_dir_all(&config_dir).unwrap(); fs::write( config_dir.join("wt.toml"), r#"post-start = "echo 'bash background'""#, ) .unwrap(); repo.commit("Add post-start command"); // Pre-approve the command repo.write_test_approvals( r#"[projects."../origin"] approved-commands = ["echo 'bash background'"] "#, ); // Build the setup script that defines the wt function let mut setup_script = String::new(); append_wrapper_setup(&mut setup_script, "bash", &repo); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let env_vars: Vec<(&str, &str)> = vec![ ("CLICOLOR_FORCE", "1"), ("WORKTRUNK_CONFIG_PATH", &config_path), ("WORKTRUNK_APPROVALS_PATH", &approvals_path), ("TERM", "xterm"), ("GIT_AUTHOR_NAME", "Test User"), ("GIT_AUTHOR_EMAIL", "test@example.com"), ("GIT_COMMITTER_NAME", "Test User"), ("GIT_COMMITTER_EMAIL", "test@example.com"), ]; // Run wt at the prompt (where job notifications appear) let (output, exit_code) = exec_bash_truly_interactive( &setup_script, "wt switch --create bash-job-test", "and worktree", repo.root_path(), &env_vars, ); assert_eq!(exit_code, 0, "Command should succeed.\nOutput:\n{}", output); // Verify the command completed successfully assert!( output.contains("Created branch") && output.contains("and worktree"), "Should show success message.\nOutput:\n{}", output ); // Verify no job control messages leak through. // The shell wrapper suppresses both START notifications (`[1] 12345` via stderr // redirection) and DONE notifications (`[1]+ Done` via `set +m`). // This test uses true interactive mode to ensure we'd see them if they leaked. assert!( !JOB_CONTROL_REGEX.is_match(&output), "Output contains job control messages (e.g., '[1] 12345' or '[1]+ Done'):\n{}", output ); } // ======================================================================== // Completion Functionality Tests // ======================================================================== /// Test that bash completions are properly registered /// Note: Completions are inline in the wrapper script (lazy loading) #[rstest] fn test_bash_completions_registered(repo: TestRepo) { // Use a marker file to avoid PTY output race conditions. // PTY buffer flushing is unreliable on CI, so we write to a file and poll for it. let marker_file = repo.root_path().join(".completions_test_marker"); let marker_path = marker_file.to_string_lossy().to_string(); // Script that sources wrapper and checks if completion is registered // (completions are inline in the wrapper via lazy loading) let marker_quoted = shell_quote(&marker_path); let mut script = String::new(); append_wrapper_setup(&mut script, "bash", &repo); script.push_str(&format!( r#" # Check if wt completion is registered and write result to marker file if complete -p wt 2>/dev/null; then echo "__COMPLETION_REGISTERED__" > {} else echo "__NO_COMPLETION__" > {} fi "#, marker_quoted, marker_quoted, )); let final_script = format!("( {} ) 2>&1", script); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let env_vars: Vec<(&str, &str)> = vec![ ("WORKTRUNK_CONFIG_PATH", &config_path), ("WORKTRUNK_APPROVALS_PATH", &approvals_path), ("TERM", "xterm"), ]; let (_combined, exit_code) = exec_in_pty_interactive("bash", &final_script, repo.root_path(), &env_vars, &[]); assert_eq!(exit_code, 0); // Poll for marker file instead of relying on PTY output wait_for_file_content(&marker_file); let result = std::fs::read_to_string(&marker_file).unwrap(); assert!( result.contains("__COMPLETION_REGISTERED__"), "Bash completions should be registered after sourcing wrapper.\nMarker file content:\n{}", result ); } /// Test that fish completions are properly registered #[rstest] fn test_fish_completions_registered(repo: TestRepo) { let completions_script = generate_completions(&repo, "fish"); // Use a marker file to avoid PTY output race conditions. // PTY buffer flushing is unreliable on CI, so we write to a file and poll for it. let marker_file = repo.root_path().join(".completions_test_marker"); let marker_path = marker_file.to_string_lossy().to_string(); // Script that sources wrapper, completions, and checks if completion is registered let marker_quoted = shell_quote(&marker_path); let mut script = String::new(); append_wrapper_setup(&mut script, "fish", &repo); script.push_str(&completions_script); script.push_str(&format!( r#" # Check if wt completions are registered and write result to marker file if complete -c wt 2>/dev/null | grep -q . echo "__COMPLETION_REGISTERED__" > {} else echo "__NO_COMPLETION__" > {} end "#, marker_quoted, marker_quoted, )); let final_script = format!("begin\n{}\nend 2>&1", script); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let env_vars: Vec<(&str, &str)> = vec![ ("WORKTRUNK_CONFIG_PATH", &config_path), ("WORKTRUNK_APPROVALS_PATH", &approvals_path), ("TERM", "xterm"), ]; let (_combined, exit_code) = exec_in_pty_interactive("fish", &final_script, repo.root_path(), &env_vars, &[]); assert_eq!(exit_code, 0); // Poll for marker file instead of relying on PTY output wait_for_file_content(&marker_file); let result = std::fs::read_to_string(&marker_file).unwrap(); assert!( result.contains("__COMPLETION_REGISTERED__"), "Fish completions should be registered after sourcing wrapper.\nMarker file content:\n{}", result ); } /// Test that zsh wrapper function is properly defined /// Note: Completions are inline in the wrapper script (lazy loading via compdef) #[rstest] fn test_zsh_wrapper_function_registered(repo: TestRepo) { let wt_bin = wt_bin(); let wrapper_script = generate_wrapper(&repo, "zsh"); // Use a marker file to avoid PTY output race conditions. // PTY buffer flushing is unreliable on CI, so we write to a file and poll for it. let marker_file = repo.root_path().join(".wrapper_test_marker"); let marker_path = marker_file.to_string_lossy().to_string(); // Script that sources wrapper and checks if wt function exists let wt_bin_quoted = shell_quote(&wt_bin.display().to_string()); let config_quoted = shell_quote(&repo.test_config_path().display().to_string()); let approvals_quoted = shell_quote(&repo.test_approvals_path().display().to_string()); let marker_quoted = shell_quote(&marker_path); let script = format!( r#" export WORKTRUNK_BIN={wt_bin} export WORKTRUNK_CONFIG_PATH={config} export WORKTRUNK_APPROVALS_PATH={approvals} {wrapper} # Check if wt wrapper function is defined and write result to marker file if (( $+functions[wt] )); then echo "__WRAPPER_REGISTERED__" > {marker} else echo "__NO_WRAPPER__" > {marker} fi "#, wt_bin = wt_bin_quoted, config = config_quoted, approvals = approvals_quoted, wrapper = wrapper_script, marker = marker_quoted, ); let final_script = format!("( {} ) 2>&1", script); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let env_vars: Vec<(&str, &str)> = vec![ ("WORKTRUNK_CONFIG_PATH", &config_path), ("WORKTRUNK_APPROVALS_PATH", &approvals_path), ("TERM", "xterm"), ("ZDOTDIR", "/dev/null"), ]; let (_combined, exit_code) = exec_in_pty_interactive("zsh", &final_script, repo.root_path(), &env_vars, &[]); assert_eq!(exit_code, 0); // Poll for marker file instead of relying on PTY output wait_for_file_content(&marker_file); let result = std::fs::read_to_string(&marker_file).unwrap(); assert!( result.contains("__WRAPPER_REGISTERED__"), "Zsh wrapper function should be registered after sourcing.\nMarker file content:\n{}", result ); } // ======================================================================== // WORKTRUNK_BIN Fallback Tests // ======================================================================== /// Test that shell integration works when wt is not in PATH but WORKTRUNK_BIN is set // Note: Nushell not included - this test builds custom scripts with bash syntax #[rstest] #[case("bash")] #[case("fish")] fn test_worktrunk_bin_fallback(#[case] shell: &str, repo: TestRepo) { let wt_bin = wt_bin(); let wrapper_script = generate_wrapper(&repo, shell); // Use shell_quote to handle paths with special chars (like single quotes) let wt_bin_quoted = shell_quote(&wt_bin.display().to_string()); let config_quoted = shell_quote(&repo.test_config_path().display().to_string()); let approvals_quoted = shell_quote(&repo.test_approvals_path().display().to_string()); let path = crate::common::setup_minimal_path_with_git(&repo.home_path().join("test-bin")); let path_quoted = shell_quote(&path); // Script that explicitly removes wt from PATH but sets WORKTRUNK_BIN let script = match shell { "fish" => format!( r#" # Clear PATH to ensure wt is not found via PATH set -x PATH {} set -x WORKTRUNK_BIN {} set -x WORKTRUNK_CONFIG_PATH {} set -x WORKTRUNK_APPROVALS_PATH {} set -x CLICOLOR_FORCE 1 {} wt switch --create fallback-test echo "__PWD__ $PWD" "#, path_quoted, wt_bin_quoted, config_quoted, approvals_quoted, wrapper_script ), _ => format!( r#" # Clear PATH to ensure wt is not found via PATH export PATH={} export WORKTRUNK_BIN={} export WORKTRUNK_CONFIG_PATH={} export WORKTRUNK_APPROVALS_PATH={} export CLICOLOR_FORCE=1 {} wt switch --create fallback-test echo "__PWD__ $PWD" "#, path_quoted, wt_bin_quoted, config_quoted, approvals_quoted, wrapper_script ), }; let final_script = match shell { "fish" => format!("begin\n{}\nend 2>&1", script), _ => format!("( {} ) 2>&1", script), }; let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let env_vars = build_test_env_vars(&config_path, &approvals_path); let (combined, exit_code) = exec_in_pty_interactive(shell, &final_script, repo.root_path(), &env_vars, &[]); let output = ShellOutput { combined, exit_code, }; assert_eq!( output.exit_code, 0, "{}: Command should succeed with WORKTRUNK_BIN fallback", shell ); output.assert_no_directive_leaks(); assert!( output.combined.contains("Created branch") && output.combined.contains("and worktree"), "{}: Should create worktree using WORKTRUNK_BIN fallback.\nOutput:\n{}", shell, output.combined ); // Verify we actually cd'd to the new worktree assert!( output.combined.contains("fallback-test"), "{}: Should be in the new worktree directory.\nOutput:\n{}", shell, output.combined ); } /// Test that fish wrapper shows clear error when wt binary is not available /// /// This tests the scenario where: /// 1. User has shell integration installed (functions/wt.fish exists) /// 2. But wt binary is not in PATH /// 3. And WORKTRUNK_BIN is not set /// /// The fish function should show "wt: command not found" and exit 127. /// This is fish-specific because bash/zsh have an outer guard that prevents /// the function from being defined when wt isn't available. #[rstest] #[case("fish")] fn test_fish_binary_not_found_clear_error(#[case] shell: &str, repo: TestRepo) { let wrapper_script = generate_wrapper(&repo, shell); // Use a marker file for the exit code — PTY output capture can be empty on macOS let marker_file = repo.root_path().join(".test-exit-code-marker"); // Script that clears PATH and does NOT set WORKTRUNK_BIN // This simulates having the fish function installed but wt not available let script = format!( r#" # Clear PATH to ensure wt is not found via PATH set -x PATH /usr/bin /bin # Explicitly unset WORKTRUNK_BIN to ensure it's not set set -e WORKTRUNK_BIN set -x CLICOLOR_FORCE 1 {wrapper_script} wt --version set -l wt_exit_status $status # Write exit code to marker file (reliable even when PTY output is empty) echo $wt_exit_status > {marker_file} "#, wrapper_script = wrapper_script, marker_file = marker_file.display() ); let final_script = format!("begin\n{}\nend 2>&1", script); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let env_vars = build_test_env_vars(&config_path, &approvals_path); let (combined, exit_code) = exec_in_pty_interactive(shell, &final_script, repo.root_path(), &env_vars, &[]); let output = ShellOutput { combined, exit_code, }; // PRIMARY CHECK: Verify exit code 127 via marker file (reliable on all platforms) assert!( marker_file.exists(), "Fish wrapper did not complete (marker file not created).\n\ Exit code: {}\nOutput:\n{}", output.exit_code, output.combined ); let marker_content = fs::read_to_string(&marker_file).unwrap_or_default(); let marker_exit_code: i32 = marker_content.trim().parse().unwrap_or(-1); assert_eq!( marker_exit_code, 127, "Fish wrapper should return exit code 127 when binary is missing.\n\ Marker file content: {:?}\nPTY exit code: {}\nOutput:\n{}", marker_content, output.exit_code, output.combined ); // TODO(macos-pty): PTY output capture for fish returns empty on macOS, so we // can only assert the error message on Linux. We'd like to re-enable this on // macOS once the underlying PTY issue is resolved. See #1268. if !output.combined.is_empty() { assert!( output.combined.contains("wt: command not found"), "Fish wrapper should show 'wt: command not found' when binary is missing.\nOutput:\n{}", output.combined ); } } /// Test that fish WRAPPER (bootstrap) handles missing binary gracefully /// /// This tests the WRAPPER file (fish_wrapper.fish) that gets installed to /// ~/.config/fish/functions/wt.fish. Unlike the full function (tested above), /// the wrapper tries to SOURCE the full function from the binary at runtime. /// /// When wt isn't in PATH: /// - `command wt config shell init fish` fails /// - The wrapper should return 127, NOT infinite loop /// /// This is different from test_fish_binary_not_found_clear_error which tests /// the FULL function (which has its own WORKTRUNK_BIN check). #[rstest] #[case("fish")] fn test_fish_wrapper_binary_not_found_no_infinite_loop(#[case] shell: &str, repo: TestRepo) { // Use the WRAPPER template (not the full function from generate_wrapper) let init = shell::ShellInit::with_prefix(shell::Shell::Fish, "wt".to_string()); let wrapper_content = init.generate_fish_wrapper().unwrap(); // Create a marker file path to prove the script completed (didn't infinite loop) let marker_file = repo.root_path().join(".test-completed-marker"); // Script that clears PATH so wt isn't found, then calls wt. // The marker file is written AFTER the wt call to prove we didn't infinite loop. // We capture the exit status before writing the marker so it's preserved. let script = format!( r#" # Clear PATH to ensure wt is not found set -x PATH /usr/bin /bin set -x CLICOLOR_FORCE 1 {wrapper_content} wt --version set -l wt_exit_status $status # Write marker file to prove script completed (didn't infinite loop) echo $wt_exit_status > {marker_file} exit $wt_exit_status "#, wrapper_content = wrapper_content, marker_file = marker_file.display() ); let final_script = format!("begin\n{}\nend 2>&1", script); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let env_vars = build_test_env_vars(&config_path, &approvals_path); let (combined, exit_code) = exec_in_pty_interactive(shell, &final_script, repo.root_path(), &env_vars, &[]); // PRIMARY CHECK: The marker file must exist, proving the script completed // (didn't get stuck in an infinite loop). This is reliable even when PTY // output capture fails on macOS. assert!( marker_file.exists(), "Fish wrapper infinite looped (marker file not created).\n\ Exit code: {}\nOutput:\n{}", exit_code, combined ); // Read the exit status from the marker file. We use this rather than the PTY's // exit_code because PTY layer behavior can differ from the shell's $status. let marker_content = fs::read_to_string(&marker_file).unwrap_or_default(); let marker_exit_code: i32 = marker_content.trim().parse().unwrap_or(-1); // Verify exit code 127 (command not found) assert_eq!( marker_exit_code, 127, "Fish wrapper should return exit code 127 when binary is missing.\n\ Marker file content: {:?}\nPTY exit code: {}\nOutput:\n{}", marker_content, exit_code, combined ); // SECONDARY CHECK: When output is available, verify no infinite recursion signs. // One occurrence of "in function 'wt'" is normal (fish's error trace). // Infinite recursion would show this MANY times. if !combined.is_empty() { let function_call_count = combined.matches("in function 'wt'").count(); assert!( function_call_count <= 1, "Fish wrapper shows signs of infinite loop ({} recursive calls).\nOutput:\n{}", function_call_count, combined ); } } // ======================================================================== // README Example Tests (PTY-based for interleaved output) // ======================================================================== // // These tests generate snapshots for README.md examples. They use PTY execution // to capture stdout/stderr interleaved in the order users see them. // // See tests/AGENTS.md for background on why PTY-based tests are needed for README examples. /// README example: Pre-merge hooks with squash and LLM commit message /// /// This test demonstrates: /// - Multiple commits being squashed with LLM commit message /// - Pre-merge hooks (test, lint) running before merge /// /// Source: tests/snapshots/shell_wrapper__tests__readme_example_hooks_pre_merge.snap #[rstest] fn test_readme_example_hooks_pre_merge(mut repo: TestRepo) { // Create project config with pre-merge hooks let config_dir = repo.root_path().join(".config"); fs::create_dir_all(&config_dir).unwrap(); // Create mock commands for realistic output let bin_dir = repo.root_path().join(".bin"); fs::create_dir_all(&bin_dir).unwrap(); // Mock pytest command let pytest_script = r#"#!/bin/sh cat << 'EOF' ============================= test session starts ============================== collected 3 items tests/test_auth.py::test_login_success PASSED [ 33%] tests/test_auth.py::test_login_invalid_password PASSED [ 66%] tests/test_auth.py::test_token_validation PASSED [100%] ============================== 3 passed in 0.8s =============================== EOF exit 0 "#; fs::write(bin_dir.join("pytest"), pytest_script).unwrap(); // Mock ruff command let ruff_script = r#"#!/bin/sh if [ "$1" = "check" ]; then echo "" echo "All checks passed!" echo "" exit 0 else echo "ruff: unknown command '$1'" exit 1 fi "#; fs::write(bin_dir.join("ruff"), ruff_script).unwrap(); // Mock llm command for commit message let llm_script = r#"#!/bin/sh cat > /dev/null cat << 'EOF' feat(api): Add user authentication endpoints Implement login and token refresh endpoints with JWT validation. Includes comprehensive test coverage and input validation. EOF "#; fs::write(bin_dir.join("llm"), llm_script).unwrap(); // Mock uv command for running pytest and ruff let uv_script = r#"#!/bin/sh if [ "$1" = "run" ] && [ "$2" = "pytest" ]; then exec pytest elif [ "$1" = "run" ] && [ "$2" = "ruff" ]; then shift 2 exec ruff "$@" else echo "uv: unknown command '$1 $2'" exit 1 fi "#; fs::write(bin_dir.join("uv"), uv_script).unwrap(); // Make scripts executable (Unix only) #[cfg(unix)] { use std::os::unix::fs::PermissionsExt; for script in &["pytest", "ruff", "llm", "uv"] { let mut perms = fs::metadata(bin_dir.join(script)).unwrap().permissions(); perms.set_mode(0o755); fs::set_permissions(bin_dir.join(script), perms).unwrap(); } } let config_content = r#" pre-merge = [ {"test" = "uv run pytest"}, {"lint" = "uv run ruff check"}, ] "#; fs::write(config_dir.join("wt.toml"), config_content).unwrap(); // Commit the config repo.run_git(&["add", ".config/wt.toml", ".bin"]); repo.run_git(&["commit", "-m", "Add pre-merge hooks"]); // Create a feature worktree and make multiple commits let feature_wt = repo.add_worktree("feature-auth"); // First commit - create initial auth.py with login endpoint fs::create_dir_all(feature_wt.join("api")).unwrap(); let auth_py_v1 = r#"# Authentication API endpoints from typing import Dict, Optional import jwt from datetime import datetime, timedelta, timezone def login(username: str, password: str) -> Optional[Dict]: """Authenticate user and return JWT token.""" # Validate credentials (stub) if not username or not password: return None # Generate JWT token payload = { 'sub': username, 'exp': datetime.now(timezone.utc) + timedelta(hours=1) } token = jwt.encode(payload, 'secret', algorithm='HS256') return {'token': token, 'expires_in': 3600} "#; std::fs::write(feature_wt.join("api/auth.py"), auth_py_v1).unwrap(); repo.run_git_in(&feature_wt, &["add", "api/auth.py"]); repo.run_git_in(&feature_wt, &["commit", "-m", "Add login endpoint"]); // Second commit - add tests fs::create_dir_all(feature_wt.join("tests")).unwrap(); let test_auth_py = r#"# Authentication endpoint tests import pytest from api.auth import login def test_login_success(): result = login('user', 'pass') assert result and 'token' in result def test_login_invalid_password(): result = login('user', '') assert result is None def test_token_validation(): assert login('valid_user', 'valid_pass')['expires_in'] == 3600 "#; std::fs::write(feature_wt.join("tests/test_auth.py"), test_auth_py).unwrap(); repo.run_git_in(&feature_wt, &["add", "tests/test_auth.py"]); repo.run_git_in(&feature_wt, &["commit", "-m", "Add authentication tests"]); // Third commit - add refresh endpoint let auth_py_v2 = r#"# Authentication API endpoints from typing import Dict, Optional import jwt from datetime import datetime, timedelta, timezone def login(username: str, password: str) -> Optional[Dict]: """Authenticate user and return JWT token.""" # Validate credentials (stub) if not username or not password: return None # Generate JWT token payload = { 'sub': username, 'exp': datetime.now(timezone.utc) + timedelta(hours=1) } token = jwt.encode(payload, 'secret', algorithm='HS256') return {'token': token, 'expires_in': 3600} def refresh_token(token: str) -> Optional[Dict]: """Refresh an existing JWT token.""" try: payload = jwt.decode(token, 'secret', algorithms=['HS256']) new_payload = { 'sub': payload['sub'], 'exp': datetime.now(timezone.utc) + timedelta(hours=1) } new_token = jwt.encode(new_payload, 'secret', algorithm='HS256') return {'token': new_token, 'expires_in': 3600} except jwt.InvalidTokenError: return None "#; std::fs::write(feature_wt.join("api/auth.py"), auth_py_v2).unwrap(); repo.run_git_in(&feature_wt, &["add", "api/auth.py"]); repo.run_git_in(&feature_wt, &["commit", "-m", "Add validation"]); // Configure LLM in worktrunk config let llm_path = bin_dir.join("llm"); let worktrunk_config = format!( r#"worktree-path = "../repo.{{{{ branch }}}}" [commit.generation] command = "{}" "#, llm_path.display() ); repo.write_test_config(&worktrunk_config); // Set PATH with mock binaries and run merge let path_with_bin = format!( "{}:/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin", bin_dir.display() ); let output = exec_through_wrapper_with_env( "bash", &repo, "merge", &["main", "--yes"], &feature_wt, &[], &[("PATH", &path_with_bin)], ); output.assert_success(); shell_wrapper_settings().bind(|| assert_snapshot!(&output.combined)); } /// README example: Creating worktree with pre-start and post-start hooks /// /// This test demonstrates: /// - Pre-start hooks (install dependencies) /// - Post-start hooks (start dev server) /// /// Uses shell wrapper to avoid "To enable automatic cd" hint. /// /// Source: tests/snapshots/shell_wrapper__tests__readme_example_hooks_pre_start.snap #[rstest] fn test_readme_example_hooks_pre_start(repo: TestRepo) { // Create project config with pre-start and post-start hooks let config_dir = repo.root_path().join(".config"); fs::create_dir_all(&config_dir).unwrap(); // Create mock commands for realistic output let bin_dir = repo.root_path().join(".bin"); fs::create_dir_all(&bin_dir).unwrap(); // Mock uv command that simulates dependency installation let uv_script = r#"#!/bin/sh if [ "$1" = "sync" ]; then echo "" echo " Resolved 24 packages in 145ms" echo " Installed 24 packages in 1.2s" exit 0 elif [ "$1" = "run" ] && [ "$2" = "dev" ]; then echo "" echo " Starting dev server on http://localhost:3000..." exit 0 else echo "uv: unknown command '$1 $2'" exit 1 fi "#; fs::write(bin_dir.join("uv"), uv_script).unwrap(); // Make scripts executable (Unix only) #[cfg(unix)] { use std::os::unix::fs::PermissionsExt; let mut perms = fs::metadata(bin_dir.join("uv")).unwrap().permissions(); perms.set_mode(0o755); fs::set_permissions(bin_dir.join("uv"), perms).unwrap(); } let config_content = r#" [pre-start] "install" = "uv sync" [post-start] "dev" = "uv run dev" "#; fs::write(config_dir.join("wt.toml"), config_content).unwrap(); // Commit the config repo.run_git(&["add", ".config/wt.toml", ".bin"]); repo.run_git(&["commit", "-m", "Add project hooks"]); // Set PATH with mock binaries and run switch --create let path_with_bin = format!( "{}:/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin", bin_dir.display() ); let output = exec_through_wrapper_with_env( "bash", &repo, "switch", &["--create", "feature-x", "--yes"], repo.root_path(), &[], &[("PATH", &path_with_bin)], ); output.assert_success(); shell_wrapper_settings().bind(|| assert_snapshot!(&output.combined)); } /// README example: approval prompt for pre-start commands /// This test captures just the prompt (before responding) to show what users see. /// /// Note: This uses direct PTY execution (not shell wrapper) because interactive prompts /// require direct stdin access. The shell wrapper approach detects non-interactive mode. /// The shell integration hint is truncated from the output. #[rstest] fn test_readme_example_approval_prompt(repo: TestRepo) { use portable_pty::CommandBuilder; use std::io::Write; // Remove origin so worktrunk uses directory name as project identifier repo.run_git(&["remote", "remove", "origin"]); // Create project config with named pre-start commands repo.write_project_config( r#"pre-start = [ {install = "echo 'Installing dependencies...'"}, {build = "echo 'Building project...'"}, {test = "echo 'Running tests...'"}, ] "#, ); repo.commit("Add config"); let pair = crate::common::open_pty(); let cargo_bin = wt_bin(); let mut cmd = CommandBuilder::new(cargo_bin); cmd.arg("switch"); cmd.arg("--create"); cmd.arg("test-approval"); cmd.cwd(repo.root_path()); // Set environment crate::common::configure_pty_command(&mut cmd); for (key, value) in repo.test_env_vars() { cmd.env(key, value); } let mut child = pair.slave.spawn_command(cmd).unwrap(); drop(pair.slave); let mut reader = pair.master.try_clone_reader().unwrap(); let mut writer = pair.master.take_writer().unwrap(); // Send "n" to decline and complete the command writer.write_all(b"n\n").unwrap(); writer.flush().unwrap(); drop(writer); // Read all output let buf = crate::common::pty::read_pty_master_to_string(&mut reader); child.wait().unwrap(); // Normalize: strip ANSI codes and control characters let ansi_regex = regex::Regex::new(r"\x1b\[[0-9;]*m").unwrap(); let output = ansi_regex .replace_all(&buf, "") .replace("\r\n", "\n") .to_string(); // Remove ^D and backspaces (macOS PTY artifacts) let ctrl_d_regex = regex::Regex::new(r"\^D\x08+").unwrap(); let output = ctrl_d_regex.replace_all(&output, "").to_string(); // Normalize paths (local regexes since we're extracting content, not snapshotting) let tmpdir_regex = regex::Regex::new( r#"(?:/private)?/var/folders/[^/]+/[^/]+/T/\.tmp[^\s/'\x1b\)]+|/tmp/\.tmp[^\s/'\x1b\)]+"#, ) .unwrap(); let output = tmpdir_regex.replace_all(&output, "[TMPDIR]").to_string(); let collapse_regex = regex::Regex::new(r"\[TMPDIR](?:/?\[TMPDIR])+").unwrap(); let output = collapse_regex.replace_all(&output, "[TMPDIR]").to_string(); assert!( output.contains("needs approval"), "Should show approval prompt" ); assert!( output.contains("[y/N]"), "Should show the interactive prompt" ); // Extract just the prompt portion (from "🟡" to "[y/N]") // This removes the echoed input at the start and anything after the prompt let prompt_start = output.find("🟡").unwrap_or(0); let prompt_end = output.find("[y/N]").map(|i| i + "[y/N]".len()); let prompt_only = if let Some(end) = prompt_end { output[prompt_start..end].trim().to_string() } else { output[prompt_start..].trim().to_string() }; assert_snapshot!(prompt_only); } /// Black-box test: bash completion is registered and produces correct output. /// /// This test verifies completion works WITHOUT knowing internal function names. /// It uses `complete -p wt` to discover whatever completion function is registered, /// then calls it via shell completion machinery. /// /// This catches bugs like: /// - Completion not registered at all /// - Completion function not loading (lazy loading broken) /// - Completion output being executed as commands (the COMPLETE mode bug) #[rstest] fn test_bash_completion_produces_correct_output(repo: TestRepo) { let wt_bin = wt_bin(); let wt_bin_dir = wt_bin.parent().unwrap(); // Generate wrapper without WORKTRUNK_BIN (simulates installed wt) let output = std::process::Command::new(&wt_bin) .args(["config", "shell", "init", "bash"]) .output() .unwrap(); let wrapper_script = String::from_utf8_lossy(&output.stdout); // Black-box test: don't reference internal function names let script = format!( r#" # Do NOT set WORKTRUNK_BIN - simulate real user scenario export CLICOLOR_FORCE=1 # Source the shell integration {wrapper_script} # Step 1: Verify SOME completion is registered for 'wt' (black-box check) if ! complete -p wt >/dev/null 2>&1; then echo "FAILURE: No completion registered for wt" exit 1 fi echo "SUCCESS: Completion is registered for wt" # Step 2: Get the completion function name (whatever it's called) completion_func=$(complete -p wt 2>/dev/null | sed -n 's/.*-F \([^ ]*\).*/\1/p') if [[ -z "$completion_func" ]]; then echo "FAILURE: Could not extract completion function name" exit 1 fi echo "SUCCESS: Found completion function: $completion_func" # Step 3: Set up completion environment and call the function COMP_WORDS=(wt "") COMP_CWORD=1 COMP_TYPE=9 # TAB COMP_LINE="wt " COMP_POINT=${{#COMP_LINE}} # Call the completion function (this triggers lazy loading if needed) "$completion_func" wt "" wt 2>&1 # Step 4: Verify we got completions (black-box: just check we got results) if [[ "${{#COMPREPLY[@]}}" -eq 0 ]]; then echo "FAILURE: No completions returned" echo "COMPREPLY is empty" exit 1 fi echo "SUCCESS: Got ${{#COMPREPLY[@]}} completions" # Print completions for c in "${{COMPREPLY[@]}}"; do echo " - $c" done # Step 5: Verify expected subcommands are present if printf '%s\n' "${{COMPREPLY[@]}}" | grep -q '^config$'; then echo "VERIFIED: 'config' is in completions" else echo "FAILURE: 'config' not found in completions" exit 1 fi if printf '%s\n' "${{COMPREPLY[@]}}" | grep -q '^list$'; then echo "VERIFIED: 'list' is in completions" else echo "FAILURE: 'list' not found in completions" exit 1 fi "#, wrapper_script = wrapper_script ); let pair = crate::common::open_pty(); let mut cmd = crate::common::shell_command("bash", Some(wt_bin_dir)); cmd.arg("-c"); cmd.arg(&script); cmd.cwd(repo.root_path()); let mut child = pair.slave.spawn_command(cmd).unwrap(); drop(pair.slave); let mut reader = pair.master.try_clone_reader().unwrap(); let buf = crate::common::pty::read_pty_master_to_string(&mut reader); let status = child.wait().unwrap(); let output = buf.replace("\r\n", "\n"); // Verify no "command not found" error (the COMPLETE mode bug) assert!( !output.contains("command not found"), "Completion output should NOT be executed as a command.\n\ This indicates the COMPLETE mode fix is not working.\n\ Output: {}", output ); assert!( output.contains("SUCCESS: Completion is registered"), "Completion should be registered.\nOutput: {}\nExit: {}", output, status.exit_code() ); assert!( output.contains("SUCCESS: Got") && output.contains("completions"), "Completion should return results.\nOutput: {}\nExit: {}", output, status.exit_code() ); assert!( output.contains("VERIFIED: 'config' is in completions"), "Expected 'config' subcommand in completions.\nOutput: {}", output ); assert!( output.contains("VERIFIED: 'list' is in completions"), "Expected 'list' subcommand in completions.\nOutput: {}", output ); } /// Black-box test: zsh completion is registered and produces correct output. /// /// This test verifies completion works WITHOUT knowing internal function names. /// It checks that a completion is registered for 'wt' and that calling the /// wt command with COMPLETE=zsh produces completion candidates. #[rstest] fn test_zsh_completion_produces_correct_output(repo: TestRepo) { let wt_bin = wt_bin(); let wt_bin_dir = wt_bin.parent().unwrap(); // Generate wrapper without WORKTRUNK_BIN (simulates installed wt) let output = std::process::Command::new(&wt_bin) .args(["config", "shell", "init", "zsh"]) .output() .unwrap(); let wrapper_script = String::from_utf8_lossy(&output.stdout); // Black-box test: don't reference internal function names let script = format!( r#" autoload -Uz compinit && compinit -i 2>/dev/null # Do NOT set WORKTRUNK_BIN - simulate real user scenario export CLICOLOR_FORCE=1 # Source the shell integration {wrapper_script} # Step 1: Verify SOME completion is registered for 'wt' (black-box check) # In zsh, $_comps[wt] contains the completion function if registered if (( $+_comps[wt] )); then echo "SUCCESS: Completion is registered for wt" else echo "FAILURE: No completion registered for wt" exit 1 fi # Step 2: Test that COMPLETE mode works through our shell function # This is the key test - the wt() shell function must detect COMPLETE # and call the binary directly, not through wt_exec which would eval the output words=(wt "") CURRENT=2 _CLAP_COMPLETE_INDEX=1 _CLAP_IFS=$'\n' # Call wt with COMPLETE=zsh - this goes through our shell function completions=$(COMPLETE=zsh _CLAP_IFS="$_CLAP_IFS" _CLAP_COMPLETE_INDEX="$_CLAP_COMPLETE_INDEX" wt -- "${{words[@]}}" 2>&1) if [[ -z "$completions" ]]; then echo "FAILURE: No completions returned" exit 1 fi echo "SUCCESS: Got completions" # Print first few completions echo "$completions" | head -10 | while read line; do echo " - $line" done # Step 3: Verify expected subcommands are present if echo "$completions" | grep -q 'config'; then echo "VERIFIED: 'config' is in completions" else echo "FAILURE: 'config' not found in completions" exit 1 fi "#, wrapper_script = wrapper_script ); let pair = crate::common::open_pty(); let mut cmd = crate::common::shell_command("zsh", Some(wt_bin_dir)); cmd.arg("-c"); cmd.arg(&script); cmd.cwd(repo.root_path()); let mut child = pair.slave.spawn_command(cmd).unwrap(); drop(pair.slave); let mut reader = pair.master.try_clone_reader().unwrap(); let buf = crate::common::pty::read_pty_master_to_string(&mut reader); let status = child.wait().unwrap(); let output = buf.replace("\r\n", "\n"); // Verify no "command not found" error (the COMPLETE mode bug) assert!( !output.contains("command not found"), "Completion output should NOT be executed as a command.\n\ Output: {}", output ); assert!( output.contains("SUCCESS: Completion is registered"), "Completion should be registered.\nOutput: {}\nExit: {}", output, status.exit_code() ); assert!( output.contains("SUCCESS: Got completions"), "Completion should return results.\nOutput: {}\nExit: {}", output, status.exit_code() ); assert!( output.contains("VERIFIED: 'config' is in completions"), "Expected 'config' subcommand in completions.\nOutput: {}", output ); } /// Build a hermetic PATH for completion tests. /// /// Creates a temp dir with a symlink to the `wt` binary, then builds PATH /// from that dir + system dirs (excluding cargo target directories). This /// prevents co-built binaries like `wt-perf` from leaking into completion /// output as custom subcommands. /// /// NOTE: passing this via `.env("PATH", ...)` is not enough when spawning /// a shell whose startup files mutate PATH: a typical `~/.zshenv` sources /// `~/.cargo/env` (even for non-interactive `zsh -c`), and `~/.bashrc` or /// `~/.bash_profile` can do the same. Invoke the shell with its /// rc-bypass flag (`zsh -f`, `bash --noprofile --norc`) alongside the /// PATH override. `/etc/zshenv` is always sourced and cannot be bypassed, /// but it doesn't typically touch PATH on the environments we care about. fn completion_test_path(wt_bin: &std::path::Path) -> (tempfile::TempDir, String) { let dir = tempfile::tempdir().unwrap(); std::os::unix::fs::symlink(wt_bin, dir.path().join("wt")).unwrap(); // Only include the symlink dir + essential system dirs. This prevents // any user-installed `wt-*` binaries (e.g. ~/.cargo/bin/wt-sync) or // co-compiled helpers (target/debug/wt-perf) from appearing. let path = format!("{}:/usr/bin:/bin:/usr/sbin:/sbin", dir.path().display()); (dir, path) } /// Point the spawned `wt` (and its child shells) at empty user, system, /// and project configs so aliases don't leak into completion output. /// Aliases surface as top-level completion candidates, so without this /// isolation any aliases in the developer's /// `~/.config/worktrunk/config.toml`, a system config, or this repo's own /// `.config/wt.toml` would pollute the snapshot. fn set_empty_configs(cmd: &mut std::process::Command) { cmd.env("WORKTRUNK_CONFIG_PATH", "/dev/null"); cmd.env("WORKTRUNK_SYSTEM_CONFIG_PATH", "/dev/null"); cmd.env("WORKTRUNK_PROJECT_CONFIG_PATH", "/dev/null"); } /// Black-box test: zsh completion produces correct subcommands. /// /// Sources actual `wt config shell init zsh`, triggers completion, snapshots result. #[test] fn test_zsh_completion_subcommands() { let wt_bin = wt_bin(); let init = std::process::Command::new(&wt_bin) .args(["config", "shell", "init", "zsh"]) .output() .unwrap(); let shell_integration = String::from_utf8_lossy(&init.stdout); // Override _describe to print completions (it normally writes to zsh's internal state) let script = format!( r#" autoload -Uz compinit && compinit -i 2>/dev/null _describe() {{ while [[ "$1" == -* ]]; do shift; done; shift for arr in "$@"; do for item in "${{(@P)arr}}"; do echo "${{item%%:*}}"; done; done }} {shell_integration} words=(wt "") CURRENT=2 _wt_lazy_complete "# ); // Filter PATH to exclude cargo target directories so `wt-perf` (test // helper) doesn't leak into completion output as a custom subcommand. let (_dir, clean_path) = completion_test_path(&wt_bin); // `-f` skips ~/.zshenv (which typically sources ~/.cargo/env and // re-prepends ~/.cargo/bin). `/etc/zshenv` is still read — it can't // be bypassed — but doesn't touch PATH in our test environments. let mut cmd = std::process::Command::new("zsh"); cmd.args(["-f", "-c"]).arg(&script).env("PATH", &clean_path); set_empty_configs(&mut cmd); let output = cmd.output().unwrap(); assert_snapshot!(String::from_utf8_lossy(&output.stdout)); } /// Black-box test: bash completion produces correct subcommands. /// /// Sources actual `wt config shell init bash`, triggers completion, snapshots result. #[test] fn test_bash_completion_subcommands() { let wt_bin = wt_bin(); let init = std::process::Command::new(&wt_bin) .args(["config", "shell", "init", "bash"]) .output() .unwrap(); let shell_integration = String::from_utf8_lossy(&init.stdout); let script = format!( r#" {shell_integration} COMP_WORDS=(wt "") COMP_CWORD=1 _wt_lazy_complete for c in "${{COMPREPLY[@]}}"; do echo "${{c%% *}}"; done "# ); let (_dir, clean_path) = completion_test_path(&wt_bin); // `--noprofile --norc` skips ~/.bash_profile, ~/.bashrc, /etc/profile // so our clean PATH isn't polluted with ~/.cargo/bin etc. let mut cmd = std::process::Command::new("bash"); cmd.args(["--noprofile", "--norc", "-c"]) .arg(&script) .env("PATH", &clean_path); set_empty_configs(&mut cmd); let output = cmd.output().unwrap(); assert_snapshot!(String::from_utf8_lossy(&output.stdout)); } /// Black-box test: fish completion produces correct subcommands. /// /// Fish completions call binary with COMPLETE=fish (separate from init script). #[test] fn test_fish_completion_subcommands() { let wt_bin = wt_bin(); let (_dir, clean_path) = completion_test_path(&wt_bin); let mut cmd = std::process::Command::new(&wt_bin); cmd.args(["--", "wt", ""]) .env("COMPLETE", "fish") .env("_CLAP_COMPLETE_INDEX", "1") .env("PATH", &clean_path); set_empty_configs(&mut cmd); let output = cmd.output().unwrap(); // Fish format is "value\tdescription" - extract just values let completions: String = String::from_utf8_lossy(&output.stdout) .lines() .map(|line| line.split('\t').next().unwrap_or(line)) .collect::>() .join("\n"); assert_snapshot!(completions); } /// Black-box test: nushell completion produces correct subcommands. /// /// Nushell completions call binary with COMPLETE=nu (same protocol as fish). #[test] fn test_nushell_completion_subcommands() { let wt_bin = wt_bin(); let (_dir, clean_path) = completion_test_path(&wt_bin); let mut cmd = std::process::Command::new(&wt_bin); cmd.args(["--", "wt", ""]) .env("COMPLETE", "nu") .env("PATH", &clean_path); set_empty_configs(&mut cmd); let output = cmd.output().unwrap(); // Nushell format is "value\tdescription" - extract just values let completions: String = String::from_utf8_lossy(&output.stdout) .lines() .map(|line| line.split('\t').next().unwrap_or(line)) .collect::>() .join("\n"); assert_snapshot!(completions); } /// Shell integration test: completing a custom subcommand's flags /// forwards the request to the `wt-*` binary on PATH. /// /// Places a `wt-fake` script in the hermetic PATH, then triggers /// `wt fake --` via the fish completion protocol. Verifies that: /// 1. The `wt-fake` script's output appears (forwarding works) /// 2. `_CLAP_COMPLETE_INDEX` is decremented by 1 (index adjustment) #[test] fn test_fish_completion_forwards_to_custom() { use std::os::unix::fs::PermissionsExt; let wt_bin = wt_bin(); let (dir, clean_path) = completion_test_path(&wt_bin); // Place a wt-fake script that outputs distinctive completions and // echoes the received _CLAP_COMPLETE_INDEX so we can verify adjustment. let script = dir.path().join("wt-fake"); std::fs::write( &script, "#!/bin/sh\nprintf '%s\\n%s\\n' '--fake-flag' \"idx:${_CLAP_COMPLETE_INDEX}\"\n", ) .unwrap(); std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap(); // Fish protocol: `wt -- wt fake --` with COMPLETE=fish. // _CLAP_COMPLETE_INDEX=2 (completing the 3rd word "—" in "wt fake --"). // The forwarding code should detect "fake" is external, forward to // wt-fake, and decrement the index to 1. let output = std::process::Command::new(&wt_bin) .args(["--", "wt", "fake", "--"]) .env("COMPLETE", "fish") .env("_CLAP_COMPLETE_INDEX", "2") .env("PATH", &clean_path) .output() .unwrap(); let stdout = String::from_utf8_lossy(&output.stdout); assert!( stdout.contains("--fake-flag"), "Forwarded completions should include the `wt-fake` script output: {stdout}" ); assert!( stdout.contains("idx:1"), "_CLAP_COMPLETE_INDEX should be adjusted from 2 to 1: {stdout}" ); } /// Shell integration test: bash completion forwards to custom subcommands. /// /// Sources the real `wt config shell init bash` output, places a `wt-fake` /// script on the hermetic PATH, and triggers `wt fake --` through /// bash's completion machinery. #[test] fn test_bash_completion_forwards_to_custom() { use std::os::unix::fs::PermissionsExt; let wt_bin = wt_bin(); let (dir, clean_path) = completion_test_path(&wt_bin); // Place a wt-fake script that outputs completions let ext_script = dir.path().join("wt-fake"); std::fs::write( &ext_script, "#!/bin/sh\nprintf '%s\\n%s\\n' '--fake-opt' '--fake-verbose'\n", ) .unwrap(); std::fs::set_permissions(&ext_script, std::fs::Permissions::from_mode(0o755)).unwrap(); let init = std::process::Command::new(&wt_bin) .args(["config", "shell", "init", "bash"]) .output() .unwrap(); let shell_integration = String::from_utf8_lossy(&init.stdout); // Trigger completion for "wt fake --" through bash's completion system. let script = format!( r#" {shell_integration} COMP_WORDS=(wt fake --) COMP_CWORD=2 _wt_lazy_complete for c in "${{COMPREPLY[@]}}"; do echo "${{c%% *}}"; done "# ); let output = std::process::Command::new("bash") .args(["--noprofile", "--norc", "-c"]) .arg(&script) .env("PATH", &clean_path) .output() .unwrap(); let stdout = String::from_utf8_lossy(&output.stdout); assert!( stdout.contains("--fake-opt"), "Bash completion should forward to wt-fake and show its output: {stdout}" ); assert!( stdout.contains("--fake-verbose"), "Bash completion should include all external completions: {stdout}" ); } // ======================================================================== // Stderr/Stdout Redirection Tests // ======================================================================== // // These tests verify that output redirection works correctly through the // shell wrapper. When a user runs `wt --help &> file`, ALL output should // go to the file - nothing should leak to the terminal. // // This is particularly important for fish where command substitution `(...)` // doesn't propagate stderr redirects from the calling function. /// Test that `wt --help &> file` redirects all output to the file. /// /// This test verifies that stderr redirection works correctly through the /// shell wrapper. The issue being tested: in some shells (particularly fish), /// command substitution doesn't propagate stderr redirects, causing help /// output to appear on the terminal even when redirected. // Note: Nushell not included - this test builds custom scripts with bash syntax #[rstest] #[case("bash")] #[case("fish")] fn test_wrapper_help_redirect_captures_all_output(#[case] shell: &str, repo: TestRepo) { let wt_bin = wt_bin(); let wt_bin_dir = wt_bin.parent().unwrap(); // Create a temp file for the redirect target let tmp_dir = tempfile::tempdir().unwrap(); let redirect_file = tmp_dir.path().join("subprocess.log"); let redirect_path = redirect_file.display().to_string(); // Generate wrapper script let output = std::process::Command::new(&wt_bin) .args(["config", "shell", "init", shell]) .output() .unwrap(); let wrapper_script = String::from_utf8_lossy(&output.stdout); // Build shell script that: // 1. Sources the wrapper // 2. Runs `wt --help &> file` // 3. Echoes a marker so we know the script completed let script = match shell { "fish" => format!( r#" set -x WORKTRUNK_BIN '{wt_bin}' set -x CLICOLOR_FORCE 1 # Source the shell integration {wrapper_script} # Run help with redirect - ALL output should go to file wt --help &>'{redirect_path}' # Marker to show script completed echo "SCRIPT_COMPLETED" "#, wt_bin = wt_bin.display(), wrapper_script = wrapper_script, redirect_path = redirect_path, ), _ => format!( r#" export WORKTRUNK_BIN='{wt_bin}' export CLICOLOR_FORCE=1 # Source the shell integration {wrapper_script} # Run help with redirect - ALL output should go to file wt --help &>'{redirect_path}' # Marker to show script completed echo "SCRIPT_COMPLETED" "#, wt_bin = wt_bin.display(), wrapper_script = wrapper_script, redirect_path = redirect_path, ), }; let pair = crate::common::open_pty(); let mut cmd = crate::common::shell_command(shell, Some(wt_bin_dir)); cmd.arg("-c"); cmd.arg(&script); cmd.cwd(repo.root_path()); let mut child = pair.slave.spawn_command(cmd).unwrap(); drop(pair.slave); let mut reader = pair.master.try_clone_reader().unwrap(); let buf = crate::common::pty::read_pty_master_to_string(&mut reader); let _status = child.wait().unwrap(); let terminal_output = buf.replace("\r\n", "\n"); // Read the redirect file let file_content = fs::read_to_string(&redirect_file).unwrap_or_else(|e| { panic!( "{}: Failed to read redirect file: {}\nTerminal output:\n{}", shell, e, terminal_output ) }); // Verify script completed assert!( terminal_output.contains("SCRIPT_COMPLETED"), "{}: Script did not complete successfully.\nTerminal output:\n{}", shell, terminal_output ); // Verify help content went to the file assert!( file_content.contains("Usage:") || file_content.contains("wt"), "{}: Help content should be in the redirect file.\nFile content:\n{}\nTerminal output:\n{}", shell, file_content, terminal_output ); // Verify help content did NOT leak to the terminal // We check for specific help markers that shouldn't appear on terminal let help_markers = ["Usage:", "Commands:", "Options:", "USAGE:"]; for marker in help_markers { if terminal_output.contains(marker) { panic!( "{}: Help output leaked to terminal (found '{}').\n\ This indicates stderr redirection is not working correctly.\n\ Terminal output:\n{}\n\ File content:\n{}", shell, marker, terminal_output, file_content ); } } } /// Test that interactive `wt --help` uses a pager. /// /// This is the complement to `test_wrapper_help_redirect_captures_all_output`: /// - Redirect case (`&>file`): pager should be SKIPPED (output goes to file) /// - Interactive case (no redirect): pager should be USED /// /// We verify pager invocation by setting GIT_PAGER to a script that creates /// a marker file before passing through the content. // Note: Nushell not included - this test builds custom scripts with bash syntax #[rstest] #[case("bash")] #[case("fish")] fn test_wrapper_help_interactive_uses_pager(#[case] shell: &str, repo: TestRepo) { let wt_bin = wt_bin(); let wt_bin_dir = wt_bin.parent().unwrap(); // Create temp dir for marker file and pager script let tmp_dir = tempfile::tempdir().unwrap(); let marker_file = tmp_dir.path().join("pager_invoked.marker"); let pager_script = tmp_dir.path().join("test_pager.sh"); // Create a pager script that: // 1. Creates a marker file to prove it was invoked // 2. Passes stdin through to stdout (like cat) fs::write( &pager_script, format!("#!/bin/sh\ntouch '{}'\ncat\n", marker_file.display()), ) .unwrap(); // Make script executable #[cfg(unix)] { use std::os::unix::fs::PermissionsExt; fs::set_permissions(&pager_script, fs::Permissions::from_mode(0o755)).unwrap(); } // Generate wrapper script let output = std::process::Command::new(&wt_bin) .args(["config", "shell", "init", shell]) .output() .unwrap(); let wrapper_script = String::from_utf8_lossy(&output.stdout); // Build shell script that sources wrapper and runs help interactively let script = match shell { "fish" => format!( r#" set -x WORKTRUNK_BIN '{wt_bin}' set -x GIT_PAGER '{pager_script}' set -x CLICOLOR_FORCE 1 # Source the shell integration {wrapper_script} # Run help interactively (no redirect) - pager should be invoked wt --help # Marker to show script completed echo "SCRIPT_COMPLETED" "#, wt_bin = wt_bin.display(), pager_script = pager_script.display(), wrapper_script = wrapper_script, ), _ => format!( r#" export WORKTRUNK_BIN='{wt_bin}' export GIT_PAGER='{pager_script}' export CLICOLOR_FORCE=1 # Source the shell integration {wrapper_script} # Run help interactively (no redirect) - pager should be invoked wt --help # Marker to show script completed echo "SCRIPT_COMPLETED" "#, wt_bin = wt_bin.display(), pager_script = pager_script.display(), wrapper_script = wrapper_script, ), }; let pair = crate::common::open_pty(); let mut cmd = crate::common::shell_command(shell, Some(wt_bin_dir)); cmd.arg("-c"); cmd.arg(&script); cmd.cwd(repo.root_path()); let mut child = pair.slave.spawn_command(cmd).unwrap(); drop(pair.slave); let mut reader = pair.master.try_clone_reader().unwrap(); let buf = crate::common::pty::read_pty_master_to_string(&mut reader); let _status = child.wait().unwrap(); let terminal_output = buf.replace("\r\n", "\n"); // Verify script completed assert!( terminal_output.contains("SCRIPT_COMPLETED"), "{}: Script did not complete successfully.\nTerminal output:\n{}", shell, terminal_output ); // Verify pager was invoked (marker file should exist) assert!( marker_file.exists(), "{}: Pager was NOT invoked for interactive help.\n\ The marker file was not created, indicating show_help_in_pager() \n\ skipped the pager even though stderr is a TTY.\n\ Terminal output:\n{}", shell, terminal_output ); } } // ============================================================================= // Windows PowerShell Tests // ============================================================================= // // All Windows-specific tests are in this module, gated by #[cfg(windows)]. // This keeps platform-specific tests clearly separated. #[cfg(windows)] mod windows_tests { use super::*; use crate::common::repo; use rstest::rstest; // ConPTY Output Limitation (2026-01): // // The `test_powershell_*` wrapper tests are marked #[ignore] because ConPTY // output is not captured when the host process (cargo test) has its stdout // redirected. This is a known Windows limitation documented in: // https://github.com/microsoft/terminal/issues/11276 // // The simplified PowerShell template (`& $wtBin @Arguments`) works correctly // in normal terminal usage. Only the test harness is affected because cargo // test redirects stdout to capture test output. // // MANUAL VERIFICATION (2026-01): // The PowerShell wrapper was hand-tested on macOS using PowerShell Core (pwsh): // - Wrapper function registration works // - `wt list`, `wt --version` work correctly // - `wt switch --create` creates worktree, runs hooks, and changes directory // - Error handling returns correct exit codes // - `wt remove` works correctly // The wrapper logic is sound; only the CI test harness has the ConPTY issue. // // TODO: Re-enable these tests if a workaround for ConPTY stdout capture is found. // // The `test_conpty_*` diagnostic tests still run because they test direct // command execution without the shell wrapper. // ConPTY Handling Notes (2026-01): // // ConPTY behaves differently from Unix PTYs: // - Output pipe doesn't close when child exits (owned by pseudoconsole) // - ClosePseudoConsole must be called on separate thread while draining output // - Cursor position requests (ESC[6n) MUST be answered or console hangs // // Our implementation in tests/common/pty.rs handles this by: // 1. Keeping writer alive to respond to cursor queries // 2. Reading in chunks (not read_to_string) // 3. Detecting ESC[6n and responding with ESC[1;1R // 4. Closing master on separate thread while continuing to drain // // References: // - https://learn.microsoft.com/en-us/windows/console/closepseudoconsole // - https://github.com/microsoft/terminal/discussions/17716 /// Diagnostic test: Verify basic ConPTY functionality works with our cursor response handling. /// This test runs cmd.exe which is simpler than PowerShell and validates the core ConPTY fix. #[test] fn test_conpty_basic_cmd() { use crate::common::pty::{build_pty_command, exec_cmd_in_pty}; // Use cmd.exe for simplest possible test let tmp = tempfile::tempdir().unwrap(); let cmd = build_pty_command( "cmd.exe", &["/C", "echo CONPTY_WORKS"], tmp.path(), &[], None, ); let (output, exit_code) = exec_cmd_in_pty(cmd, ""); eprintln!("ConPTY test output: {:?}", output); eprintln!("ConPTY test exit code: {}", exit_code); // Accept exit code 0 or check for expected output // On ConPTY, we should now get the output without blocking assert!( output.contains("CONPTY_WORKS") || exit_code == 0, "ConPTY basic test should work. Output: {}, Exit: {}", output, exit_code ); } /// Diagnostic test: Verify wt --version works via ConPTY. #[test] fn test_conpty_wt_version() { use crate::common::pty::{build_pty_command, exec_cmd_in_pty}; use crate::common::wt_bin; let wt_bin = wt_bin(); let tmp = tempfile::tempdir().unwrap(); let cmd = build_pty_command( wt_bin.to_str().unwrap(), &["--version"], tmp.path(), &[], None, ); let (output, exit_code) = exec_cmd_in_pty(cmd, ""); eprintln!("wt --version output: {:?}", output); eprintln!("wt --version exit code: {}", exit_code); // wt --version should exit 0 and contain version info assert_eq!( exit_code, 0, "wt --version should succeed. Output: {}", output ); assert!( output.contains("wt") || output.contains("worktrunk"), "Should contain version info. Output: {}", output ); } /// Diagnostic test: Verify basic PowerShell execution works via PTY. #[test] fn test_conpty_powershell_basic() { let pair = crate::common::open_pty(); let shell_binary = shell_binary("powershell"); let mut cmd = portable_pty::CommandBuilder::new(shell_binary); cmd.env_clear(); // Set minimal Windows env vars if let Ok(val) = std::env::var("SystemRoot") { cmd.env("SystemRoot", &val); } if let Ok(val) = std::env::var("TEMP") { cmd.env("TEMP", &val); } cmd.env("PATH", std::env::var("PATH").unwrap_or_default()); cmd.arg("-NoProfile"); cmd.arg("-Command"); cmd.arg("Write-Host 'POWERSHELL_WORKS'; exit 42"); let tmp = tempfile::tempdir().unwrap(); cmd.cwd(tmp.path()); crate::common::pass_coverage_env_to_pty_cmd(&mut cmd); let mut child = pair.slave.spawn_command(cmd).unwrap(); drop(pair.slave); let reader = pair.master.try_clone_reader().unwrap(); let writer = pair.master.take_writer().unwrap(); let (output, exit_code) = crate::common::pty::read_pty_output(reader, writer, pair.master, &mut child); let normalized = output.replace("\r\n", "\n"); eprintln!("PowerShell basic test output: {:?}", normalized); eprintln!("PowerShell basic test exit code: {}", exit_code); assert_eq!(exit_code, 42, "Should get exit code from PowerShell"); assert!( normalized.contains("POWERSHELL_WORKS"), "Should capture PowerShell output. Got: {}", normalized ); } /// Test that PowerShell shell integration works for switch --create #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_switch_create(repo: TestRepo) { // Debug: print the script being generated let script = build_shell_script("powershell", &repo, "switch", &["--create", "feature"]); eprintln!("=== PowerShell Script Being Executed ==="); eprintln!("{}", script); eprintln!("=== End Script ==="); eprintln!("Script length: {} bytes", script.len()); let output = exec_through_wrapper("powershell", &repo, "switch", &["--create", "feature"]); eprintln!("=== PowerShell Output ==="); eprintln!("{:?}", output.combined); eprintln!("Exit code: {}", output.exit_code); eprintln!("=== End Output ==="); assert_eq!(output.exit_code, 0, "PowerShell: Command should succeed"); output.assert_no_directive_leaks(); assert!( output.combined.contains("Created branch") && output.combined.contains("and worktree"), "PowerShell: Should show success message.\nOutput:\n{}", output.combined ); } /// Test that PowerShell shell integration handles command failures correctly #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_command_failure(mut repo: TestRepo) { // Create a worktree that already exists repo.add_worktree("existing"); // Try to create it again - should fail let output = exec_through_wrapper("powershell", &repo, "switch", &["--create", "existing"]); assert_eq!( output.exit_code, 1, "PowerShell: Command should fail with exit code 1" ); output.assert_no_directive_leaks(); assert!( output.combined.contains("already exists"), "PowerShell: Error message should mention 'already exists'.\nOutput:\n{}", output.combined ); } /// Test that PowerShell shell integration works for remove #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_remove(mut repo: TestRepo) { // Create a worktree to remove repo.add_worktree("to-remove"); let output = exec_through_wrapper("powershell", &repo, "remove", &["to-remove"]); assert_eq!(output.exit_code, 0, "PowerShell: Command should succeed"); output.assert_no_directive_leaks(); } /// Test that PowerShell shell integration works for wt list #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_list(repo: TestRepo) { let output = exec_through_wrapper("powershell", &repo, "list", &[]); assert_eq!(output.exit_code, 0, "PowerShell: Command should succeed"); output.assert_no_directive_leaks(); // Should show the main worktree assert!( output.combined.contains("main"), "PowerShell: Should show main branch.\nOutput:\n{}", output.combined ); } /// Test that PowerShell correctly propagates exit codes from --execute commands #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_execute_exit_code_propagation(repo: TestRepo) { // Create a worktree with --execute that exits with a specific code let output = exec_through_wrapper( "powershell", &repo, "switch", &[ "--create", "feature", "--execute", "pwsh", "--", "-NoProfile", "-Command", "exit 42", ], ); // The wrapper should propagate the exit code from the executed command assert_eq!( output.exit_code, 42, "PowerShell: Should propagate exit code 42 from --execute.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); } /// Test that PowerShell handles branch names with slashes correctly #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_branch_with_slashes(repo: TestRepo) { let output = exec_through_wrapper("powershell", &repo, "switch", &["--create", "feature/auth"]); assert_eq!( output.exit_code, 0, "PowerShell: Should handle branch names with slashes.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); // Verify the worktree was created with sanitized name assert!( output.combined.contains("feature/auth") || output.combined.contains("feature-auth"), "PowerShell: Should show branch name.\nOutput:\n{}", output.combined ); } /// Test that PowerShell handles branch names with dashes and underscores #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_branch_with_dashes_underscores(repo: TestRepo) { let output = exec_through_wrapper( "powershell", &repo, "switch", &["--create", "my-feature_branch"], ); assert_eq!( output.exit_code, 0, "PowerShell: Should handle branch names with dashes/underscores.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); } /// Test that PowerShell wrapper function is properly registered #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_wrapper_function_registered(repo: TestRepo) { // Test that the wrapper function is defined by checking if it exists let wt_bin = wt_bin(); let wrapper_script = generate_wrapper(&repo, "powershell"); // Build a script that sources the wrapper and checks if wt is a function // Note: powershell_quote adds single quotes, so don't add them in the format string let script = format!( "$env:WORKTRUNK_BIN = {}\n\ $env:WORKTRUNK_CONFIG_PATH = {}\n\ $env:WORKTRUNK_APPROVALS_PATH = {}\n\ {}\n\ if (Get-Command wt -CommandType Function -ErrorAction SilentlyContinue) {{\n\ Write-Host 'WRAPPER_REGISTERED'\n\ exit 0\n\ }} else {{\n\ Write-Host 'WRAPPER_NOT_REGISTERED'\n\ exit 1\n\ }}", powershell_quote(&wt_bin.display().to_string()), powershell_quote(&repo.test_config_path().display().to_string()), powershell_quote(&repo.test_approvals_path().display().to_string()), wrapper_script ); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let env_vars = build_test_env_vars(&config_path, &approvals_path); let (combined, exit_code) = exec_in_pty_interactive("powershell", &script, repo.root_path(), &env_vars, &[]); assert_eq!( exit_code, 0, "PowerShell: Wrapper function should be registered.\nOutput:\n{}", combined ); assert!( combined.contains("WRAPPER_REGISTERED"), "PowerShell: Should confirm wrapper is registered.\nOutput:\n{}", combined ); } /// Test that PowerShell completion is registered #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_completion_registered(repo: TestRepo) { let wt_bin = wt_bin(); let wrapper_script = generate_wrapper(&repo, "powershell"); // Build a script that sources the wrapper and checks for completion // Note: powershell_quote adds single quotes, so don't add them in the format string let script = format!( "$env:WORKTRUNK_BIN = {}\n\ $env:WORKTRUNK_CONFIG_PATH = {}\n\ $env:WORKTRUNK_APPROVALS_PATH = {}\n\ {}\n\ $completers = Get-ArgumentCompleter -Native\n\ if ($completers | Where-Object {{ $_.CommandName -eq 'wt' }}) {{\n\ Write-Host 'COMPLETION_REGISTERED'\n\ exit 0\n\ }} else {{\n\ Write-Host 'COMPLETION_NOT_REGISTERED'\n\ exit 1\n\ }}", powershell_quote(&wt_bin.display().to_string()), powershell_quote(&repo.test_config_path().display().to_string()), powershell_quote(&repo.test_approvals_path().display().to_string()), wrapper_script ); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let env_vars = build_test_env_vars(&config_path, &approvals_path); let (combined, exit_code) = exec_in_pty_interactive("powershell", &script, repo.root_path(), &env_vars, &[]); // Completion registration might fail silently if COMPLETE env handling differs // Just verify the wrapper loaded without errors assert!( exit_code == 0 || combined.contains("COMPLETION"), "PowerShell: Should attempt completion registration.\nOutput:\n{}", combined ); } /// Test that PowerShell step for-each works across worktrees #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_step_for_each(mut repo: TestRepo) { // Create multiple worktrees repo.add_worktree("feature-1"); repo.add_worktree("feature-2"); let output = exec_through_wrapper( "powershell", &repo, "step", &["for-each", "--", "git", "status", "--short"], ); assert_eq!( output.exit_code, 0, "PowerShell: step for-each should succeed.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); } /// Test that PowerShell handles help output correctly #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_help_output(repo: TestRepo) { let output = exec_through_wrapper("powershell", &repo, "--help", &[]); assert_eq!( output.exit_code, 0, "PowerShell: --help should succeed.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); // Should show usage information assert!( output.combined.contains("Usage:") || output.combined.contains("USAGE:"), "PowerShell: Should show usage in help.\nOutput:\n{}", output.combined ); } /// Test that PowerShell preserves WORKTRUNK_BIN environment variable #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_worktrunk_bin_env(repo: TestRepo) { // This tests the fix we just made - WORKTRUNK_BIN should be used let wt_bin = wt_bin(); let wrapper_script = generate_wrapper(&repo, "powershell"); // Script that prints which binary would be used // Note: powershell_quote adds single quotes, so don't add them in the format string let script = format!( "$env:WORKTRUNK_BIN = {}\n\ $env:WORKTRUNK_CONFIG_PATH = {}\n\ $env:WORKTRUNK_APPROVALS_PATH = {}\n\ {}\n\ Write-Host \"BIN_PATH: $env:WORKTRUNK_BIN\"", powershell_quote(&wt_bin.display().to_string()), powershell_quote(&repo.test_config_path().display().to_string()), powershell_quote(&repo.test_approvals_path().display().to_string()), wrapper_script ); let config_path = repo.test_config_path().to_string_lossy().to_string(); let approvals_path = repo.test_approvals_path().to_string_lossy().to_string(); let env_vars = build_test_env_vars(&config_path, &approvals_path); let (combined, exit_code) = exec_in_pty_interactive("powershell", &script, repo.root_path(), &env_vars, &[]); assert_eq!( exit_code, 0, "PowerShell: Script should succeed.\nOutput:\n{}", combined ); assert!( combined.contains("BIN_PATH:"), "PowerShell: Should show bin path.\nOutput:\n{}", combined ); } /// Test that PowerShell merge command works #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_merge(mut repo: TestRepo) { // Create a feature branch worktree repo.add_worktree("feature"); let output = exec_through_wrapper("powershell", &repo, "merge", &["main"]); assert_eq!( output.exit_code, 0, "PowerShell: merge should succeed.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); } /// Test that PowerShell switch with execute works #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_switch_with_execute(repo: TestRepo) { // Use --yes to skip approval prompt let output = exec_through_wrapper( "powershell", &repo, "switch", &[ "--create", "test-exec", "--yes", "--execute", "pwsh", "--", "-NoProfile", "-Command", "Write-Host 'executed'", ], ); assert_eq!( output.exit_code, 0, "PowerShell: switch with execute should succeed.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); assert!( output.combined.contains("executed"), "PowerShell: Execute command output missing.\nOutput:\n{}", output.combined ); } /// Test PowerShell switch to existing worktree (no --create) #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_switch_existing(mut repo: TestRepo) { // First create a worktree repo.add_worktree("existing-feature"); // Now switch to it without --create let output = exec_through_wrapper("powershell", &repo, "switch", &["existing-feature"]); assert_eq!( output.exit_code, 0, "PowerShell: switch to existing should succeed.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); } /// Test PowerShell with --format json output #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_list_json(repo: TestRepo) { let output = exec_through_wrapper("powershell", &repo, "list", &["--format", "json"]); assert_eq!( output.exit_code, 0, "PowerShell: list --format json should succeed.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); // JSON output should be parseable (contains array brackets) assert!( output.combined.contains('[') && output.combined.contains(']'), "PowerShell: Should output JSON array.\nOutput:\n{}", output.combined ); } /// Test PowerShell config show command #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_config_show(repo: TestRepo) { let output = exec_through_wrapper("powershell", &repo, "config", &["show"]); assert_eq!( output.exit_code, 0, "PowerShell: config show should succeed.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); } /// Test PowerShell version command #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_version(repo: TestRepo) { let output = exec_through_wrapper("powershell", &repo, "--version", &[]); assert_eq!( output.exit_code, 0, "PowerShell: --version should succeed.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); // Should contain version number assert!( output.combined.contains("wt ") || output.combined.contains("worktrunk"), "PowerShell: Should show version info.\nOutput:\n{}", output.combined ); } /// Test that PowerShell suppresses shell integration hint when running through wrapper #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_shell_integration_hint_suppressed(repo: TestRepo) { // When running through the shell wrapper, the "To enable automatic cd" hint // should NOT appear because the user already has shell integration let output = exec_through_wrapper("powershell", &repo, "switch", &["--create", "ps-test"]); // Critical: shell integration hint must be suppressed when shell integration is active assert!( !output.combined.contains("To enable automatic cd"), "PowerShell: Shell integration hint should not appear when running through wrapper.\nOutput:\n{}", output.combined ); // Should still have the success message assert!( output.combined.contains("Created branch") && output.combined.contains("worktree"), "PowerShell: Success message missing.\nOutput:\n{}", output.combined ); } /// Test PowerShell switch from one worktree to another #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_switch_between_worktrees(mut repo: TestRepo) { // Create two worktrees repo.add_worktree("feature-first"); repo.add_worktree("feature-second"); // Switch from main to feature-first let output = exec_through_wrapper("powershell", &repo, "switch", &["feature-first"]); assert_eq!( output.exit_code, 0, "PowerShell: switch to existing worktree should succeed.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); } /// Test PowerShell with long branch names #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_long_branch_name(repo: TestRepo) { let long_name = "feature-with-a-really-long-descriptive-branch-name-that-goes-on"; let output = exec_through_wrapper("powershell", &repo, "switch", &["--create", long_name]); assert_eq!( output.exit_code, 0, "PowerShell: Should handle long branch names.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); } /// Test PowerShell remove with branch name argument #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_remove_by_name(mut repo: TestRepo) { // Create a worktree repo.add_worktree("to-delete"); // Remove it by name let output = exec_through_wrapper("powershell", &repo, "remove", &["to-delete"]); assert_eq!( output.exit_code, 0, "PowerShell: remove by name should succeed.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); } /// Test PowerShell list with verbose output /// /// NOTE: This test is ignored due to a ConPTY race condition where the output pipe /// doesn't properly close when the child exits. The --verbose flag produces enough /// output to trigger this race. Other PowerShell tests pass because they produce /// less output. This is a known limitation of ConPTY - see Microsoft docs on /// ClosePseudoConsole for background. #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_list_verbose(mut repo: TestRepo) { // Create a worktree repo.add_worktree("verbose-test"); let output = exec_through_wrapper("powershell", &repo, "list", &["--verbose"]); assert_eq!( output.exit_code, 0, "PowerShell: list --verbose should succeed.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); } /// Test PowerShell config shell init output #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_config_shell_init(repo: TestRepo) { let output = exec_through_wrapper( "powershell", &repo, "config", &["shell", "init", "powershell"], ); assert_eq!( output.exit_code, 0, "PowerShell: config shell init should succeed.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); // Should output PowerShell init script assert!( output.combined.contains("function") || output.combined.contains("WORKTRUNK"), "PowerShell: Should output shell init script.\nOutput:\n{}", output.combined ); } /// Test PowerShell handles missing branch gracefully #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_switch_nonexistent_branch(repo: TestRepo) { // Try to switch to a branch that doesn't exist (without --create) let output = exec_through_wrapper("powershell", &repo, "switch", &["nonexistent-branch"]); // Should fail with appropriate error assert_ne!( output.exit_code, 0, "PowerShell: switch to nonexistent branch should fail.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); } /// Test PowerShell step next command #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_step_next(mut repo: TestRepo) { // Create worktrees to step through repo.add_worktree("step-1"); repo.add_worktree("step-2"); let output = exec_through_wrapper("powershell", &repo, "step", &["next"]); // Step next might succeed or indicate nothing to step to output.assert_no_directive_leaks(); } /// Test PowerShell step prev command #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_step_prev(mut repo: TestRepo) { // Create worktrees repo.add_worktree("prev-1"); repo.add_worktree("prev-2"); let output = exec_through_wrapper("powershell", &repo, "step", &["prev"]); // Step prev might succeed or indicate nothing to step to output.assert_no_directive_leaks(); } /// Test PowerShell handles paths with spaces (common on Windows) /// Note: This test creates a branch name, not a path with spaces /// Path with spaces handling is tested implicitly via temp directories #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_special_branch_name(repo: TestRepo) { // Test a branch name with various special characters let output = exec_through_wrapper("powershell", &repo, "switch", &["--create", "fix_bug-123"]); assert_eq!( output.exit_code, 0, "PowerShell: Should handle special chars in branch names.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); } /// Test PowerShell hook show command #[rstest] #[ignore = "ConPTY output not captured when cargo test redirects stdout"] fn test_powershell_hook_show(repo: TestRepo) { let output = exec_through_wrapper("powershell", &repo, "hook", &["show"]); assert_eq!( output.exit_code, 0, "PowerShell: hook show should succeed.\nOutput:\n{}", output.combined ); output.assert_no_directive_leaks(); } }