Began moving database communication into a client.

src/lib.rs

@@ -7,8 +7,9 @@ mod queue;
 
 use document::{Clock, CreateDoc, Session};
 use isolang::Language;
-use message::{wrapper::Message, MessageAction};
+use message::{wrapper::Message, MessageID, MessageAction};
 use queue::{
+    SenderID,
     data_director::{RegMsg, Register},
     router::Queue,
 };
@@ -38,6 +39,68 @@ mod support_tests {
 
 static TIMEOUT: Duration = Duration::from_secs(10);
 
+pub struct MTTClient {
+    queue: Queue,
+    rx: Receiver<Message>,
+    sender_id: SenderID,
+    session_id: Uuid,
+}
+
+impl MTTClient {
+    fn new(mut queue: Queue) -> Self {
+        let sess_name = Session::doc_names()[0].clone();
+        let (tx, rx) = channel();
+        let sender_id = queue.add_sender(tx);
+        let msg_id = MessageID::new();
+        let paths = [
+            Path::new(
+                Include::Just(msg_id.clone()),
+                Include::Just(sess_name.clone().into()),
+                Include::Just(Action::Records),
+            ),
+            Path::new(
+                Include::Just(msg_id.clone()),
+                Include::All,
+                Include::Just(Action::Error),
+            ),
+        ];
+        for path in paths.iter().cloned() {
+            let reg_msg = Register::new(sender_id.clone(), RegMsg::AddRoute(path));
+            queue.send(Message::with_id(msg_id.clone(), reg_msg));
+            let result = rx.recv().unwrap();
+        }
+        let add = Addition::new(sess_name);
+        queue.send(Message::with_id(msg_id, add));
+        let sess_info = rx.recv().unwrap();
+        let session_id = match sess_info.get_action() {
+            MsgAction::Records(data) => {
+                let rec = data.iter().last().unwrap();
+                match rec.get(Session::id_field_names()[0].clone()).unwrap().clone() {
+                    Field::Uuid(id) => id.clone(),
+                    _ => unreachable!("should only return uuid"),
+                }
+            }
+            _ => unreachable!("new session request should always succeed"),
+        };
+        Self {
+            queue: queue,
+            rx: rx,
+            sender_id: sender_id,
+            session_id: session_id,
+        }
+    }
+
+    pub fn session_id(&self) -> String {
+        self.session_id.to_string()
+    }
+}
+
+impl Drop for MTTClient {
+    fn drop(&mut self) {
+        self.queue.remove_sender(&self.sender_id);
+    }
+}
+
 #[derive(Clone)]
 pub struct MoreThanText {
     queue: Queue,
@@ -57,6 +120,10 @@ impl MoreThanText {
         output
     }
 
+    pub fn client(&self) -> MTTClient {
+        MTTClient::new(self.queue.clone())
+    }
+
     fn new_session(lang: Option<Language>) -> ClientAction {
         let mut output = Addition::new(Session::doc_names()[0].clone());
         match lang {

src/message/wrapper.rs

@@ -47,11 +47,19 @@ pub struct Message {
 
 impl Message {
     pub fn new<A>(action: A) -> Self
+    where
+        A: Into<MsgAction>,
+    {
+        let msg_id = MessageID::new();
+        Self::with_id(msg_id, action)
+    }
+
+    pub fn with_id<A>(msg_id: MessageID, action: A) -> Self
     where
         A: Into<MsgAction>,
     {
         Self {
-            msg_id: MessageID::new(),
+            msg_id: msg_id,
             action: action.into(),
             route: Route::default(),
         }

tests/client_test.rs

@@ -0,0 +1,14 @@
+use morethantext::MoreThanText;
+use std::collections::HashSet;
+
+#[test]
+fn are_session_ids_unique() {
+    let count = 10;
+    let mtt = MoreThanText::new();
+    let mut ids: HashSet<String> = HashSet::new();
+    for _ in 0..count {
+        let client = mtt.client();
+        ids.insert(client.session_id());
+    }
+    assert_eq!(ids.len(), count, "ids = {:?}", ids);
+}