sal-git 0.1.0

SAL Git - Git repository management and operations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use sal_git::*;
use std::fs;
use tempfile::TempDir;

#[test]
fn test_clone_existing_repository() {
    let temp_dir = TempDir::new().unwrap();
    let base_path = temp_dir.path().to_str().unwrap();

    let git_tree = GitTree::new(base_path).unwrap();

    // First clone
    let result1 = git_tree.get("https://github.com/octocat/Hello-World.git");

    // Second clone of same repo - should return existing
    let result2 = git_tree.get("https://github.com/octocat/Hello-World.git");

    match (result1, result2) {
        (Ok(repos1), Ok(repos2)) => {
            // git_tree.get() returns Vec<GitRepo>, should have exactly 1 repo
            assert_eq!(
                repos1.len(),
                1,
                "First clone should return exactly 1 repository"
            );
            assert_eq!(
                repos2.len(),
                1,
                "Second clone should return exactly 1 repository"
            );
            assert_eq!(
                repos1[0].path(),
                repos2[0].path(),
                "Both clones should point to same path"
            );

            // Verify the path actually exists
            assert!(
                std::path::Path::new(repos1[0].path()).exists(),
                "Repository path should exist"
            );
        }
        (Err(e1), Err(e2)) => {
            // Both failed - acceptable if network/git issues
            println!("Note: Clone test skipped due to errors: {} / {}", e1, e2);
        }
        _ => {
            panic!(
                "Inconsistent results: one clone succeeded, other failed - this indicates a bug"
            );
        }
    }
}

#[test]
fn test_repository_operations_on_cloned_repo() {
    let temp_dir = TempDir::new().unwrap();
    let base_path = temp_dir.path().to_str().unwrap();

    let git_tree = GitTree::new(base_path).unwrap();

    match git_tree.get("https://github.com/octocat/Hello-World.git") {
        Ok(repos) if repos.len() == 1 => {
            let repo = &repos[0];

            // Test has_changes on fresh clone
            match repo.has_changes() {
                Ok(has_changes) => assert!(!has_changes, "Fresh clone should have no changes"),
                Err(_) => println!("Note: has_changes test skipped due to git availability"),
            }

            // Test path is valid
            assert!(repo.path().len() > 0);
            assert!(std::path::Path::new(repo.path()).exists());
        }
        _ => {
            println!(
                "Note: Repository operations test skipped due to network/environment constraints"
            );
        }
    }
}

#[test]
fn test_multiple_repositories_in_git_tree() {
    let temp_dir = TempDir::new().unwrap();
    let base_path = temp_dir.path().to_str().unwrap();

    // Create some fake git repositories for testing
    let repo1_path = temp_dir.path().join("github.com/user1/repo1");
    let repo2_path = temp_dir.path().join("github.com/user2/repo2");

    fs::create_dir_all(&repo1_path).unwrap();
    fs::create_dir_all(&repo2_path).unwrap();
    fs::create_dir_all(repo1_path.join(".git")).unwrap();
    fs::create_dir_all(repo2_path.join(".git")).unwrap();

    let git_tree = GitTree::new(base_path).unwrap();
    let repos = git_tree.list().unwrap();

    assert!(repos.len() >= 2, "Should find at least 2 repositories");
}

#[test]
fn test_invalid_git_repository_handling() {
    let temp_dir = TempDir::new().unwrap();
    let fake_repo_path = temp_dir.path().join("fake_repo");
    fs::create_dir_all(&fake_repo_path).unwrap();

    // Create a directory that looks like a repo but isn't (no .git directory)
    let repo = GitRepo::new(fake_repo_path.to_str().unwrap().to_string());

    // Operations should fail gracefully on non-git directories
    // Note: has_changes might succeed if git is available and treats it as empty repo
    // So we test the operations that definitely require .git directory
    assert!(
        repo.pull().is_err(),
        "Pull should fail on non-git directory"
    );
    assert!(
        repo.reset().is_err(),
        "Reset should fail on non-git directory"
    );
}