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

use crate::commands::Exec;

pub fn run<T: Exec>(
    cmd: &T,
    base: &str,
    number: Option<u32>,
    verbose: bool,
) -> Result<(), Option<String>> {
    let mut args = vec![
        "-c",
        "sequence.editor=:", // used in order to prevent --interactive blocking the autosquash
        "rebase",
        "--interactive",
        "--autosquash",
    ];
    let arg: String;

    match number {
        Some(number) => {
            arg = format!("HEAD~{number}");
            args.push(&arg);
        }
        None => args.push(base),
    }

    cmd.exec(&args, verbose, false)
        .map(|_| ())
        .map_err(|()| Some("Failed to auto squash commits".to_string()))
}

#[cfg(test)]
mod tests {
    use crate::commands::MockCmd;

    use super::*;

    #[test]
    fn test_with_number_supplied() {
        let mut cmd = MockCmd::new();
        cmd.expect_exec()
            .withf(|args, verbose, inherit_stderr| {
                args == [
                    "-c",
                    "sequence.editor=:",
                    "rebase",
                    "--interactive",
                    "--autosquash",
                    "HEAD~1",
                ] && !(*verbose)
                    && !(*inherit_stderr)
            })
            .times(1)
            .returning(|_, _, _| Ok(String::new()));

        let result = run(&cmd, "HEAD~1", None, false);

        assert!(result.is_ok());
    }

    #[test]
    fn test_with_base_supplied() {
        let mut cmd = MockCmd::new();
        cmd.expect_exec()
            .withf(|args, verbose, inherit_stderr| {
                args == [
                    "-c",
                    "sequence.editor=:",
                    "rebase",
                    "--interactive",
                    "--autosquash",
                    "main",
                ] && !(*verbose)
                    && !(*inherit_stderr)
            })
            .times(1)
            .returning(|_, _, _| Ok(String::new()));

        let result = run(&cmd, "main", None, false);

        assert!(result.is_ok());
    }
}