morethantext/src/message/action.rs

use crate::{
    document::definition::DocDef,
    message::wrapper::{Addition, Delete, Query, Records, Reply, Update},
    mtterror::MTTError,
    queue::data_director::Register,
};

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub enum Action {
    Addition,
    Create,
    Delete,
    Error,
    OnAddition,
    OnDelete,
    OnQuery,
    OnUpdate,
    Query,
    Records,
    Register,
    Reply,
    Show,
    Update,
}

impl From<MsgAction> for Action {
    fn from(value: MsgAction) -> Self {
        match value {
            MsgAction::Addition(_) => Action::Addition,
            MsgAction::Create(_) => Action::Create,
            MsgAction::Delete(_) => Action::Delete,
            MsgAction::Error(_) => Action::Error,
            MsgAction::OnAddition(_) => Action::OnAddition,
            MsgAction::OnDelete(_) => Action::OnDelete,
            MsgAction::OnQuery(_) => Action::OnQuery,
            MsgAction::OnUpdate(_) => Action::OnUpdate,
            MsgAction::Query(_) => Action::Query,
            MsgAction::Records(_) => Action::Records,
            MsgAction::Register(_) => Action::Register,
            MsgAction::Reply(_) => Action::Reply,
            MsgAction::Show => Action::Show,
            MsgAction::Update(_) => Action::Update,
        }
    }
}

impl From<&MsgAction> for Action {
    fn from(value: &MsgAction) -> Self {
        let action = value.clone();
        Self::from(action)
    }
}

#[derive(Clone, Debug)]
pub enum MsgAction {
    Addition(Addition),
    Create(DocDef),
    Error(MTTError),
    OnAddition(Records),
    OnDelete(Records),
    OnQuery(Records),
    OnUpdate(Records),
    Query(Query),
    Records(Records),
    Register(Register),
    Reply(Reply),
    Show,
    Delete(Delete),
    Update(Update),
}

impl From<Addition> for MsgAction {
    fn from(value: Addition) -> Self {
        MsgAction::Addition(value)
    }
}

impl From<Delete> for MsgAction {
    fn from(value: Delete) -> Self {
        MsgAction::Delete(value)
    }
}

impl From<DocDef> for MsgAction {
    fn from(value: DocDef) -> Self {
        MsgAction::Create(value)
    }
}

impl From<MTTError> for MsgAction {
    fn from(value: MTTError) -> Self {
        MsgAction::Error(value)
    }
}

impl From<Query> for MsgAction {
    fn from(value: Query) -> Self {
        MsgAction::Query(value)
    }
}

impl From<Records> for MsgAction {
    fn from(value: Records) -> Self {
        MsgAction::Records(value)
    }
}

impl From<Register> for MsgAction {
    fn from(value: Register) -> Self {
        MsgAction::Register(value)
    }
}

impl From<Reply> for MsgAction {
    fn from(value: Reply) -> Self {
        MsgAction::Reply(value)
    }
}

impl From<Update> for MsgAction {
    fn from(value: Update) -> Self {
        MsgAction::Update(value)
    }
}

#[cfg(test)]
mod msgactions {
    use super::*;
    use crate::name::Name;
    use uuid::Uuid;

    #[test]
    fn turn_document_definition_into_action() {
        let name = Name::english(Uuid::new_v4().to_string().as_str());
        let value = DocDef::new(name.clone());
        let result: MsgAction = value.into();
        match result {
            MsgAction::Create(def) => assert_eq!(def.get_document_names(), &[name].to_vec()),
            _ => unreachable!("Got {:?}: dhould have been create", result),
        }
    }

    #[test]
    fn turn_error_into_action() {
        let data = "data".to_string();
        let value = MTTError::DocumentAlreadyExists(data.clone());
        let result: MsgAction = value.into();
        match result {
            MsgAction::Error(result) => match result {
                MTTError::DocumentAlreadyExists(output) => assert_eq!(output, data),
                _ => unreachable!("Got {:?}: dhould have been create", result),
            },
            _ => unreachable!("Got {:?}: dhould have been create", result),
        }
        let value = MTTError::DocumentNotFound(data.clone());
        let result: MsgAction = value.into();
        match result {
            MsgAction::Error(result) => match result {
                MTTError::DocumentNotFound(output) => assert_eq!(output, data),
                _ => unreachable!("Got {:?}: dhould have been create", result),
            },
            _ => unreachable!("Got {:?}: dhould have been create", result),
        }
    }

    #[test]
    fn turn_query_into_action() {
        let value = Query::new();
        let result: MsgAction = value.into();
        match result {
            MsgAction::Query(_) => {}
            _ => unreachable!("Got {:?}: dhould have been query", result),
        }
    }

    #[test]
    fn turn_reply_into_action() {
        let value = Reply::new();
        let result: MsgAction = value.into();
        match result {
            MsgAction::Reply(_) => {}
            _ => unreachable!("Got {:?}: dhould have been reply", result),
        }
    }
}