Readded multiple additions test.

src/message.rs

@@ -4243,60 +4243,6 @@ impl DocumentFile {
             records.push(rec);
         }
         records.into()
-        
-        
-
-
-        /*
-        let mut reply = Reply::new();
-        if !holder.is_empty() {
-            let mut oid = Oid::new();
-            while self.docs.contains_key(&oid) {
-                oid = Oid::new();
-            }
-            self.docs.insert(oid, holder);
-
-            self.docs.insert(oid.clone(), holder.clone());
-            for (key, value) in holder.iter() {
-                self.add_to_index(&key, value.clone(), oid.clone());
-            }
-            reply.add(holder);
-        }
-        reply.into()
-
-        let mut holder = Document::new();
-        let doc = addition.get_document();
-        for (key, value) in doc.iter() {
-            match self.validate(key.clone(), Some(value.clone())) {
-                Ok(data) => {
-                    holder.add_field(key.clone(), value.clone());
-                }
-                Err(err) => return Self::add_field_to_error(key.to_string(), err).into(),
-            }
-        }
-        for (key, value) in self.docdef.iter() {
-            match holder.get_field(key) {
-                Some(_) => {}
-                None => match self.validate(key, None) {
-                    Ok(data) => holder.add_field(key.clone(), data.clone()),
-                    Err(err) => return Self::add_field_to_error(key.to_string(), err).into(),
-                },
-            }
-        }
-        let mut oid = Oid::new();
-        let mut reply = Reply::new();
-        if !holder.is_empty() {
-            while self.docs.contains_key(&oid) {
-                oid = Oid::new();
-            }
-            self.docs.insert(oid.clone(), holder.clone());
-            for (key, value) in holder.iter() {
-                self.add_to_index(&key, value.clone(), oid.clone());
-            }
-            reply.add(holder);
-        }
-        reply.into()
-        */
     }
 
     fn delete(&mut self, delete: &Delete) -> MsgAction {
@@ -4719,32 +4665,46 @@ mod document_files {
         testing(Message::new(doc_name.clone(), Query::new()));
     }
 
-    /*
     #[test]
     fn can_add_multiple_documents() {
-        let count = 4;
-        let mut docdef = DocDef::new();
-        let name = "field";
-        let doc_name = "document";
-        let data = Uuid::new_v4();
-        docdef.add_field(name.to_string(), FieldType::Uuid);
-        let (queue, rx) = test_doc(doc_name, docdef, standard_routes());
-        let mut new_doc = Addition::new();
-        new_doc.add_field(name.to_string(), data.clone());
-        for _ in 0..count {
-            let msg = Message::new(doc_name, new_doc.clone());
-            queue.send(msg.clone()).unwrap();
-            rx.recv_timeout(TIMEOUT).unwrap(); // eats the confirmation reply.
+        let doc_name = Name::english("multiple".to_string());
+        let mut docdef = DocDef::new(doc_name.clone());
+        let name = Name::english("count".to_string());
+        docdef.add_field(name.clone(), FieldType::Integer);
+        let mut test_doc: TestDocument = docdef.clone().into();
+        test_doc.start();
+        let queue = test_doc.get_queue();
+        let count = 5;
+        for i in 0..count {
+            let mut new_doc = Addition::new();
+            new_doc.add_field(name.clone(), i);
+            queue.send(Message::new(doc_name.clone(), new_doc)).unwrap();
+            test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         }
-        let msg = Message::new(doc_name, Query::new());
-        queue.send(msg).unwrap();
-        let result = rx.recv_timeout(TIMEOUT).unwrap();
-        match result.get_action() {
-            MsgAction::Reply(data) => assert_eq!(data.len(), count),
-            _ => unreachable!("got {:?}: should have been a reply", result.get_action()),
+        queue.send(Message::new(doc_name, Query::new()));
+        let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
+        let action = result.get_action();
+        let mut entries: HashSet<i128> = (0..count).collect();
+        match action {
+            MsgAction::Records(output) => {
+                let entry_count: usize = count.try_into().unwrap();
+                assert_eq!(output.len(), entry_count, "should have the same number of entries");
+                for record in output.clone() {
+                    let holder = record.get(&name).unwrap();
+                    let data = match holder {
+                        Field::Integer(item) => item.clone(),
+                        _ => unreachable!("got {:?}, should have been integer", holder),
+                    };
+                    assert!(entries.contains(&data), "did not find {:?} in {:?}", data, entries);
+                    entries.remove(&data);
+                }
+            }
+            _ => unreachable!("\n\ngot {:?}\n\nshould have been records", action),
         }
+        assert!(entries.is_empty(), "did not use {:?}", entries);
     }
 
+    /*
     #[test]
     fn errors_on_wrong_field_name() {
         let (docdef, doc_name) = create_docdef([FieldType::Uuid].to_vec());