Can now show a document description.

src/message.rs

@@ -27,6 +27,7 @@ enum Action {
     Error,
     Query,
     Reply,
+    Show,
 }
 
 impl From<MsgAction> for Action {
@@ -36,6 +37,7 @@ impl From<MsgAction> for Action {
             MsgAction::Error(_) => Action::Error,
             MsgAction::Query(_) => Action::Query,
             MsgAction::Reply(_) => Action::Reply,
+            MsgAction::Show => Action::Show,
         }
     }
 }
@@ -85,6 +87,7 @@ enum MsgAction {
     Error(MTTError),
     Query(Access),
     Reply(Response),
+    Show,
     // Add
     // Delete
 }
@@ -171,7 +174,7 @@ mod msgactions {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 struct Message {
     msg_id: Uuid,
     document_id: NameID,
@@ -948,11 +951,18 @@ impl Document {
             NameID::Name(name) => name.clone(),
             NameID::ID(id) => id.to_string(),
         };
-        let routes = [RouteRequest::new(
+        let routes = [
-            Include::All,
+            RouteRequest::new(
-            Include::Some(name.clone()),
+                Include::All,
-            Include::Some(Action::Query),
+                Include::Some(name.clone()),
-        )]
+                Include::Some(Action::Query),
+            ),
+            RouteRequest::new(
+                Include::All,
+                Include::Some(name.clone()),
+                Include::Some(Action::Show),
+            ),
+        ]
         .to_vec();
         match queue.register(tx, name, routes) {
             Ok(_) => {}
@@ -984,44 +994,59 @@ mod documents {
     use super::{support_test::TIMEOUT, *};
     use std::sync::mpsc::RecvTimeoutError;
 
-    struct TestDoc {
+    fn test_doc(
-        queue: Queue,
+        name: &str,
-        rx: Receiver<Message>,
+        docdef: DocDef,
-    }
+        routes: Vec<RouteRequest>,
-
+    ) -> (Queue, Receiver<Message>) {
-    impl TestDoc {
+        let (tx, rx) = channel();
-        fn new(name: &str, docdef: DocDef) -> Self {
+        let mut queue = Queue::new();
-            let mut queue = Queue::new();
+        let msg = Message::new(name, docdef);
-            let msg = Message::new(name, docdef);
+        Document::start(queue.clone(), msg);
-            Document::start(queue.clone(), msg);
+        queue
-            let (tx, rx) = channel();
+            .register(tx, Uuid::new_v4().to_string(), routes)
-            let routes = [RouteRequest::new(Include::All, Include::All, Include::All)].to_vec();
+            .unwrap();
-            queue.register(tx, name.to_string(), routes);
+        (queue, rx)
-            Self {
-                queue: queue,
-                rx: rx,
-            }
-        }
-
-        fn send(&self, msg: Message) -> Result<(), MTTError> {
-            match self.queue.send(msg) {
-                // Removes the just sent message from the queue.
-                Ok(_) => self.rx.recv_timeout(TIMEOUT).unwrap(),
-                Err(err) => return Err(err),
-            };
-            Ok(())
-        }
-
-        fn recv(&self) -> Result<Message, RecvTimeoutError> {
-            self.rx.recv_timeout(TIMEOUT)
-        }
     }
 
     #[test]
-    fn has_data_fields() {
+    fn can_show_document_details() {
         let docdef = DocDef::new();
         let name = "first";
-        let doc = TestDoc::new(name, docdef);
+        let routes = [RouteRequest::new(
+            Include::All,
+            Include::All,
+            Include::Some(Action::Reply),
+        )]
+        .to_vec();
+        let (queue, rx) = test_doc(name, docdef, routes);
+        let msg = Message::new(name, MsgAction::Show);
+        queue.send(msg.clone()).unwrap();
+        let show = rx.recv_timeout(TIMEOUT).unwrap();
+    }
+
+    fn only_responses_to_its_show_request() {
+        let docdef = DocDef::new();
+        let name = "quiet";
+        let routes = [RouteRequest::new(
+            Include::All,
+            Include::All,
+            Include::Some(Action::Reply),
+        )]
+        .to_vec();
+        let (mut queue, rx) = test_doc(name, docdef, routes);
+        let other = "alternate";
+        let (tx, _) = channel();
+        queue.register(tx, other.to_string(), Vec::new()).unwrap();
+        let msg = Message::new(other, MsgAction::Show);
+        queue.send(msg).unwrap();
+        match rx.recv_timeout(TIMEOUT) {
+            Ok(msg) => unreachable!("should not receive: {:?}", msg),
+            Err(err) => match err {
+                RecvTimeoutError::Timeout => {}
+                _ => unreachable!("should have timed out"),
+            },
+        }
     }
 }