git-outpost 0.1.2

Create self-contained Git outposts from a local repository for editor and devcontainer workflows.
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

mod common;

fn count_command_line(help: &str, command: &str) -> usize {
    let prefix = format!("  {command}");
    help.lines()
        .filter(|line| {
            line.strip_prefix(&prefix)
                .is_some_and(|rest| rest.starts_with(' ') || rest.is_empty())
        })
        .count()
}

fn help_for(args: &[&str]) -> String {
    let output = common::run(common::gop_command().args(args));
    assert!(
        output.status.success(),
        "help for {args:?} failed:\n{}",
        common::stderr(&output)
    );
    common::stdout(&output)
}

#[test]
fn e_03_help_lists_commands_and_long_flags() {
    let output = common::run(common::gop_command().arg("--help"));
    assert!(
        output.status.success(),
        "help failed:\n{}",
        common::stderr(&output)
    );

    let help = common::stdout(&output);
    for command in [
        "add", "pull", "source", "merge", "rebase", "push", "list", "lock", "unlock", "move",
        "remove", "prune", "status", "analyze",
    ] {
        assert_eq!(
            count_command_line(&help, command),
            1,
            "expected {command} exactly once in help:\n{help}"
        );
    }

    for flag in [
        "--no-color",
        "--remote-name",
        "--reason",
        "--verbose",
        "--force",
        "--no-branch-cleanup",
        "--dry-run",
    ] {
        assert!(help.contains(flag), "expected {flag} in help:\n{help}");
    }

    for (args, flags) in [
        (&["add", "--help"][..], &["--remote-name"][..]),
        (&["list", "--help"][..], &["--verbose"][..]),
        (&["lock", "--help"][..], &["--reason"][..]),
        (&["move", "--help"][..], &["--force"][..]),
        (
            &["remove", "--help"][..],
            &["--force", "--no-branch-cleanup"][..],
        ),
        (&["prune", "--help"][..], &["--dry-run", "--verbose"][..]),
    ] {
        let subcommand_help = help_for(args);
        for flag in flags {
            assert!(
                subcommand_help.contains(flag),
                "expected {flag} in help for {args:?}:\n{subcommand_help}"
            );
        }
    }
}

#[test]
fn h_01_git_outpost_help_uses_git_outpost_name() {
    let output = common::run(common::git_outpost_command().arg("--help"));
    assert!(
        output.status.success(),
        "help failed:\n{}",
        common::stderr(&output)
    );

    let help = common::stdout(&output);
    assert!(help.contains("Usage: git-outpost"), "{help}");
    assert!(!help.contains("Usage: gop"), "{help}");
}

#[test]
fn h_02_gop_help_uses_gop_name() {
    let output = common::run(common::gop_command().arg("--help"));
    assert!(
        output.status.success(),
        "help failed:\n{}",
        common::stderr(&output)
    );

    let help = common::stdout(&output);
    assert!(help.contains("Usage: gop"), "{help}");
}

#[test]
fn h_03_git_dispatch_help_does_not_use_gop_name() {
    // Git intercepts `git outpost --help` as a manpage request before running
    // external commands, while `-h` is forwarded to `git-outpost`.
    let output = common::run(common::git_dispatch_command().arg("-h"));
    assert!(
        output.status.success(),
        "git dispatch help failed:\n{}",
        common::stderr(&output)
    );

    let help = common::stdout(&output);
    assert!(
        help.contains("Usage: git-outpost") || help.contains("Usage: git outpost"),
        "{help}"
    );
    assert!(!help.contains("Usage: gop"), "{help}");
}