Add test coverage

Author: simeg

src/lib.rs

@@ -35,7 +35,14 @@ impl std::fmt::Display for GitXError {
     }
 }
 
-impl std::error::Error for GitXError {}
+impl std::error::Error for GitXError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            GitXError::Io(err) => Some(err),
+            GitXError::GitCommand(_) | GitXError::Parse(_) => None,
+        }
+    }
+}
 
 impl From<std::io::Error> for GitXError {
     fn from(err: std::io::Error) -> Self {

src/sync.rs

@@ -67,15 +67,15 @@ pub fn run(merge: bool) {
 }
 
 #[derive(Debug, PartialEq)]
-enum SyncStatus {
+pub enum SyncStatus {
     UpToDate,
     Behind(u32),
     Ahead(u32),
     Diverged(u32, u32), // behind, ahead
 }
 
 // Helper function to get current branch
-fn get_current_branch() -> Result<String, &'static str> {
+pub fn get_current_branch() -> Result<String, &'static str> {
     let output = Command::new("git")
         .args(["rev-parse", "--abbrev-ref", "HEAD"])
         .output()
@@ -89,7 +89,7 @@ fn get_current_branch() -> Result<String, &'static str> {
 }
 
 // Helper function to get upstream branch
-fn get_upstream_branch(branch: &str) -> Result<String, &'static str> {
+pub fn get_upstream_branch(branch: &str) -> Result<String, &'static str> {
     let output = Command::new("git")
         .args(["rev-parse", "--abbrev-ref", &format!("{branch}@{{u}}")])
         .output()
@@ -103,7 +103,7 @@ fn get_upstream_branch(branch: &str) -> Result<String, &'static str> {
 }
 
 // Helper function to fetch from upstream
-fn fetch_upstream(upstream: &str) -> Result<(), &'static str> {
+pub fn fetch_upstream(upstream: &str) -> Result<(), &'static str> {
     let remote = upstream.split('/').next().unwrap_or("origin");
 
     let status = Command::new("git")
@@ -119,7 +119,7 @@ fn fetch_upstream(upstream: &str) -> Result<(), &'static str> {
 }
 
 // Helper function to get sync status
-fn get_sync_status(branch: &str, upstream: &str) -> Result<SyncStatus, &'static str> {
+pub fn get_sync_status(branch: &str, upstream: &str) -> Result<SyncStatus, &'static str> {
     let output = Command::new("git")
         .args([
             "rev-list",
@@ -162,7 +162,7 @@ pub fn parse_sync_counts(output: &str) -> Result<(u32, u32), &'static str> {
 }
 
 // Helper function to sync with upstream
-fn sync_with_upstream(upstream: &str, merge: bool) -> Result<(), &'static str> {
+pub fn sync_with_upstream(upstream: &str, merge: bool) -> Result<(), &'static str> {
     let args = if merge {
         ["merge", upstream]
     } else {

tests/test_lib.rs

@@ -0,0 +1,79 @@
+use git_x::{GitXError, Result};
+use std::io;
+
+#[test]
+fn test_gitx_error_git_command() {
+    let error = GitXError::GitCommand("git status failed".to_string());
+    assert_eq!(format!("{error}"), "Git command failed: git status failed");
+}
+
+#[test]
+fn test_gitx_error_io() {
+    let io_error = io::Error::new(io::ErrorKind::NotFound, "File not found");
+    let error = GitXError::Io(io_error);
+    assert_eq!(format!("{error}"), "IO error: File not found");
+}
+
+#[test]
+fn test_gitx_error_parse() {
+    let error = GitXError::Parse("Invalid format".to_string());
+    assert_eq!(format!("{error}"), "Parse error: Invalid format");
+}
+
+#[test]
+fn test_gitx_error_debug() {
+    let error = GitXError::GitCommand("test".to_string());
+    let debug_str = format!("{error:?}");
+    assert!(debug_str.contains("GitCommand"));
+    assert!(debug_str.contains("test"));
+}
+
+#[test]
+fn test_gitx_error_is_error() {
+    let error = GitXError::Parse("test error".to_string());
+    let _: &dyn std::error::Error = &error;
+}
+
+#[test]
+fn test_from_io_error() {
+    let io_error = io::Error::new(io::ErrorKind::PermissionDenied, "Access denied");
+    let gitx_error: GitXError = io_error.into();
+
+    match gitx_error {
+        GitXError::Io(err) => {
+            assert_eq!(err.kind(), io::ErrorKind::PermissionDenied);
+            assert_eq!(format!("{err}"), "Access denied");
+        }
+        _ => panic!("Expected GitXError::Io"),
+    }
+}
+
+#[test]
+fn test_result_type() {
+    let success: i32 = 42;
+    assert_eq!(success, 42);
+
+    let failure: Result<i32> = Err(GitXError::Parse("test".to_string()));
+    assert!(failure.is_err());
+}
+
+#[test]
+fn test_error_chain() {
+    let io_error = io::Error::other("Original error");
+    let gitx_error: GitXError = io_error.into();
+
+    let error_string = format!("{gitx_error}");
+    assert!(error_string.contains("IO error"));
+    assert!(error_string.contains("Original error"));
+}
+
+#[test]
+fn test_gitx_error_source() {
+    let io_error = io::Error::new(io::ErrorKind::InvalidInput, "Bad input");
+    let gitx_error = GitXError::Io(io_error);
+
+    // Test that it implements Error trait properly
+    use std::error::Error;
+    let error_trait: &dyn Error = &gitx_error;
+    assert!(error_trait.source().is_some());
+}

tests/test_rename_branch.rs

@@ -1,8 +1,13 @@
 mod common;
 
+use assert_cmd::Command as AssertCmd;
 use common::repo_with_branch;
 use git_x::rename_branch::*;
+use predicates::prelude::*;
+use std::fs;
+use std::path::PathBuf;
 use std::process::Command;
+use tempfile::TempDir;
 
 #[test]
 fn test_rename_branch_in_isolated_repo() {
@@ -139,5 +144,187 @@ fn test_format_rename_success_message() {
     );
 }
 
-// Note: rename_branch::run() interacts with remotes, making it difficult to test directly
-// The CLI integration tests cover this functionality instead
+// Helper function to create a test git repository
+fn create_test_repo() -> (TempDir, PathBuf) {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+    let repo_path = temp_dir.path().to_path_buf();
+
+    // Initialize git repo
+    Command::new("git")
+        .args(["init"])
+        .current_dir(&repo_path)
+        .output()
+        .expect("Failed to init repo");
+
+    // Configure git
+    Command::new("git")
+        .args(["config", "user.name", "Test User"])
+        .current_dir(&repo_path)
+        .output()
+        .expect("Failed to configure user");
+
+    Command::new("git")
+        .args(["config", "user.email", "test@example.com"])
+        .current_dir(&repo_path)
+        .output()
+        .expect("Failed to configure email");
+
+    // Create initial commit
+    fs::write(repo_path.join("README.md"), "Initial commit").expect("Failed to write file");
+    Command::new("git")
+        .args(["add", "README.md"])
+        .current_dir(&repo_path)
+        .output()
+        .expect("Failed to add file");
+
+    Command::new("git")
+        .args(["commit", "-m", "Initial commit"])
+        .current_dir(&repo_path)
+        .output()
+        .expect("Failed to commit");
+
+    (temp_dir, repo_path)
+}
+
+#[test]
+fn test_rename_branch_run_outside_git_repo() {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+
+    let mut cmd = AssertCmd::cargo_bin("git-x").expect("Failed to find binary");
+    cmd.args(["rename-branch", "new-name"])
+        .current_dir(temp_dir.path())
+        .assert()
+        .failure()
+        .code(1)
+        .stderr(predicate::str::contains(
+            "Failed to get current branch name",
+        ));
+}
+
+#[test]
+fn test_rename_branch_same_name() {
+    let (_temp_dir, repo_path) = create_test_repo();
+
+    // Get current branch name (should be main or master)
+    let output = Command::new("git")
+        .args(["rev-parse", "--abbrev-ref", "HEAD"])
+        .current_dir(&repo_path)
+        .output()
+        .expect("Failed to get current branch");
+
+    let current_branch = String::from_utf8_lossy(&output.stdout).trim().to_string();
+
+    let mut cmd = AssertCmd::cargo_bin("git-x").expect("Failed to find binary");
+    cmd.args(["rename-branch", &current_branch])
+        .current_dir(&repo_path)
+        .assert()
+        .success()
+        .stdout(predicate::str::contains(format!(
+            "Current branch is already named '{current_branch}'. Nothing to do."
+        )));
+}
+
+#[test]
+fn test_rename_branch_local_rename_failure() {
+    let (_temp_dir, repo_path) = create_test_repo();
+
+    // Create a branch with an invalid name that would cause rename to fail
+    // Use invalid characters that git doesn't allow
+    let mut cmd = AssertCmd::cargo_bin("git-x").expect("Failed to find binary");
+    cmd.args(["rename-branch", "branch..with..double..dots"])
+        .current_dir(&repo_path)
+        .assert()
+        .failure()
+        .code(1)
+        .stderr(predicate::str::contains("Failed to rename local branch"));
+}
+
+#[test]
+fn test_rename_branch_command_help() {
+    let mut cmd = AssertCmd::cargo_bin("git-x").expect("Failed to find binary");
+    cmd.args(["rename-branch", "--help"])
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("Rename the current branch"));
+}
+
+#[test]
+fn test_rename_branch_push_failure() {
+    let (_temp_dir, repo_path) = create_test_repo();
+
+    // Add a fake remote that doesn't exist to cause push failure
+    Command::new("git")
+        .args([
+            "remote",
+            "add",
+            "origin",
+            "https://github.com/nonexistent/repo.git",
+        ])
+        .current_dir(&repo_path)
+        .output()
+        .expect("Failed to add remote");
+
+    let mut cmd = AssertCmd::cargo_bin("git-x").expect("Failed to find binary");
+    cmd.args(["rename-branch", "new-branch-name"])
+        .current_dir(&repo_path)
+        .assert()
+        .failure()
+        .code(1)
+        .stderr(predicate::str::contains(
+            "Failed to push new branch to origin",
+        ));
+}
+
+#[test]
+fn test_rename_branch_edge_cases() {
+    // Test various edge cases in formatting and validation
+
+    // Test empty branch name handling
+    assert_eq!(
+        format_already_named_message(""),
+        "Current branch is already named ''. Nothing to do."
+    );
+
+    // Test special characters in branch names
+    assert_eq!(
+        format_rename_start_message("feature/test-123", "hotfix/urgent_fix"),
+        "Renaming branch 'feature/test-123' to 'hotfix/urgent_fix'"
+    );
+
+    // Test long branch names
+    let long_name = "very-long-branch-name-that-exceeds-normal-length";
+    assert_eq!(
+        format_delete_success_message(long_name),
+        format!("Deleted old branch '{long_name}' from origin.")
+    );
+}
+
+#[test]
+fn test_rename_branch_args_completeness() {
+    // Ensure all argument generation functions produce valid arrays
+    let current_args = get_current_branch_args();
+    assert_eq!(current_args.len(), 3);
+    assert!(current_args.contains(&"rev-parse"));
+    assert!(current_args.contains(&"--abbrev-ref"));
+    assert!(current_args.contains(&"HEAD"));
+
+    let local_rename_args = get_local_rename_args("test");
+    assert_eq!(local_rename_args.len(), 3);
+    assert!(local_rename_args.contains(&"branch".to_string()));
+    assert!(local_rename_args.contains(&"-m".to_string()));
+    assert!(local_rename_args.contains(&"test".to_string()));
+
+    let push_args = get_push_new_branch_args("test");
+    assert_eq!(push_args.len(), 4);
+    assert!(push_args.contains(&"push".to_string()));
+    assert!(push_args.contains(&"-u".to_string()));
+    assert!(push_args.contains(&"origin".to_string()));
+    assert!(push_args.contains(&"test".to_string()));
+
+    let delete_args = get_delete_old_branch_args("old");
+    assert_eq!(delete_args.len(), 4);
+    assert!(delete_args.contains(&"push".to_string()));
+    assert!(delete_args.contains(&"origin".to_string()));
+    assert!(delete_args.contains(&"--delete".to_string()));
+    assert!(delete_args.contains(&"old".to_string()));
+}