lumin 0.1.16

A library for searching and displaying local files
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
133

use anyhow::Result;
use log::Level;
use lumin::telemetry::{LogMessage, init, log_with_context};
use std::sync::Mutex;
use std::sync::Once;

// Since we can't easily capture log output in unit tests, these tests focus more on
// ensuring the telemetry functions don't panic and behave as expected

static INIT_TEST: Once = Once::new();
static INIT_RESULT: Mutex<Option<Result<()>>> = Mutex::new(None);

#[test]
fn test_telemetry_init() {
    // Initialize telemetry system
    INIT_TEST.call_once(|| {
        let result = init();
        let mut guard = INIT_RESULT.lock().unwrap();
        *guard = Some(result);
    });

    // Check if initialization succeeded
    let guard = INIT_RESULT.lock().unwrap();
    if let Some(ref result) = *guard {
        assert!(
            result.is_ok(),
            "Telemetry initialization failed: {:?}",
            result
        );
    } else {
        panic!("Initialization result not set");
    }
}

#[test]
fn test_log_with_context_basic() {
    // Ensure telemetry is initialized
    init().ok();

    // Test basic logging without context
    let msg = LogMessage {
        message: "Test log message".to_string(),
        module: "telemetry_test",
        context: None,
    };

    // This should not panic
    log_with_context(Level::Info, msg);
}

#[test]
fn test_log_with_context_detailed() {
    // Ensure telemetry is initialized
    init().ok();

    // Test logging with context at different log levels
    // For each level we need to create a new LogMessage since it doesn't implement Clone

    // Info level
    log_with_context(
        Level::Info,
        LogMessage {
            message: "Test log message with context".to_string(),
            module: "telemetry_test",
            context: Some(vec![
                ("test_key", "test_value".to_string()),
                ("numeric_value", "42".to_string()),
            ]),
        },
    );

    // Debug level
    log_with_context(
        Level::Debug,
        LogMessage {
            message: "Test log message with context".to_string(),
            module: "telemetry_test",
            context: Some(vec![
                ("test_key", "test_value".to_string()),
                ("numeric_value", "42".to_string()),
            ]),
        },
    );

    // Warn level
    log_with_context(
        Level::Warn,
        LogMessage {
            message: "Test log message with context".to_string(),
            module: "telemetry_test",
            context: Some(vec![
                ("test_key", "test_value".to_string()),
                ("numeric_value", "42".to_string()),
            ]),
        },
    );

    // Error level
    log_with_context(
        Level::Error,
        LogMessage {
            message: "Test log message with context".to_string(),
            module: "telemetry_test",
            context: Some(vec![
                ("test_key", "test_value".to_string()),
                ("numeric_value", "42".to_string()),
            ]),
        },
    );

    // Trace level
    log_with_context(
        Level::Trace,
        LogMessage {
            message: "Test log message with context".to_string(),
            module: "telemetry_test",
            context: Some(vec![
                ("test_key", "test_value".to_string()),
                ("numeric_value", "42".to_string()),
            ]),
        },
    );
}

#[test]
fn test_multiple_init_calls() {
    // Multiple init calls should be safe and only initialize once
    let first_result = init();
    let second_result = init();

    assert!(first_result.is_ok());
    assert!(second_result.is_ok());
}