Moved session into own module.

src/router.rs

@@ -47,7 +47,10 @@ impl Router {
         if id == &Uuid::nil() {
             return;
         }
-        self.senders.get(id).unwrap().send(msg).unwrap();
+        match self.senders.get(id) {
+            Some(sender) => sender.send(msg).unwrap(),
+            None => {}
+        }
     }
 
     fn send(&self, msg: Message) {
@@ -100,34 +103,70 @@ mod routers {
         name::Name,
         support_tests::TIMEOUT,
     };
-    use std::collections::HashSet;
+    use std::{
+        collections::HashSet,
+        sync::mpsc::{Receiver, RecvTimeoutError},
+    };
+
+    struct Setup {
+        test_mod: Router,
+        rx: Receiver<Message>,
+    }
+
+    impl Setup {
+        fn new() -> Self {
+            let (tx, rx) = channel();
+            Self {
+                test_mod: Router::new(tx),
+                rx: rx,
+            }
+        }
+
+        fn get_router(&self) -> &Router {
+            &self.test_mod
+        }
+
+        fn get_router_mut(&mut self) -> &mut Router {
+            &mut self.test_mod
+        }
+
+        fn recv(&self) -> Result<Message, RecvTimeoutError> {
+            self.rx.recv_timeout(TIMEOUT)
+        }
+    }
 
     #[test]
     fn can_pass_message() {
-        let (tx, rx) = channel();
-        let router = Router::new(tx);
+        let setup = Setup::new();
+        let router = setup.get_router();
         let msg = Message::new(Name::english("task"), Query::new());
         router.send(msg.clone());
-        let result = rx.recv_timeout(TIMEOUT).unwrap();
+        let result = setup.recv().unwrap();
         assert_eq!(result.get_message_id(), msg.get_message_id());
     }
 
     #[test]
     fn can_forward_message() {
-        let (tx, _) = channel();
-        let mut router = Router::new(tx);
-        let (sender, receiver) = channel();
-        let id = router.add_sender(sender);
-        let msg = Message::new(Name::english("wiki"), Query::new());
-        router.forward(&id, msg.clone());
-        let result = receiver.recv_timeout(TIMEOUT).unwrap();
-        assert_eq!(result.get_message_id(), msg.get_message_id());
+        let mut setup = Setup::new();
+        let router = setup.get_router_mut();
+        let mut receivers: HashMap<Uuid, Receiver<Message>> = HashMap::new();
+        for _ in 0..10 {
+            let (tx, rx) = channel();
+            let id = router.add_sender(tx);
+            receivers.insert(id, rx);
+        }
+        for (id, recv) in receivers.iter() {
+            let msg = Message::new(Name::english(id.to_string().as_str()), Query::new());
+            router.forward(id, msg.clone());
+            let result = recv.recv_timeout(TIMEOUT).unwrap();
+            assert_eq!(result.get_message_id(), msg.get_message_id());
+        }
     }
 
     #[test]
     fn sender_ids_are_unique() {
-        let (tx, _) = channel();
-        let mut router = Router::new(tx);
+        let mut setup = Setup::new();
+        let router = setup.get_router_mut();
         let count = 10;
         let mut holder: HashSet<Uuid> = HashSet::new();
         for _ in 0..count {
@@ -139,33 +178,154 @@ mod routers {
 
     #[test]
     fn can_remove_sender() {
-        let (tx, rx) = channel();
-        let mut router = Router::new(tx);
-        let (data, _) = channel();
-        let id = router.add_sender(data);
-        assert_eq!(router.senders.len(), 1, "should have only one sender");
-        router.remove_sender(&id);
-        assert_eq!(router.senders.len(), 0, "should have no senders.");
-        let result = rx.recv_timeout(TIMEOUT).unwrap();
-        let action = result.get_action();
+        let mut setup = Setup::new();
+        let router = setup.get_router_mut();
+        let mut receivers: HashMap<Uuid, Receiver<Message>> = HashMap::new();
+        for _ in 0..10 {
+            let (tx, rx) = channel();
+            let id = router.add_sender(tx);
+            receivers.insert(id, rx);
+        }
+        let removed = receivers.keys().last().unwrap().clone();
+        router.remove_sender(&removed);
+        let router = setup.get_router();
+        let removed_recv = receivers.remove(&removed).unwrap();
+        router.forward(&removed, Message::new(NameType::None, Query::new()));
+        match removed_recv.recv_timeout(TIMEOUT) {
+            Err(err) => match err {
+                RecvTimeoutError::Disconnected => {}
+                _ => unreachable!("got {:?}, should have been disconnected", err),
+            },
+            _ => unreachable!("should have returned an error"),
+        }
+        let announce = setup.recv().unwrap();
+        let action = announce.get_action();
         match action {
-            MsgAction::Register(reg_msg) => {
-                let reg_action = reg_msg.get_msg();
-                match reg_action {
-                    RegMsg::RemoveSender(result) => assert_eq!(result, &id),
-                    _ => unreachable!("got {:?}, should have been remove sender", reg_action),
+            MsgAction::Register(data) => {
+                let output = data.get_msg();
+                match output {
+                    RegMsg::RemoveSender(id) => assert_eq!(id, &removed),
+                    _ => unreachable!("got {:?} should have been sender removal", output),
                 }
             }
-            _ => unreachable!("got {:?}, should have been registry message", action),
+            _ => unreachable!("got {:?}, should have been register", action),
+        }
+        for (id, recv) in receivers.iter() {
+            let msg = Message::new(Name::english(id.to_string().as_str()), Query::new());
+            router.forward(id, msg.clone());
+            let result = recv.recv_timeout(TIMEOUT).unwrap();
+            assert_eq!(result.get_message_id(), msg.get_message_id());
         }
     }
 
     #[test]
     fn ignores_bad_id_removals() {
-        let (tx, rx) = channel();
-        let mut router = Router::new(tx);
-        router.remove_sender(&Uuid::new_v4());
+        let mut setup = Setup::new();
+        let router = setup.get_router_mut();
+        let removed = Uuid::new_v4();
+        router.remove_sender(&removed);
         assert_eq!(router.senders.len(), 0, "should have no senders.");
-        rx.recv_timeout(TIMEOUT).unwrap();
+        let announce = setup.recv().unwrap();
+        let action = announce.get_action();
+        match action {
+            MsgAction::Register(data) => {
+                let output = data.get_msg();
+                match output {
+                    RegMsg::RemoveSender(id) => assert_eq!(id, &removed),
+                    _ => unreachable!("got {:?} should have been sender removal", output),
+                }
+            }
+            _ => unreachable!("got {:?}, should have been register", action),
+        }
+    }
+}
+
+#[cfg(test)]
+mod queues {
+    use super::*;
+    use crate::{
+        data_director::{Include, Path},
+        message::MsgAction,
+        name::Name,
+        support_tests::TIMEOUT,
+    };
+    use std::sync::mpsc::{Receiver, RecvTimeoutError};
+
+    struct Setup {
+        test_mod: Queue,
+        rx: Receiver<Message>,
+        rx_id: Uuid,
+    }
+
+    impl Setup {
+        fn new() -> Self {
+            let mut queue = Queue::new();
+            let (tx, rx) = channel();
+            let id = queue.add_sender(tx);
+            Self {
+                test_mod: queue,
+                rx: rx,
+                rx_id: id,
+            }
+        }
+
+        fn send_reg_msg(&self, msg: RegMsg) {
+            let reg_msg = Register::new(self.rx_id.clone(), msg);
+            self.test_mod
+                .send(Message::new(NameType::None, reg_msg))
+                .unwrap();
+        }
+
+        fn recv(&self) -> Result<Message, RecvTimeoutError> {
+            self.rx.recv_timeout(TIMEOUT)
+        }
+    }
+
+    #[test]
+    fn can_add_names_registry() {
+        let setup = Setup::new();
+        let name = Name::english(Uuid::new_v4().to_string().as_str());
+        let reg = RegMsg::AddDocName(vec![name.clone()]);
+        setup.send_reg_msg(reg);
+        let result = setup.recv().unwrap();
+        let action = result.get_action();
+        match action {
+            MsgAction::Register(data) => {
+                let regmsg = data.get_msg();
+                match data.get_msg() {
+                    RegMsg::DocumentNameID(_) => {}
+                    _ => unreachable!("got {:?} should have been document id", regmsg),
+                }
+            }
+            _ => unreachable!("got {:?} should have been register", action),
+        }
+    }
+
+    #[test]
+    fn returns_error_when_document_name_not_found() {
+        let setup = Setup::new();
+        let name = Name::english(Uuid::new_v4().to_string().as_str());
+        let path = Path::new(
+            Include::All,
+            Include::Just(name.clone().into()),
+            Include::All,
+        );
+        let reg = RegMsg::AddRoute(path);
+        setup.send_reg_msg(reg);
+        let result = setup.recv().unwrap();
+        let action = result.get_action();
+        match action {
+            MsgAction::Register(data) => {
+                let regmsg = data.get_msg();
+                match data.get_msg() {
+                    RegMsg::Error(err) => match err {
+                        MTTError::NameNotFound(failed_name) => assert_eq!(failed_name, &name),
+                        _ => unreachable!("got {:?} should have been missing name", err),
+                    },
+                    _ => unreachable!("got {:?} should have been error", regmsg),
+                }
+            }
+            _ => unreachable!("got {:?} should have been register", action),
+        }
     }
 }