Refactor test files to eliminate code duplication

- Remove duplicate create_test_repo() functions from test_fixup.rs, test_upstream.rs, and test_sync.rs
- Extend tests/common/mod.rs with enhanced test utilities:
  - TestUtils for directory management and command helpers
  - TestRepoBuilder for flexible test repository creation
  - TestAssertions for common test patterns
  - Enhanced TestRepo with create_commit_with_hash(), stage_files(), etc.
- Update test files to use shared utilities instead of duplicated code
- Eliminate ~120+ lines of duplicated test code across multiple files
- Maintain all existing test functionality while improving maintainability

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: simeg

tests/common/mod.rs

@@ -436,3 +436,197 @@ pub fn repo_with_remote_ahead(branch_name: &str) -> (TestRepo, TestRepo) {
 
     (repo, remote)
 }
+
+/// Test utilities for common testing patterns
+pub struct TestUtils;
+
+impl TestUtils {
+    /// Run a test function in a specific directory, automatically restoring the original directory
+    pub fn with_current_dir<F, R>(dir: &Path, test_fn: F) -> R
+    where
+        F: FnOnce() -> R,
+    {
+        let original_dir = std::env::current_dir().expect("Failed to get current directory");
+        std::env::set_current_dir(dir).expect("Failed to change directory");
+
+        let result = test_fn();
+
+        // Always restore directory, even if the test panics
+        let _ = std::env::set_current_dir(&original_dir);
+        result
+    }
+
+    /// Run a git-x command and return the Command for assertions
+    pub fn run_git_x_cmd(_args: &[&str]) -> Command {
+        Command::cargo_bin("git-x").expect("Failed to find git-x binary")
+    }
+
+    /// Create a git-x command with args for testing
+    pub fn git_x_with_args(args: &[&str]) -> Command {
+        let mut cmd = Self::run_git_x_cmd(args);
+        cmd.args(args);
+        cmd
+    }
+
+    /// Test that a command runs without panicking in a repo directory
+    pub fn test_command_in_repo<F>(repo: &TestRepo, test_fn: F)
+    where
+        F: FnOnce(),
+    {
+        Self::with_current_dir(repo.path(), test_fn)
+    }
+
+    /// Test that a command handles non-git directories gracefully
+    pub fn test_command_outside_repo<F>(test_fn: F)
+    where
+        F: FnOnce(),
+    {
+        let temp_dir = tempdir().expect("Failed to create temp directory");
+        Self::with_current_dir(temp_dir.path(), test_fn)
+    }
+}
+
+/// Enhanced test repository creation with more options
+pub struct TestRepoBuilder {
+    branch_name: Option<String>,
+    commit_count: usize,
+    with_remote: bool,
+    conventional_commits: bool,
+}
+
+impl TestRepoBuilder {
+    pub fn new() -> Self {
+        Self {
+            branch_name: None,
+            commit_count: 1,
+            with_remote: false,
+            conventional_commits: false,
+        }
+    }
+
+    pub fn with_branch(mut self, branch_name: &str) -> Self {
+        self.branch_name = Some(branch_name.to_string());
+        self
+    }
+
+    pub fn with_commits(mut self, count: usize) -> Self {
+        self.commit_count = count;
+        self
+    }
+
+    pub fn with_remote(mut self) -> Self {
+        self.with_remote = true;
+        self
+    }
+
+    pub fn with_conventional_commits(mut self) -> Self {
+        self.conventional_commits = true;
+        self
+    }
+
+    pub fn build(self) -> TestRepo {
+        if self.conventional_commits {
+            return repo_with_conventional_commits();
+        }
+
+        let repo = if let Some(branch_name) = &self.branch_name {
+            repo_with_branch(branch_name)
+        } else {
+            basic_repo()
+        };
+
+        // Add additional commits if requested
+        for i in 1..self.commit_count {
+            repo.add_commit(
+                &format!("file{}.txt", i + 1),
+                &format!("content {}", i + 1),
+                &format!("commit {}", i + 1),
+            );
+        }
+
+        if self.with_remote {
+            let branch = self.branch_name.as_deref().unwrap_or("main");
+            repo.setup_remote(branch);
+        }
+
+        repo
+    }
+}
+
+impl Default for TestRepoBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Assertion helpers for common test patterns
+pub struct TestAssertions;
+
+impl TestAssertions {
+    /// Assert that output contains expected success indicators
+    pub fn assert_success_output(output: &str) {
+        assert!(
+            output.contains("✅") || output.contains("success"),
+            "Expected success indicators in output: {output}"
+        );
+    }
+
+    /// Assert that output contains expected error indicators
+    pub fn assert_error_output(output: &str) {
+        assert!(
+            output.contains("❌") || output.contains("error") || output.contains("failed"),
+            "Expected error indicators in output: {output}"
+        );
+    }
+
+    /// Assert that a git command was successful in a repo
+    pub fn assert_git_command_success(repo: &TestRepo, args: &[&str]) {
+        StdCommand::new("git")
+            .args(args)
+            .current_dir(repo.path())
+            .assert()
+            .success();
+    }
+
+    /// Get git command output as string
+    pub fn get_git_output(repo: &TestRepo, args: &[&str]) -> String {
+        let output = StdCommand::new("git")
+            .args(args)
+            .current_dir(repo.path())
+            .output()
+            .expect("Failed to run git command");
+
+        String::from_utf8_lossy(&output.stdout).trim().to_string()
+    }
+}
+
+/// Additional repository helper functions
+impl TestRepo {
+    /// Create a commit and return its hash
+    pub fn create_commit_with_hash(&self, filename: &str, content: &str, message: &str) -> String {
+        self.add_commit(filename, content, message);
+        TestAssertions::get_git_output(self, &["rev-parse", "HEAD"])
+    }
+
+    /// Stage specific files (as opposed to add_commit which stages all files)
+    pub fn stage_files(&self, files: &[&str]) {
+        for file in files {
+            StdCommand::new("git")
+                .args(["add", file])
+                .current_dir(&self.path)
+                .assert()
+                .success();
+        }
+    }
+
+    /// Get current commit hash
+    pub fn get_current_commit_hash(&self) -> String {
+        TestAssertions::get_git_output(self, &["rev-parse", "HEAD"])
+    }
+
+    /// Check if there are staged changes
+    pub fn has_staged_changes(&self) -> bool {
+        let output = TestAssertions::get_git_output(self, &["diff", "--cached", "--name-only"]);
+        !output.is_empty()
+    }
+}

tests/test_fixup.rs

@@ -1,77 +1,12 @@
+mod common;
+
 use assert_cmd::Command;
+use common::basic_repo;
 use git_x::fixup::*;
 use predicates::prelude::*;
 use std::fs;
-use std::path::PathBuf;
 use tempfile::TempDir;
 
-// 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)
-        .assert()
-        .success();
-
-    // Configure git
-    Command::new("git")
-        .args(["config", "user.name", "Test User"])
-        .current_dir(&repo_path)
-        .assert()
-        .success();
-
-    Command::new("git")
-        .args(["config", "user.email", "test@example.com"])
-        .current_dir(&repo_path)
-        .assert()
-        .success();
-
-    // 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)
-        .assert()
-        .success();
-
-    Command::new("git")
-        .args(["commit", "-m", "Initial commit"])
-        .current_dir(&repo_path)
-        .assert()
-        .success();
-
-    (temp_dir, repo_path)
-}
-
-// Helper function to create a commit and return its hash
-fn create_commit(repo_path: &PathBuf, filename: &str, content: &str, message: &str) -> String {
-    fs::write(repo_path.join(filename), content).expect("Failed to write file");
-    Command::new("git")
-        .args(["add", filename])
-        .current_dir(repo_path)
-        .assert()
-        .success();
-
-    Command::new("git")
-        .args(["commit", "-m", message])
-        .current_dir(repo_path)
-        .assert()
-        .success();
-
-    // Get the commit hash
-    let output = Command::new("git")
-        .args(["rev-parse", "HEAD"])
-        .current_dir(repo_path)
-        .output()
-        .expect("Failed to get commit hash");
-
-    String::from_utf8_lossy(&output.stdout).trim().to_string()
-}
-
 #[test]
 fn test_is_valid_commit_hash_format() {
     // Valid hashes
@@ -193,68 +128,51 @@ fn test_fixup_run_function_outside_git_repo() {
 
 #[test]
 fn test_fixup_invalid_commit_hash() {
-    let (_temp_dir, repo_path) = create_test_repo();
+    let repo = basic_repo();
 
-    let mut cmd = Command::cargo_bin("git-x").expect("Failed to find binary");
-    cmd.args(["fixup", "nonexistent123"])
-        .current_dir(&repo_path)
-        .assert()
+    repo.run_git_x(&["fixup", "nonexistent123"])
         .success() // The command succeeds but shows an error message
         .stderr(predicate::str::contains("Commit hash does not exist"));
 }
 
 #[test]
 fn test_fixup_no_staged_changes() {
-    let (_temp_dir, repo_path) = create_test_repo();
-    let commit_hash = create_commit(&repo_path, "test.txt", "test content", "Test commit");
+    let repo = basic_repo();
+    let commit_hash = repo.create_commit_with_hash("test.txt", "test content", "Test commit");
 
-    let mut cmd = Command::cargo_bin("git-x").expect("Failed to find binary");
-    cmd.args(["fixup", &commit_hash[0..7]]) // Use short hash
-        .current_dir(&repo_path)
-        .assert()
+    repo.run_git_x(&["fixup", &commit_hash[0..7]]) // Use short hash
         .success() // The command succeeds but shows an error message
         .stderr(predicate::str::contains("No staged changes found"));
 }
 
 #[test]
 fn test_fixup_with_staged_changes() {
-    let (_temp_dir, repo_path) = create_test_repo();
-    let commit_hash = create_commit(&repo_path, "test.txt", "test content", "Test commit");
+    let repo = basic_repo();
+    let commit_hash = repo.create_commit_with_hash("test.txt", "test content", "Test commit");
 
     // Create and stage some changes
-    fs::write(repo_path.join("test.txt"), "modified content").expect("Failed to write file");
-    Command::new("git")
-        .args(["add", "test.txt"])
-        .current_dir(&repo_path)
-        .assert()
-        .success();
+    fs::write(repo.path().join("test.txt"), "modified content").expect("Failed to write file");
+    repo.stage_files(&["test.txt"]);
 
-    let mut cmd = Command::cargo_bin("git-x").expect("Failed to find binary");
-    cmd.args(["fixup", &commit_hash[0..7]]) // Use short hash
-        .current_dir(&repo_path)
-        .assert()
+    repo.run_git_x(&["fixup", &commit_hash[0..7]]) // Use short hash
         .success()
         .stdout(predicate::str::contains("Fixup commit created"))
         .stdout(predicate::str::contains("To squash the fixup commit"));
 }
 
 #[test]
 fn test_fixup_with_rebase_flag() {
-    let (_temp_dir, repo_path) = create_test_repo();
-    let commit_hash = create_commit(&repo_path, "test.txt", "test content", "Test commit");
+    let repo = basic_repo();
+    let commit_hash = repo.create_commit_with_hash("test.txt", "test content", "Test commit");
 
     // Create and stage some changes
-    fs::write(repo_path.join("test.txt"), "modified content").expect("Failed to write file");
-    Command::new("git")
-        .args(["add", "test.txt"])
-        .current_dir(&repo_path)
-        .assert()
-        .success();
+    fs::write(repo.path().join("test.txt"), "modified content").expect("Failed to write file");
+    repo.stage_files(&["test.txt"]);
 
     // Set environment to make interactive rebase work in tests
     let mut cmd = Command::cargo_bin("git-x").expect("Failed to find binary");
     cmd.args(["fixup", &commit_hash[0..7], "--rebase"])
-        .current_dir(&repo_path)
+        .current_dir(repo.path())
         .env("GIT_SEQUENCE_EDITOR", "true") // Auto-accept rebase plan
         .assert()
         .success()