morethantext/src/mtterror.rs

use crate::{
    action::{Field, FieldType},
    message::MessageAction,
    name::{Name, NameType},
};
use isolang::Language;
use std::{error::Error, fmt};
use uuid::Uuid;

#[derive(Clone, Debug)]
pub enum ErrorID {
    DocumentNameAlreadyExists,
    DocumentNotFound,
    FieldDataMustBeUnique,
    FieldInvalidNone,
    FieldInvalidType,
    FieldMissingData,
    FieldNameAlreadyExists,
    IndexEntryAlreadyExists,
    InvalidFieldName(Name),
    NameAlreadyExists,
    NameLanguageNotUnique,
    NameNotFound,
    TimeOut,
}

#[derive(Clone, Debug)]
pub struct MTTError {
    doc_name: NameType,
    error_id: ErrorID,
}

impl MTTError {
    pub fn new<NT>(doc_name: NT, error: ErrorID) -> MTTError
    where
        NT: Into<NameType>,
    {
        Self {
            doc_name: doc_name.into(),
            error_id: error,
        }
    }

    pub fn error_id(&self) -> &ErrorID {
        &self.error_id
    }
}

impl fmt::Display for MTTError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:?} error: {:?}", self.doc_name, self.error_id)
    }
}

impl Error for MTTError {}

impl MessageAction for MTTError {
    fn doc_name(&self) -> &NameType {
        &self.doc_name
    }
}

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

    #[test]
    fn can_create_error() {
        let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
        let expected_name: NameType = doc_name.clone().into();
        let error = ErrorID::DocumentNameAlreadyExists;
        let err = MTTError::new(doc_name.clone(), error.clone());
        assert_eq!(err.doc_name(), &expected_name);
        let err_id = err.error_id();
        match err_id {
            ErrorID::DocumentNameAlreadyExists => {}
            _ => unreachable!("got {:?}, should have been invalid document name", err_id),
        }
        assert_eq!(
            err.to_string(),
            format!("{:?} error: {:?}", NameType::Name(doc_name), error)
        );
    }

    #[test]
    fn does_error_ids_contain_data() {
        let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
        let expected_name: NameType = doc_name.clone().into();
        let field_name = Name::english(Uuid::new_v4().to_string().as_str());
        let error = ErrorID::InvalidFieldName(field_name.clone());
        let err = MTTError::new(doc_name.clone(), error.clone());
        assert_eq!(err.doc_name(), &expected_name);
        let err_id = err.error_id();
        match err_id {
            ErrorID::InvalidFieldName(data) => assert_eq!(data, &field_name),
            _ => unreachable!("got {:?}, should have been invalid field name", err_id),
        }
        assert_eq!(
            err.to_string(),
            format!("{:?} error: {:?}", NameType::Name(doc_name), error)
        );
    }
}