diffguard 0.2.0

CLI for diff-scoped governance linting in pull requests
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

use assert_cmd::Command;
use assert_cmd::cargo;
use tempfile::TempDir;

fn run_git(dir: &std::path::Path, args: &[&str]) -> String {
    let out = std::process::Command::new("git")
        .current_dir(dir)
        .args(args)
        .output()
        .expect("git should run");
    assert!(
        out.status.success(),
        "git {:?} failed: {}",
        args,
        String::from_utf8_lossy(&out.stderr)
    );
    String::from_utf8_lossy(&out.stdout).trim().to_string()
}

fn init_repo() -> (TempDir, String) {
    let td = TempDir::new().expect("temp");
    let dir = td.path();

    run_git(dir, &["init"]);
    run_git(dir, &["config", "user.email", "test@example.com"]);
    run_git(dir, &["config", "user.name", "Test"]);

    // baseline file
    std::fs::create_dir_all(dir.join("src")).unwrap();
    std::fs::write(
        dir.join("src/lib.rs"),
        "pub fn f() -> Option<u32> { Some(1) }\n",
    )
    .unwrap();

    run_git(dir, &["add", "."]);
    run_git(dir, &["commit", "-m", "base"]);

    let base = run_git(dir, &["rev-parse", "HEAD"]);
    (td, base)
}

#[test]
fn fails_on_unwrap_by_default() {
    let (td, base) = init_repo();
    let dir = td.path();

    // introduce unwrap
    std::fs::write(
        dir.join("src/lib.rs"),
        "pub fn f() -> u32 { Some(1).unwrap() }\n",
    )
    .unwrap();

    run_git(dir, &["add", "."]);
    run_git(dir, &["commit", "-m", "change"]);
    let head = run_git(dir, &["rev-parse", "HEAD"]);

    let mut cmd = Command::new(cargo::cargo_bin!("diffguard"));
    cmd.current_dir(dir)
        .arg("check")
        .arg("--base")
        .arg(&base)
        .arg("--head")
        .arg(&head)
        .arg("--out")
        .arg("artifacts/diffguard/report.json")
        .arg("--md")
        .arg("artifacts/diffguard/comment.md");

    cmd.assert().code(2);

    let receipt = std::fs::read_to_string(dir.join("artifacts/diffguard/report.json")).unwrap();
    assert!(receipt.contains("diffguard.check.v1"));
    assert!(receipt.contains("rust.no_unwrap"));
}

#[test]
fn warnings_do_not_fail_by_default_but_can() {
    let (td, base) = init_repo();
    let dir = td.path();

    // introduce println (warn)
    std::fs::write(dir.join("src/lib.rs"), "pub fn f() { println!(\"hi\"); }\n").unwrap();

    run_git(dir, &["add", "."]);
    run_git(dir, &["commit", "-m", "change"]);
    let head = run_git(dir, &["rev-parse", "HEAD"]);

    // default: fail_on=error => exit 0 even with warnings
    let mut cmd = Command::new(cargo::cargo_bin!("diffguard"));
    cmd.current_dir(dir)
        .arg("check")
        .arg("--base")
        .arg(&base)
        .arg("--head")
        .arg(&head)
        .arg("--out")
        .arg("artifacts/diffguard/report.json");

    cmd.assert().code(0);

    // configured: fail_on=warn => exit 3
    let mut cmd = Command::new(cargo::cargo_bin!("diffguard"));
    cmd.current_dir(dir)
        .arg("check")
        .arg("--base")
        .arg(&base)
        .arg("--head")
        .arg(&head)
        .arg("--fail-on")
        .arg("warn")
        .arg("--out")
        .arg("artifacts/diffguard/report2.json");

    cmd.assert().code(3);
}