Moved bad query type test.

src/document/create.rs

@@ -592,8 +592,17 @@ impl DocumentFile {
         let mut indexed: HashMap<NameID, Calculation> = HashMap::new();
         let mut unindexed: HashMap<NameID, Calculation> = HashMap::new();
         for (field, data) in query.iter() {
-            let id = match self.docdef.get_field_id(field) {
+            let id = match self.docdef.get_field_id(field.clone()) {
-                Ok(fid) => fid,
+                Ok(fid) => {
+                    let expected_type = self.docdef.get_field_type(field.clone()).unwrap();
+                    if &data.get_type() != expected_type {
+                        let mut err = MTTError::new(ErrorID::FieldTypeExpected(expected_type.clone()));
+                        err.add_parent(ErrorID::Field(field.clone()));
+                        err.add_parent(ErrorID::Document(query.doc_name().clone()));
+                        return Err(err);
+                    }
+                    fid
+                }
                 Err(mut err) => {
                     err.add_parent(ErrorID::Field(field.clone()));
                     err.add_parent(ErrorID::Document(query.doc_name().clone()));
@@ -1478,9 +1487,9 @@ mod document_files {
             _ => unreachable!("got {:?}: should have been a error", action),
         }
     }
-    */
 
     #[test]
+    #[ignore = "moving"]
     fn errors_on_bad_field_type_with_index() {
         let mut doc = TestDocument::new([FieldType::Uuid].to_vec());
         doc.get_docdef_mut()
@@ -1503,6 +1512,7 @@ mod document_files {
             _ => unreachable!("got {:?}: should have been a error", action),
         }
     }
+    */
 
     #[test]
     fn can_use_default_values() {

src/document/definition.rs

@@ -23,6 +23,10 @@ impl FieldSetting {
         }
     }
 
+    fn get_field_type(&self) -> &FieldType {
+        &self.fieldtype
+    }
+
     fn set_default<CV>(&mut self, holder: CV) -> Result<(), MTTError>
     where
         CV: Into<CalcValue>,
@@ -78,6 +82,16 @@ mod fieldsettings {
     use chrono::Utc;
     use std::time::Duration;
 
+    #[test]
+    fn can_field_type_be_retrieved() {
+        let dtype0 = FieldType::Uuid;
+        let dtype1 = FieldType::StaticString;
+        let fset0 = FieldSetting::new(dtype0.clone());
+        let fset1 = FieldSetting::new(dtype1.clone());
+        assert_eq!(fset0.get_field_type(), &dtype0);
+        assert_eq!(fset1.get_field_type(), &dtype1);
+    }
+
     #[test]
     fn validates_field_type() {
         let fset = FieldSetting::new(FieldType::Uuid);
@@ -286,6 +300,14 @@ impl DocDef {
         self.fields.insert(id, FieldSetting::new(ftype));
     }
 
+    pub fn get_field_type<NT>(&self, field_name: NT) -> Result<&FieldType, MTTError> where NT: Into<NameType> {
+        let id = match self.field_names.get_id(field_name) {
+            Ok(data) => data,
+            Err(err) => return Err(err),
+        };
+        Ok(self.fields.get(&id).unwrap().get_field_type())
+    }
+
     pub fn get_field_id<NT>(&self, field_name: NT) -> Result<NameID, MTTError>
     where
         NT: Into<NameType>,
@@ -401,6 +423,20 @@ mod docdefs {
         }
     }
 
+    #[test]
+    fn can_field_types_be_retrieved() {
+        let docname = Name::english("something");
+        let mut docdef = DocDef::new(docname);
+        let field1 = Name::english("field1");
+        let field2 = Name::english("field2");
+        let ftype1 = FieldType::Uuid;
+        let ftype2 = FieldType::StaticString;
+        docdef.add_field(field1.clone(), ftype1.clone());
+        docdef.add_field(field2.clone(), ftype2.clone());
+        assert_eq!(docdef.get_field_type(&field1).unwrap(), &ftype1);
+        assert_eq!(docdef.get_field_type(&field2).unwrap(), &ftype2);
+    }
+
     #[test]
     fn produces_error_for_bad_fields() {
         let docname = Name::english("tester");

tests/query_test.rs

@@ -279,3 +279,21 @@ fn does_it_error_on_bad_field_name() {
     let result = mtt.records(qry).unwrap_err();
     assert_eq!(result.to_string(), expected.to_string());
 }
+
+#[test]
+fn does_it_error_on_bad_field_type() {
+    let mut mtt = MoreThanText::new();
+    let test_doc = TestDocument::new(vec![FieldType::Uuid]);
+    mtt.create_document(test_doc.get_docdef());
+    let mut calc = Calculation::new(Operand::Equal);
+    calc.add_value("a").unwrap();
+    calc.add_value(CalcValue::Existing(FieldType::StaticString))
+        .unwrap();
+    let mut qry = Query::new(test_doc.get_doc_name());
+    qry.add(test_doc.get_field_name(0), calc);
+    let mut expected = MTTError::new(ErrorID::FieldTypeExpected(FieldType::Uuid));
+    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(qry).unwrap_err();
+    assert_eq!(result.to_string(), expected.to_string());
+}