✅ Reorganize test suite into modular structure

Split monolithic git_tests.rs into focused test modules

- Add basic_git_operations_tests.rs for core Git functionality
- Add branch_comparisons_tests.rs for branch comparison logic
- Add file_exclusions_tests.rs for file filtering behavior
- Add project_metadata_tests.rs for metadata detection tests
- Add remote_git_repositories_tests.rs for remote repo handling
- Add token_optimization_integration_tests.rs for token limits
- Create test_utils.rs with shared setup_git_repo() function
- Update lib.rs to include test_utils module
- Remove original git_tests.rs file

Each test module focuses on a specific area of functionality with
shared utilities for consistent test setup across modules.

Author: hyperb1iss

tests/basic_git_operations_tests.rs

@@ -0,0 +1,301 @@
+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)
+}
+
+#[tokio::test]
+async fn test_get_git_info() {
+    let (temp_dir, git_repo) = setup_git_repo();
+    let config = Config::default();
+
+    let context = git_repo
+        .get_git_info(&config)
+        .await
+        .expect("Failed to get git info");
+
+    // Test branch name
+    assert!(
+        context.branch == "main" || context.branch == "master",
+        "Branch should be 'main' or 'master', but got '{}'",
+        context.branch
+    );
+
+    // Test recent commits
+    assert_eq!(context.recent_commits.len(), 1);
+    assert!(context.recent_commits[0].message.contains("Initial commit"));
+
+    // Test staged files (should be empty after commit)
+    assert_eq!(context.staged_files.len(), 0);
+
+    // Test project metadata
+    assert_eq!(
+        context.project_metadata.language,
+        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 an unstaged file
+    let unstaged_file_path = temp_dir.path().join("unstaged.txt");
+    fs::write(&unstaged_file_path, "Unstaged content").expect("Failed to write unstaged file");
+
+    // Get updated git info
+    let updated_context = git_repo
+        .get_git_info(&config)
+        .await
+        .expect("Failed to get updated git info");
+
+    // Test staged files
+    assert_eq!(updated_context.staged_files.len(), 1);
+    assert_eq!(updated_context.staged_files[0].path, "new_file.txt");
+    assert!(matches!(
+        updated_context.staged_files[0].change_type,
+        ChangeType::Added
+    ));
+}
+
+#[tokio::test]
+async fn test_commit() {
+    let (temp_dir, git_repo) = setup_git_repo();
+    let config = Config::default();
+
+    // 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");
+
+    // Perform commit
+    let result = git_repo.commit("Test commit message");
+    assert!(result.is_ok(), "Failed to perform commit");
+
+    // Verify commit
+    let context = git_repo
+        .get_git_info(&config)
+        .await
+        .expect("Failed to get git info after commit");
+    assert_eq!(context.recent_commits.len(), 2);
+    assert!(
+        context.recent_commits[0]
+            .message
+            .contains("Test commit message")
+    );
+}
+
+#[tokio::test]
+async fn test_multiple_staged_files() {
+    let (temp_dir, git_repo) = setup_git_repo();
+    let config = Config::default();
+
+    // Create and stage multiple files
+    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");
+    }
+
+    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!(
+            context
+                .staged_files
+                .iter()
+                .any(|file| file.path == format!("file{i}.txt"))
+        );
+    }
+}
+
+#[tokio::test]
+async fn test_modified_file() {
+    let (temp_dir, git_repo) = setup_git_repo();
+    let config = Config::default();
+
+    // 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");
+
+    let context = git_repo
+        .get_git_info(&config)
+        .await
+        .expect("Failed to get git info");
+    assert_eq!(context.staged_files.len(), 1);
+    assert!(
+        context
+            .staged_files
+            .iter()
+            .any(|file| file.path == "initial.txt"
+                && matches!(file.change_type, ChangeType::Modified))
+    );
+}
+
+#[tokio::test]
+async fn test_deleted_file() {
+    let (temp_dir, git_repo) = setup_git_repo();
+    let config = Config::default();
+
+    // 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");
+    let repo = Repository::open(temp_dir.path()).expect("Failed to open repository");
+    let mut index = repo.index().expect("Failed to get repository index");
+    index
+        .remove_path(Path::new("initial.txt"))
+        .expect("Failed to remove file from index");
+    index.write().expect("Failed to write index");
+
+    let context = git_repo
+        .get_git_info(&config)
+        .await
+        .expect("Failed to get git info");
+    assert_eq!(context.staged_files.len(), 1);
+    assert!(
+        context
+            .staged_files
+            .iter()
+            .any(|file| file.path == "initial.txt"
+                && matches!(file.change_type, ChangeType::Deleted))
+    );
+}
+
+#[tokio::test]
+async fn test_binary_file() {
+    let (temp_dir, git_repo) = setup_git_repo();
+    let config = Config::default();
+
+    // Create a binary file (a simple PNG file)
+    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
+    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("image.png"))
+        .expect("Failed to add binary file to index");
+    index.write().expect("Failed to write index");
+
+    let context = git_repo
+        .get_git_info(&config)
+        .await
+        .expect("Failed to get git info");
+
+    // Check if the binary file is in staged files
+    assert!(
+        context
+            .staged_files
+            .iter()
+            .any(|file| file.path == "image.png")
+    );
+
+    // Check if the diff for the binary file is "[Binary file changed]"
+    let binary_file = context
+        .staged_files
+        .iter()
+        .find(|file| file.path == "image.png")
+        .expect("Failed to find binary file in staged files");
+    assert_eq!(binary_file.diff, "[Binary file changed]");
+
+    // Check if the status is correct
+    assert!(matches!(binary_file.change_type, ChangeType::Added));
+}