Moved documents to document.

src/document/clock.rs

@@ -0,0 +1,89 @@
+use crate::{
+    data_director::{RegMsg, Register},
+    message::{Message, MsgAction, Records},
+    name::{Name, NameType, Names},
+    router::Queue,
+};
+use std::{
+    sync::mpsc::channel,
+    thread::{sleep, spawn},
+    time::Duration,
+};
+
+pub struct Clock {
+    queue: Queue,
+}
+
+impl Clock {
+    fn new(queue: Queue) -> Self {
+        Self { queue: queue }
+    }
+
+    pub fn start(mut queue: Queue) {
+        let clock = Clock::new(queue.clone());
+        let (tx, rx) = channel();
+        let id = queue.add_sender(tx);
+        let reg_msg = Register::new(id, RegMsg::AddDocName([Name::english("clock")].to_vec()));
+        let msg = Message::new(NameType::None, reg_msg.clone());
+        queue.send(msg).unwrap();
+        rx.recv().unwrap();
+        spawn(move || {
+            clock.listen();
+        });
+    }
+
+    fn listen(&self) {
+        loop {
+            self.queue
+                .send(Message::new(
+                    Name::english("clock"),
+                    MsgAction::OnUpdate(Records::new(Names::new())),
+                ))
+                .unwrap();
+            sleep(Duration::from_secs(1));
+        }
+    }
+}
+
+#[cfg(test)]
+mod clocks {
+    use super::*;
+    use crate::data_director::{Include, Path};
+    use chrono::{TimeDelta, Utc};
+
+    static TIMEOUT: Duration = Duration::from_millis(1500);
+
+    #[test]
+    fn does_clock_send_reply_every_second() {
+        let mut queue = Queue::new();
+        let (tx, rx) = channel();
+        let id = queue.add_sender(tx);
+        let request = Register::new(
+            id.clone(),
+            RegMsg::AddRoute(Path::new(Include::All, Include::All, Include::All)),
+        );
+        queue.send(Message::new(NameType::None, request)).unwrap();
+        rx.recv_timeout(TIMEOUT).unwrap();
+        let mut holder: Vec<Message> = Vec::new();
+        let start = Utc::now();
+        Clock::start(queue.clone());
+        while holder.len() < 2 {
+            holder.push(rx.recv_timeout(TIMEOUT).unwrap());
+        }
+        let end = Utc::now();
+        assert!((end - start) > TimeDelta::seconds(1));
+        assert!((end - start) < TimeDelta::seconds(2));
+        let reg_request = Register::new(id, RegMsg::GetNameID(Name::english("clock")));
+        queue
+            .send(Message::new(NameType::None, reg_request))
+            .unwrap();
+        rx.recv_timeout(TIMEOUT).unwrap();
+        for msg in holder.iter() {
+            let action = msg.get_action();
+            match action {
+                MsgAction::OnUpdate(result) => assert_eq!(result.len(), 0),
+                _ => unreachable!("got {:?}, should have been empty record", action),
+            }
+        }
+    }
+}