Swapped old code with new.

src/lib.rs

@@ -1,202 +1,134 @@
-mod client;
-mod clock;
-mod doctype;
-mod document;
-mod field;
 mod message;
-mod queue;
-mod session;
 
-use client::{Client, ClientChannel};
-use clock::Clock;
-use document::Document;
-use field::Field;
-use queue::{Message, MsgType, Queue};
-use session::Session;
+use message::{
+    Action, Addition, CalcValue, Calculation, Clock, CreateDoc, Delete, DocDef, DocFuncType, Field,
+    FieldType, Include, IndexType, Message, Name, NameType, Operand, Path, Queue, RegMsg, Register,
+    Session, Update,
+};
+pub use message::{MsgAction, Query};
+use std::{
+    sync::mpsc::{channel, Receiver},
+    time::Duration,
+};
 use uuid::Uuid;
 
-#[derive(Clone, Debug, PartialEq)]
-pub enum ActionType {
-    Get,
-    Add,
-    Update,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum ErrorType {
-    DocumentAlreadyExists,
-    DocumentInvalidRequest,
-    DocumentNotFound,
-}
-
-pub struct MTTReply {
-    document: String,
-    error_type: Option<ErrorType>,
-}
-
-impl MTTReply {
-    fn new(msg: Message) -> Self {
-        Self {
-            document: match msg.get_data("doc") {
-                Some(doc) => doc.to_string(),
-                None => "".to_string(),
-            },
-            error_type: match msg.get_data("error_type") {
-                Some(err) => Some(err.to_error_type().unwrap()),
-                None => None,
-            },
-        }
-    }
-
-    pub fn get_document(&self) -> String {
-        self.document.clone()
-    }
-
-    pub fn get_error(&self) -> Option<ErrorType> {
-        self.error_type.clone()
-    }
-}
-
-#[cfg(test)]
-mod mtt_replies {
-    use super::*;
-
-    #[test]
-    fn create_reply_with_no_error() {
-        let mut msg = Message::new(MsgType::Document);
-        let content = format!("content-{}", Uuid::new_v4());
-        msg.add_data("doc", content.to_string());
-        let reply = MTTReply::new(msg);
-        assert!(reply.get_error().is_none());
-        assert_eq!(reply.get_document(), content);
-    }
-
-    #[test]
-    fn create_reply_with_error() {
-        let mut msg = Message::new(MsgType::Error);
-        msg.add_data("error_type", ErrorType::DocumentNotFound);
-        let reply = MTTReply::new(msg);
-        match reply.get_error() {
-            Some(err) => match err {
-                ErrorType::DocumentNotFound => {}
-                _ => unreachable!("got {:?}: should have been document not found", err),
-            },
-            None => unreachable!("should return an error type"),
-        }
-        assert_eq!(reply.get_document(), "");
-    }
-
-    #[test]
-    fn no_error() {
-        let msg = Message::new(MsgType::Document);
-        let reply = MTTReply::new(msg);
-        assert!(reply.get_error().is_none());
-    }
-
-    #[test]
-    fn some_error() {
-        let mut msg = Message::new(MsgType::Error);
-        msg.add_data("error_type", ErrorType::DocumentNotFound);
-        let reply = MTTReply::new(msg);
-        match reply.get_error() {
-            Some(err) => match err {
-                ErrorType::DocumentNotFound => {}
-                _ => unreachable!("got {:?}: should have been document not found", err),
-            },
-            None => unreachable!("should return an error type"),
-        }
-    }
-}
-
 #[derive(Clone)]
 pub struct MoreThanText {
-    client_channel: ClientChannel,
+    queue: Queue,
 }
 
 impl MoreThanText {
     pub fn new() -> Self {
-        let queue = Queue::new();
+        let mut queue = Queue::new();
         Clock::start(queue.clone());
-        Document::start(queue.clone());
-        Session::start(queue.clone());
-        Self {
-            client_channel: Client::start(queue.clone()),
+        CreateDoc::start(queue.clone());
+        let session = Session::new();
+        session.create(queue.clone());
+        Self { queue: queue }
+    }
+
+    fn recursive_session_request(
+        &mut self,
+        rx: Receiver<Message>,
+        action: MsgAction,
+        msg: Message,
+    ) -> Uuid {
+        let reply = msg.response(action);
+        self.queue.send(reply).unwrap();
+        let result = rx.recv().unwrap();
+        match result.get_action() {
+            MsgAction::Records(data) => {
+                if data.len() == 0 {
+                    self.recursive_session_request(rx, Addition::new().into(), msg)
+                } else {
+                    let rec = data.iter().last().unwrap();
+                    let field = rec.get(Name::english("id")).unwrap();
+                    match field {
+                        Field::Uuid(result) => result,
+                        _ => unreachable!("should only receive uuid"),
+                    }
+                }
+            }
+            _ => unreachable!("session queries should always return"),
         }
     }
 
-    pub fn validate_session<F>(&mut self, session: Option<F>) -> Uuid
-    where
-        F: Into<Field>,
-    {
-        let mut msg = Message::new(MsgType::SessionValidate);
-        match session {
-            Some(id) => msg.add_data("sess_id", id.into()),
-            None => {}
-        }
-        let rx = self.client_channel.send(msg);
-        let reply = rx.recv().unwrap();
-        reply.get_data("sess_id").unwrap().to_uuid().unwrap()
+    pub fn validate_session(&mut self, session: Option<String>) -> Uuid {
+        let (tx, rx) = channel();
+        let sender_id = self.queue.add_sender(tx);
+        let new_session: MsgAction = Addition::new().into();
+        let action = match session {
+            Some(data) => match Uuid::try_from(data.as_str()) {
+                Ok(id) => {
+                    let mut query = Query::new();
+                    let mut calc = Calculation::new(Operand::Equal);
+                    calc.add_value(CalcValue::Existing(FieldType::Uuid));
+                    calc.add_value(id);
+                    query.add(Name::english("id"), calc);
+                    query.into()
+                }
+                Err(_) => new_session,
+            },
+            None => new_session,
+        };
+        let doc_name = Name::english("session");
+        let msg = Message::new(doc_name.clone(), action.clone());
+        let msg_id = msg.get_message_id();
+        let path = Path::new(
+            Include::Just(msg_id.clone()),
+            Include::Just(doc_name.clone().into()),
+            Include::Just(Action::Records),
+        );
+        let reg_msg = Register::new(sender_id.clone(), RegMsg::AddRoute(path));
+        self.queue
+            .send(msg.forward(NameType::None, reg_msg))
+            .unwrap();
+        rx.recv().unwrap(); // Wait for completion.
+        self.recursive_session_request(rx, action, msg)
     }
 
-    pub fn get_document<S>(
-        &self,
-        sess_id: Uuid,
-        action: ActionType,
-        doc_name: S,
-        data: String,
-    ) -> MTTReply
-    where
-        S: Into<String>,
-    {
-        let mut msg = Message::new(MsgType::DocumentRequest);
-        msg.add_data("sess_id", sess_id);
-        msg.add_data("action", action);
-        msg.add_data("name", doc_name.into());
-        msg.add_data("doc", data);
-        let rx = self.client_channel.send(msg);
-        let reply = rx.recv().unwrap();
-        MTTReply::new(reply)
+    pub fn get_document(&self) -> String {
+        "something".to_string()
     }
 }
 
 #[cfg(test)]
-mod mtt {
+mod mtts {
     use super::*;
 
     #[test]
-    fn session_id_is_unique() {
+    fn are_session_ids_unique() {
         let mut mtt = MoreThanText::new();
-        let input: Option<String> = None;
-        let mut ids: Vec<Uuid> = Vec::new();
-        for _ in 0..10 {
-            let id = mtt.validate_session(input.clone());
-            assert!(!ids.contains(&id));
-            ids.push(id);
+        let count = 10;
+        let mut result: Vec<Uuid> = Vec::new();
+        for _ in 0..count {
+            let id = mtt.validate_session(None);
+            assert!(!result.contains(&id), "found {} in {:?}", id, result);
+            result.push(id);
         }
     }
 
     #[test]
-    fn reuse_existing_session() {
+    fn bad_session_id_returns_new_id() {
         let mut mtt = MoreThanText::new();
-        let initial: Option<String> = None;
-        let id = mtt.validate_session(initial);
-        let output = mtt.validate_session(Some(id.clone()));
-        assert_eq!(output, id);
+        let id1 = mtt.validate_session(Some("stuff".to_string()));
+        let id2 = mtt.validate_session(Some("stuff".to_string()));
+        assert_ne!(id1, id2);
     }
 
     #[test]
-    fn get_root_document_with_str() {
+    fn creates_new_session_if_bad_or_expired() {
         let mut mtt = MoreThanText::new();
-        let id = mtt.validate_session(Some(Uuid::new_v4()));
-        let output = mtt.get_document(id, ActionType::Get, "root", "".to_string());
-        assert!(output.get_error().is_none());
+        let id1 = mtt.validate_session(Some(Uuid::nil().to_string()));
+        let id2 = mtt.validate_session(Some(Uuid::nil().to_string()));
+        assert_ne!(id1, id2);
     }
 
     #[test]
-    fn get_root_document_with_string() {
+    fn returns_same_session_id_when_valid() {
         let mut mtt = MoreThanText::new();
-        let id = mtt.validate_session(Some(Uuid::new_v4()));
-        let output = mtt.get_document(id, ActionType::Get, "root".to_string(), "".to_string());
-        assert!(output.get_error().is_none());
+        let id = mtt.validate_session(None);
+        let result = mtt.validate_session(Some(id.to_string()));
+        assert_eq!(result, id);
     }
 }