Moved some update errors into lib testing.

src/document/create.rs

@@ -599,14 +599,12 @@ impl DocumentFile {
                         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()));
                     return Err(err);
                 }
             };
@@ -659,7 +657,8 @@ impl DocumentFile {
         };
         let records = match self.run_query(query) {
             Ok(data) => data,
-            Err(err) => {
+            Err(mut err) => {
+                err.add_parent(ErrorID::Document(msg.doc_name().into()));
                 let reply = msg.response(err);
                 self.queue.send(reply);
                 return;
@@ -683,8 +682,20 @@ impl DocumentFile {
         let mut changes: HashMap<NameID, &CalcValue> = HashMap::new();
         for (key, value) in update.get_values().iter() {
             let field_id = match self.docdef.get_field_id(key) {
-                Ok(data) => data,
+                Ok(id) => {
-                Err(err) => return Err(err),
+                    let expected_type = self.docdef.get_field_type(key.clone()).unwrap();
+                    if &value.get_type() != expected_type {
+                        let mut err =
+                            MTTError::new(ErrorID::FieldTypeExpected(expected_type.clone()));
+                        err.add_parent(ErrorID::Field(key.clone()));
+                        return Err(err);
+                    }
+                    id
+                }
+                Err(mut err) => {
+                    err.add_parent(ErrorID::Field(key.clone()));
+                    return Err(err);
+                }
             };
             changes.insert(field_id, value);
         }
@@ -733,7 +744,8 @@ impl DocumentFile {
         };
         let original = match self.run_query(update.get_query()) {
             Ok(result) => result,
-            Err(err) => {
+            Err(mut err) => {
+                err.add_parent(ErrorID::Document(msg.doc_name().into()));
                 let reply = msg.response(err);
                 self.queue.send(reply);
                 return;
@@ -741,7 +753,8 @@ impl DocumentFile {
         };
         let data = match self.run_update(&original, update, msg) {
             Ok(output) => output,
-            Err(err) => {
+            Err(mut err) => {
+                err.add_parent(ErrorID::Document(msg.doc_name().into()));
                 let reply = msg.response(err);
                 self.queue.send(reply);
                 return;
@@ -1778,7 +1791,6 @@ mod document_files {
         testing(Message::new(update));
         testing(Message::new(Query::new(doc_name.clone())));
     }
-    */
 
     #[test]
     fn update_errors_on_bad_field_name() {
@@ -1834,6 +1846,7 @@ mod document_files {
             _ => unreachable!("got {:?}: should have gotten an error", action),
         }
     }
+    */
 
     #[test]
     fn does_update_maintain_unique_fields() {

tests/query_test.rs

@@ -9,21 +9,6 @@ use support::{setup_range, TestDocument};
 
 const COUNT: usize = 5;
 
-/*
-fn setup_range(COUNT) -> (MoreThanText, TestDocument) {
-    let mut mtt = MoreThanText::new();
-    let test_doc = TestDocument::new(vec![FieldType::Integer]);
-    mtt.create_document(test_doc.get_docdef()).unwrap();
-    let mut data: Vec<Vec<i128>> = Vec::new();
-    for i in 0..COUNT {
-        let holder: i128 = i.try_into().unwrap();
-        data.push(vec![holder]);
-    }
-    test_doc.populate_multiple(&mut mtt, data);
-    (mtt, test_doc)
-}
-*/
-
 #[test]
 fn does_empty_query_get_all_documents() {
     let (mut mtt, test_doc) = setup_range(COUNT);

tests/update_test.rs

@@ -1,7 +1,7 @@
 mod support;
 
 use morethantext::{
-    CalcValue, Calculation, Field, FieldType, MoreThanText, Operand, Query, Records, Update,
+    CalcValue, Calculation, ErrorID, Field, FieldType, MTTError, MoreThanText, Name, Operand, Query, Records, Update,
 };
 use std::collections::HashSet;
 use support::{setup_range, TestDocument};
@@ -128,3 +128,56 @@ fn can_multiple_documents_be_update() {
         docs
     );
 }
+
+#[test]
+fn does_update_error_on_a_bad_query() {
+    let (mut mtt, test_doc) = setup_range(1);
+    let bad_name = Name::japanese("正しくない");
+    let mut update = Update::new(test_doc.get_doc_name());
+    let mut qry_calc = Calculation::new(Operand::Equal);
+    qry_calc.add_value(0).unwrap();
+    qry_calc.add_value(CalcValue::Existing(FieldType::Integer))
+        .unwrap();
+    update.get_query_mut().add(bad_name.clone(), qry_calc);
+    update.add_field(test_doc.get_field_name(0), 5);
+    let mut expected = MTTError::new(ErrorID::NameNotFound(bad_name.clone().into()));
+    expected.add_parent(ErrorID::Field(bad_name.into()));
+    expected.add_parent(ErrorID::Document(test_doc.get_doc_name().into()));
+    let result = mtt.records(update).unwrap_err();
+    assert_eq!(result.to_string(), expected.to_string());
+}
+
+#[test]
+fn does_update_error_on_a_bad_field_name() {
+    let (mut mtt, test_doc) = setup_range(1);
+    let bad_name = Name::japanese("正しくない");
+    let mut update = Update::new(test_doc.get_doc_name());
+    let mut qry_calc = Calculation::new(Operand::Equal);
+    qry_calc.add_value(0).unwrap();
+    qry_calc.add_value(CalcValue::Existing(FieldType::Integer))
+        .unwrap();
+    update.get_query_mut().add(test_doc.get_field_name(0), qry_calc);
+    update.add_field(bad_name.clone(), 5);
+    let mut expected = MTTError::new(ErrorID::NameNotFound(bad_name.clone().into()));
+    expected.add_parent(ErrorID::Field(bad_name.into()));
+    expected.add_parent(ErrorID::Document(test_doc.get_doc_name().into()));
+    let result = mtt.records(update).unwrap_err();
+    assert_eq!(result.to_string(), expected.to_string());
+}
+
+#[test]
+fn does_update_error_on_a_bad_field_type() {
+    let (mut mtt, test_doc) = setup_range(1);
+    let mut update = Update::new(test_doc.get_doc_name());
+    let mut qry_calc = Calculation::new(Operand::Equal);
+    qry_calc.add_value(0).unwrap();
+    qry_calc.add_value(CalcValue::Existing(FieldType::Integer))
+        .unwrap();
+    update.get_query_mut().add(test_doc.get_field_name(0), qry_calc);
+    update.add_field(test_doc.get_field_name(0), "wrong type");
+    let mut expected = MTTError::new(ErrorID::FieldTypeExpected(FieldType::Integer));
+    expected.add_parent(ErrorID::Field(test_doc.get_field_name(0).into()));
+    expected.add_parent(ErrorID::Document(test_doc.get_doc_name().into()));
+    let result = mtt.records(update).unwrap_err();
+    assert_eq!(result.to_string(), expected.to_string());
+}