improve coverage

Author: ozankasikci

src/cli/mod.rs

@@ -165,3 +165,125 @@ fn resolve_worktree_name(name: Option<String>, repo: &Repo) -> color_eyre::Resul
 
     Ok(components.join("/"))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::{env, fs, path::Path, process::Command as StdCommand};
+
+    use color_eyre::eyre::{self, WrapErr};
+
+    use tempfile::TempDir;
+
+    struct DirGuard {
+        original: std::path::PathBuf,
+    }
+
+    impl DirGuard {
+        fn change_to(path: &Path) -> color_eyre::Result<Self> {
+            let original = env::current_dir().wrap_err("failed to capture current directory")?;
+            env::set_current_dir(path)
+                .wrap_err_with(|| eyre::eyre!("failed to switch to `{}`", path.display()))?;
+            Ok(Self { original })
+        }
+    }
+
+    impl Drop for DirGuard {
+        fn drop(&mut self) {
+            let _ = env::set_current_dir(&self.original);
+        }
+    }
+
+    fn init_git_repo(dir: &TempDir) -> color_eyre::Result<()> {
+        run(dir, ["git", "init"])?;
+        fs::write(dir.path().join("README.md"), "test")?;
+        run(dir, ["git", "add", "README.md"])?;
+        run(
+            dir,
+            [
+                "git",
+                "-c",
+                "user.name=Test",
+                "-c",
+                "user.email=test@example.com",
+                "commit",
+                "-m",
+                "Initial commit",
+            ],
+        )?;
+        Ok(())
+    }
+
+    fn run(dir: &TempDir, cmd: impl IntoIterator<Item = &'static str>) -> color_eyre::Result<()> {
+        let mut iter = cmd.into_iter();
+        let program = iter.next().expect("command must not be empty");
+        let status = StdCommand::new(program)
+            .current_dir(dir.path())
+            .args(iter)
+            .status()
+            .wrap_err_with(|| eyre::eyre!("failed to run `{program}`"))?;
+
+        if !status.success() {
+            return Err(eyre::eyre!("`{program}` exited with status {status}"));
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn resolve_worktree_name_returns_cli_argument_when_present() -> color_eyre::Result<()> {
+        let repo_dir = TempDir::new()?;
+        init_git_repo(&repo_dir)?;
+        let repo = Repo::discover_from(repo_dir.path())?;
+
+        let resolved = resolve_worktree_name(Some("feature/test".into()), &repo)?;
+        assert_eq!(resolved, "feature/test");
+
+        Ok(())
+    }
+
+    #[test]
+    fn resolve_worktree_name_infers_from_cwd_inside_worktree() -> color_eyre::Result<()> {
+        let repo_dir = TempDir::new()?;
+        init_git_repo(&repo_dir)?;
+        let repo = Repo::discover_from(repo_dir.path())?;
+        let worktree_dir = repo.ensure_worktrees_dir()?.join("feature/nested");
+        fs::create_dir_all(&worktree_dir)?;
+
+        let _guard = DirGuard::change_to(&worktree_dir)?;
+        let resolved = resolve_worktree_name(None, &repo)?;
+        assert_eq!(resolved, "feature/nested");
+
+        Ok(())
+    }
+
+    #[test]
+    fn resolve_worktree_name_requires_running_inside_worktree() -> color_eyre::Result<()> {
+        let repo_dir = TempDir::new()?;
+        init_git_repo(&repo_dir)?;
+        let repo = Repo::discover_from(repo_dir.path())?;
+        let _guard = DirGuard::change_to(repo.root())?;
+
+        let err = resolve_worktree_name(None, &repo).unwrap_err();
+        assert!(err.to_string().contains("must be run from inside"));
+
+        Ok(())
+    }
+
+    #[test]
+    fn resolve_worktree_name_rejects_rsworktree_root() -> color_eyre::Result<()> {
+        let repo_dir = TempDir::new()?;
+        init_git_repo(&repo_dir)?;
+        let repo = Repo::discover_from(repo_dir.path())?;
+        let worktrees_dir = repo.ensure_worktrees_dir()?;
+        let _guard = DirGuard::change_to(&worktrees_dir)?;
+
+        let err = resolve_worktree_name(None, &repo).unwrap_err();
+        assert!(
+            err.to_string()
+                .contains("Run `rsworktree pr-github` from inside")
+        );
+
+        Ok(())
+    }
+}

src/commands/cd/mod.rs

@@ -79,7 +79,11 @@ pub(crate) fn shell_command() -> (String, Vec<String>) {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::{fs, process::Command as StdCommand};
+    use std::{
+        env, fs,
+        process::Command as StdCommand,
+        sync::{Mutex, OnceLock},
+    };
 
     use tempfile::TempDir;
 
@@ -147,4 +151,88 @@ mod tests {
         let command = CdCommand::new("missing".into(), true);
         assert!(command.execute(&repo).is_err());
     }
+
+    struct EnvGuard {
+        key: &'static str,
+        previous: Option<std::ffi::OsString>,
+        had_value: bool,
+    }
+
+    impl EnvGuard {
+        fn set(key: &'static str, value: &str) -> Self {
+            let previous = env::var_os(key);
+            unsafe {
+                env::set_var(key, value);
+            }
+            Self {
+                key,
+                previous,
+                had_value: true,
+            }
+        }
+
+        fn remove(key: &'static str) -> Self {
+            let previous = env::var_os(key);
+            unsafe {
+                env::remove_var(key);
+            }
+            Self {
+                key,
+                previous,
+                had_value: false,
+            }
+        }
+    }
+
+    impl Drop for EnvGuard {
+        fn drop(&mut self) {
+            if let Some(value) = self.previous.take() {
+                unsafe {
+                    env::set_var(self.key, value);
+                }
+            } else if self.had_value {
+                unsafe {
+                    env::remove_var(self.key);
+                }
+            }
+        }
+    }
+
+    fn env_lock() -> &'static Mutex<()> {
+        static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
+        LOCK.get_or_init(|| Mutex::new(()))
+    }
+
+    #[test]
+    fn shell_command_prefers_override_env() {
+        let _lock = env_lock().lock().unwrap();
+        let _shell_guard = EnvGuard::remove("SHELL");
+        let _override_guard = EnvGuard::set(SHELL_OVERRIDE_ENV, "/custom/shell");
+
+        let (program, args) = shell_command();
+        assert_eq!(program, "/custom/shell");
+        assert!(args.is_empty());
+    }
+
+    #[test]
+    fn shell_command_uses_shell_env_when_override_missing() {
+        let _lock = env_lock().lock().unwrap();
+        let _override_guard = EnvGuard::remove(SHELL_OVERRIDE_ENV);
+        let _shell_guard = EnvGuard::set("SHELL", "/bin/bash");
+
+        let (program, args) = shell_command();
+        assert_eq!(program, "/bin/bash");
+        assert_eq!(args, vec![String::from("-i")]);
+    }
+
+    #[test]
+    fn shell_command_falls_back_to_default() {
+        let _lock = env_lock().lock().unwrap();
+        let _override_guard = EnvGuard::set(SHELL_OVERRIDE_ENV, "");
+        let _shell_guard = EnvGuard::set("SHELL", "");
+
+        let (program, args) = shell_command();
+        assert_eq!(program, "/bin/sh");
+        assert_eq!(args, vec![String::from("-i")]);
+    }
 }

src/commands/pr_github/mod.rs

@@ -353,6 +353,53 @@ mod tests {
 
     use tempfile::TempDir;
 
+    #[test]
+    fn metadata_flag_allows_known_noninteractive_values() {
+        for flag in [
+            "--fill",
+            "-f",
+            "--fill-first",
+            "--fill-verbose",
+            "--web",
+            "-w",
+            "--title",
+            "--body",
+            "--body-file",
+            "--title=Ready",
+            "--body=Looks good",
+            "--body-file=notes.md",
+        ] {
+            assert!(
+                metadata_flag_allows_noninteractive(flag),
+                "flag `{flag}` should be accepted"
+            );
+        }
+    }
+
+    #[test]
+    fn metadata_flag_allows_noninteractive_rejects_positional_separator_and_plain_args() {
+        for flag in ["--", "--reviewer", "ready"] {
+            assert!(
+                !metadata_flag_allows_noninteractive(flag),
+                "flag `{flag}` should be rejected"
+            );
+        }
+    }
+
+    #[test]
+    fn format_command_quotes_arguments_with_special_characters() {
+        let command = format_command(
+            "gh",
+            &[
+                "pr".into(),
+                "create".into(),
+                "--title".into(),
+                "Ready for review".into(),
+            ],
+        );
+        assert_eq!(command, "gh pr create --title 'Ready for review'");
+    }
+
     #[derive(Debug, Default)]
     struct MockCommandRunner {
         responses: VecDeque<color_eyre::Result<CommandOutput>>,