♻️ Refactor test suite to use centralized infrastructure

Replace duplicated test setup code with centralized test utilities

- Import and use shared test_utils module across all test files
- Replace local setup_git_repo functions with centralized version
- Standardize mock data creation using MockDataBuilder
- Consolidate test assertions into TestAssertions helper
- Add specialized helpers for Git operations and hooks testing
- Remove redundant code while maintaining test functionality
- Improve test maintainability and consistency across modules

All tests continue to pass with the new infrastructure while
eliminating code duplication and providing better abstractions.

Author: hyperb1iss

tests/basic_git_operations_tests.rs

@@ -1,84 +1,26 @@
-use git_iris::config::Config;
 use git_iris::context::ChangeType;
-use git_iris::git::GitRepo;
 use git2::Repository;
 use std::fs;
 use std::path::Path;
-use tempfile::TempDir;
-
-fn setup_git_repo() -> (TempDir, GitRepo) {
-    let temp_dir = TempDir::new().expect("Failed to create temporary directory");
-    let repo = Repository::init(temp_dir.path()).expect("Failed to initialize repository");
-
-    // Configure git user
-    let mut config = repo.config().expect("Failed to get repository config");
-    config
-        .set_str("user.name", "Test User")
-        .expect("Failed to set user name");
-    config
-        .set_str("user.email", "[email protected]")
-        .expect("Failed to set user email");
-
-    // Create and commit an initial file
-    let initial_file_path = temp_dir.path().join("initial.txt");
-    fs::write(&initial_file_path, "Initial content").expect("Failed to write initial file");
-
-    let mut index = repo.index().expect("Failed to get repository index");
-    index
-        .add_path(Path::new("initial.txt"))
-        .expect("Failed to add file to index");
-    index.write().expect("Failed to write index");
-
-    let tree_id = index.write_tree().expect("Failed to write tree");
-    let tree = repo.find_tree(tree_id).expect("Failed to find tree");
-    let signature = repo.signature().expect("Failed to create signature");
-    repo.commit(
-        Some("HEAD"),
-        &signature,
-        &signature,
-        "Initial commit",
-        &tree,
-        &[],
-    )
-    .expect("Failed to commit");
-
-    // Ensure the default branch is named 'main' for consistency across environments
-    {
-        let head_commit = repo
-            .head()
-            .expect("Failed to get HEAD")
-            .peel_to_commit()
-            .expect("Failed to peel HEAD to commit");
-        let current_branch = repo
-            .head()
-            .ok()
-            .and_then(|h| h.shorthand().map(std::string::ToString::to_string))
-            .unwrap_or_default();
-        if current_branch != "main" {
-            // Create or update the 'main' branch pointing to the current HEAD commit
-            repo.branch("main", &head_commit, true)
-                .expect("Failed to create 'main' branch");
-            repo.set_head("refs/heads/main")
-                .expect("Failed to set HEAD to 'main' branch");
-            repo.checkout_head(Some(git2::build::CheckoutBuilder::default().force()))
-                .expect("Failed to checkout 'main' branch");
-        }
-    }
 
-    let git_repo = GitRepo::new(temp_dir.path()).expect("Failed to create GitRepo");
-    (temp_dir, git_repo)
-}
+// Use our centralized test infrastructure
+#[path = "test_utils.rs"]
+mod test_utils;
+use test_utils::{GitTestHelper, MockDataBuilder, TestAssertions, setup_git_repo};
 
 #[tokio::test]
 async fn test_get_git_info() {
     let (temp_dir, git_repo) = setup_git_repo();
-    let config = Config::default();
+    let config = MockDataBuilder::config();
 
     let context = git_repo
         .get_git_info(&config)
         .await
         .expect("Failed to get git info");
 
+    // Use centralized assertions
+    TestAssertions::assert_commit_context_basics(&context);
+
     // Test branch name
     assert!(
         context.branch == "main" || context.branch == "master",
@@ -99,15 +41,11 @@ async fn test_get_git_info() {
         Some("Unknown".to_string())
     );
 
-    // Create and stage a new file
-    let new_file_path = temp_dir.path().join("new_file.txt");
-    fs::write(&new_file_path, "New content").expect("Failed to write new file");
-    let repo = Repository::open(temp_dir.path()).expect("Failed to open repository");
-    let mut index = repo.index().expect("Failed to get repository index");
-    index
-        .add_path(Path::new("new_file.txt"))
-        .expect("Failed to add new file to index");
-    index.write().expect("Failed to write index");
+    // Create and stage a new file using helper
+    let helper = GitTestHelper::new(&temp_dir).expect("Failed to create GitTestHelper");
+    helper
+        .create_and_stage_file("new_file.txt", "New content")
+        .expect("Failed to create and stage file");
 
     // Create an unstaged file
     let unstaged_file_path = temp_dir.path().join("unstaged.txt");
@@ -131,17 +69,13 @@ async fn test_get_git_info() {
 #[tokio::test]
 async fn test_commit() {
     let (temp_dir, git_repo) = setup_git_repo();
-    let config = Config::default();
+    let config = MockDataBuilder::config();
 
-    // Create and stage a new file
-    let new_file_path = temp_dir.path().join("commit_test.txt");
-    fs::write(&new_file_path, "Commit test content").expect("Failed to write commit test file");
-    let repo = Repository::open(temp_dir.path()).expect("Failed to open repository");
-    let mut index = repo.index().expect("Failed to get repository index");
-    index
-        .add_path(Path::new("commit_test.txt"))
-        .expect("Failed to add commit test file to index");
-    index.write().expect("Failed to write index");
+    // Create and stage a new file using helper
+    let helper = GitTestHelper::new(&temp_dir).expect("Failed to create GitTestHelper");
+    helper
+        .create_and_stage_file("commit_test.txt", "Commit test content")
+        .expect("Failed to create and stage file");
 
     // Perform commit
     let result = git_repo.commit("Test commit message");
@@ -163,25 +97,22 @@ async fn test_commit() {
 #[tokio::test]
 async fn test_multiple_staged_files() {
     let (temp_dir, git_repo) = setup_git_repo();
-    let config = Config::default();
+    let config = MockDataBuilder::config();
+
+    let helper = GitTestHelper::new(&temp_dir).expect("Failed to create GitTestHelper");
 
-    // Create and stage multiple files
+    // Create and stage multiple files using helper
     for i in 1..=3 {
-        let file_path = temp_dir.path().join(format!("file{i}.txt"));
-        fs::write(&file_path, format!("Content {i}"))
-            .expect("Failed to write multiple staged file");
-        let repo = Repository::open(temp_dir.path()).expect("Failed to open repository");
-        let mut index = repo.index().expect("Failed to get repository index");
-        index
-            .add_path(Path::new(&format!("file{i}.txt")))
-            .expect("Failed to add multiple staged file to index");
-        index.write().expect("Failed to write index");
+        helper
+            .create_and_stage_file(&format!("file{i}.txt"), &format!("Content {i}"))
+            .expect("Failed to create and stage file");
     }
 
     let context = git_repo
         .get_git_info(&config)
         .await
         .expect("Failed to get git info");
+
     assert_eq!(context.staged_files.len(), 3);
     for i in 1..=3 {
         assert!(
@@ -196,22 +127,19 @@ async fn test_multiple_staged_files() {
 #[tokio::test]
 async fn test_modified_file() {
     let (temp_dir, git_repo) = setup_git_repo();
-    let config = Config::default();
+    let config = MockDataBuilder::config();
 
-    // Modify the initial file
-    let initial_file_path = temp_dir.path().join("initial.txt");
-    fs::write(&initial_file_path, "Modified content").expect("Failed to modify file content");
-    let repo = Repository::open(temp_dir.path()).expect("Failed to open repository");
-    let mut index = repo.index().expect("Failed to get repository index");
-    index
-        .add_path(Path::new("initial.txt"))
-        .expect("Failed to add modified file to index");
-    index.write().expect("Failed to write index");
+    // Modify the initial file and stage it using helper
+    let helper = GitTestHelper::new(&temp_dir).expect("Failed to create GitTestHelper");
+    helper
+        .create_and_stage_file("initial.txt", "Modified content")
+        .expect("Failed to modify and stage file");
 
     let context = git_repo
         .get_git_info(&config)
         .await
         .expect("Failed to get git info");
+
     assert_eq!(context.staged_files.len(), 1);
     assert!(
         context
@@ -225,11 +153,13 @@ async fn test_modified_file() {
 #[tokio::test]
 async fn test_deleted_file() {
     let (temp_dir, git_repo) = setup_git_repo();
-    let config = Config::default();
+    let config = MockDataBuilder::config();
 
     // Delete the initial file
     let initial_file_path = temp_dir.path().join("initial.txt");
     fs::remove_file(&initial_file_path).expect("Failed to remove initial file");
+
+    // Stage the deletion
     let repo = Repository::open(temp_dir.path()).expect("Failed to open repository");
     let mut index = repo.index().expect("Failed to get repository index");
     index
@@ -241,6 +171,7 @@ async fn test_deleted_file() {
         .get_git_info(&config)
         .await
         .expect("Failed to get git info");
+
     assert_eq!(context.staged_files.len(), 1);
     assert!(
         context
@@ -254,20 +185,14 @@ async fn test_deleted_file() {
 #[tokio::test]
 async fn test_binary_file() {
     let (temp_dir, git_repo) = setup_git_repo();
-    let config = Config::default();
+    let config = MockDataBuilder::config();
 
-    // Create a binary file (a simple PNG file)
+    // Create a binary file using mock data
+    let binary_content = MockDataBuilder::mock_binary_content();
     let binary_file_path = temp_dir.path().join("image.png");
-    let binary_content = [
-        0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44,
-        0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1F,
-        0x15, 0xC4, 0x89, 0x00, 0x00, 0x00, 0x0A, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9C, 0x63, 0x00,
-        0x01, 0x00, 0x00, 0x05, 0x00, 0x01, 0x0D, 0x0A, 0x2D, 0xB4, 0x00, 0x00, 0x00, 0x00, 0x49,
-        0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82,
-    ];
     fs::write(&binary_file_path, binary_content).expect("Failed to write binary file");
 
-    // Stage the binary file
+    // Stage the binary file (need to use git2 directly for existing files)
     let repo = Repository::open(temp_dir.path()).expect("Failed to open repository");
     let mut index = repo.index().expect("Failed to get repository index");
     index