test: add common test modules and custom path behavior tests

- Add reusable test repository and UI mock utilities
- Implement comprehensive custom path worktree creation tests
- Improve test code organization and reduce duplication
- Enhance test coverage for edge cases and error scenarios

Author: Test User

tests/common/mod.rs

@@ -0,0 +1,7 @@
+//! Common test utilities
+
+mod test_repo;
+mod test_ui;
+
+pub use test_repo::TestRepo;
+pub use test_ui::TestUI;

tests/common/test_repo.rs

@@ -0,0 +1,78 @@
+//! Test repository setup utilities
+
+use anyhow::Result;
+use git2::{Repository, Signature};
+use git_workers::git::GitWorktreeManager;
+use std::fs;
+use std::path::{Path, PathBuf};
+use tempfile::TempDir;
+
+/// A test repository with helper methods
+pub struct TestRepo {
+    path: PathBuf,
+    repo: Repository,
+}
+
+impl TestRepo {
+    /// Create a new test repository
+    pub fn new(temp_dir: &TempDir) -> Result<Self> {
+        let path = temp_dir.path().join("test-repo");
+        fs::create_dir_all(&path)?;
+
+        let repo = Repository::init(&path)?;
+
+        // Create initial commit
+        let sig = Signature::now("Test User", "test@example.com")?;
+        let tree_id = {
+            let mut index = repo.index()?;
+            index.write()?;
+            index.write_tree()?
+        };
+
+        let tree = repo.find_tree(tree_id)?;
+        repo.commit(Some("HEAD"), &sig, &sig, "Initial commit", &tree, &[])?;
+
+        // Drop tree before moving repo
+        drop(tree);
+
+        Ok(Self { path, repo })
+    }
+
+    /// Get the repository path
+    pub fn path(&self) -> &Path {
+        &self.path
+    }
+
+    /// Create a GitWorktreeManager for this test repository
+    pub fn manager(&self) -> Result<GitWorktreeManager> {
+        GitWorktreeManager::new_from_path(&self.path)
+    }
+
+    /// Create a new branch
+    pub fn create_branch(&self, name: &str) -> Result<()> {
+        let head = self.repo.head()?.target().unwrap();
+        let commit = self.repo.find_commit(head)?;
+        self.repo.branch(name, &commit, false)?;
+        Ok(())
+    }
+
+    /// Create a new commit
+    #[allow(dead_code)]
+    pub fn create_commit(&self, message: &str) -> Result<()> {
+        let sig = Signature::now("Test User", "test@example.com")?;
+        let tree_id = {
+            let mut index = self.repo.index()?;
+            index.write()?;
+            index.write_tree()?
+        };
+
+        let tree = self.repo.find_tree(tree_id)?;
+        let parent = self.repo.head()?.target().unwrap();
+        let parent_commit = self.repo.find_commit(parent)?;
+
+        self.repo
+            .commit(Some("HEAD"), &sig, &sig, message, &tree, &[&parent_commit])?;
+
+        Ok(())
+    }
+}

tests/common/test_ui.rs

@@ -0,0 +1,148 @@
+//! Test implementation of UserInterface for testing
+
+use anyhow::Result;
+use git_workers::ui::UserInterface;
+use std::sync::{Arc, Mutex};
+
+/// Test implementation of UserInterface that provides pre-programmed responses
+#[derive(Clone)]
+pub struct TestUI {
+    inputs: Arc<Mutex<Vec<String>>>,
+    selections: Arc<Mutex<Vec<usize>>>,
+    confirmations: Arc<Mutex<Vec<bool>>>,
+    expect_error: Arc<Mutex<bool>>,
+}
+
+impl TestUI {
+    /// Create a new TestUI with no pre-programmed responses
+    pub fn new() -> Self {
+        Self {
+            inputs: Arc::new(Mutex::new(Vec::new())),
+            selections: Arc::new(Mutex::new(Vec::new())),
+            confirmations: Arc::new(Mutex::new(Vec::new())),
+            expect_error: Arc::new(Mutex::new(false)),
+        }
+    }
+
+    /// Add an input response
+    pub fn with_input(self, input: &str) -> Self {
+        self.inputs.lock().unwrap().push(input.to_string());
+        self
+    }
+
+    /// Add a selection response
+    pub fn with_selection(self, selection: usize) -> Self {
+        self.selections.lock().unwrap().push(selection);
+        self
+    }
+
+    /// Add a confirmation response
+    pub fn with_confirmation(self, confirm: bool) -> Self {
+        self.confirmations.lock().unwrap().push(confirm);
+        self
+    }
+
+    /// Indicate that the next operation should simulate an error/cancellation
+    pub fn with_error(self) -> Self {
+        *self.expect_error.lock().unwrap() = true;
+        self
+    }
+}
+
+impl UserInterface for TestUI {
+    fn multiselect(&self, _prompt: &str, items: &[String]) -> Result<Vec<usize>> {
+        // For tests, we don't support multiselect - just return empty selection
+        let _ = items;
+        Ok(vec![])
+    }
+    fn input(&self, _prompt: &str) -> Result<String> {
+        let mut inputs = self.inputs.lock().unwrap();
+        if *self.expect_error.lock().unwrap() {
+            *self.expect_error.lock().unwrap() = false;
+            return Err(anyhow::anyhow!("User cancelled input"));
+        }
+        if inputs.is_empty() {
+            return Err(anyhow::anyhow!("No more test inputs"));
+        }
+        Ok(inputs.remove(0))
+    }
+
+    fn input_with_default(&self, _prompt: &str, default: &str) -> Result<String> {
+        let mut inputs = self.inputs.lock().unwrap();
+        if *self.expect_error.lock().unwrap() {
+            *self.expect_error.lock().unwrap() = false;
+            return Err(anyhow::anyhow!("User cancelled input"));
+        }
+        if inputs.is_empty() {
+            Ok(default.to_string())
+        } else {
+            Ok(inputs.remove(0))
+        }
+    }
+
+    fn select(&self, _prompt: &str, _items: &[String]) -> Result<usize> {
+        let mut selections = self.selections.lock().unwrap();
+        if *self.expect_error.lock().unwrap() {
+            *self.expect_error.lock().unwrap() = false;
+            return Err(anyhow::anyhow!("User cancelled selection"));
+        }
+        if selections.is_empty() {
+            return Err(anyhow::anyhow!("No more test selections"));
+        }
+        Ok(selections.remove(0))
+    }
+
+    fn select_with_default(
+        &self,
+        _prompt: &str,
+        _items: &[String],
+        default: usize,
+    ) -> Result<usize> {
+        let mut selections = self.selections.lock().unwrap();
+        if *self.expect_error.lock().unwrap() {
+            *self.expect_error.lock().unwrap() = false;
+            return Err(anyhow::anyhow!("User cancelled selection"));
+        }
+        if selections.is_empty() {
+            Ok(default)
+        } else {
+            Ok(selections.remove(0))
+        }
+    }
+
+    fn fuzzy_select(&self, _prompt: &str, items: &[String]) -> Result<usize> {
+        // For tests, fuzzy select behaves like regular select
+        self.select(_prompt, items)
+    }
+
+    fn confirm(&self, _prompt: &str) -> Result<bool> {
+        let mut confirmations = self.confirmations.lock().unwrap();
+        if *self.expect_error.lock().unwrap() {
+            *self.expect_error.lock().unwrap() = false;
+            return Err(anyhow::anyhow!("User cancelled confirmation"));
+        }
+        if confirmations.is_empty() {
+            return Err(anyhow::anyhow!("No more test confirmations"));
+        }
+        Ok(confirmations.remove(0))
+    }
+
+    fn confirm_with_default(&self, _prompt: &str, default: bool) -> Result<bool> {
+        let mut confirmations = self.confirmations.lock().unwrap();
+        if *self.expect_error.lock().unwrap() {
+            *self.expect_error.lock().unwrap() = false;
+            return Err(anyhow::anyhow!("User cancelled confirmation"));
+        }
+        if confirmations.is_empty() {
+            Ok(default)
+        } else {
+            Ok(confirmations.remove(0))
+        }
+    }
+}
+
+impl Default for TestUI {
+    fn default() -> Self {
+        Self::new()
+    }
+}