auths-cli 0.1.2

Command-line interface for Auths decentralized identity system
Documentation 
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

use super::helpers::TestEnv;

fn setup_signed_commit() -> TestEnv {
    let env = TestEnv::new();
    env.init_identity();

    std::fs::write(env.repo_path.join("test.txt"), "hello").unwrap();
    let add = env.git_cmd().args(["add", "test.txt"]).output().unwrap();
    assert!(add.status.success());
    let commit = env
        .git_cmd()
        .args(["commit", "-m", "signed commit"])
        .output()
        .unwrap();
    assert!(
        commit.status.success(),
        "commit failed: {}",
        String::from_utf8_lossy(&commit.stderr)
    );

    // Add the in-band Auths-Id / Auths-Device trailers for KEL-native verification.
    let sign = env.cmd("auths").args(["sign", "HEAD"]).output().unwrap();
    assert!(
        sign.status.success(),
        "auths sign failed: {}",
        String::from_utf8_lossy(&sign.stderr)
    );

    env
}

#[test]
fn test_verify_json_output_on_signed_commit() {
    let env = setup_signed_commit();

    let output = env
        .cmd("auths")
        .args(["verify", "HEAD", "--json"])
        .output()
        .unwrap();

    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).unwrap();
    let result: serde_json::Value = serde_json::from_str(&stdout).unwrap();

    assert!(
        result["commit"].is_string(),
        "commit field should be a string"
    );
    assert_eq!(result["valid"], true, "valid should be true");
    assert!(
        result["ssh_valid"].is_boolean(),
        "ssh_valid should be a boolean"
    );
}

#[test]
fn test_verify_json_output_on_unsigned_commit() {
    let env = TestEnv::new();
    env.init_identity();

    // Disable signing
    let _ = env
        .git_cmd()
        .args(["config", "--local", "commit.gpgsign", "false"])
        .output();

    std::fs::write(env.repo_path.join("unsigned.txt"), "no sig").unwrap();
    let add = env
        .git_cmd()
        .args(["add", "unsigned.txt"])
        .output()
        .unwrap();
    assert!(add.status.success());
    let commit = env
        .git_cmd()
        .args(["commit", "-m", "unsigned"])
        .output()
        .unwrap();
    assert!(commit.status.success());

    // No `auths sign` → no trailer → KEL-native verify rejects it.
    let output = env
        .cmd("auths")
        .args(["verify", "HEAD", "--json"])
        .output()
        .unwrap();

    assert!(!output.status.success());
    let stdout = String::from_utf8(output.stdout).unwrap();
    let result: serde_json::Value = serde_json::from_str(&stdout).unwrap();

    assert_eq!(result["valid"], false, "valid should be false for unsigned");
    assert!(
        result["error"].is_string(),
        "error field should describe the issue"
    );
}

#[test]
fn test_verify_json_output_on_invalid_ref() {
    let env = TestEnv::new();
    env.init_identity();

    let output = env
        .cmd("auths")
        .args(["verify", "NONEXISTENT_REF", "--json"])
        .output()
        .unwrap();

    assert!(!output.status.success());

    // Error JSON may be on stdout (from handle_error) or stderr (from renderer)
    let stdout = String::from_utf8(output.stdout).unwrap();
    let stderr = String::from_utf8(output.stderr).unwrap();
    let json_str = if stdout.trim().starts_with('{') {
        &stdout
    } else {
        &stderr
    };

    let result: serde_json::Value = serde_json::from_str(json_str.trim()).unwrap();
    assert!(
        result["error"].is_string() || result["message"].is_string(),
        "should contain error info, got: {}",
        json_str
    );
}