rustauth-core 0.2.0

Core types and primitives for RustAuth.
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

use std::sync::{Arc, Mutex};

use rustauth_core::env::logger::{create_logger, should_publish_log, LogLevel, LoggerOptions};

#[test]
fn should_publish_log_follows_level_ordering() {
    assert!(should_publish_log(LogLevel::Debug, LogLevel::Debug));
    assert!(should_publish_log(LogLevel::Debug, LogLevel::Error));
    assert!(!should_publish_log(LogLevel::Info, LogLevel::Debug));
    assert!(should_publish_log(LogLevel::Warn, LogLevel::Error));
    assert!(!should_publish_log(LogLevel::Error, LogLevel::Warn));
}

#[test]
fn logger_does_not_publish_below_configured_level() {
    let entries = Arc::new(Mutex::new(Vec::new()));
    let captured = Arc::clone(&entries);
    let logger = create_logger(LoggerOptions::new(LogLevel::Warn).with_handler(
        move |level, message, args| {
            captured
                .lock()
                .map(|mut entries| {
                    entries.push((
                        level,
                        message.to_owned(),
                        args.iter().map(|arg| (*arg).to_owned()).collect(),
                    ))
                })
                .ok();
        },
    ));

    logger.info("ignored", &[]);
    logger.warn("published", &["arg"]);

    assert_eq!(
        entries.lock().map(|entries| entries.clone()).ok(),
        Some(vec![(
            LogLevel::Warn,
            "published".to_owned(),
            vec!["arg".to_owned()]
        )])
    );
}

#[test]
fn logger_maps_success_to_info_for_custom_handler() {
    let entries = Arc::new(Mutex::new(Vec::new()));
    let captured = Arc::clone(&entries);
    let logger = create_logger(LoggerOptions::new(LogLevel::Debug).with_handler(
        move |level, message, _args| {
            captured
                .lock()
                .map(|mut entries| entries.push((level, message.to_owned())))
                .ok();
        },
    ));

    logger.success("created", &[]);

    assert_eq!(
        entries.lock().map(|entries| entries.clone()).ok(),
        Some(vec![(LogLevel::Info, "created".to_owned())])
    );
}

#[test]
fn disabled_logger_does_not_publish() {
    let entries = Arc::new(Mutex::new(Vec::new()));
    let captured = Arc::clone(&entries);
    let logger = create_logger(
        LoggerOptions::new(LogLevel::Debug)
            .disabled(true)
            .with_handler(move |level, message, _args| {
                captured
                    .lock()
                    .map(|mut entries| entries.push((level, message.to_owned())))
                    .ok();
            }),
    );

    logger.error("ignored", &[]);

    assert_eq!(entries.lock().map(|entries| entries.len()).ok(), Some(0));
}