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