keyring 3.3.0

Cross-platform library for managing passwords/credentials
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
129
130
131
132

use common::generate_random_string;
use keyring::{Entry, Error};

mod common;

#[test]
fn test_missing_entry() {
    let name = generate_random_string();
    let entry = Entry::new(&name, &name).expect("Can't create entry");
    assert!(
        matches!(entry.get_password(), Err(Error::NoEntry)),
        "Missing entry has password"
    )
}

#[test]
#[cfg(all(target_os = "linux", not(feature = "linux-native")))]
fn test_empty_password() {
    let name = generate_random_string();
    let entry = Entry::new(&name, &name).expect("Can't create entry");
    let in_pass = "";
    entry
        .set_password(in_pass)
        .expect("Can't set empty password");
    let out_pass = entry.get_password().expect("Can't get empty password");
    assert_eq!(
        in_pass, out_pass,
        "Retrieved and set empty passwords don't match"
    );
    entry.delete_credential().expect("Can't delete password");
    assert!(
        matches!(entry.get_password(), Err(Error::NoEntry)),
        "Able to read a deleted password"
    )
}

#[test]
fn test_round_trip_ascii_password() {
    let name = generate_random_string();
    let entry = Entry::new(&name, &name).expect("Can't create entry");
    let password = "test ascii password";
    entry
        .set_password(password)
        .expect("Can't set ascii password");
    let stored_password = entry.get_password().expect("Can't get ascii password");
    assert_eq!(
        stored_password, password,
        "Retrieved and set ascii passwords don't match"
    );
    entry
        .delete_credential()
        .expect("Can't delete ascii password");
    assert!(
        matches!(entry.get_password(), Err(Error::NoEntry)),
        "Able to read a deleted ascii password"
    )
}

#[test]
fn test_round_trip_non_ascii_password() {
    let name = generate_random_string();
    let entry = Entry::new(&name, &name).expect("Can't create entry");
    let password = "このきれいな花は桜です";
    entry
        .set_password(password)
        .expect("Can't set non-ascii password");
    let stored_password = entry.get_password().expect("Can't get non-ascii password");
    assert_eq!(
        stored_password, password,
        "Retrieved and set non-ascii passwords don't match"
    );
    entry
        .delete_credential()
        .expect("Can't delete non-ascii password");
    assert!(
        matches!(entry.get_password(), Err(Error::NoEntry)),
        "Able to read a deleted non-ascii password"
    )
}

#[test]
fn test_round_trip_random_secret() {
    use rand::{rngs::OsRng, Rng};
    let name = generate_random_string();
    let entry = Entry::new(&name, &name).expect("Can't create entry");
    let mut secret: [u8; 16] = [0; 16];
    OsRng.fill(&mut secret);
    entry.set_secret(&secret).expect("Can't set random secret");
    let stored_secret = entry.get_secret().expect("Can't get random secret");
    assert_eq!(
        &stored_secret, &secret,
        "Retrieved and set random secrets don't match"
    );
    entry
        .delete_credential()
        .expect("Can't delete random secret");
    assert!(
        matches!(entry.get_password(), Err(Error::NoEntry)),
        "Able to read a deleted random secret"
    )
}

#[test]
fn test_update() {
    let name = generate_random_string();
    let entry = Entry::new(&name, &name).expect("Can't create entry");
    let password = "test ascii password";
    entry
        .set_password(password)
        .expect("Can't set initial ascii password");
    let stored_password = entry.get_password().expect("Can't get ascii password");
    assert_eq!(
        stored_password, password,
        "Retrieved and set initial ascii passwords don't match"
    );
    let password = "このきれいな花は桜です";
    entry
        .set_password(password)
        .expect("Can't update ascii with non-ascii password");
    let stored_password = entry.get_password().expect("Can't get non-ascii password");
    assert_eq!(
        stored_password, password,
        "Retrieved and updated non-ascii passwords don't match"
    );
    entry
        .delete_credential()
        .expect("Can't delete updated password");
    assert!(
        matches!(entry.get_password(), Err(Error::NoEntry)),
        "Able to read a deleted updated password"
    )
}