gy 1.2.1

good,yes — the ledger of what work rests on before a requirement is confirmed
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

//! A peer writing with a newer gy (n-670a B, r-3f07): the pulled
//! `Gy-Version` is noticed on sync and handover, and silence when versions
//! match. Two copies share one file:// remote; the peer's newer version is
//! hand-written into its commit message.
mod common;
use common::{fixture, stderr, stdout};
use std::path::Path;
use std::process::Command;

fn git(cwd: &Path, args: &[&str]) {
    let out = Command::new("git")
        .args(args)
        .current_dir(cwd)
        .env("GIT_TERMINAL_PROMPT", "0")
        .env("GIT_AUTHOR_NAME", "piko")
        .env("GIT_AUTHOR_EMAIL", "piko@example.com")
        .env("GIT_COMMITTER_NAME", "piko")
        .env("GIT_COMMITTER_EMAIL", "piko@example.com")
        .output()
        .unwrap();
    assert!(
        out.status.success(),
        "git {args:?}: {}",
        String::from_utf8_lossy(&out.stderr)
    );
}

fn commit_with_version(ledger: &Path, version: &str, seq: u64) {
    git(ledger, &["add", "events.jsonl"]);
    let message = format!("hand\n\nactor: piko\nby: piko\nGy-Version: {version}\nGy-Seq: {seq}\n");
    let out = Command::new("git")
        .args(["commit", "-q", "-m", &message])
        .current_dir(ledger)
        .env("GIT_TERMINAL_PROMPT", "0")
        .env("GIT_AUTHOR_NAME", "piko")
        .env("GIT_AUTHOR_EMAIL", "piko@example.com")
        .env("GIT_COMMITTER_NAME", "piko")
        .env("GIT_COMMITTER_EMAIL", "piko@example.com")
        .output()
        .unwrap();
    assert!(
        out.status.success(),
        "{}",
        String::from_utf8_lossy(&out.stderr)
    );
    git(ledger, &["push", "-q", "origin", "HEAD:main"]);
}

fn run(fx: &common::Fixture, args: &[&str]) -> std::process::Output {
    let mut command = Command::new(env!("CARGO_BIN_EXE_gy"));
    command
        .current_dir(&fx.root)
        .env("XDG_DATA_HOME", &fx.data)
        .env("GY_ACTOR", "piko")
        .env("GIT_AUTHOR_NAME", "piko")
        .env("GIT_AUTHOR_EMAIL", "piko@example.com")
        .env("GIT_COMMITTER_NAME", "piko")
        .env("GIT_COMMITTER_EMAIL", "piko@example.com")
        .args(args);
    command.output().unwrap()
}

fn write_toml(fx: &common::Fixture, remote: &str) {
    std::fs::write(
        fx.root.join("gy.toml"),
        format!("remote = \"{remote}\"\n\n[scopes.a]\n"),
    )
    .unwrap();
}

/// Two copies sharing one bare remote, the first already synced.
fn pair() -> (tempfile::TempDir, common::Fixture, common::Fixture) {
    let temp = tempfile::tempdir().unwrap();
    let remote = temp.path().join("remote.git");
    std::fs::create_dir_all(&remote).unwrap();
    let out = Command::new("git")
        .args(["init", "-q", "--bare"])
        .arg(&remote)
        .output()
        .unwrap();
    assert!(out.status.success());
    let (fx1, fx2) = (fixture(), fixture());
    let url = format!("file://{}", remote.display());
    write_toml(&fx1, &url);
    write_toml(&fx2, &url);
    let out = run(&fx1, &["criterion", "add", "an ac"]);
    assert!(out.status.success(), "{}", stderr(&out));
    let out = run(&fx1, &["remote", "sync"]);
    assert!(out.status.success(), "{}", stderr(&out));
    let out = run(&fx2, &["remote", "sync"]);
    assert!(out.status.success(), "{}", stderr(&out));
    (temp, fx1, fx2)
}

#[test]
fn newer_peer_is_noticed_on_sync_and_handover() {
    let (_temp, fx1, fx2) = pair();
    let out = run(&fx1, &["criterion", "add", "peer ac"]);
    assert!(out.status.success(), "{}", stderr(&out));
    commit_with_version(&fx1.ledger(), "9.9.9", 2);

    let out = run(&fx2, &["remote", "sync"]);
    assert!(out.status.success(), "{}", stderr(&out));
    let text = stdout(&out);
    let last = text.lines().last().unwrap_or_default();
    assert!(
        last.contains("someone sharing this ledger writes with gy 9.9.9"),
        "{text}"
    );
    assert!(last.contains("cargo install gy --locked"), "{text}");

    let out = run(&fx2, &["handover"]);
    assert!(out.status.success(), "{}", stderr(&out));
    assert!(stderr(&out).contains("9.9.9"), "{}", stderr(&out));
}

#[test]
fn newer_peer_keeps_json_stdout_pure() {
    let (_temp, fx1, fx2) = pair();
    let out = run(&fx1, &["criterion", "add", "peer ac"]);
    assert!(out.status.success(), "{}", stderr(&out));
    commit_with_version(&fx1.ledger(), "9.9.9", 2);

    let out = run(&fx2, &["remote", "sync", "--json"]);
    assert!(out.status.success(), "{}", stderr(&out));
    let value: serde_json::Value = serde_json::from_str(&stdout(&out)).unwrap();
    assert!(value.get("peer_version").is_none(), "{value}");
    assert!(stderr(&out).contains("9.9.9"), "{}", stderr(&out));
}

#[test]
fn matching_versions_stay_silent() {
    let (_temp, fx1, fx2) = pair();
    let out = run(&fx1, &["criterion", "add", "peer ac"]);
    assert!(out.status.success(), "{}", stderr(&out));
    let out = run(&fx1, &["remote", "sync"]);
    assert!(out.status.success(), "{}", stderr(&out));

    let out = run(&fx2, &["remote", "sync"]);
    assert!(out.status.success(), "{}", stderr(&out));
    assert!(!stdout(&out).contains("cargo install"), "{}", stdout(&out));
    assert!(!stderr(&out).contains("cargo install"), "{}", stderr(&out));
    let out = run(&fx2, &["handover"]);
    assert!(out.status.success(), "{}", stderr(&out));
    assert!(!stderr(&out).contains("cargo install"), "{}", stderr(&out));
}