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

Refactored existing testing.
Some checks failed
Gitea Actions Demo / Explore-Gitea-Actions (push) Failing after 1s
Details

Browse Source
This commit is contained in:
Jeff Baskin 2025-10-17 10:15:15 -04:00
parent 7674734021
commit 2a324bff96
1 changed files with 119 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

238
src/message.rs
View File

@ -192,7 +192,7 @@ mod msgactions {
#[test] #[test]
fn turn_document_definition_into_action() { fn turn_document_definition_into_action() {
let name = Name::english(Uuid::new_v4().to_string()); let name = Name::english(Uuid::new_v4());
let value = DocDef::new(name.clone()); let value = DocDef::new(name.clone());
let result: MsgAction = value.into(); let result: MsgAction = value.into();
match result { match result {
@ -305,8 +305,8 @@ mod messages {
#[test] #[test]
fn can_the_document_be_a_stringi_reference() { fn can_the_document_be_a_stringi_reference() {
let dts = [ let dts = [
Name::english("one".to_string()), Name::english("one"),
Name::english("two".to_string()), Name::english("two"),
]; ];
for document in dts.into_iter() { for document in dts.into_iter() {
let msg = Message::new( let msg = Message::new(
@ -342,7 +342,7 @@ mod messages {
fn is_the_message_id_random() { fn is_the_message_id_random() {
let mut ids: Vec<Uuid> = Vec::new(); let mut ids: Vec<Uuid> = Vec::new();
for _ in 0..5 { for _ in 0..5 {
let msg = Message::new(Name::english("tester".to_string()), Query::new()); let msg = Message::new(Name::english("tester"), Query::new());
let id = msg.get_message_id().clone(); let id = msg.get_message_id().clone();
assert!(!ids.contains(&id), "{:?} containts {}", ids, id); assert!(!ids.contains(&id), "{:?} containts {}", ids, id);
ids.push(id); ids.push(id);
@ -351,7 +351,7 @@ mod messages {
#[test] #[test]
fn Can_make_reply_message() { fn Can_make_reply_message() {
let name = Name::english("testing".to_string()); let name = Name::english("testing");
let msg = Message::new(name.clone(), MsgAction::Query(Query::new())); let msg = Message::new(name.clone(), MsgAction::Query(Query::new()));
let responce = Reply::new(); let responce = Reply::new();
let reply = msg.response(responce); let reply = msg.response(responce);
@ -368,7 +368,7 @@ mod messages {
#[test] #[test]
fn Can_make_error_message() { fn Can_make_error_message() {
let name = Name::english("testing".to_string()); let name = Name::english("testing");
let msg = Message::new(name.clone(), MsgAction::Query(Query::new())); let msg = Message::new(name.clone(), MsgAction::Query(Query::new()));
let err_msg = Uuid::new_v4().to_string(); let err_msg = Uuid::new_v4().to_string();
let result = msg.response(MTTError::DocumentNotFound(err_msg.clone())); let result = msg.response(MTTError::DocumentNotFound(err_msg.clone()));
@ -552,16 +552,16 @@ impl Name {
&self.lang &self.lang
} }
fn english(name: String) -> Self { fn english<S>(name: S) -> Self where S: Into<String> {
Self { Self {
name: name, name: name.into(),
lang: Language::from_639_1("en").unwrap(), lang: Language::from_639_1("en").unwrap(),
} }
} }
fn japanese(name: String) -> Self { fn japanese<S>(name: S) -> Self where S: Into<String> {
Self { Self {
name: name, name: name.into(),
lang: Language::from_639_1("ja").unwrap(), lang: Language::from_639_1("ja").unwrap(),
} }
} }
@ -640,10 +640,10 @@ impl Names {
if self.ids.contains_key(&data) { if self.ids.contains_key(&data) {
Ok(data) Ok(data)
} else { } else {
Err(MTTError::NameNotFound(Name::english(data.to_string()))) Err(MTTError::NameNotFound(Name::english(data)))
} }
} }
NameType::None => Err(MTTError::NameNotFound(Name::english("none".to_string()))), NameType::None => Err(MTTError::NameNotFound(Name::english("none"))),
} }
} }
@ -686,7 +686,7 @@ mod names {
let data = ["one", "two", "three", "four", "five"]; let data = ["one", "two", "three", "four", "five"];
let mut ids: HashSet<Uuid> = HashSet::new(); let mut ids: HashSet<Uuid> = HashSet::new();
for item in data.iter() { for item in data.iter() {
let name = Name::english(item.to_string()); let name = Name::english(item.clone());
ids.insert(names.add_name(name).unwrap()); ids.insert(names.add_name(name).unwrap());
} }
assert_eq!(ids.len(), data.len()); assert_eq!(ids.len(), data.len());
@ -698,7 +698,7 @@ mod names {
let data = ["one", "two"]; let data = ["one", "two"];
let mut ids: HashMap<Name, Uuid> = HashMap::new(); let mut ids: HashMap<Name, Uuid> = HashMap::new();
for item in data.iter() { for item in data.iter() {
let name = Name::english(item.to_string()); let name = Name::english(item.clone());
ids.insert(name.clone(), names.add_name(name).unwrap()); ids.insert(name.clone(), names.add_name(name).unwrap());
} }
for (name, id) in ids.iter() { for (name, id) in ids.iter() {
@ -715,7 +715,7 @@ mod names {
#[test] #[test]
fn errors_on_name_not_found() { fn errors_on_name_not_found() {
let mut names = Names::new(); let mut names = Names::new();
let name = Name::english("missing".to_string()); let name = Name::english("missing");
let result = names.get_id(&name); let result = names.get_id(&name);
match result { match result {
Ok(_) => unreachable!("got {:?}, should have been error", result), Ok(_) => unreachable!("got {:?}, should have been error", result),
@ -743,7 +743,7 @@ mod names {
#[test] #[test]
fn errors_on_missing_translation() { fn errors_on_missing_translation() {
let mut names = Names::new(); let mut names = Names::new();
let name = Name::english("task".to_string()); let name = Name::english("task");
let lang = Language::from_639_1("ja").unwrap(); let lang = Language::from_639_1("ja").unwrap();
let id = names.add_name(name).unwrap(); let id = names.add_name(name).unwrap();
let result = names.get_name(&id, &lang); let result = names.get_name(&id, &lang);
@ -759,8 +759,8 @@ mod names {
#[test] #[test]
fn errors_on_duplicate_names() { fn errors_on_duplicate_names() {
let mut names = Names::new(); let mut names = Names::new();
let data = "test".to_string(); let data = "test";
let name = Name::english(data.clone()); let name = Name::english(data);
let id = names.add_name(name.clone()); let id = names.add_name(name.clone());
let output = names.add_name(name.clone()); let output = names.add_name(name.clone());
match output { match output {
@ -778,10 +778,10 @@ mod names {
#[test] #[test]
fn allows_alternate_names() { fn allows_alternate_names() {
let mut names = Names::new(); let mut names = Names::new();
let data = "test".to_string(); let data = "test";
let alt = "テスト".to_string(); let alt = "テスト";
let english = Name::english(data.clone()); let english = Name::english(data);
let japanese = Name::japanese(alt.clone()); let japanese = Name::japanese(alt);
let id = names.add_name(english.clone()).unwrap(); let id = names.add_name(english.clone()).unwrap();
let result = names.add_translation(english, japanese.clone()).unwrap(); let result = names.add_translation(english, japanese.clone()).unwrap();
assert_eq!(result, id); assert_eq!(result, id);
@ -793,10 +793,10 @@ mod names {
#[test] #[test]
fn errors_on_bad_translation() { fn errors_on_bad_translation() {
let mut names = Names::new(); let mut names = Names::new();
let data = "test".to_string(); let data = "test";
let alt = "テスト".to_string(); let alt = "テスト";
let english = Name::english(data.clone()); let english = Name::english(data);
let japanese = Name::japanese(alt.clone()); let japanese = Name::japanese(alt);
let result = names.add_translation(japanese.clone(), english); let result = names.add_translation(japanese.clone(), english);
match result { match result {
Ok(_) => unreachable!("got {:?}, should be invalid id error", result), Ok(_) => unreachable!("got {:?}, should be invalid id error", result),
@ -810,10 +810,10 @@ mod names {
#[test] #[test]
fn errors_on_translation_duplicates() { fn errors_on_translation_duplicates() {
let mut names = Names::new(); let mut names = Names::new();
let data = "test".to_string(); let data = "test";
let alt = "テスト".to_string(); let alt = "テスト";
let english = Name::english(data.clone()); let english = Name::english(data);
let japanese = Name::japanese(alt.clone()); let japanese = Name::japanese(alt);
let id = names.add_name(english.clone()).unwrap(); let id = names.add_name(english.clone()).unwrap();
let id = names.add_name(japanese.clone()).unwrap(); let id = names.add_name(japanese.clone()).unwrap();
let result = names.add_translation(english, japanese.clone()); let result = names.add_translation(english, japanese.clone());
@ -832,8 +832,8 @@ mod names {
#[test] #[test]
fn convert_path_to_route_with_ids() { fn convert_path_to_route_with_ids() {
let mut names = Names::new(); let mut names = Names::new();
let data = "data".to_string(); let data = "data";
let english = Name::english(data.clone()); let english = Name::english(data);
let id = names.add_name(english.clone()).unwrap(); let id = names.add_name(english.clone()).unwrap();
let msg_id = Uuid::new_v4(); let msg_id = Uuid::new_v4();
let action = Action::Query; let action = Action::Query;
@ -851,8 +851,8 @@ mod names {
#[test] #[test]
fn convert_path_name_to_route() { fn convert_path_name_to_route() {
let mut names = Names::new(); let mut names = Names::new();
let data = "data".to_string(); let data = "data";
let english = Name::english(data.clone()); let english = Name::english(data);
let id = names.add_name(english.clone()).unwrap(); let id = names.add_name(english.clone()).unwrap();
let msg_id = Uuid::new_v4(); let msg_id = Uuid::new_v4();
let action = Action::Error; let action = Action::Error;
@ -926,7 +926,7 @@ mod names {
fn convert_path_with_bad_name() { fn convert_path_with_bad_name() {
let mut names = Names::new(); let mut names = Names::new();
let msg_id = Uuid::new_v4(); let msg_id = Uuid::new_v4();
let name = Name::english("wrong".to_string()); let name = Name::english("wrong");
let action = Action::Query; let action = Action::Query;
let path = Path::new( let path = Path::new(
Include::Some(msg_id.clone()), Include::Some(msg_id.clone()),
@ -1551,7 +1551,7 @@ mod routers {
fn can_pass_message() { fn can_pass_message() {
let (tx, rx) = channel(); let (tx, rx) = channel();
let router = Router::new(tx); let router = Router::new(tx);
let msg = Message::new(Name::english("task".to_string()), Query::new()); let msg = Message::new(Name::english("task"), Query::new());
router.send(msg.clone()); router.send(msg.clone());
let result = rx.recv_timeout(TIMEOUT).unwrap(); let result = rx.recv_timeout(TIMEOUT).unwrap();
assert_eq!(result.get_message_id(), msg.get_message_id()); assert_eq!(result.get_message_id(), msg.get_message_id());
@ -1563,7 +1563,7 @@ mod routers {
let mut router = Router::new(tx); let mut router = Router::new(tx);
let (sender, receiver) = channel(); let (sender, receiver) = channel();
let id = router.add_sender(sender); let id = router.add_sender(sender);
let msg = Message::new(Name::english("wiki".to_string()), Query::new()); let msg = Message::new(Name::english("wiki"), Query::new());
router.forward(&id, msg.clone()); router.forward(&id, msg.clone());
let result = receiver.recv_timeout(TIMEOUT).unwrap(); let result = receiver.recv_timeout(TIMEOUT).unwrap();
assert_eq!(result.get_message_id(), msg.get_message_id()); assert_eq!(result.get_message_id(), msg.get_message_id());
@ -1678,7 +1678,7 @@ mod queues {
fn can_forward_message() { fn can_forward_message() {
let mut tester = TestQueue::new(); let mut tester = TestQueue::new();
let mut queue = tester.get_queue(); let mut queue = tester.get_queue();
let msg = Message::new(Name::english("wiki".to_string()), Query::new()); let msg = Message::new(Name::english("wiki"), Query::new());
queue.forward(tester.get_preset_id(), msg.clone()); queue.forward(tester.get_preset_id(), msg.clone());
let result = tester.get_preset_rx().recv_timeout(TIMEOUT).unwrap(); let result = tester.get_preset_rx().recv_timeout(TIMEOUT).unwrap();
assert_eq!(result.get_message_id(), msg.get_message_id()); assert_eq!(result.get_message_id(), msg.get_message_id());
@ -1700,7 +1700,7 @@ mod queues {
fn can_register_document_name() { fn can_register_document_name() {
let mut tester = TestQueue::new(); let mut tester = TestQueue::new();
let mut queue = tester.get_queue(); let mut queue = tester.get_queue();
let doc_name = Name::english(Uuid::new_v4().to_string()); let doc_name = Name::english(Uuid::new_v4());
let reg_msg = Register::new( let reg_msg = Register::new(
tester.get_preset_id().clone(), tester.get_preset_id().clone(),
RegMsg::AddDocName(doc_name.clone()), RegMsg::AddDocName(doc_name.clone()),
@ -1724,7 +1724,7 @@ mod queues {
let mut tester = TestQueue::new(); let mut tester = TestQueue::new();
let mut queue = tester.get_queue(); let mut queue = tester.get_queue();
let receiver = tester.get_preset_rx(); let receiver = tester.get_preset_rx();
let doc_name = Name::english(Uuid::new_v4().to_string()); let doc_name = Name::english(Uuid::new_v4());
let reg_msg = Register::new( let reg_msg = Register::new(
tester.get_preset_id().clone(), tester.get_preset_id().clone(),
RegMsg::AddDocName(doc_name.clone()), RegMsg::AddDocName(doc_name.clone()),
@ -1756,8 +1756,8 @@ mod queues {
let mut tester = TestQueue::new(); let mut tester = TestQueue::new();
let mut queue = tester.get_queue(); let mut queue = tester.get_queue();
let names = [ let names = [
Name::english("task".to_string()), Name::english("task"),
Name::english("recipe".to_string()), Name::english("recipe"),
]; ];
for name in names.iter() { for name in names.iter() {
tester.add_document(name.clone()); tester.add_document(name.clone());
@ -1786,8 +1786,8 @@ mod queues {
let mut tester = TestQueue::new(); let mut tester = TestQueue::new();
let mut queue = tester.get_queue(); let mut queue = tester.get_queue();
let names = [ let names = [
Name::english("task".to_string()), Name::english("task"),
Name::english("recipe".to_string()), Name::english("recipe"),
]; ];
let route_req = Path::new(Include::All, Include::All, Include::All); let route_req = Path::new(Include::All, Include::All, Include::All);
let reg_msg = RegMsg::AddRoute(route_req); let reg_msg = RegMsg::AddRoute(route_req);
@ -1810,7 +1810,7 @@ mod queues {
fn does_receiver_only_receives_the_message_once() { fn does_receiver_only_receives_the_message_once() {
let mut tester = TestQueue::new(); let mut tester = TestQueue::new();
let mut queue = tester.get_queue(); let mut queue = tester.get_queue();
let name = Name::english("something".to_string()); let name = Name::english("something");
tester.add_document(name.clone()); tester.add_document(name.clone());
let paths = [ let paths = [
Path::new(Include::All, Include::All, Include::All), Path::new(Include::All, Include::All, Include::All),
@ -1845,8 +1845,8 @@ mod queues {
let mut tester = TestQueue::new(); let mut tester = TestQueue::new();
let mut queue = tester.get_queue(); let mut queue = tester.get_queue();
let names = [ let names = [
Name::english("one".to_string()), Name::english("one"),
Name::english("two".to_string()), Name::english("two"),
]; ];
let mut inputs: HashMap<Name, Message> = HashMap::new(); let mut inputs: HashMap<Name, Message> = HashMap::new();
for name in names.iter() { for name in names.iter() {
@ -1886,8 +1886,8 @@ mod queues {
let mut tester = TestQueue::new(); let mut tester = TestQueue::new();
let mut queue = tester.get_queue(); let mut queue = tester.get_queue();
let names = [ let names = [
Name::english("one".to_string()), Name::english("one"),
Name::english("two".to_string()), Name::english("two"),
]; ];
let mut inputs: HashMap<Name, Message> = HashMap::new(); let mut inputs: HashMap<Name, Message> = HashMap::new();
for name in names.iter() { for name in names.iter() {
@ -1927,8 +1927,8 @@ mod queues {
let mut tester = TestQueue::new(); let mut tester = TestQueue::new();
let mut queue = tester.get_queue(); let mut queue = tester.get_queue();
let names = [ let names = [
Name::english("one".to_string()), Name::english("one"),
Name::english("two".to_string()), Name::english("two"),
]; ];
let paths = [ let paths = [
Path::new(Include::All, Include::All, Include::Some(Action::Reply)), Path::new(Include::All, Include::All, Include::Some(Action::Reply)),
@ -2384,7 +2384,7 @@ mod additions {
#[test] #[test]
fn can_add_static_string() { fn can_add_static_string() {
let mut add = Addition::new(); let mut add = Addition::new();
let name = Name::english(Uuid::new_v4().to_string()); let name = Name::english(Uuid::new_v4());
let data = Uuid::new_v4().to_string(); let data = Uuid::new_v4().to_string();
add.add_field(name.clone(), data.clone()); add.add_field(name.clone(), data.clone());
let result = add.get_field(&name).unwrap(); let result = add.get_field(&name).unwrap();
@ -2396,7 +2396,7 @@ mod additions {
fn can_add_uuid() { fn can_add_uuid() {
let mut add = Addition::new(); let mut add = Addition::new();
let name = Name::english(Uuid::new_v4().to_string()); let name = Name::english(Uuid::new_v4());
let data = Uuid::new_v4(); let data = Uuid::new_v4();
add.add_field(name.clone(), data.clone()); add.add_field(name.clone(), data.clone());
let result = add.get_field(&name).unwrap(); let result = add.get_field(&name).unwrap();
@ -2408,7 +2408,7 @@ mod additions {
fn can_get_document() { fn can_get_document() {
let mut add = Addition::new(); let mut add = Addition::new();
let name = Name::english(Uuid::new_v4().to_string()); let name = Name::english(Uuid::new_v4());
let data = Uuid::new_v4(); let data = Uuid::new_v4();
add.add_field(name.clone(), data.clone()); add.add_field(name.clone(), data.clone());
let doc: Document = add.get_document(); let doc: Document = add.get_document();
@ -2571,9 +2571,9 @@ mod docdefs {
#[test] #[test]
fn can_field_be_added() { fn can_field_be_added() {
let docname = Name::english("tester".to_string()); let docname = Name::english("tester");
let mut docdef = DocDef::new(docname); let mut docdef = DocDef::new(docname);
let name = Name::english(Uuid::new_v4().to_string()); let name = Name::english(Uuid::new_v4());
let field_type = FieldType::Uuid; let field_type = FieldType::Uuid;
docdef.add_field(name.clone(), field_type.clone()); docdef.add_field(name.clone(), field_type.clone());
let result = docdef.get_field(name).unwrap(); let result = docdef.get_field(name).unwrap();
@ -2585,9 +2585,9 @@ mod docdefs {
#[test] #[test]
fn produces_error_for_bad_fields() { fn produces_error_for_bad_fields() {
let docname = Name::english("tester".to_string()); let docname = Name::english("tester");
let docdef = DocDef::new(docname); let docdef = DocDef::new(docname);
let name = Name::english(Uuid::new_v4().to_string()); let name = Name::english(Uuid::new_v4());
match docdef.get_field(&name) { match docdef.get_field(&name) {
Ok(_) => unreachable!("should return non existant field error"), Ok(_) => unreachable!("should return non existant field error"),
Err(err) => match err { Err(err) => match err {
@ -2599,15 +2599,15 @@ mod docdefs {
#[test] #[test]
fn can_multiple_fields_be_added() { fn can_multiple_fields_be_added() {
let docname = Name::english("testing".to_string()); let docname = Name::english("testing");
let mut docdef = DocDef::new(docname); let mut docdef = DocDef::new(docname);
let names = ["one", "two", "three"]; let names = ["one", "two", "three"];
let field_type = FieldType::StaticString; let field_type = FieldType::StaticString;
for name in names.iter() { for name in names.iter() {
docdef.add_field(Name::english(name.to_string()), field_type.clone()); docdef.add_field(Name::english(name.clone()), field_type.clone());
} }
for name in names.iter() { for name in names.iter() {
let result = docdef.get_field(Name::english(name.to_string())).unwrap(); let result = docdef.get_field(Name::english(name.clone())).unwrap();
match result.validate(Some("".into())) { match result.validate(Some("".into())) {
Ok(_) => {} Ok(_) => {}
Err(err) => unreachable!("got {:?}: should have been a value", err), Err(err) => unreachable!("got {:?}: should have been a value", err),
@ -2617,9 +2617,9 @@ mod docdefs {
#[test] #[test]
fn can_change_field_default_to_function() { fn can_change_field_default_to_function() {
let docname = Name::english("something".to_string()); let docname = Name::english("something");
let mut docdef = DocDef::new(docname); let mut docdef = DocDef::new(docname);
let name = Name::english("defaultfunction".to_string()); let name = Name::english("defaultfunction");
docdef.add_field(name.clone(), FieldType::StaticString); docdef.add_field(name.clone(), FieldType::StaticString);
let mut calc = Calculation::new(Operand::Assign); let mut calc = Calculation::new(Operand::Assign);
calc.add_value(FieldType::StaticString); calc.add_value(FieldType::StaticString);
@ -2635,9 +2635,9 @@ mod docdefs {
#[test] #[test]
fn does_set_default_function_error_on_bad_field_name() { fn does_set_default_function_error_on_bad_field_name() {
let docname = Name::english("something".to_string()); let docname = Name::english("something");
let mut docdef = DocDef::new(docname); let mut docdef = DocDef::new(docname);
let field_name = Name::english("wrong".to_string()); let field_name = Name::english("wrong");
let calc = Calculation::new(Operand::Assign); let calc = Calculation::new(Operand::Assign);
match docdef.set_default(&field_name, calc) { match docdef.set_default(&field_name, calc) {
Ok(_) => unreachable!("should be an error"), Ok(_) => unreachable!("should be an error"),
@ -2650,9 +2650,9 @@ mod docdefs {
#[test] #[test]
fn does_set_default_value_error_on_bad_field_name() { fn does_set_default_value_error_on_bad_field_name() {
let docname = Name::english("something".to_string()); let docname = Name::english("something");
let mut docdef = DocDef::new(docname); let mut docdef = DocDef::new(docname);
let field_name = Name::english(Uuid::new_v4().to_string()); let field_name = Name::english(Uuid::new_v4());
let mut calc = Calculation::new(Operand::Assign); let mut calc = Calculation::new(Operand::Assign);
calc.add_value(Uuid::new_v4()); calc.add_value(Uuid::new_v4());
match docdef.set_default(&field_name, calc) { match docdef.set_default(&field_name, calc) {
@ -2666,9 +2666,9 @@ mod docdefs {
#[test] #[test]
fn does_set_default_value_error_on_bad_field_type() { fn does_set_default_value_error_on_bad_field_type() {
let docname = Name::english("something".to_string()); let docname = Name::english("something");
let mut docdef = DocDef::new(docname); let mut docdef = DocDef::new(docname);
let name = Name::english("defaultvalue".to_string()); let name = Name::english("defaultvalue");
docdef.add_field(name.clone(), FieldType::Uuid); docdef.add_field(name.clone(), FieldType::Uuid);
let mut calc = Calculation::new(Operand::Assign); let mut calc = Calculation::new(Operand::Assign);
calc.add_value("fred"); calc.add_value("fred");
@ -3246,7 +3246,7 @@ mod queries {
#[test] #[test]
fn holds_calculation_to_run_query() { fn holds_calculation_to_run_query() {
let name = Name::english(Uuid::new_v4().to_string()); let name = Name::english(Uuid::new_v4());
let data = Uuid::new_v4(); let data = Uuid::new_v4();
let mut bad_data = data.clone(); let mut bad_data = data.clone();
while bad_data == data { while bad_data == data {
@ -3281,7 +3281,7 @@ mod queries {
let mut calc = Calculation::new(Operand::Assign); let mut calc = Calculation::new(Operand::Assign);
calc.add_value(Uuid::nil()); calc.add_value(Uuid::nil());
let mut query = Query::new(); let mut query = Query::new();
match query.add(Name::english("name".to_string()), calc) { match query.add(Name::english("name"), calc) {
Ok(_) => unreachable!("Should have received an error"), Ok(_) => unreachable!("Should have received an error"),
Err(err) => match err { Err(err) => match err {
MTTError::QueryCannotChangeData => {} MTTError::QueryCannotChangeData => {}
@ -3360,7 +3360,7 @@ mod replies {
#[test] #[test]
fn can_retrieve_documents() { fn can_retrieve_documents() {
let fieldname = Name::english("field".to_string()); let fieldname = Name::english("field");
let mut doc1 = Document::new(); let mut doc1 = Document::new();
doc1.add_field(fieldname.clone(), "one"); doc1.add_field(fieldname.clone(), "one");
let mut doc2 = Document::new(); let mut doc2 = Document::new();
@ -3544,13 +3544,13 @@ mod records {
} }
let mut name_ids: HashMap<Name, Uuid> = HashMap::new(); let mut name_ids: HashMap<Name, Uuid> = HashMap::new();
for id in ids.iter() { for id in ids.iter() {
let name = Name::english(id.to_string()); let name = Name::english(id.clone());
let field_id = names.add_name(name.clone()).unwrap(); let field_id = names.add_name(name.clone()).unwrap();
name_ids.insert(name, field_id); name_ids.insert(name, field_id);
} }
let mut rec = Record::new(names); let mut rec = Record::new(names);
for id in ids.iter() { for id in ids.iter() {
let name = Name::english(id.to_string()); let name = Name::english(id.clone());
rec.insert(name, id.clone()); rec.insert(name, id.clone());
} }
for (name, id) in name_ids.iter() { for (name, id) in name_ids.iter() {
@ -3577,7 +3577,7 @@ mod records {
fn does_insert_error_on_bad_field_name() { fn does_insert_error_on_bad_field_name() {
let names = Names::new(); let names = Names::new();
let mut rec = Record::new(names); let mut rec = Record::new(names);
let name = Name::english("wrong".to_string()); let name = Name::english("wrong");
match rec.insert(name.clone(), "bad") { match rec.insert(name.clone(), "bad") {
Ok(_) => unreachable!("should return not found error"), Ok(_) => unreachable!("should return not found error"),
Err(err) => match err { Err(err) => match err {
@ -3591,7 +3591,7 @@ mod records {
fn does_get_error_on_bad_field_name() { fn does_get_error_on_bad_field_name() {
let names = Names::new(); let names = Names::new();
let mut rec = Record::new(names); let mut rec = Record::new(names);
let name = Name::english("missing".to_string()); let name = Name::english("missing");
match rec.get(&name) { match rec.get(&name) {
Ok(_) => unreachable!("should return not found error"), Ok(_) => unreachable!("should return not found error"),
Err(err) => match err { Err(err) => match err {
@ -3604,7 +3604,7 @@ mod records {
#[test] #[test]
fn does_get_error_on_missing_data() { fn does_get_error_on_missing_data() {
let mut names = Names::new(); let mut names = Names::new();
let name = Name::english("empty".to_string()); let name = Name::english("empty");
names.add_name(name.clone()).unwrap(); names.add_name(name.clone()).unwrap();
let mut rec = Record::new(names); let mut rec = Record::new(names);
match rec.get(&name) { match rec.get(&name) {
@ -3618,7 +3618,7 @@ mod records {
#[test] #[test]
fn can_records_hold_multiple_entries() { fn can_records_hold_multiple_entries() {
let field_name = Name::english("field".to_string()); let field_name = Name::english("field");
let mut names = Names::new(); let mut names = Names::new();
names.add_name(field_name.clone()); names.add_name(field_name.clone());
let count: isize = 5; let count: isize = 5;
@ -3664,8 +3664,8 @@ mod records {
#[test] #[test]
fn errors_on_mismatched_entries() { fn errors_on_mismatched_entries() {
let mut names = Names::new(); let mut names = Names::new();
let name1 = Name::english("first".to_string()); let name1 = Name::english("first");
let name2 = Name::english("second".to_string()); let name2 = Name::english("second");
names.add_name(name1.clone()).unwrap(); names.add_name(name1.clone()).unwrap();
names.add_name(name2.clone()).unwrap(); names.add_name(name2.clone()).unwrap();
let mut rec1 = Record::new(names.clone()); let mut rec1 = Record::new(names.clone());
@ -3759,7 +3759,7 @@ mod documents {
#[test] #[test]
fn can_add_static_string() { fn can_add_static_string() {
let mut add = Document::new(); let mut add = Document::new();
let name = Name::english(Uuid::new_v4().to_string()); let name = Name::english(Uuid::new_v4());
let data = Uuid::new_v4().to_string(); let data = Uuid::new_v4().to_string();
add.add_field(name.clone(), data.clone()); add.add_field(name.clone(), data.clone());
let result = add.get_field(&name).unwrap(); let result = add.get_field(&name).unwrap();
@ -3771,7 +3771,7 @@ mod documents {
fn can_add_uuid() { fn can_add_uuid() {
let mut add = Document::new(); let mut add = Document::new();
let name = Name::english(Uuid::new_v4().to_string()); let name = Name::english(Uuid::new_v4());
let data = Uuid::new_v4(); let data = Uuid::new_v4();
add.add_field(name.clone(), data.clone()); add.add_field(name.clone(), data.clone());
let result = add.get_field(&name).unwrap(); let result = add.get_field(&name).unwrap();
@ -4531,7 +4531,7 @@ mod document_files {
impl TestDocument { impl TestDocument {
fn new(field_types: Vec<FieldType>) -> Self { fn new(field_types: Vec<FieldType>) -> Self {
let doc_name = Name::english(Uuid::new_v4().to_string()); let doc_name = Name::english(Uuid::new_v4());
let mut docdef = DocDef::new(doc_name.clone()); let mut docdef = DocDef::new(doc_name.clone());
let mut count = 0; let mut count = 0;
for field_type in field_types.iter() { for field_type in field_types.iter() {
@ -4623,10 +4623,10 @@ mod document_files {
#[test] #[test]
fn does_not_respond_to_create() { fn does_not_respond_to_create() {
let name = Name::english("quiet".to_string()); let name = Name::english("quiet");
let docdef = DocDef::new(name.clone()); let docdef = DocDef::new(name.clone());
let mut test_doc: TestDocument = docdef.into(); let mut test_doc: TestDocument = docdef.into();
let alt = Name::english("alternate".to_string()); let alt = Name::english("alternate");
test_doc.start(); test_doc.start();
let docdef = DocDef::new(alt); let docdef = DocDef::new(alt);
let msg = Message::new(name.clone(), docdef); let msg = Message::new(name.clone(), docdef);
@ -4642,7 +4642,7 @@ mod document_files {
#[test] #[test]
fn does_document_respond_to_requests() { fn does_document_respond_to_requests() {
let name = Name::english("listen".to_string()); let name = Name::english("listen");
let docdef = DocDef::new(name.clone()); let docdef = DocDef::new(name.clone());
let mut test_doc: TestDocument = docdef.into(); let mut test_doc: TestDocument = docdef.into();
test_doc.start(); test_doc.start();
@ -4685,8 +4685,8 @@ mod document_files {
#[test] #[test]
fn does_not_respond_to_other_document_requests() { fn does_not_respond_to_other_document_requests() {
let name = Name::english("quiet".to_string()); let name = Name::english("quiet");
let alt = Name::english("alternate".to_string()); let alt = Name::english("alternate");
let docdef = DocDef::new(name.clone()); let docdef = DocDef::new(name.clone());
let mut test_doc: TestDocument = docdef.into(); let mut test_doc: TestDocument = docdef.into();
test_doc.start(); test_doc.start();
@ -4717,9 +4717,9 @@ mod document_files {
#[test] #[test]
fn can_document_be_added() { fn can_document_be_added() {
let doc_name = Name::english("document".to_string()); let doc_name = Name::english("document");
let mut docdef = DocDef::new(doc_name.clone()); let mut docdef = DocDef::new(doc_name.clone());
let name = Name::english("field".to_string()); let name = Name::english("field");
let data = Uuid::new_v4(); let data = Uuid::new_v4();
docdef.add_field(name.clone(), FieldType::Uuid); docdef.add_field(name.clone(), FieldType::Uuid);
let mut test_doc: TestDocument = docdef.clone().into(); let mut test_doc: TestDocument = docdef.clone().into();
@ -4754,9 +4754,9 @@ mod document_files {
#[test] #[test]
fn can_add_multiple_documents() { fn can_add_multiple_documents() {
let doc_name = Name::english("multiple".to_string()); let doc_name = Name::english("multiple");
let mut docdef = DocDef::new(doc_name.clone()); let mut docdef = DocDef::new(doc_name.clone());
let name = Name::english("count".to_string()); let name = Name::english("count");
docdef.add_field(name.clone(), FieldType::Integer); docdef.add_field(name.clone(), FieldType::Integer);
let mut test_doc: TestDocument = docdef.clone().into(); let mut test_doc: TestDocument = docdef.clone().into();
test_doc.start(); test_doc.start();
@ -4796,7 +4796,7 @@ mod document_files {
let mut test_doc = TestDocument::new(Vec::new()); let mut test_doc = TestDocument::new(Vec::new());
test_doc.start(); test_doc.start();
let queue = test_doc.get_queue(); let queue = test_doc.get_queue();
let name = Name::english("bad".to_string()); let name = Name::english("bad");
let mut addition = Addition::new(); let mut addition = Addition::new();
addition.add_field(name.clone(), "doesn't matter"); addition.add_field(name.clone(), "doesn't matter");
queue.send(Message::new(test_doc.get_docdef().get_document_name(), addition)).unwrap(); queue.send(Message::new(test_doc.get_docdef().get_document_name(), addition)).unwrap();
@ -4816,7 +4816,7 @@ mod document_files {
test_doc.start(); test_doc.start();
let queue = test_doc.get_queue(); let queue = test_doc.get_queue();
let mut addition = Addition::new(); let mut addition = Addition::new();
addition.add_field(Name::english("field0".to_string()), "string"); addition.add_field(Name::english("field0"), "string");
queue.send(Message::new(test_doc.get_docdef().get_document_name(), addition)); queue.send(Message::new(test_doc.get_docdef().get_document_name(), addition));
let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
match result.get_action() { match result.get_action() {
@ -4840,7 +4840,7 @@ mod document_files {
test_doc.start(); test_doc.start();
let queue = test_doc.get_queue(); let queue = test_doc.get_queue();
let mut addition = Addition::new(); let mut addition = Addition::new();
addition.add_field(Name::english("field0".to_string()), 1); addition.add_field(Name::english("field0"), 1);
queue.send(Message::new(test_doc.get_docdef().get_document_name(), addition)); queue.send(Message::new(test_doc.get_docdef().get_document_name(), addition));
let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
match result.get_action() { match result.get_action() {
@ -4866,7 +4866,7 @@ mod document_files {
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value(expected.clone()); calc.add_value(expected.clone());
let mut query = Query::new(); let mut query = Query::new();
query.add(Name::english("field0".to_string()), calc); query.add(Name::english("field0"), calc);
queue.send(Message::new(test_doc.get_docdef().get_document_name(), query)); queue.send(Message::new(test_doc.get_docdef().get_document_name(), query));
let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
@ -4880,7 +4880,7 @@ mod document_files {
action action
); );
for doc in data.clone() { for doc in data.clone() {
assert_eq!(doc.get(&Name::english("field0".to_string())).unwrap(), expected.into()); assert_eq!(doc.get(&Name::english("field0")).unwrap(), expected.into());
} }
} }
_ => unreachable!("got {:?}: should have been a reply", action), _ => unreachable!("got {:?}: should have been a reply", action),
@ -4902,7 +4902,7 @@ mod document_files {
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value(data.clone()); calc.add_value(data.clone());
let mut query = Query::new(); let mut query = Query::new();
query.add(Name::english("field0".to_string()), calc); query.add(Name::english("field0"), calc);
queue.send(Message::new(test_doc.get_docdef().get_document_name(), query)); queue.send(Message::new(test_doc.get_docdef().get_document_name(), query));
let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
@ -4916,7 +4916,7 @@ mod document_files {
action action
); );
for doc in docs.clone() { for doc in docs.clone() {
assert_eq!(doc.get(&Name::english("field0".to_string())).unwrap(), data.into()); assert_eq!(doc.get(&Name::english("field0")).unwrap(), data.into());
} }
} }
_ => unreachable!("got {:?}: should have been a reply", action), _ => unreachable!("got {:?}: should have been a reply", action),
@ -4940,10 +4940,10 @@ mod document_files {
let mut query = Query::new(); let mut query = Query::new();
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value("a"); calc.add_value("a");
query.add(Name::english("field0".to_string()), calc); query.add(Name::english("field0"), calc);
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value("b"); calc.add_value("b");
query.add(Name::english("field1".to_string()), calc); query.add(Name::english("field1"), calc);
doc.send(query).unwrap(); doc.send(query).unwrap();
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
@ -4953,8 +4953,8 @@ mod document_files {
let bfield: Field = "b".into(); let bfield: Field = "b".into();
assert_eq!(data.len(), 1, "should return one entry:\n{:?}", action); assert_eq!(data.len(), 1, "should return one entry:\n{:?}", action);
for doc in data.clone() { for doc in data.clone() {
assert_eq!(doc.get(&Name::english("field0".to_string())).unwrap(), afield); assert_eq!(doc.get(&Name::english("field0")).unwrap(), afield);
assert_eq!(doc.get(&Name::english("field1".to_string())).unwrap(), bfield); assert_eq!(doc.get(&Name::english("field1")).unwrap(), bfield);
} }
} }
_ => unreachable!("got {:?}: should have been a reply", action), _ => unreachable!("got {:?}: should have been a reply", action),
@ -4966,8 +4966,8 @@ mod document_files {
let mut doc = let mut doc =
TestDocument::new([FieldType::StaticString, FieldType::StaticString].to_vec()); TestDocument::new([FieldType::StaticString, FieldType::StaticString].to_vec());
let docdef = doc.get_docdef_mut(); let docdef = doc.get_docdef_mut();
docdef.add_index(&Name::english("field0".to_string()), IndexType::Index); docdef.add_index(&Name::english("field0"), IndexType::Index);
docdef.add_index(&Name::english("field1".to_string()), IndexType::Index); docdef.add_index(&Name::english("field1"), IndexType::Index);
doc.start(); doc.start();
let values = [ let values = [
["a".into(), "a".into()].to_vec(), ["a".into(), "a".into()].to_vec(),
@ -4981,10 +4981,10 @@ mod document_files {
let mut query = Query::new(); let mut query = Query::new();
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value("a"); calc.add_value("a");
query.add(Name::english("field0".to_string()), calc); query.add(Name::english("field0"), calc);
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value("b"); calc.add_value("b");
query.add(Name::english("field1".to_string()), calc); query.add(Name::english("field1"), calc);
doc.send(query).unwrap(); doc.send(query).unwrap();
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
@ -4994,21 +4994,20 @@ mod document_files {
let bfield: Field = "b".into(); let bfield: Field = "b".into();
assert_eq!(data.len(), 1, "should return one entry:\n{:?}", action); assert_eq!(data.len(), 1, "should return one entry:\n{:?}", action);
for doc in data.clone() { for doc in data.clone() {
assert_eq!(doc.get(&Name::english("field0".to_string())).unwrap(), afield); assert_eq!(doc.get(&Name::english("field0")).unwrap(), afield);
assert_eq!(doc.get(&Name::english("field1".to_string())).unwrap(), bfield); assert_eq!(doc.get(&Name::english("field1")).unwrap(), bfield);
} }
} }
_ => unreachable!("got {:?}: should have been a reply", action), _ => unreachable!("got {:?}: should have been a reply", action),
} }
} }
/*
#[test] #[test]
fn query_should_work_with_mixed_inexed_fields() { fn query_should_work_with_mixed_inexed_fields() {
let mut doc = let mut doc =
TestDocument::new([FieldType::StaticString, FieldType::StaticString].to_vec()); TestDocument::new([FieldType::StaticString, FieldType::StaticString].to_vec());
let docdef = doc.get_docdef_mut(); let docdef = doc.get_docdef_mut();
docdef.add_index("field0".to_string(), IndexType::Index); docdef.add_index(&Name::english("field0"), IndexType::Index);
doc.start(); doc.start();
let values = [ let values = [
["a".into(), "a".into()].to_vec(), ["a".into(), "a".into()].to_vec(),
@ -5022,27 +5021,28 @@ mod document_files {
let mut query = Query::new(); let mut query = Query::new();
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value("a"); calc.add_value("a");
query.add("field0".to_string(), calc); query.add(Name::english("field0"), calc);
let mut calc = Calculation::new(Operand::Equal); let mut calc = Calculation::new(Operand::Equal);
calc.add_value("b"); calc.add_value("b");
query.add("field1".to_string(), calc); query.add(Name::english("field1"), calc);
doc.send(query).unwrap(); doc.send(query).unwrap();
let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap(); let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
let action = result.get_action(); let action = result.get_action();
match action { match action {
MsgAction::Reply(data) => { MsgAction::Records(data) => {
let afield: Field = "a".into(); let afield: Field = "a".into();
let bfield: Field = "b".into(); let bfield: Field = "b".into();
assert_eq!(data.len(), 1, "should return one entry:\n{:?}", action); assert_eq!(data.len(), 1, "should return one entry:\n{:?}", action);
for doc in data.iter() { for doc in data.clone() {
assert_eq!(doc.get_field("field0").unwrap(), afield); assert_eq!(doc.get(&Name::english("field0")).unwrap(), afield);
assert_eq!(doc.get_field("field1").unwrap(), bfield); assert_eq!(doc.get(&Name::english("field1")).unwrap(), bfield);
} }
} }
_ => unreachable!("got {:?}: should have been a reply", action), _ => unreachable!("got {:?}: should have been a reply", action),
} }
} }
/*
#[test] #[test]
fn errors_on_bad_field_name() { fn errors_on_bad_field_name() {
let (docdef, doc_name) = create_docdef(Vec::new()); let (docdef, doc_name) = create_docdef(Vec::new());
@ -5682,7 +5682,7 @@ mod createdocs {
#[test] #[test]
#[ignore] #[ignore]
fn create_document_creation() { fn create_document_creation() {
let name = Name::english("project".to_string()); let name = Name::english("project");
let routes = [RouteRequest::new( let routes = [RouteRequest::new(
Include::All, Include::All,
Include::All, Include::All,
@ -5713,7 +5713,7 @@ mod createdocs {
#[test] #[test]
#[ignore] #[ignore]
fn does_duplicates_generate_error() { fn does_duplicates_generate_error() {
let name = Name::english("duplicate".to_string()); let name = Name::english("duplicate");
let routes = [ let routes = [
RouteRequest::new(Include::All, Include::All, Include::Some(Action::Reply)), RouteRequest::new(Include::All, Include::All, Include::Some(Action::Reply)),
RouteRequest::new(Include::All, Include::All, Include::Some(Action::Error)), RouteRequest::new(Include::All, Include::All, Include::Some(Action::Error)),