MoreThanText/morethantext
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated error to be more expressive.
Some checks failed
Gitea Actions Demo / Explore-Gitea-Actions (push) Failing after 1s
Details

Browse Source
This commit is contained in:
Jeff Baskin 2026-02-25 10:16:50 -05:00
parent 7e067fde8c
commit 5251689158
15 changed files with 211 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/action/calculation.rs
View File

@ -352,7 +352,7 @@ impl Calculation {
if base == ftype {
self.values.push(holder);
} else {
let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
let err = MTTError::new(ErrorID::FieldInvalidType);
return Err(err);
}
Ok(())
@ -380,7 +380,7 @@ impl Calculation {
if base == ftype {
Ok(())
} else {
let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
let err = MTTError::new(ErrorID::FieldInvalidType);
return Err(err);
}
}
@ -452,7 +452,7 @@ mod calculations {
match calc.add_value("other") {
Ok(_) => unreachable!("should have errored with wrong type"),
Err(err) => {
let err_id = err.error_id();
let err_id = err.get_error_ids().back().unwrap();
match err_id {
ErrorID::FieldInvalidType => {}
_ => unreachable!("got {:?}, expected wrong field type", err_id),
@ -605,7 +605,7 @@ mod calculations {
calc.add_value(Uuid::nil()).unwrap();
match calc.add_value("mismatch") {
Ok(_) => unreachable!("should have returned an error"),
Err(err) => match err.error_id() {
Err(err) => match err.get_error_ids().back().unwrap() {
ErrorID::FieldInvalidType => {}
_ => unreachable!("got {:?}, expected wrong field type", err),
},

8
src/action/message.rs
View File

@ -130,15 +130,15 @@ mod msgactions {
fn turn_error_into_action() {
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());
let error = ErrorID::Document(expected_name.clone());
let err = MTTError::new(error.clone());
let result: MsgAction = err.into();
match result {
MsgAction::Error(err) => {
assert_eq!(err.doc_name(), &expected_name);
let err_id = err.error_id();
let err_id = err.get_error_ids().back().unwrap();
match err_id {
ErrorID::DocumentNameAlreadyExists => {}
ErrorID::Document(_) => {}
_ => unreachable!("got {:?}, expected document name exists", err_id),
}
}

34
src/document/create.rs
View File

@ -118,7 +118,7 @@ impl Index {
}
};
if self.unique && oids.len() > 0 {
let err = MTTError::new(NameType::None, ErrorID::IndexEntryAlreadyExists);
let err = MTTError::new(ErrorID::IndexEntryAlreadyExists);
return Err(err);
} else {
oids.insert(oid);
@ -136,7 +136,7 @@ impl Index {
}
}
_ => {
let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
let err = MTTError::new(ErrorID::FieldInvalidType);
return Err(err);
}
}
@ -160,7 +160,7 @@ impl Index {
if self.unique {
match self.data.get(field) {
Some(_) => {
let err = MTTError::new(NameType::None, ErrorID::IndexEntryAlreadyExists);
let err = MTTError::new(ErrorID::IndexEntryAlreadyExists);
return Err(err);
}
None => {}
@ -320,7 +320,7 @@ mod indexes {
match index.add(field.clone(), oids[0].clone()) {
Ok(_) => unreachable!("should have been an error"),
Err(err) => {
let err_id = err.error_id();
let err_id = err.get_error_ids().back().unwrap();
match err_id {
ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}: should have been duplicate field", err),
@ -349,7 +349,7 @@ mod indexes {
index.add(field.clone(), oid).unwrap();
match index.validate(&field) {
Ok(_) => unreachable!("should have gotten a duplication error"),
Err(err) => match err.error_id() {
Err(err) => match err.get_error_ids().back().unwrap() {
ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}: should have been duplicate field", err),
},
@ -1040,6 +1040,7 @@ mod document_files {
}
}
/*
#[test]
fn can_document_be_added() {
let doc_name = Name::english("document");
@ -1124,6 +1125,7 @@ mod document_files {
}
assert!(entries.is_empty(), "did not use {:?}", entries);
}
*/
#[test]
fn errors_on_wrong_field_name() {
@ -1136,7 +1138,7 @@ mod document_files {
queue.send(Message::new(addition));
let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
match result.get_action() {
MsgAction::Error(err) => match err.error_id() {
MsgAction::Error(err) => match err.get_error_ids().back().unwrap() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should have been document field not found.", err),
},
@ -1154,7 +1156,7 @@ mod document_files {
queue.send(Message::new(addition));
let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
match result.get_action() {
MsgAction::Error(err) => match err.error_id() {
MsgAction::Error(err) => match err.get_error_ids().back().unwrap() {
ErrorID::FieldInvalidType => {}
_ => unreachable!(
"got {:?}: should have been document field data mismatch.",
@ -1175,7 +1177,7 @@ mod document_files {
queue.send(Message::new(addition));
let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
match result.get_action() {
MsgAction::Error(err) => match err.error_id() {
MsgAction::Error(err) => match err.get_error_ids().back().unwrap() {
ErrorID::FieldInvalidNone => {}
_ => unreachable!("got {:?}: should have been document field missing", err),
},
@ -1446,7 +1448,7 @@ mod document_files {
let result = rx.recv_timeout(TIMEOUT).unwrap();
let action = result.get_action();
match action {
MsgAction::Error(data) => match data.error_id() {
MsgAction::Error(data) => match data.get_error_ids().back().unwrap() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should been field not found", data),
},
@ -1470,7 +1472,7 @@ mod document_files {
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action();
match action {
MsgAction::Error(data) => match data.error_id() {
MsgAction::Error(data) => match data.get_error_ids().back().unwrap() {
ErrorID::FieldInvalidType => {}
_ => unreachable!("got {:?}: should been invalid field type", data),
},
@ -1758,7 +1760,7 @@ mod document_files {
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action();
match action {
MsgAction::Error(err) => match err.error_id() {
MsgAction::Error(err) => match err.get_error_ids().back().unwrap() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should have gotten an missing field", err),
},
@ -1789,7 +1791,7 @@ mod document_files {
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action();
match action {
MsgAction::Error(err) => match err.error_id() {
MsgAction::Error(err) => match err.get_error_ids().back().unwrap() {
ErrorID::FieldInvalidType => {}
_ => unreachable!("got {:?}: should have gotten incorrect file type", err),
},
@ -1840,7 +1842,7 @@ mod document_files {
let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action();
match action {
MsgAction::Error(err) => match err.error_id() {
MsgAction::Error(err) => match err.get_error_ids().back().unwrap() {
ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}: should have gotten incorrect file type", err),
},
@ -1927,7 +1929,7 @@ mod document_files {
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action();
match action {
MsgAction::Error(err) => match err.error_id() {
MsgAction::Error(err) => match err.get_error_ids().back().unwrap() {
ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}: should have gotten an missing field", err),
},
@ -1968,7 +1970,7 @@ mod document_files {
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action();
match action {
MsgAction::Error(err) => match err.error_id() {
MsgAction::Error(err) => match err.get_error_ids().back().unwrap() {
ErrorID::IndexEntryAlreadyExists => {}
_ => unreachable!("got {:?}: should have gotten field duplicate", err),
},
@ -2081,7 +2083,7 @@ mod document_files {
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action();
match action {
MsgAction::Error(err) => match err.error_id() {
MsgAction::Error(err) => match err.get_error_ids().back().unwrap() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should have gotten an missing field", err),
},

20
src/document/definition.rs
View File

@ -31,19 +31,19 @@ impl FieldSetting {
match &value {
CalcValue::Calculate(calc) => {
if self.fieldtype != calc.get_type() {
let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
let err = MTTError::new(ErrorID::FieldInvalidType);
return Err(err);
}
}
CalcValue::Existing(ftype) | CalcValue::FType(ftype) => {
if &self.fieldtype != ftype {
let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
let err = MTTError::new(ErrorID::FieldInvalidType);
return Err(err);
}
}
CalcValue::Value(ref item) => {
if item.get_type() != self.fieldtype {
let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
let err = MTTError::new(ErrorID::FieldInvalidType);
return Err(err);
}
}
@ -56,13 +56,13 @@ impl FieldSetting {
fn validate(&self, value: &Field) -> Result<Field, MTTError> {
match value {
Field::None => match &self.default_value {
CalcValue::None => Err(MTTError::new(NameType::None, ErrorID::FieldInvalidNone)),
CalcValue::None => Err(MTTError::new(ErrorID::FieldInvalidNone)),
_ => Ok(self.default_value.get(&Field::None)),
},
_ => {
let vft: FieldType = value.into();
if vft != self.fieldtype {
let err = MTTError::new(NameType::None, ErrorID::FieldInvalidType);
let err = MTTError::new(ErrorID::FieldInvalidType);
return Err(err);
}
Ok(value.clone())
@ -94,7 +94,7 @@ mod fieldsettings {
let value: Field = "text".into();
match fset.validate(&value) {
Ok(data) => unreachable!("got {:?}: should have gotten an error", data),
Err(err) => match err.error_id() {
Err(err) => match err.get_error_ids().back().unwrap() {
ErrorID::FieldInvalidType => {}
_ => unreachable!("got {:?}: should have gotten a value", err),
},
@ -106,7 +106,7 @@ mod fieldsettings {
let fset = FieldSetting::new(FieldType::Uuid);
match fset.validate(&Field::None) {
Ok(data) => unreachable!("got {:?}: should have gotten an error", data),
Err(err) => match err.error_id() {
Err(err) => match err.get_error_ids().back().unwrap() {
ErrorID::FieldInvalidNone => {}
_ => unreachable!("got {:?}: should have gotten a invalid none", err),
},
@ -407,7 +407,7 @@ mod docdefs {
let name = Name::english(Uuid::new_v4().to_string().as_str());
match docdef.get_field(&name) {
Ok(_) => unreachable!("should return non existant field error"),
Err(err) => match err.error_id() {
Err(err) => match err.get_error_ids().back().unwrap() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should have been document field not found", err),
},
@ -455,7 +455,7 @@ mod docdefs {
let field_name = Name::english(Uuid::new_v4().to_string().as_str());
match docdef.set_default(&field_name, FieldType::Uuid) {
Ok(_) => unreachable!("should be an error"),
Err(err) => match err.error_id() {
Err(err) => match err.get_error_ids().back().unwrap() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}: should have been field not found", err),
},
@ -470,7 +470,7 @@ mod docdefs {
docdef.add_field(name.clone(), FieldType::Uuid);
match docdef.set_default(&name, "fred") {
Ok(data) => unreachable!("got {:?}, should be an error", data),
Err(err) => match err.error_id() {
Err(err) => match err.get_error_ids().back().unwrap() {
ErrorID::FieldInvalidType => {}
_ => unreachable!("got {:?}: should have been field not found", err),
},

2
src/document/record.rs
View File

@ -136,7 +136,7 @@ impl Record {
};
match self.data.get(&id) {
Some(data) => Ok(data.clone()),
None => Err(MTTError::new(NameType::None, ErrorID::FieldMissingData)),
None => Err(MTTError::new(ErrorID::FieldMissingData)),
}
}
}

15
src/lib.rs
View File

@ -24,9 +24,14 @@ pub use queue::data_director::{Include, Path};
#[cfg(test)]
mod support_tests {
use super::*;
use std::time::Duration;
pub static TIMEOUT: Duration = Duration::from_millis(500);
pub fn random_name() -> Name {
Name::english(Uuid::new_v4().to_string().as_str())
}
}
static TIMEOUT: Duration = Duration::from_secs(10);
@ -127,7 +132,7 @@ impl MoreThanText {
MsgAction::Error(err) => Err(err.clone()),
_ => unreachable!("should only receive records or errors"),
},
Err(_) => Err(MTTError::new(NameType::None, ErrorID::TimeOut)),
Err(_) => Err(MTTError::new(ErrorID::TimeOut)),
};
self.queue.remove_sender(&sender_id);
output
@ -162,7 +167,7 @@ impl MoreThanText {
MsgAction::Error(err) => Err(err.clone()),
_ => unreachable!("should only receive records or errors"),
},
Err(_) => Err(MTTError::new(NameType::None, ErrorID::TimeOut)),
Err(_) => Err(MTTError::new(ErrorID::TimeOut)),
};
self.queue.remove_sender(&sender_id);
output
@ -172,7 +177,7 @@ impl MoreThanText {
if name == "page" {
Ok("something".to_string())
} else {
Err(MTTError::new(NameType::None, ErrorID::DocumentNotFound))
Err(MTTError::new(ErrorID::DocumentNotFound))
}
}
}
@ -212,10 +217,6 @@ impl TestMoreThanText {
self.queue.send(msg);
}
pub fn random_name() -> Name {
Name::english(Uuid::new_v4().to_string().as_str())
}
pub fn register_channel(&self, paths: Vec<Path>) -> Receiver<Message> {
let mut queue = self.mtt.queue.clone();
let (tx, rx) = channel();

2
src/main.rs
View File

@ -108,7 +108,7 @@ async fn mtt_conn(
result = data.clone();
}
Err(err) => {
status = match err.error_id() {
status = match err.get_error_ids().back().unwrap() {
ErrorID::DocumentNotFound => StatusCode::NOT_FOUND,
_ => StatusCode::INTERNAL_SERVER_ERROR,
};

8
src/message/wrapper.rs
View File

@ -191,10 +191,10 @@ mod messages {
let name = Name::english("testing");
let msg = Message::new(Query::new(name.clone()));
let err_msg = Uuid::new_v4().to_string();
let result = msg.response(MTTError::new(NameType::None, ErrorID::DocumentNotFound));
let result = msg.response(MTTError::new(ErrorID::DocumentNotFound));
assert_eq!(result.get_message_id(), msg.get_message_id());
match result.get_action() {
MsgAction::Error(data) => match data.error_id() {
MsgAction::Error(data) => match data.get_error_ids().back().unwrap() {
ErrorID::DocumentNotFound => {}
_ => unreachable!("got {:?}, should have received not found", data),
},
@ -207,13 +207,13 @@ mod messages {
let doc_id = Uuid::new_v4();
let msg = Message::new(Query::new(doc_id.clone()));
let data = Uuid::new_v4().to_string();
let result1 = msg.response(MTTError::new(NameType::None, ErrorID::DocumentNotFound));
let result1 = msg.response(MTTError::new(ErrorID::DocumentNotFound));
let result2 = msg.response(Reply::new(NameType::None));
assert_eq!(result1.get_message_id(), msg.get_message_id());
assert_eq!(result2.get_message_id(), msg.get_message_id());
let action1 = result1.get_action();
match action1 {
MsgAction::Error(err) => match err.error_id() {
MsgAction::Error(err) => match err.get_error_ids().back().unwrap() {
ErrorID::DocumentNotFound => {}
_ => unreachable!("got {:?}: should have received document not found", err),
},

116
src/mtterror.rs
View File

@ -4,11 +4,12 @@ use crate::{
name::{Name, NameType},
};
use isolang::Language;
use std::{error::Error, fmt};
use std::{collections::VecDeque, error::Error, fmt};
use uuid::Uuid;
#[derive(Clone, Debug)]
pub enum ErrorID {
Document(NameType),
DocumentNameAlreadyExists,
DocumentNotFound,
FieldDataMustBeUnique,
@ -24,31 +25,60 @@ pub enum ErrorID {
TimeOut,
}
impl MessageAction for ErrorID {
fn doc_name(&self) -> &NameType {
match self {
Self::Document(data) => data,
_ => &NameType::None,
}
}
}
#[cfg(test)]
mod error_ids {
use super::*;
use crate::support_tests::random_name;
#[test]
fn do_errors_return_none_doc_name() {
let errors = [ErrorID::FieldInvalidNone, ErrorID::FieldMissingData];
for err in errors.iter() {
assert_eq!(err.doc_name(), &NameType::None);
}
}
#[test]
fn does_document_error_return_document_name() {
let name: NameType = random_name().into();
let err = ErrorID::Document(name.clone());
assert_eq!(err.doc_name(), &name);
}
}
#[derive(Clone, Debug)]
pub struct MTTError {
doc_name: NameType,
error_id: ErrorID,
errors: VecDeque<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 new(err: ErrorID) -> Self {
let mut errs = VecDeque::new();
errs.push_front(err);
Self { errors: errs }
}
pub fn error_id(&self) -> &ErrorID {
&self.error_id
pub fn add_parent(&mut self, err: ErrorID) {
self.errors.push_front(err);
}
pub fn get_error_ids(&self) -> &VecDeque<ErrorID> {
&self.errors
}
}
impl fmt::Display for MTTError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{:?} error: {:?}", self.doc_name, self.error_id)
write!(f, "error: {:?}", self.errors)
}
}
@ -56,48 +86,44 @@ impl Error for MTTError {}
impl MessageAction for MTTError {
fn doc_name(&self) -> &NameType {
&self.doc_name
self.errors.front().unwrap().doc_name()
}
}
#[cfg(test)]
mod errors {
use super::*;
use crate::support_tests::random_name;
#[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)
);
fn can_create_new_error() {
let err = MTTError::new(ErrorID::FieldInvalidNone);
assert_eq!(err.doc_name(), &NameType::None);
}
#[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),
fn does_error_return_none_for_most_errors() {
let base_err = ErrorID::FieldInvalidNone;
let mut holder: VecDeque<ErrorID> = VecDeque::new();
holder.push_front(base_err.clone());
let expected = format!("error: {:?}", holder);
let err = MTTError::new(base_err.clone());
assert_eq!(err.to_string(), expected);
assert_eq!(err.doc_name(), &NameType::None);
}
assert_eq!(
err.to_string(),
format!("{:?} error: {:?}", NameType::Name(doc_name), error)
);
#[test]
fn can_add_parent_error() {
let base_err = ErrorID::FieldInvalidNone;
let name: NameType = random_name().into();
let doc_err = ErrorID::Document(name.clone());
let mut err = MTTError::new(ErrorID::FieldInvalidNone);
err.add_parent(doc_err.clone());
let mut holder: VecDeque<ErrorID> = VecDeque::new();
holder.push_front(base_err.clone());
holder.push_front(doc_err.clone());
let expected = format!("error: {:?}", holder);
assert_eq!(err.to_string(), expected);
assert_eq!(err.doc_name(), &name);
}
}

16
src/name.rs
View File

@ -103,13 +103,13 @@ impl Names {
for name in names.iter() {
let lang = name.get_language();
if languages.contains(&lang) {
let err = MTTError::new(NameType::None, ErrorID::NameLanguageNotUnique);
let err = MTTError::new(ErrorID::NameLanguageNotUnique);
return Err(err);
} else {
languages.push(lang);
}
if self.names.contains_key(&name) {
let err = MTTError::new(NameType::None, ErrorID::NameAlreadyExists);
let err = MTTError::new(ErrorID::NameAlreadyExists);
return Err(err);
}
}
@ -133,7 +133,7 @@ impl Names {
match name.into() {
NameType::Name(data) => match self.names.get(&data) {
Some(id) => Ok(id.clone()),
None => Err(MTTError::new(NameType::None, ErrorID::NameNotFound)),
None => Err(MTTError::new(ErrorID::NameNotFound)),
},
NameType::ID(data) => {
if self.ids.contains_key(&data) {
@ -142,7 +142,7 @@ impl Names {
if data == Uuid::nil() {
Ok(data)
} else {
Err(MTTError::new(NameType::None, ErrorID::NameNotFound))
Err(MTTError::new(ErrorID::NameNotFound))
}
}
}
@ -206,7 +206,7 @@ mod names {
names.add_names(vec![name.clone()]).unwrap();
match names.add_names(vec![name.clone()]) {
Ok(data) => unreachable!("got {:?}, should have been duplicate error", data),
Err(err) => match err.error_id() {
Err(err) => match err.get_error_ids().back().unwrap() {
ErrorID::NameAlreadyExists => {}
_ => unreachable!("got {:?}, should have been duplicate error", err),
},
@ -221,7 +221,7 @@ mod names {
let mut names = Names::new();
match names.add_names(vec![name1, name2, name3.clone()]) {
Ok(data) => unreachable!("got {:?}, should have been needs to be unique", data),
Err(err) => match err.error_id() {
Err(err) => match err.get_error_ids().back().unwrap() {
ErrorID::NameLanguageNotUnique => {}
_ => unreachable!("got {:?}, should have been name needs to be unique", err),
},
@ -234,7 +234,7 @@ mod names {
let names = Names::new();
match names.get_id(name.clone()) {
Ok(data) => unreachable!("got {:?}, should have been missing error", data),
Err(err) => match err.error_id() {
Err(err) => match err.get_error_ids().back().unwrap() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}, should have been missing error", err),
},
@ -247,7 +247,7 @@ mod names {
let names = Names::new();
match names.get_id(id.clone()) {
Ok(data) => unreachable!("got {:?}, should have been missing error", data),
Err(err) => match err.error_id() {
Err(err) => match err.get_error_ids().back().unwrap() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?}, should have been missing error", err),
},

2
src/queue/router.rs
View File

@ -313,7 +313,7 @@ mod queues {
MsgAction::Register(data) => {
let regmsg = data.get_msg();
match data.get_msg() {
RegMsg::Error(err) => match err.error_id() {
RegMsg::Error(err) => match err.get_error_ids().back().unwrap() {
ErrorID::NameNotFound => {}
_ => unreachable!("got {:?} should have been missing name", err),
},

67
tests/add_test.rs Normal file
View File

@ -0,0 +1,67 @@
mod support;
use morethantext::{
action::{Addition, DocDef, Field, FieldType, Query},
ErrorID, MoreThanText, Name,
};
use std::collections::HashSet;
use support::random_name;
use uuid::Uuid;
#[test]
fn can_new_documents_be_added() {
let count = 5;
let mut mtt = MoreThanText::new();
let doc_name = random_name();
let field_name = random_name();
let mut data: HashSet<Field> = HashSet::new();
for i in 0..count {
data.insert(i.into());
}
let mut docdef = DocDef::new(doc_name.clone());
docdef.add_field(field_name.clone(), FieldType::Integer);
mtt.create_document(docdef);
for item in data.iter() {
let mut add = Addition::new(doc_name.clone());
add.add_field(field_name.clone(), item.clone());
mtt.records(add).unwrap();
}
let qry = Query::new(doc_name.clone());
let recs = mtt.records(qry).unwrap();
assert_eq!(recs.len(), data.len());
for rec in recs.iter() {
let result = rec.get(&field_name).unwrap();
assert!(
data.contains(&result),
"did not find {:?} in {:?}",
result,
data
);
data.remove(&result);
}
assert_eq!(data.len(), 0, "{:?} did not appear in query", data);
}
#[test]
#[ignore = "need to alter error"]
fn does_it_error_on_a_bad_field_name() {
let mut mtt = MoreThanText::new();
let doc_name = Name::english("empty");
mtt.create_document(DocDef::new(doc_name.clone()));
let mut add = Addition::new(doc_name.clone());
add.add_field(Name::english("missing"), "stuff");
let result = mtt
.records(add)
.unwrap_err()
.get_error_ids()
.back()
.unwrap()
.clone();
match result {
ErrorID::NameNotFound => {}
_ => unreachable!(
"got {:?}: should have been document field not found.",
result
),
}
}

7
tests/document_test.rs
View File

@ -1,8 +1,11 @@
mod support;
use morethantext::{action::*, ErrorID, Include, MoreThanText, Name, Path, TestMoreThanText};
use std::{
sync::mpsc::{channel, RecvTimeoutError},
time::Duration,
};
use support::random_name;
use uuid::Uuid;
pub static TIMEOUT: Duration = Duration::from_millis(500);
@ -14,7 +17,7 @@ fn are_errors_produced_for_duplicate_names() {
mtt.create_document(docdef.clone()).unwrap();
match mtt.create_document(docdef) {
Ok(_) => assert!(false, "should have failed"),
Err(err) => match err.error_id() {
Err(err) => match err.get_error_ids().back().unwrap() {
ErrorID::NameAlreadyExists => {}
_ => unreachable!("got {:?}, should be name already exists", err),
},
@ -24,7 +27,7 @@ fn are_errors_produced_for_duplicate_names() {
#[test]
fn does_document_respond_to() {
let mut mtt = MoreThanText::new();
let doc_name = TestMoreThanText::random_name();
let doc_name = random_name();
let mut requests: Vec<UserAction> = Vec::new();
requests.push(Addition::new(doc_name.clone()).into());
requests.push(Delete::new(doc_name.clone()).into());

0
tests/lib_session_test.rs → tests/session_test.rs
View File

6
tests/support.rs Normal file
View File

@ -0,0 +1,6 @@
use morethantext::Name;
use uuid::Uuid;
pub fn random_name() -> Name {
Name::english(Uuid::new_v4().to_string().as_str())
}