rcman 0.2.2

Framework-agnostic settings management with schema, backup/restore, secrets and derive macro support
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! Hot-reload integration tests
//!
//! These tests validate the feature-gated watcher runtime using polling mode for
//! deterministic behavior across CI environments.

mod common;

use common::TestFixture;
use rcman::{HotReloadBackend, HotReloadConfig, HotReloadEvent, HotReloadRuntime};
use std::sync::{Arc, mpsc};
use std::time::{Duration, Instant};

#[test]
fn test_hot_reload_applies_external_file_change() {
    let fixture = TestFixture::new();
    let manager = Arc::new(fixture.manager);

    let (event_tx, event_rx) = mpsc::channel::<HotReloadEvent>();
    let callback = move |event: HotReloadEvent| {
        let _ = event_tx.send(event);
    };

    let config = HotReloadConfig {
        debounce_ms: 75,
        poll_interval_ms: 50,
        backend: HotReloadBackend::Poll,
    };

    let mut runtime = HotReloadRuntime::start(Arc::clone(&manager), config, callback).unwrap();

    // Give the watcher thread a brief warm-up window before mutating files.
    std::thread::sleep(Duration::from_millis(250));

    let settings_path = manager.config().settings_path();
    std::fs::write(
        &settings_path,
        r#"{"ui":{"theme":"light","font_size":14.0}}"#,
    )
    .unwrap();

    let deadline = Instant::now() + Duration::from_secs(4);
    let mut reloaded = false;

    while Instant::now() < deadline {
        if let Ok(event) = event_rx.recv_timeout(Duration::from_millis(150)) {
            match event {
                HotReloadEvent::Reloaded { .. } => {
                    reloaded = true;
                    break;
                }
                HotReloadEvent::WatchError { reason } => {
                    panic!("watcher emitted setup/runtime error: {reason}");
                }
                HotReloadEvent::ReloadFailed { reason, .. } => {
                    panic!("reload failed unexpectedly: {reason}");
                }
            }
        }
    }

    assert!(reloaded, "expected at least one Reloaded event");
    assert_eq!(manager.get::<String>("ui.theme").unwrap(), "light");

    runtime.stop();
}

#[test]
fn test_hot_reload_stop_stops_emitting_events() {
    let fixture = TestFixture::new();
    let manager = Arc::new(fixture.manager);

    let (event_tx, event_rx) = mpsc::channel::<HotReloadEvent>();
    let callback = move |event: HotReloadEvent| {
        let _ = event_tx.send(event);
    };

    let config = HotReloadConfig {
        debounce_ms: 50,
        poll_interval_ms: 50,
        backend: HotReloadBackend::Poll,
    };

    let mut runtime = HotReloadRuntime::start(Arc::clone(&manager), config, callback).unwrap();
    runtime.stop();

    let settings_path = manager.config().settings_path();
    std::fs::write(&settings_path, r#"{"ui":{"theme":"solarized"}}"#).unwrap();

    let received = event_rx.recv_timeout(Duration::from_millis(500));
    assert!(received.is_err(), "watcher emitted event after stop");
}

#[test]
fn test_hot_reload_rapid_consecutive_changes_apply_latest_value() {
    let fixture = TestFixture::new();
    let manager = Arc::new(fixture.manager);

    let (event_tx, event_rx) = mpsc::channel::<HotReloadEvent>();
    let callback = move |event: HotReloadEvent| {
        let _ = event_tx.send(event);
    };

    let config = HotReloadConfig {
        debounce_ms: 50,
        poll_interval_ms: 50,
        backend: HotReloadBackend::Poll,
    };

    let mut runtime = HotReloadRuntime::start(Arc::clone(&manager), config, callback).unwrap();

    std::thread::sleep(Duration::from_millis(250));

    let settings_path = manager.config().settings_path();

    std::fs::write(&settings_path, r#"{"ui":{"theme":"light"}}"#).unwrap();
    std::thread::sleep(Duration::from_millis(40));
    std::fs::write(&settings_path, r#"{"ui":{"theme":"dark"}}"#).unwrap();

    let deadline = Instant::now() + Duration::from_secs(4);
    let mut saw_reload = false;
    let mut latest_applied = false;

    while Instant::now() < deadline {
        if let Ok(event) = event_rx.recv_timeout(Duration::from_millis(150)) {
            match event {
                HotReloadEvent::Reloaded { .. } => {
                    saw_reload = true;
                    if manager.get::<String>("ui.theme").unwrap() == "dark" {
                        latest_applied = true;
                        break;
                    }
                }
                HotReloadEvent::WatchError { reason } => {
                    panic!("watcher emitted setup/runtime error: {reason}");
                }
                HotReloadEvent::ReloadFailed { reason, .. } => {
                    panic!("reload failed unexpectedly: {reason}");
                }
            }
        }
    }

    assert!(saw_reload, "expected at least one Reloaded event");
    assert!(latest_applied, "latest rapid edit was not applied");

    runtime.stop();
}