morethantext/src/lib.rs

mod data_director;
mod documents;
mod field;
mod message;
mod mtterror;
mod name;
mod router;

use data_director::{Include, Path, RegMsg, Register};
use documents::{clock::Clock, create::CreateDoc};
use field::{Field, FieldType};
use message::{Action, Addition, CalcValue, Calculation, Message, Operand, Session};
pub use message::{MsgAction, Query};
use name::{Name, NameType};
use router::Queue;
use std::sync::mpsc::{channel, Receiver};
use uuid::Uuid;

#[cfg(test)]
mod support_tests {
    use std::time::Duration;

    pub static TIMEOUT: Duration = Duration::from_millis(500);
}

#[derive(Clone)]
pub struct MoreThanText {
    queue: Queue,
}

impl MoreThanText {
    pub fn new() -> Self {
        let queue = Queue::new();
        Clock::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(&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))
                        .unwrap();
                    calc.add_value(id).unwrap();
                    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(&self) -> String {
        "something".to_string()
    }
}

#[cfg(test)]
mod mtts {
    use super::*;

    #[test]
    fn are_session_ids_unique() {
        let mut mtt = MoreThanText::new();
        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 bad_session_id_returns_new_id() {
        let mut mtt = MoreThanText::new();
        let id1 = mtt.validate_session(Some("stuff".to_string()));
        let id2 = mtt.validate_session(Some("stuff".to_string()));
        assert_ne!(id1, id2);
    }

    #[test]
    fn creates_new_session_if_bad_or_expired() {
        let mut mtt = MoreThanText::new();
        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 returns_same_session_id_when_valid() {
        let mut mtt = MoreThanText::new();
        let id = mtt.validate_session(None);
        let result = mtt.validate_session(Some(id.to_string()));
        assert_eq!(result, id);
    }
}