monochromatic-git-policy-cli 0.5.29

Repository-owned Git policy wrapper: forwards Git commands and checks commits against configured policies.
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
143
144

//! What:
//!  Which `checkout` and `restore` command lines take one side of a conflicted file,
//! in each spelling.
//! Why:
//!  A line that qualified by mistake would let a forced,
//! patched or unreadable form through the guard;
//! a line that was
//!  turned away by mistake blocks the command the owner decided to allow.
//!
//! In TS you'd write (pseudocode):
//! ```ts
//! // expect(conflictSideRequest('checkout', ['--theirs', '--', 'a.rs'])).toEqual({ paths: ['a.rs'] });
//! ```

use super::{SideRequest, conflict_side_request};
use crate::command_test_support::os_arguments;

/// The request a line gives,
/// with the paths as text.
fn paths_of(word: &str, values: &[&str]) -> Option<Vec<String>> {
    let region = os_arguments(values);
    return conflict_side_request(word.as_bytes(), region.as_slice())
        .map(|SideRequest { paths }| { return paths.iter().map(|path| { return path.to_string_lossy().into_owned(); }).collect(); });
}

/// Each checkout form that chooses a side,
/// names a revision,
/// or sets how a file is written qualifies and names its paths.
#[test]
fn checkout_forms_that_take_a_side_qualify() {
    for (values, expected) in [
        (vec!["--ours", "--", "a.rs"], vec!["a.rs"]),
        (vec!["--theirs", "--", "a.rs", "dir/b.rs"], vec!["a.rs", "dir/b.rs"]),
        (vec!["-2", "--", "a.rs"], vec!["a.rs"]),
        (vec!["-3", "--", "a.rs"], vec!["a.rs"]),
        (vec!["topic", "--", "a.rs"], vec!["a.rs"]),
        (vec!["HEAD~1", "--", "a.rs"], vec!["a.rs"]),
        (vec!["-m", "--", "a.rs"], vec!["a.rs"]),
        (vec!["--merge", "--", "a.rs"], vec!["a.rs"]),
        (vec!["--conflict=diff3", "--", "a.rs"], vec!["a.rs"]),
        (vec!["-q", "--theirs", "--", "a.rs"], vec!["a.rs"]),
        (vec!["--the", "--", "a.rs"], vec!["a.rs"]),
        (vec!["--", "a.rs"], vec!["a.rs"]),
    ] {
        assert_eq!(paths_of("checkout", values.as_slice()), Some(expected.iter().map(|each| { return String::from(*each); }).collect()), "{values:?}");
    }
}

/// Anything that forces,
/// patches,
/// reads paths from a file,
/// makes a branch,
/// has no `--`,
/// or names nothing after it does not qualify.
#[test]
fn checkout_forms_that_discard_more_or_say_less_do_not_qualify() {
    for values in [
        vec!["-f", "--", "a.rs"],
        vec!["--force", "--ours", "--", "a.rs"],
        vec!["-p", "--", "a.rs"],
        vec!["--patch", "topic", "--", "a.rs"],
        vec!["--pathspec-from-file=list", "--ours"],
        vec!["--pathspec-from-file=list", "--", "a.rs"],
        vec!["-b", "topic", "--", "a.rs"],
        vec!["-B", "topic", "--", "a.rs"],
        vec!["--orphan", "topic", "--", "a.rs"],
        vec!["-d", "--", "a.rs"],
        vec!["--ours", "a.rs"],
        vec!["topic", "a.rs"],
        vec!["--ours", "--"],
        vec!["topic", "other", "--", "a.rs"],
        vec!["--no-such-option", "--", "a.rs"],
        vec!["topic"],
        vec![],
    ] {
        assert_eq!(paths_of("checkout", values.as_slice()), None, "{values:?}");
    }
}

/// The restore forms that write worktree files from a side or a revision qualify;
/// index-only and abbreviated ones do not.
#[test]
fn restore_forms_are_read_exactly() {
    for (values, expected) in [
        (vec!["--ours", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["--theirs", "--", "a.rs", "b.rs"], Some(vec!["a.rs", "b.rs"])),
        (vec!["--source=topic", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["--source", "topic", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["-s", "HEAD~1", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["-W", "--source=topic", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["--worktree", "--theirs", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["-S", "-W", "--theirs", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["--staged", "--worktree", "--theirs", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["-m", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["--conflict=zdiff3", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["--conflict", "diff3", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["-S", "--theirs", "--", "a.rs"], None),
        (vec!["--staged", "--source=topic", "--", "a.rs"], None),
        (vec!["--theirs", "a.rs"], None),
        (vec!["--the", "--", "a.rs"], None),
        (vec!["-p", "--", "a.rs"], None),
        (vec!["--patch", "--", "a.rs"], None),
        (vec!["--pathspec-from-file=list"], None),
        (vec!["--theirs", "--"], None),
        (vec!["-sHEAD", "--", "a.rs"], None),
        (vec![], None),
    ] {
        let typed: Option<Vec<String>> = expected.map(|paths| { return paths.iter().map(|each| { return String::from(*each); }).collect(); });
        assert_eq!(paths_of("restore", values.as_slice()), typed, "{values:?}");
    }
}

/// Every other command word is not a way to take a side.
#[test]
fn other_commands_never_qualify() {
    for word in ["switch", "reset", "rm", "merge", "checkout-index", "stash", "add"] {
        assert_eq!(paths_of(word, &["--theirs", "--", "a.rs"]), None, "{word}");
    }
}

/// A token that Git takes as the value of `--source`,
/// `-s` or `--conflict` is not an option:
/// `-W` there does not make an
///  index-only restore a worktree restore,
/// and `-S` there does not make a worktree restore an index-only one.
#[test]
fn an_option_value_is_not_read_as_an_option() {
    for (values, expected) in [
        (vec!["--source", "-W", "--staged", "--", "a.rs"], None),
        (vec!["--staged", "--source", "-W", "--", "a.rs"], None),
        (vec!["-S", "-s", "-W", "--", "a.rs"], None),
        (vec!["--staged", "--conflict", "-W", "--", "a.rs"], None),
        (vec!["--staged", "--source", "--worktree", "--", "a.rs"], None),
        (vec!["--source=-W", "--staged", "--", "a.rs"], None),
        (vec!["--source", "-W", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["--source", "--staged", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["--source", "-S", "-W", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["--staged", "-W", "--source", "HEAD", "--", "a.rs"], Some(vec!["a.rs"])),
        (vec!["--source", "HEAD", "--staged", "--worktree", "--", "a.rs"], Some(vec!["a.rs"])),
    ] {
        let typed: Option<Vec<String>> = expected.map(|paths| { return paths.iter().map(|each| { return String::from(*each); }).collect(); });
        assert_eq!(paths_of("restore", values.as_slice()), typed, "{values:?}");
    }
}