monochromatic-git-policy-cli 0.5.13

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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210

//! Controls for the native check that decides whether a command left the branch ahead of its upstream: the walk over the
//! commit parents against real Git, and the tip decision on disposable repositories.

use super::*;
use crate::repo_read_layout::read_layout_in;
use crate::test_support::{fixture, git, remove};

/// A repository with a bare remote, `main` pushed and tracking `origin/main`.
fn repository(name: &str) -> (PathBuf, PathBuf) {
    let root = fixture(name);
    let remote = root.join("remote.git");
    let repo = root.join("repo");
    git(&root, &["init", "--bare", "--quiet", "--initial-branch=main", "remote.git"]);
    git(&root, &["init", "--quiet", "--initial-branch=main", "repo"]);
    git(&repo, &["commit", "--quiet", "--allow-empty", "--message=base"]);
    git(&repo, &["remote", "add", "origin", remote.to_str().expect("utf-8")]);
    git(&repo, &["push", "--quiet", "--set-upstream", "origin", "main"]);
    return (root, repo);
}

/// The commit a revision names.
fn oid(repo: &Path, revision: &str) -> String {
    return String::from_utf8_lossy(&git(repo, &["rev-parse", revision]).stdout).trim().to_owned();
}

/// Whether real Git says `ancestor` is an ancestor of `descendant`.
fn git_says_ancestor(repo: &Path, ancestor: &str, descendant: &str) -> bool {
    return crate::test_support::git_output(repo, &["merge-base", "--is-ancestor", ancestor, descendant]).status.success();
}

/// A watch of the repository as the wrapper would start it, with the fixture's environment.
fn watch(repo: &Path) -> TipWatch {
    let overlay: Vec<(OsString, OsString)> = crate::test_support::isolated_overlay();
    return watch_tip(repo, Path::new("/usr/bin/git"), overlay.as_slice(), &[]).expect("a branch with a tip");
}

/// The walk answers like `git merge-base --is-ancestor` for ancestors, non-ancestors and the commit itself.
#[test]
fn the_walk_agrees_with_git_about_ancestry() {
    let (root, repo) = repository("atr-walk");
    let base = oid(&repo, "HEAD");
    git(&repo, &["switch", "--quiet", "--create", "side"]);
    git(&repo, &["commit", "--quiet", "--allow-empty", "--message=side"]);
    let side = oid(&repo, "HEAD");
    git(&repo, &["switch", "--quiet", "main"]);
    git(&repo, &["commit", "--quiet", "--allow-empty", "--message=main"]);
    git(&repo, &["merge", "--quiet", "--no-ff", "--no-edit", "side"]);
    let merged = oid(&repo, "HEAD");
    let layout = read_layout_in(&repo, crate::test_support::isolated_overlay().as_slice()).expect("layout");
    let database = ObjectDatabase::open(layout.common_dir.as_path(), None, layout.object_format).expect("database");
    for (from, target) in [(&merged, &base), (&merged, &side), (&side, &base), (&base, &side), (&side, &merged), (&base, &base)] {
        assert_eq!(
            reaches(&database, &layout, from, target, WALK_BUDGET),
            Some(git_says_ancestor(&repo, target, from)),
            "{target} from {from}"
        );
    }
    assert_eq!(reaches(&database, &layout, &merged, &base, 0), None, "a walk past its budget does not guess");
    remove(&root);
}

/// A commit on top of the upstream is handed over; the same tip is not handed over twice, and an unmoved branch is not.
#[test]
fn a_branch_that_grew_ahead_of_its_upstream_is_handed_over() {
    let (root, repo) = repository("atr-grew");
    let watched = watch(&repo);
    assert_eq!(tip_to_push(&watched), None, "nothing moved");
    git(&repo, &["commit", "--quiet", "--allow-empty", "--message=more"]);
    assert_eq!(tip_to_push(&watched), Some(oid(&repo, "HEAD")));
    remove(&root);
}

/// A branch reset to an older commit moved backwards, which is not growth.
#[test]
fn a_branch_that_moved_backwards_is_not_handed_over() {
    let (root, repo) = repository("atr-back");
    git(&repo, &["commit", "--quiet", "--allow-empty", "--message=more"]);
    git(&repo, &["push", "--quiet", "origin", "main"]);
    let watched = watch(&repo);
    git(&repo, &["reset", "--quiet", "--hard", "HEAD~1"]);
    assert_eq!(tip_to_push(&watched), None);
    remove(&root);
}

/// A rewritten branch (the same commits replayed) has grown past the upstream but not from its old tip: a rebase.
#[test]
fn a_rewritten_branch_is_not_handed_over() {
    let (root, repo) = repository("atr-rewrite");
    git(&repo, &["commit", "--quiet", "--allow-empty", "--message=local"]);
    let watched = watch(&repo);
    git(&repo, &["commit", "--quiet", "--amend", "--allow-empty", "--message=local, rewritten"]);
    assert_eq!(tip_to_push(&watched), None);
    remove(&root);
}

/// A branch that has diverged from the tracking ref is not handed over, and neither is one without an upstream.
#[test]
fn a_diverged_branch_and_a_branch_without_an_upstream_are_not_handed_over() {
    let (root, repo) = repository("atr-diverged");
    git(&repo, &["switch", "--quiet", "--create", "loose"]);
    let loose = watch(&repo);
    git(&repo, &["commit", "--quiet", "--allow-empty", "--message=more"]);
    assert_eq!(tip_to_push(&loose), None, "no upstream");
    git(&repo, &["switch", "--quiet", "main"]);
    let watched = watch(&repo);
    git(&repo, &["commit", "--quiet", "--allow-empty", "--message=mine"]);
    // The tracking ref moves to a commit the branch does not contain, as a fetch would move it.
    git(&repo, &["switch", "--quiet", "--detach", "HEAD~1"]);
    git(&repo, &["commit", "--quiet", "--allow-empty", "--message=theirs"]);
    let theirs = oid(&repo, "HEAD");
    git(&repo, &["update-ref", "refs/remotes/origin/main", &theirs]);
    git(&repo, &["switch", "--quiet", "main"]);
    assert_eq!(tip_to_push(&watched), None);
    remove(&root);
}

/// The overlay of a user whose own configuration file holds `core.fsmonitor = true`,
/// which the reader cannot prove harmless (it starts a daemon),
/// written to `file`.
fn overlay_with_fsmonitor(file: &Path) -> Vec<(OsString, OsString)> {
    std::fs::write(file, "[core]\n\tfsmonitor = true\n[user]\n\tname = Someone\n").expect("global configuration");
    let mut overlay: Vec<(OsString, OsString)> = crate::test_support::isolated_overlay()
        .into_iter()
        .filter(|(name, _)| { return name != "GIT_CONFIG_GLOBAL"; })
        .collect();
    overlay.push((OsString::from("GIT_CONFIG_GLOBAL"), file.as_os_str().to_os_string()));
    return overlay;
}

/// The repository of the live report:
/// format version 0 with `extensions.worktreeConfig`,
/// `push.default = matching`,
/// a tracking branch,
/// a linked worktree,
/// and a user-level `core.fsmonitor = true`.
/// A merge in it must be handed over:
/// the watch starts,
///  and after the merge the tip is the one to push.
/// Before,
/// the reader declined the repository for the user's setting,
/// the watch never started,
/// and the merge stayed local without a word.
#[test]
fn a_user_level_setting_the_reader_cannot_prove_does_not_stop_the_trigger() {
    let (root, repo) = repository("atr-fsmonitor");
    git(&repo, &["config", "extensions.worktreeConfig", "true"]);
    git(&repo, &["config", "push.default", "matching"]);
    git(&repo, &["worktree", "add", "--quiet", "--detach", "../linked"]);
    git(&repo, &["switch", "--quiet", "--create", "topic"]);
    git(&repo, &["commit", "--quiet", "--allow-empty", "--message=topic"]);
    git(&repo, &["switch", "--quiet", "main"]);
    let overlay: Vec<(OsString, OsString)> = overlay_with_fsmonitor(root.join("global.gitconfig").as_path());
    assert!(
        read_layout_in(&repo, overlay.as_slice()).is_none(),
        "the premise: the reader that checks every value declines this user's configuration"
    );
    let watched: TipWatch = try_watch_tip(&repo, Path::new("/usr/bin/git"), overlay.as_slice(), &[]).expect("the watch starts");
    git(&repo, &["merge", "--quiet", "--no-ff", "--no-edit", "topic"]);
    assert_eq!(tip_to_push_or_why(&watched), Ok(oid(&repo, "HEAD")));
    remove(&root);
}

/// Each step that declines names itself:
/// a branch that did not move,
/// an upstream that is the tip,
/// a rewritten branch,
/// a diverged one,
/// an upstream that is not a single plain one,
/// a detached head and a repository the reader does not take.
#[test]
fn every_decline_names_its_reason() {
    let (root, repo) = repository("atr-reasons");
    let reason = |watched: &TipWatch| -> &'static str { return tip_to_push_or_why(watched).expect_err("declined").reason; };
    let at_base: TipWatch = watch(&repo);
    assert_eq!(reason(&at_base), "tip-unchanged");
    git(&repo, &["commit", "--quiet", "--allow-empty", "--message=more"]);
    git(&repo, &["push", "--quiet", "origin", "main"]);
    assert_eq!(reason(&at_base), "upstream-equals-tip");
    let published: TipWatch = watch(&repo);
    git(&repo, &["commit", "--quiet", "--allow-empty", "--amend", "--message=rewritten"]);
    assert_eq!(reason(&published), "not-grown");
    let rewritten: TipWatch = watch(&repo);
    git(&repo, &["commit", "--quiet", "--allow-empty", "--message=on the rewrite"]);
    assert_eq!(reason(&rewritten), "not-ahead");
    git(&repo, &["config", "--unset", "branch.main.merge"]);
    assert_eq!(reason(&rewritten), "upstream-not-single");
    git(&repo, &["switch", "--quiet", "--detach"]);
    assert_eq!(reason(&rewritten), "head-detached");
    let empty = root.join("nowhere");
    std::fs::create_dir(&empty).expect("directory");
    let declined = try_watch_tip(&empty, Path::new("/usr/bin/git"), crate::test_support::isolated_overlay().as_slice(), &[]).expect_err("no repository");
    assert_eq!(declined.reason, "layout-declined");
    remove(&root);
}

/// The record line is one JSON object with the fields a person diagnoses from,
/// the reason as a word that does not change,
/// and text that needs escaping escaped.
#[test]
fn a_trigger_record_is_one_line_that_names_the_decision() {
    use crate::push_trigger_log::{Outcome as Ending, trigger_line};
    let line: String = trigger_line("merge", Ending::Declined, "upstream-equals-tip", "a \"quoted\"\nname", Some("refs/heads/main"));
    assert_eq!(line.matches('\n').count(), 1, "one line: {line:?}");
    assert!(line.ends_with("}\n"));
    for part in ["\"schemaVersion\":1", "\"command\":\"merge\"", "\"outcome\":\"declined\"", "\"reason\":\"upstream-equals-tip\"", "\"branch\":\"refs/heads/main\"", "\\\"quoted\\\"\\n"] {
        assert!(line.contains(part), "{part} in {line}");
    }
    assert!(!trigger_line("pull", Ending::HandedOver, "ahead-of-upstream", "", None).contains("\"branch\""));
    assert!(trigger_line("pull", Ending::HandedOver, "ahead-of-upstream", "", None).contains("\"outcome\":\"handed-over\""));
}