92 lines
2.3 KiB
Rust
92 lines
2.3 KiB
Rust
use crate::queue::{Message, MsgType, Queue};
|
|
use chrono::prelude::*;
|
|
use std::{
|
|
thread::{sleep, spawn},
|
|
time::Duration,
|
|
};
|
|
|
|
const SLEEP_FOR: Duration = Duration::from_millis(1000);
|
|
|
|
pub struct Clock {
|
|
queue: Queue,
|
|
}
|
|
|
|
impl Clock {
|
|
fn new(queue: Queue) -> Self {
|
|
Self { queue: queue }
|
|
}
|
|
|
|
pub fn start(queue: Queue) {
|
|
let clock = Clock::new(queue);
|
|
spawn(move || {
|
|
clock.listen();
|
|
});
|
|
}
|
|
|
|
fn listen(&self) {
|
|
loop {
|
|
let mut msg = Message::new(MsgType::Time);
|
|
msg.add_data("time", Utc::now());
|
|
match self.queue.send(msg) {
|
|
Ok(_) => {}
|
|
Err(_) => {}
|
|
};
|
|
sleep(SLEEP_FOR);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod clocks {
|
|
use super::*;
|
|
use std::{
|
|
sync::mpsc::{channel, Receiver},
|
|
time::{Duration, Instant},
|
|
};
|
|
|
|
static TIMEOUT: Duration = Duration::from_millis(500);
|
|
|
|
fn start_clock(listen_for: Vec<MsgType>) -> Receiver<Message> {
|
|
let queue = Queue::new();
|
|
let (tx, rx) = channel();
|
|
queue.add(tx, listen_for);
|
|
Clock::start(queue);
|
|
rx
|
|
}
|
|
|
|
#[test]
|
|
fn sends_timestamp() {
|
|
let rx = start_clock([MsgType::Time].to_vec());
|
|
let msg = rx.recv_timeout(TIMEOUT).unwrap();
|
|
match msg.get_class() {
|
|
MsgType::Time => {
|
|
msg.get_data("time").unwrap().to_datetime().unwrap();
|
|
}
|
|
_ => unreachable!("should have been a time message"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn continues_to_send_time() {
|
|
let start = Instant::now();
|
|
let rx = start_clock([MsgType::Time].to_vec());
|
|
let msg1 = rx.recv_timeout(TIMEOUT).unwrap();
|
|
let msg2 = rx.recv().unwrap();
|
|
assert!(
|
|
start.elapsed() >= SLEEP_FOR,
|
|
"did not pause long enough betwee sends"
|
|
);
|
|
assert!(
|
|
msg2.get_data("time").unwrap().to_datetime().unwrap()
|
|
> msg1.get_data("time").unwrap().to_datetime().unwrap(),
|
|
"shoould present the latest time"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn does_not_panic_without_listeners() {
|
|
let rx = start_clock([MsgType::SessionValidate].to_vec());
|
|
assert!(rx.recv_timeout(TIMEOUT).is_err(), "should timeout");
|
|
}
|
|
}
|