keyring-manager 0.8.0

Cross-platform library for managing passwords
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

use crate::tests::*;
use backtrace::Backtrace;
use directories::*;
use log::*;
use simplelog::*;
use std::panic;
use std::path::PathBuf;

fn get_cache_dir() -> PathBuf {
    if let Some(my_proj_dirs) = ProjectDirs::from("org", "Keyring", "KeyRingTests") {
        PathBuf::from(my_proj_dirs.cache_dir())
    } else {
        PathBuf::from("./")
    }
}

#[no_mangle]
pub extern "C" fn run_tests() {
    if let Err(e) = run_tests_internal() {
        panic!("failed to run unit tests: {}", e);
    }
}

fn run_tests_internal() -> std::result::Result<(), String> {
    let mut logs: Vec<Box<dyn SharedLogger>> = Vec::new();

    let mut cb = ConfigBuilder::new();

    logs.push(TermLogger::new(
        LevelFilter::Trace,
        cb.build(),
        TerminalMode::Mixed,
        ColorChoice::Auto,
    ));
    CombinedLogger::init(logs).map_err(|e| format!("logger init error: {}", e))?;

    panic::set_hook(Box::new(|panic_info| {
        let bt = Backtrace::new();
        if let Some(location) = panic_info.location() {
            error!(
                "panic occurred in file '{}' at line {}",
                location.file(),
                location.line(),
            );
        } else {
            error!("panic occurred but can't get location information...");
        }
        if let Some(s) = panic_info.payload().downcast_ref::<&str>() {
            error!("panic payload: {:?}", s);
        } else if let Some(s) = panic_info.payload().downcast_ref::<String>() {
            error!("panic payload: {:?}", s);
        } else if let Some(a) = panic_info.payload().downcast_ref::<std::fmt::Arguments>() {
            error!("panic payload: {:?}", a);
        } else {
            error!("no panic payload");
        }
        error!("Backtrace:\n{:?}", bt);
    }));

    run_unit_tests();

    Ok(())
}

fn run_unit_tests() {
    info!("Starting unit tests");

    let platform_keyring_manager = KeyringManager::new_secure(TEST_APPLICATION).unwrap();
    let insecure_keyring_manager = KeyringManager::new_insecure(
        TEST_APPLICATION,
        &get_cache_dir().join("test_insecure_keyring"),
    )
    .unwrap();

    info!("TEST: secure_test_escaped_password_input");
    exec_test_escaped_password_input(&platform_keyring_manager);
    info!("TEST: secure_test_add_ascii_password");
    exec_test_add_ascii_password(&platform_keyring_manager);
    info!("TEST: secure_test_round_trip_ascii_password");
    exec_test_round_trip_ascii_password(&platform_keyring_manager);
    info!("TEST: secure_test_add_non_ascii_password");
    exec_test_add_non_ascii_password(&platform_keyring_manager);
    info!("TEST: secure_test_round_trip_non_ascii_password");
    exec_test_round_trip_non_ascii_password(&platform_keyring_manager);
    info!("TEST: secure_test_multiple");
    exec_test_multiple(&platform_keyring_manager);
    info!("TEST: insecure_test_escaped_password_input");
    exec_test_escaped_password_input(&insecure_keyring_manager);
    info!("TEST: insecure_test_add_ascii_password");
    exec_test_add_ascii_password(&insecure_keyring_manager);
    info!("TEST: insecure_test_round_trip_ascii_password");
    exec_test_round_trip_ascii_password(&insecure_keyring_manager);
    info!("TEST: insecure_test_add_non_ascii_password");
    exec_test_add_non_ascii_password(&insecure_keyring_manager);
    info!("TEST: insecure_test_round_trip_non_ascii_password");
    exec_test_round_trip_non_ascii_password(&insecure_keyring_manager);
    info!("TEST: insecure_test_multiple");
    exec_test_multiple(&insecure_keyring_manager);

    info!("Finished unit tests");
}