whyno-cli 0.5.0

Linux permission debugger
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

//! Integration tests: flags, error cases, subcommands. No temp files — exercises argument handling and error reporting.

mod helpers;

use helpers::{current_username, run_whyno};

#[test]
fn help_flag_exits_zero() {
    let output = run_whyno(&["--help"]);

    assert_eq!(output.status.code(), Some(0), "expected exit 0 for --help");
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(
        stdout.contains("permission debugger"),
        "help should contain program description"
    );
}

#[test]
fn version_flag_exits_zero() {
    let output = run_whyno(&["--version"]);

    assert_eq!(
        output.status.code(),
        Some(0),
        "expected exit 0 for --version"
    );
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(
        stdout.contains("whyno"),
        "version output should contain binary name"
    );
}

#[test]
fn caps_check_exits_zero() {
    let output = run_whyno(&["caps", "check"]);

    assert_eq!(
        output.status.code(),
        Some(0),
        "expected exit 0 for caps check, stderr: {}",
        String::from_utf8_lossy(&output.stderr)
    );
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(
        stdout.contains("CAP_DAC_READ_SEARCH") || stdout.contains("No capabilities"),
        "caps check should report capability status, got: {stdout}"
    );
}

#[test]
fn nonexistent_user_exits_two() {
    let output = run_whyno(&["user:__nonexistent_whyno_test_user__", "read", "/tmp"]);

    assert_eq!(
        output.status.code(),
        Some(2),
        "expected exit 2 for nonexistent user, got stdout: {}",
        String::from_utf8_lossy(&output.stdout)
    );
}

#[test]
fn invalid_operation_exits_two() {
    let output = run_whyno(&[&current_username(), "foobar", "/tmp"]);

    assert_eq!(
        output.status.code(),
        Some(2),
        "expected exit 2 for invalid operation"
    );
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        stderr.contains("unknown operation"),
        "error message should mention unknown operation, got: {stderr}"
    );
}

#[test]
fn missing_arguments_exits_cleanly() {
    let output = run_whyno(&[]);

    // clap shows help and exits 0 for some configurations, or exits 2 if
    // arguments are required. either way, verify it doesn't crash.
    let code = output.status.code().expect("should have exit code");
    assert!(
        code == 0 || code == 2,
        "expected exit 0 or 2 for no arguments, got {code}"
    );
}

#[test]
fn relative_path_exits_two() {
    let output = run_whyno(&[&current_username(), "read", "relative/path"]);

    assert_eq!(
        output.status.code(),
        Some(2),
        "expected exit 2 for relative path"
    );
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        stderr.contains("not absolute"),
        "error should mention non-absolute path, got: {stderr}"
    );
}

#[test]
fn json_and_explain_conflict_exits_two() {
    let output = run_whyno(&[&current_username(), "read", "/tmp", "--json", "--explain"]);

    assert_eq!(
        output.status.code(),
        Some(2),
        "expected exit 2 for conflicting flags"
    );
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        stderr.contains("mutually exclusive"),
        "should report flag conflict, got: {stderr}"
    );
}