improve test coverage for cli, editor preference, and open_editor

Author: ozankasikci

src/cli/mod.rs

@@ -376,4 +376,125 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn parses_create_command_with_base() {
+        let cli = Cli::try_parse_from(["rsworktree", "create", "feature/test", "--base", "develop"])
+            .expect("create with base should parse");
+        match cli.command {
+            Commands::Create(args) => {
+                assert_eq!(args.name, "feature/test");
+                assert_eq!(args.base, Some("develop".into()));
+            }
+            _ => panic!("expected Create command"),
+        }
+    }
+
+    #[test]
+    fn parses_cd_command_with_print_flag() {
+        let cli = Cli::try_parse_from(["rsworktree", "cd", "my-worktree", "--print"])
+            .expect("cd with print should parse");
+        match cli.command {
+            Commands::Cd(args) => {
+                assert_eq!(args.name, "my-worktree");
+                assert!(args.print);
+            }
+            _ => panic!("expected Cd command"),
+        }
+    }
+
+    #[test]
+    fn parses_rm_command_with_force_flag() {
+        let cli = Cli::try_parse_from(["rsworktree", "rm", "old-worktree", "--force"])
+            .expect("rm with force should parse");
+        match cli.command {
+            Commands::Rm(args) => {
+                assert_eq!(args.name, "old-worktree");
+                assert!(args.force);
+            }
+            _ => panic!("expected Rm command"),
+        }
+    }
+
+    #[test]
+    fn parses_pr_github_with_all_flags() {
+        let cli = Cli::try_parse_from([
+            "rsworktree",
+            "pr-github",
+            "my-feature",
+            "--no-push",
+            "--draft",
+            "--fill",
+            "--web",
+            "--remote",
+            "upstream",
+            "--reviewer",
+            "alice",
+            "--reviewer",
+            "bob",
+            "--",
+            "--label",
+            "bug",
+        ])
+        .expect("pr-github with all flags should parse");
+        match cli.command {
+            Commands::PrGithub(args) => {
+                assert_eq!(args.name, Some("my-feature".into()));
+                assert!(args.no_push);
+                assert!(args.draft);
+                assert!(args.fill);
+                assert!(args.web);
+                assert_eq!(args.remote, "upstream");
+                assert_eq!(args.reviewers, vec!["alice", "bob"]);
+                assert_eq!(args.extra, vec!["--label", "bug"]);
+            }
+            _ => panic!("expected PrGithub command"),
+        }
+    }
+
+    #[test]
+    fn parses_merge_pr_github_with_remove_flag() {
+        let cli = Cli::try_parse_from(["rsworktree", "merge-pr-github", "feature", "--remove"])
+            .expect("merge-pr-github with remove should parse");
+        match cli.command {
+            Commands::MergePrGithub(args) => {
+                assert_eq!(args.name, Some("feature".into()));
+                assert!(args.remove_remote);
+            }
+            _ => panic!("expected MergePrGithub command"),
+        }
+    }
+
+    #[test]
+    fn parses_worktree_open_editor_by_name() {
+        let cli = Cli::try_parse_from(["rsworktree", "worktree", "open-editor", "feature/test"])
+            .expect("worktree open-editor by name should parse");
+        match cli.command {
+            Commands::Worktree(WorktreeCommands::OpenEditor(args)) => {
+                assert_eq!(args.name, Some("feature/test".into()));
+                assert!(args.path.is_none());
+            }
+            _ => panic!("expected Worktree OpenEditor command"),
+        }
+    }
+
+    #[test]
+    fn parses_worktree_open_editor_by_path() {
+        let cli =
+            Cli::try_parse_from(["rsworktree", "worktree", "open-editor", "--path", "/some/path"])
+                .expect("worktree open-editor by path should parse");
+        match cli.command {
+            Commands::Worktree(WorktreeCommands::OpenEditor(args)) => {
+                assert!(args.name.is_none());
+                assert_eq!(args.path, Some(PathBuf::from("/some/path")));
+            }
+            _ => panic!("expected Worktree OpenEditor command"),
+        }
+    }
+
+    #[test]
+    fn parses_ls_command() {
+        let cli = Cli::try_parse_from(["rsworktree", "ls"]).expect("ls should parse");
+        assert!(matches!(cli.command, Commands::Ls));
+    }
 }

src/editor/preference.rs

@@ -240,4 +240,155 @@ mod tests {
             EditorPreferenceResolution::Missing(PreferenceMissingReason::NotConfigured)
         ));
     }
+
+    #[test]
+    fn config_invalid_when_json_malformed() {
+        let dir = TempDir::new().expect("tempdir");
+        let repo = init_repo(&dir);
+        let worktrees_dir = repo.ensure_worktrees_dir().expect("worktrees dir");
+        let config_path = worktrees_dir.join(CONFIG_FILE_NAME);
+
+        fs::write(&config_path, "{ invalid json }").expect("write config");
+
+        match resolve_editor_preference(&repo).expect("resolution") {
+            EditorPreferenceResolution::Missing(PreferenceMissingReason::ConfigInvalid {
+                path,
+                error,
+            }) => {
+                assert_eq!(path, config_path);
+                assert!(error.contains("expected") || error.contains("key"));
+            }
+            other => panic!("expected ConfigInvalid, got: {other:?}"),
+        }
+    }
+
+    #[test]
+    fn config_invalid_when_command_empty() {
+        let dir = TempDir::new().expect("tempdir");
+        let repo = init_repo(&dir);
+        let worktrees_dir = repo.ensure_worktrees_dir().expect("worktrees dir");
+        let config_path = worktrees_dir.join(CONFIG_FILE_NAME);
+
+        let json = serde_json::json!({
+            "editor": {
+                "command": "   ",
+                "args": []
+            }
+        });
+        fs::write(&config_path, serde_json::to_vec(&json).unwrap()).expect("write config");
+
+        match resolve_editor_preference(&repo).expect("resolution") {
+            EditorPreferenceResolution::Missing(PreferenceMissingReason::ConfigInvalid {
+                error,
+                ..
+            }) => {
+                assert!(error.contains("must not be empty"));
+            }
+            other => panic!("expected ConfigInvalid, got: {other:?}"),
+        }
+    }
+
+    #[test]
+    fn config_with_no_editor_key_falls_through() {
+        let dir = TempDir::new().expect("tempdir");
+        let repo = init_repo(&dir);
+        let worktrees_dir = repo.ensure_worktrees_dir().expect("worktrees dir");
+        let config_path = worktrees_dir.join(CONFIG_FILE_NAME);
+
+        let json = serde_json::json!({
+            "other_setting": true
+        });
+        fs::write(&config_path, serde_json::to_vec(&json).unwrap()).expect("write config");
+
+        let resolution = resolve_editor_preference(&repo).expect("resolution");
+        assert!(matches!(
+            resolution,
+            EditorPreferenceResolution::Missing(PreferenceMissingReason::NotConfigured)
+        ));
+    }
+
+    #[test]
+    fn load_from_env_parses_command_with_args() {
+        let result = load_from_env_value("vim -u NONE", EditorEnvVar::Editor);
+        match result {
+            Ok(Some(pref)) => {
+                assert_eq!(pref.command, OsString::from("vim"));
+                assert_eq!(pref.args, vec![OsString::from("-u"), OsString::from("NONE")]);
+            }
+            other => panic!("expected Some preference, got: {other:?}"),
+        }
+    }
+
+    #[test]
+    fn load_from_env_handles_quoted_args() {
+        let result = load_from_env_value(r#"code --wait --new-window"#, EditorEnvVar::Visual);
+        match result {
+            Ok(Some(pref)) => {
+                assert_eq!(pref.command, OsString::from("code"));
+                assert_eq!(
+                    pref.args,
+                    vec![OsString::from("--wait"), OsString::from("--new-window")]
+                );
+            }
+            other => panic!("expected Some preference, got: {other:?}"),
+        }
+    }
+
+    #[test]
+    fn load_from_env_returns_none_for_empty() {
+        let result = load_from_env_value("", EditorEnvVar::Editor);
+        assert!(matches!(result, Ok(None)));
+    }
+
+    #[test]
+    fn load_from_env_returns_none_for_whitespace_only() {
+        let result = load_from_env_value("   ", EditorEnvVar::Editor);
+        assert!(matches!(result, Ok(None)));
+    }
+
+    #[test]
+    fn load_from_env_errors_on_unclosed_quote() {
+        let result = load_from_env_value(r#"vim "unclosed"#, EditorEnvVar::Editor);
+        match result {
+            Err(PreferenceMissingReason::EnvInvalid { variable, error }) => {
+                assert_eq!(variable, EditorEnvVar::Editor);
+                assert!(!error.is_empty());
+            }
+            other => panic!("expected EnvInvalid, got: {other:?}"),
+        }
+    }
+
+    #[test]
+    fn editor_env_var_name_returns_correct_strings() {
+        assert_eq!(EditorEnvVar::Editor.name(), "EDITOR");
+        assert_eq!(EditorEnvVar::Visual.name(), "VISUAL");
+    }
+
+    fn load_from_env_value(
+        value: &str,
+        variable: EditorEnvVar,
+    ) -> Result<Option<EditorPreference>, PreferenceMissingReason> {
+        if value.is_empty() {
+            return Ok(None);
+        }
+
+        let parts = shell_words::split(value).map_err(|error| PreferenceMissingReason::EnvInvalid {
+            variable,
+            error: error.to_string(),
+        })?;
+
+        if parts.is_empty() {
+            return Ok(None);
+        }
+
+        let mut parts_iter = parts.into_iter();
+        let command = parts_iter.next().unwrap();
+        let args = parts_iter.map(OsString::from).collect::<Vec<_>>();
+
+        Ok(Some(EditorPreference {
+            command: OsString::from(command),
+            args,
+            source: EditorPreferenceSource::Environment { variable },
+        }))
+    }
 }

tests/commands/open_editor.rs

@@ -145,3 +145,111 @@ impl Drop for EnvGuard {
         }
     }
 }
+
+#[test]
+fn open_editor_with_path_flag() -> Result<(), Box<dyn Error>> {
+    let repo_dir = TempDir::new()?;
+    init_git_repo(repo_dir.path())?;
+    create_worktree(repo_dir.path(), "feature/pathtest")?;
+
+    let worktree_path = repo_dir.path().join(".rsworktree/feature/pathtest");
+    let editor_cmd = "/usr/bin/env true";
+    let guard = EnvGuard::set("EDITOR", editor_cmd);
+
+    Command::cargo_bin("rsworktree")?
+        .current_dir(repo_dir.path())
+        .args([
+            "worktree",
+            "open-editor",
+            "--path",
+            worktree_path.to_str().unwrap(),
+        ])
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("Opened"));
+
+    drop(guard);
+    Ok(())
+}
+
+#[test]
+fn open_editor_errors_when_path_does_not_exist() -> Result<(), Box<dyn Error>> {
+    let repo_dir = TempDir::new()?;
+    init_git_repo(repo_dir.path())?;
+
+    Command::cargo_bin("rsworktree")?
+        .current_dir(repo_dir.path())
+        .args(["worktree", "open-editor", "--path", "/nonexistent/path"])
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("does not exist"));
+
+    Ok(())
+}
+
+#[test]
+fn open_editor_matches_partial_name() -> Result<(), Box<dyn Error>> {
+    let repo_dir = TempDir::new()?;
+    init_git_repo(repo_dir.path())?;
+    create_worktree(repo_dir.path(), "feature/unique-name")?;
+
+    let editor_cmd = "/usr/bin/env true";
+    let guard = EnvGuard::set("EDITOR", editor_cmd);
+
+    // Match by last segment
+    Command::cargo_bin("rsworktree")?
+        .current_dir(repo_dir.path())
+        .args(["worktree", "open-editor", "unique-name"])
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("feature/unique-name"));
+
+    drop(guard);
+    Ok(())
+}
+
+#[test]
+fn open_editor_errors_on_ambiguous_name() -> Result<(), Box<dyn Error>> {
+    let repo_dir = TempDir::new()?;
+    init_git_repo(repo_dir.path())?;
+    create_worktree(repo_dir.path(), "feature/shared")?;
+    create_worktree(repo_dir.path(), "bugfix/shared")?;
+
+    Command::cargo_bin("rsworktree")?
+        .current_dir(repo_dir.path())
+        .args(["worktree", "open-editor", "shared"])
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("ambiguous"));
+
+    Ok(())
+}
+
+#[test]
+fn open_editor_uses_preferences_file() -> Result<(), Box<dyn Error>> {
+    let repo_dir = TempDir::new()?;
+    init_git_repo(repo_dir.path())?;
+    create_worktree(repo_dir.path(), "feature/prefs")?;
+
+    // Create preferences file
+    let prefs_dir = repo_dir.path().join(".rsworktree");
+    fs::create_dir_all(&prefs_dir)?;
+    fs::write(
+        prefs_dir.join("preferences.json"),
+        r#"{"editor": {"command": "/usr/bin/env", "args": ["true"]}}"#,
+    )?;
+
+    let guard_editor = EnvGuard::remove("EDITOR");
+    let guard_visual = EnvGuard::remove("VISUAL");
+
+    Command::cargo_bin("rsworktree")?
+        .current_dir(repo_dir.path())
+        .args(["worktree", "open-editor", "feature/prefs"])
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("Opened"));
+
+    drop(guard_visual);
+    drop(guard_editor);
+    Ok(())
+}