lgit 0.9.2

CLI tool for managing git repositories
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use std::process::{self, Stdio};

use mockall::mock;

pub mod autosquash;
pub mod branch;
pub mod checkout;
pub mod cherry_pick;
pub mod delete_branches;
pub mod fixup;
pub mod git_fallback;
pub mod rebase;

pub trait Exec {
    fn exec(&self, args: &[&str], verbose: bool, inherit_stdio: bool) -> Result<String, ()>;
}

pub struct Cmd {}

impl Exec for Cmd {
    fn exec(&self, args: &[&str], verbose: bool, inherit_stdio: bool) -> Result<String, ()> {
        let cmd = "git";

        if verbose {
            println!("Executing: {} {}\n", cmd, args.join(" "));
        }

        match inherit_stdio {
            true => {
                let status = process::Command::new(cmd)
                    .args(args)
                    .stdout(Stdio::inherit())
                    .stderr(Stdio::inherit())
                    .status()
                    .expect(&format!("Failed to execute git command: git {}", args.join(" ")));

                if status.success() {
                    Ok(String::new())
                } else {
                    Err(())
                }
            }
            false => {
                let output = process::Command::new(cmd)
                    .args(args)
                    .output()
                    .expect(&format!("Failed to execute git command: git {}", args.join(" ")));

                let status = output.status;

                if status.success() {
                    let output = String::from_utf8(output.stdout).unwrap();

                    if verbose {
                        println!("{output}");
                    }

                    Ok(output)
                } else {
                    Err(())
                }
            }
        }
    }
}

mock! {
    pub Cmd {}

    impl Exec for Cmd {
        fn exec<'a>(&self, args: &[&'a str], verbose: bool, inherit_stdio: bool) -> Result<String, ()>;
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_cmd_exec_success_with_output() {
        let cmd = Cmd {};

        // Test with a simple git command that should succeed in most environments
        let result = cmd.exec(&["version"], false, false);

        // We expect this to succeed and return some output
        assert!(result.is_ok());
        let output = result.unwrap();
        assert!(!output.is_empty());
        assert!(output.starts_with("git version"));
    }

    #[test]
    fn test_cmd_exec_verbose_output() {
        let cmd = Cmd {};

        // Test verbose flag - should still work but might produce different console output
        let result = cmd.exec(&["version"], true, false);

        assert!(result.is_ok());
        let output = result.unwrap();
        assert!(output.starts_with("git version"));
    }

    #[test]
    fn test_cmd_exec_invalid_command() {
        let cmd = Cmd {};

        // Test with an invalid git command
        let result = cmd.exec(&["invalid-command-that-does-not-exist"], false, false);

        // This should fail
        assert!(result.is_err());
    }

    #[test]
    fn test_cmd_exec_inherit_stdio() {
        let cmd = Cmd {};

        // Test inherit_stdio flag - this should return empty string on success
        let result = cmd.exec(&["version"], false, true);

        // With inherit_stdio=true, successful commands return empty string
        if result.is_ok() {
            assert_eq!(result.unwrap(), "");
        }
    }

    #[test]
    fn test_cmd_exec_help() {
        let cmd = Cmd {};

        // Test with help argument which should always work
        let result = cmd.exec(&["--help"], false, false);

        // git --help should succeed and show help
        assert!(result.is_ok());
        let output = result.unwrap();
        assert!(!output.is_empty());
        assert!(output.contains("Git") || output.contains("usage"));
    }
}