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

use rhai::Engine;
use sal_git::rhai::*;

#[test]
fn test_git_clone_with_various_url_formats() {
    let mut engine = Engine::new();
    register_git_module(&mut engine).unwrap();

    let test_cases = vec![
        (
            "https://github.com/octocat/Hello-World.git",
            "HTTPS with .git",
        ),
        (
            "https://github.com/octocat/Hello-World",
            "HTTPS without .git",
        ),
        // SSH would require key setup: ("git@github.com:octocat/Hello-World.git", "SSH format"),
    ];

    for (url, description) in test_cases {
        let script = format!(
            r#"
            let result = "";
            try {{
                let repo = git_clone("{}");
                let path = repo.path();
                if path.len() > 0 {{
                    result = "success";
                }} else {{
                    result = "no_path";
                }}
            }} catch(e) {{
                if e.contains("Git error") {{
                    result = "git_error";
                }} else {{
                    result = "unexpected_error";
                }}
            }}
            result
        "#,
            url
        );

        let result = engine.eval::<String>(&script);
        assert!(
            result.is_ok(),
            "Failed to execute script for {}: {:?}",
            description,
            result
        );

        let outcome = result.unwrap();
        // Accept success or git_error (network issues)
        assert!(
            outcome == "success" || outcome == "git_error",
            "Unexpected outcome for {}: {}",
            description,
            outcome
        );
    }
}

#[test]
fn test_git_tree_operations_comprehensive() {
    let mut engine = Engine::new();
    register_git_module(&mut engine).unwrap();

    let script = r#"
        let results = [];
        
        try {
            // Test GitTree creation
            let git_tree = git_tree_new("/tmp/rhai_comprehensive_test");
            results.push("git_tree_created");
            
            // Test list on empty directory
            let repos = git_tree.list();
            results.push("list_executed");
            
            // Test find with pattern
            let found = git_tree.find("nonexistent");
            results.push("find_executed");
            
        } catch(e) {
            results.push("error_occurred");
        }
        
        results.len()
    "#;

    let result = engine.eval::<i64>(&script);
    assert!(result.is_ok());
    assert!(result.unwrap() >= 3, "Should execute at least 3 operations");
}

#[test]
fn test_error_message_quality() {
    let mut engine = Engine::new();
    register_git_module(&mut engine).unwrap();

    let script = r#"
        let error_msg = "";
        try {
            git_clone("invalid-url-format");
        } catch(e) {
            error_msg = e;
        }
        error_msg
    "#;

    let result = engine.eval::<String>(&script);
    assert!(result.is_ok());

    let error_msg = result.unwrap();
    assert!(
        error_msg.contains("Git error"),
        "Error should contain 'Git error'"
    );
    assert!(error_msg.len() > 10, "Error message should be descriptive");
}