Moved missing fields add test to lib.

src/document/create.rs

@@ -500,8 +500,6 @@ impl DocumentFile {
         };
         let mut holder = InternalRecord::new();
 
-
-
         let mut field_ids = self.docdef.get_field_ids();
         for (name, value) in addition.iter() {
             let field_id = match self.docdef.get_field_id(name) {
@@ -1187,7 +1185,6 @@ mod document_files {
             _ => unreachable!("got {:?}: should have been an error", result.get_action()),
         }
     }
-    */
 
     #[test]
     fn errors_on_missing_fields() {
@@ -1206,6 +1203,7 @@ mod document_files {
             _ => unreachable!("got {:?}: should have been an error", result.get_action()),
         }
     }
+    */
 
     #[test]
     fn does_query_return_related_entries() {

tests/add_test.rs

@@ -5,7 +5,7 @@ use morethantext::{
     ErrorID, MTTError, MoreThanText, Name,
 };
 use std::collections::HashSet;
-use support::random_name;
+use support::{random_name, TestDocument};
 use uuid::Uuid;
 
 #[test]
@@ -72,16 +72,28 @@ fn does_it_error_on_bad_field_name() {
 #[test]
 fn does_it_error_on_bad_field_type() {
     let mut mtt = MoreThanText::new();
-    let doc_name = Name::english("holder");
+    let test_doc = TestDocument::new(vec![FieldType::Uuid]);
-    let field_name = Name::english("wrong");
+    mtt.create_document(test_doc.get_docdef());
-    let mut docdef = DocDef::new(doc_name.clone());
+    let mut add = Addition::new(test_doc.get_doc_name().clone());
-    docdef.add_field(field_name.clone(), FieldType::Uuid);
+    add.add_field(test_doc.get_field_name(0), "something");
-    mtt.create_document(docdef);
-    let mut add = Addition::new(doc_name.clone());
-    add.add_field(field_name.clone(), "something");
     let mut expected = MTTError::new(ErrorID::FieldTypeExpected(FieldType::Uuid));
-    expected.add_parent(ErrorID::Field(field_name.clone().into()));
+    expected.add_parent(ErrorID::Field(test_doc.get_field_name(0).into()));
-    expected.add_parent(ErrorID::Document(doc_name.clone().into()));
+    expected.add_parent(ErrorID::Document(test_doc.get_doc_name().clone().into()));
+    let result = mtt.records(add).unwrap_err();
+    assert_eq!(result.to_string(), expected.to_string());
+}
+
+#[test]
+#[ignore = "requires session to store language preference"]
+fn does_it_error_on_missing_fields() {
+    let mut mtt = MoreThanText::new();
+    let test_doc = TestDocument::new(vec![FieldType::Integer, FieldType::Integer]);
+    mtt.create_document(test_doc.get_docdef());
+    let mut add = Addition::new(test_doc.get_doc_name().clone());
+    add.add_field(test_doc.get_field_name(0), 1);
+    let mut expected = MTTError::new(ErrorID::FieldInvalidNone);
+    expected.add_parent(ErrorID::Field(test_doc.get_field_name(0).into()));
+    expected.add_parent(ErrorID::Document(test_doc.get_doc_name().clone().into()));
     let result = mtt.records(add).unwrap_err();
     assert_eq!(result.to_string(), expected.to_string());
 }

tests/support.rs

@@ -1,6 +1,43 @@
-use morethantext::Name;
+use morethantext::{DocDef, FieldType, Name};
 use uuid::Uuid;
 
 pub fn random_name() -> Name {
     Name::english(Uuid::new_v4().to_string().as_str())
 }
+
+pub struct TestDocument {
+    doc_name: Name,
+    field_names: Vec<Name>,
+    field_types: Vec<FieldType>,
+}
+
+impl TestDocument {
+    pub fn new(fields: Vec<FieldType>) -> Self {
+        let mut fnames = Vec::new();
+        for i in 0..fields.len() {
+            let name = Name::english(format!("field{}", i).as_str());
+            fnames.push(name);
+        }
+        Self {
+            doc_name: random_name(),
+            field_names: fnames,
+            field_types: fields,
+        }
+    }
+
+    pub fn get_doc_name(&self) -> &Name {
+        &self.doc_name
+    }
+
+    pub fn get_docdef(&self) -> DocDef {
+        let mut output = DocDef::new(self.doc_name.clone());
+        for i in 0..self.field_types.len() {
+            output.add_field(self.field_names[i].clone(), self.field_types[i].clone());
+        }
+        output
+    }
+
+    pub fn get_field_name(&self, position: usize) -> Name {
+        self.field_names[position].clone()
+    }
+}

tests/support_test.rs

@@ -0,0 +1,56 @@
+mod support;
+
+use morethantext::{FieldType, Name};
+use support::TestDocument;
+
+#[test]
+fn are_document_names_unique() {
+    let test_doc1 = TestDocument::new(Vec::new());
+    let test_doc2 = TestDocument::new(Vec::new());
+    assert_ne!(test_doc1.get_doc_name(), test_doc2.get_doc_name());
+}
+
+#[test]
+fn does_test_doc_create_docdef() {
+    let test_doc = TestDocument::new(Vec::new());
+    let expected = vec![test_doc.get_doc_name().clone()];
+    let docdef = test_doc.get_docdef();
+    assert_eq!(docdef.get_document_names(), &expected);
+}
+
+#[test]
+fn can_fields_be_created() {
+    let count = 5;
+    let mut expected_fields = Vec::new();
+    for i in 0..count {
+        let name = Name::english(format!("field{}", i).as_str());
+        expected_fields.push(name);
+    }
+    let ftypes = [FieldType::Uuid, FieldType::Integer];
+    for ftype in ftypes.iter() {
+        let mut input = Vec::new();
+        for i in 0..count {
+            input.push(ftype.clone());
+        }
+        let test_doc = TestDocument::new(input);
+        for i in 0..count {
+            assert_eq!(test_doc.get_field_name(i), expected_fields[i]);
+        }
+        let docdef = test_doc.get_docdef();
+        for name in expected_fields.iter() {
+            docdef.validate(name, &ftype.get_default()).unwrap();
+        }
+    }
+}
+
+#[test]
+fn can_field_types_be_varied() {
+    let field_types = vec![FieldType::Uuid, FieldType::Integer];
+    let test_doc = TestDocument::new(field_types.clone());
+    let docdef = test_doc.get_docdef();
+    for i in 0..field_types.len() {
+        docdef
+            .validate(test_doc.get_field_name(i), &field_types[i].get_default())
+            .unwrap();
+    }
+}