cargo-allow 0.1.3

Source-tree exception ledger and policy scanner for Rust repositories.
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

use crate::*;
use clap::Parser;

#[test]
fn clap_parses_lint_exception_compat_check() {
    assert_parses_compat_kind("lint-exception", "lint exception");
}

#[test]
fn clap_parses_no_panic_allowlist_compat_check() {
    assert_parses_compat_kind("no-panic-allowlist", "no-panic allowlist");
}

#[test]
fn clap_parses_unsafe_compat_check() {
    assert_parses_compat_kind("unsafe", "unsafe");
}

#[test]
fn clap_parses_non_rust_compat_check() {
    assert_parses_compat_kind("non-rust", "non-rust");
}

#[test]
fn clap_parses_generated_compat_check() {
    assert_parses_compat_kind("generated", "generated");
}

#[test]
fn clap_parses_panic_compat_check() {
    assert_parses_compat_kind("panic", "panic");
}

#[test]
fn clap_parses_executable_compat_check() {
    assert_parses_compat_kind("executable", "executable");
}

#[test]
fn clap_parses_workflow_compat_check() {
    assert_parses_compat_kind("workflow", "workflow");
}

#[test]
fn clap_parses_dependency_surface_compat_check() {
    assert_parses_compat_kind("dependency-surface", "dependency-surface");
}

#[test]
fn clap_parses_process_compat_check() {
    assert_parses_compat_kind("process", "process");
}

#[test]
fn clap_parses_network_compat_check() {
    assert_parses_compat_kind("network", "network");
}

fn assert_parses_compat_kind(kind: &str, label: &str) {
    let parsed = CargoAllowCli::try_parse_from(argv(vec![
        "cargo-allow",
        "check",
        "--compat",
        "--kind",
        kind,
    ]))
    .unwrap_or_else(|err| {
        std::panic::panic_any(format!("CLI should parse {label} compat check: {err}"))
    });

    assert!(matches!(
        parsed.command,
        Some(CargoAllowCommand::Check(check::CheckArgs {
            compat: true,
            kind: Some(parsed_kind),
            ..
        })) if parsed_kind == kind
    ));
}

fn argv(items: Vec<&str>) -> Vec<String> {
    items.into_iter().map(String::from).collect()
}