Readded more tests.

src/message.rs

@@ -5168,50 +5168,46 @@ mod document_files {
         testing(Message::new(doc_name.clone(), Query::new()));
     }
 
-    /*
     #[test]
     fn changes_only_the_queried() {
-        let mut doc = TestDocument::new([FieldType::Uuid, FieldType::StaticString].to_vec());
+        let mut doc = TestDocument::new([FieldType::Integer, FieldType::StaticString].to_vec());
         doc.start();
-        let mut ids: HashSet<Uuid> = HashSet::new();
+        let doc_name = doc.get_docdef().get_document_name().clone();
-        while ids.len() < 2 {
-            ids.insert(Uuid::new_v4());
-        }
-        let expected = ids.iter().last().unwrap();
         let old = "old";
         let new = "new";
-        let mut values: Vec<Vec<Field>> = Vec::new();
+        let count = 5;
-        for id in ids.iter() {
+        let picked = 3;
-            let mut holder: Vec<Field> = Vec::new();
+        for i in 0..count {
-            holder.push(id.clone().into());
+            doc.populate([i.into(), old.into()].to_vec());
-            holder.push(old.into());
-            values.push(holder);
-        }
-        for value in values {
-            doc.populate(value);
         }
         let mut update = Update::new();
         let mut calc = Calculation::new(Operand::Equal);
-        calc.add_value(expected.clone());
+        calc.add_value(picked.clone());
-        update.get_query_mut().add("field0".to_string(), calc);
+        update.get_query_mut().add(Name::english("field0"), calc);
-        update.get_values_mut().add_field("field1".to_string(), new);
+        update.get_values_mut().add_field(Name::english("field1"), new);
-        doc.send(update).unwrap();
+        doc.get_queue().send(Message::new(doc_name.clone(), update)).unwrap();
-        doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
-        let mut calc = Calculation::new(Operand::Equal);
-        calc.add_value(new);
-        let mut query = Query::new();
-        query.add("field1".to_string(), calc);
-        doc.send(query).unwrap();
         let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
-        match action {
+        match action {MsgAction::Records(docs) => {
-            MsgAction::Reply(docs) => {
+                assert_eq!(docs.len(), 1, "should have one entry");
-                assert_eq!(docs.len(), 1);
+                for doc in docs.clone() {
-                let expected_id: Field = expected.clone().into();
+                    assert_eq!(doc.get(Name::english("field0")).unwrap(), picked.into());
-                let output: Field = new.into();
+                    assert_eq!(doc.get(Name::english("field1")).unwrap(), new.into());
-                for doc in docs.iter() {
+                }
-                    assert_eq!(doc.get_field("field0").unwrap(), expected_id);
+            }
-                    assert_eq!(doc.get_field("field1").unwrap(), output);
+            _ => unreachable!("got {:?}: should have gotten a reply", action),
+        }
+        doc.get_queue().send(Message::new(doc_name.clone(), Query::new())).unwrap();
+        let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
+        let action = result.get_action();
+        match action {MsgAction::Records(docs) => {
+                assert_eq!(docs.len(), 5, "should have one entry");
+                for doc in docs.clone() {
+                    if doc.get(Name::english("field0")).unwrap() == picked.into() {
+                        assert_eq!(doc.get(Name::english("field1")).unwrap(), new.into());
+                    } else {
+                        assert_eq!(doc.get(Name::english("field1")).unwrap(), old.into());
+                    }
                 }
             }
             _ => unreachable!("got {:?}: should have gotten a reply", action),
@@ -5220,50 +5216,37 @@ mod document_files {
 
     #[test]
     fn can_handle_multiple_updates() {
-        let mut doc = TestDocument::new([FieldType::Uuid, FieldType::StaticString].to_vec());
+        let mut doc = TestDocument::new([FieldType::Integer, FieldType::StaticString].to_vec());
         doc.start();
-        let count = 3;
+        let doc_name = doc.get_docdef().get_document_name().clone();
-        let id = Uuid::new_v4();
         let old = "old";
         let new = "new";
-        for _ in 0..count {
+        let count = 5;
-            doc.populate([id.into(), old.into()].to_vec());
+        let picked = 3;
+        for i in 0..count {
+            doc.populate([picked.into(), old.into()].to_vec());
         }
-        let mut calc = Calculation::new(Operand::Equal);
-        calc.add_value(id.clone());
         let mut update = Update::new();
-        update
+        let mut calc = Calculation::new(Operand::Equal);
-            .get_query_mut()
+        calc.add_value(picked.clone());
-            .add("field0".to_string(), calc.clone());
+        update.get_query_mut().add(Name::english("field0"), calc);
-        update.get_values_mut().add_field("field1".to_string(), new);
+        update.get_values_mut().add_field(Name::english("field1"), new);
-        doc.send(update).unwrap();
+        let mut testing = |msg: Message| {
-        let mut results: HashMap<String, Message> = HashMap::new();
+            doc.get_queue().send(msg).unwrap();
-        results.insert(
+            let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
-            "update".to_string(),
-            doc.get_receiver().recv_timeout(TIMEOUT).unwrap(),
-        );
-        let mut query = Query::new();
-        query.add("field0".to_string(), calc.clone());
-        doc.send(query).unwrap();
-        results.insert(
-            "query".to_string(),
-            doc.get_receiver().recv_timeout(TIMEOUT).unwrap(),
-        );
-        let expected_id: Field = id.into();
-        let output: Field = new.into();
-        for (key, result) in results.iter() {
             let action = result.get_action();
-            match action {
+            match action {MsgAction::Records(docs) => {
-                MsgAction::Reply(docs) => {
+                    assert_eq!(docs.len(), 5, "should have one entry");
-                    assert_eq!(docs.len(), count, "{}", key);
+                    for doc in docs.clone() {
-                    for doc in docs.iter() {
+                        assert_eq!(doc.get(Name::english("field0")).unwrap(), picked.into());
-                        assert_eq!(doc.get_field("field0").unwrap(), expected_id, "{}", key);
+                        assert_eq!(doc.get(Name::english("field1")).unwrap(), new.into());
-                        assert_eq!(doc.get_field("field1").unwrap(), output, "{}", key);
                     }
                 }
                 _ => unreachable!("got {:?}: should have gotten a reply", action),
             }
-        }
+        };
+        testing(Message::new(doc_name.clone(), update));
+        testing(Message::new(doc_name.clone(), Query::new()));
     }
 
     #[test]
@@ -5273,18 +5256,19 @@ mod document_files {
         let id = Uuid::new_v4();
         let old = "old";
         let new = "new";
+        let bad_name = Name::english("wrong");
         doc.populate([id.into(), old.into()].to_vec());
         let mut update = Update::new();
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value(id.clone());
-        update.get_query_mut().add("field0".to_string(), calc);
+        update.get_query_mut().add(Name::english("field0"), calc);
-        update.get_values_mut().add_field("wrong".to_string(), new);
+        update.get_values_mut().add_field(bad_name.clone(), new);
         doc.send(update).unwrap();
         let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
         match action {
             MsgAction::Error(err) => match err {
-                MTTError::DocumentFieldNotFound(data) => assert_eq!(data, "wrong"),
+                MTTError::NameNotFound(data) => assert_eq!(data, &bad_name),
                 _ => unreachable!("got {:?}: should have gotten an missing field", err),
             },
             _ => unreachable!("got {:?}: should have gotten an error", action),
@@ -5302,8 +5286,8 @@ mod document_files {
         let mut update = Update::new();
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value(id.clone());
-        update.get_query_mut().add("field0".to_string(), calc);
+        update.get_query_mut().add(Name::english("field0"), calc);
-        update.get_values_mut().add_field("field1".to_string(), new);
+        update.get_values_mut().add_field(Name::english("field1"), new);
         doc.send(update).unwrap();
         let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
@@ -5319,6 +5303,7 @@ mod document_files {
         }
     }
 
+    /*
     #[test]
     fn does_update_maintain_unique_fields() {
         let (mut docdef, doc_name) = create_docdef([FieldType::Uuid].to_vec());