Started moving update tests into lib.

src/action/update.rs

@@ -1,4 +1,4 @@
-use super::{Query, RequestData};
+use super::{CalcValue, Query, RequestData};
 use crate::{message::MessageAction, name::NameType};
 
 #[derive(Clone, Debug)]
@@ -28,6 +28,14 @@ impl Update {
         &mut self.query
     }
 
+    pub fn add_field<NT, CV>(&mut self, name: NT, field: CV)
+    where
+        CV: Into<CalcValue>,
+        NT: Into<NameType>,
+    {
+        self.values.add_field(name, field);
+    }
+
     pub fn get_values(&self) -> &RequestData {
         &self.values
     }

src/document/create.rs

@@ -596,7 +596,8 @@ impl DocumentFile {
                 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()));
+                        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);
@@ -1512,7 +1513,6 @@ mod document_files {
             _ => unreachable!("got {:?}: should have been a error", action),
         }
     }
-    */
 
     #[test]
     fn can_use_default_values() {
@@ -1778,6 +1778,7 @@ mod document_files {
         testing(Message::new(update));
         testing(Message::new(Query::new(doc_name.clone())));
     }
+    */
 
     #[test]
     fn update_errors_on_bad_field_name() {

src/document/definition.rs

@@ -300,7 +300,10 @@ 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> {
+    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),

tests/add_test.rs

@@ -97,3 +97,52 @@ fn does_it_error_on_missing_fields() {
     let result = mtt.records(add).unwrap_err();
     assert_eq!(result.to_string(), expected.to_string());
 }
+
+#[test]
+fn can_default_values_be_used() {
+    let mut mtt = MoreThanText::new();
+    let ftype = FieldType::StaticString;
+    let test_doc = TestDocument::new(vec![ftype.clone()]);
+    let mut docdef = test_doc.get_docdef();
+    docdef.set_default(&test_doc.get_field_name(0), ftype.clone());
+    mtt.create_document(docdef);
+    let add = Addition::new(test_doc.get_doc_name().clone());
+    let results = mtt.records(add).unwrap();
+    let rec = results.iter().last().unwrap();
+    assert_eq!(rec.get(test_doc.get_field_name(0)).unwrap(), "".into());
+}
+
+#[test]
+fn can_default_values_be_set() {
+    let mut mtt = MoreThanText::new();
+    let ftype = FieldType::StaticString;
+    let fdefault = Uuid::new_v4().to_string();
+    let test_doc = TestDocument::new(vec![ftype.clone()]);
+    let mut docdef = test_doc.get_docdef();
+    docdef.set_default(&test_doc.get_field_name(0), fdefault.clone());
+    mtt.create_document(docdef);
+    let add = Addition::new(test_doc.get_doc_name().clone());
+    let results = mtt.records(add).unwrap();
+    let rec = results.iter().last().unwrap();
+    assert_eq!(
+        rec.get(test_doc.get_field_name(0)).unwrap(),
+        fdefault.into()
+    );
+}
+
+#[test]
+fn can_default_values_be_overwritten() {
+    let mut mtt = MoreThanText::new();
+    let ftype = FieldType::StaticString;
+    let fdefault = Uuid::new_v4().to_string();
+    let used = "something";
+    let test_doc = TestDocument::new(vec![ftype.clone()]);
+    let mut docdef = test_doc.get_docdef();
+    docdef.set_default(&test_doc.get_field_name(0), fdefault.clone());
+    mtt.create_document(docdef);
+    let mut add = Addition::new(test_doc.get_doc_name().clone());
+    add.add_field(test_doc.get_field_name(0), used);
+    let results = mtt.records(add).unwrap();
+    let rec = results.iter().last().unwrap();
+    assert_eq!(rec.get(test_doc.get_field_name(0)).unwrap(), used.into());
+}

tests/query_test.rs

@@ -5,11 +5,12 @@ use morethantext::{
     Name, Operand, Query,
 };
 use std::collections::HashSet;
-use support::TestDocument;
+use support::{setup_range, TestDocument};
 
 const COUNT: usize = 5;
 
-fn setup_range() -> (MoreThanText, TestDocument) {
+/*
+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();
@@ -21,10 +22,11 @@ fn setup_range() -> (MoreThanText, TestDocument) {
     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();
+    let (mut mtt, test_doc) = setup_range(COUNT);
     let mut query = Query::new(test_doc.get_doc_name());
     let result = mtt.records(query).unwrap();
     assert_eq!(result.len(), 5, "got {:?}", result);
@@ -42,7 +44,7 @@ fn does_empty_query_get_all_documents() {
 
 #[test]
 fn does_query_pull_specific_information() {
-    let (mut mtt, test_doc) = setup_range();
+    let (mut mtt, test_doc) = setup_range(COUNT);
     let expected = 3;
     let mut calc = Calculation::new(Operand::Equal);
     calc.add_value(expected.clone()).unwrap();
@@ -61,7 +63,7 @@ fn does_query_pull_specific_information() {
 
 #[test]
 fn does_query_work_with_less_than() {
-    let (mut mtt, test_doc) = setup_range();
+    let (mut mtt, test_doc) = setup_range(COUNT);
     let expected = 2;
     let mut calc = Calculation::new(Operand::LessThan);
     calc.add_value(expected.clone()).unwrap();
@@ -85,7 +87,7 @@ fn does_query_work_with_less_than() {
 
 #[test]
 fn does_query_work_with_less_than_equal() {
-    let (mut mtt, test_doc) = setup_range();
+    let (mut mtt, test_doc) = setup_range(COUNT);
     let expected = 2;
     let mut calc = Calculation::new(Operand::LessThanEqual);
     calc.add_value(expected.clone()).unwrap();
@@ -109,7 +111,7 @@ fn does_query_work_with_less_than_equal() {
 
 #[test]
 fn does_query_work_with_greater_than() {
-    let (mut mtt, test_doc) = setup_range();
+    let (mut mtt, test_doc) = setup_range(COUNT);
     let expected = 2;
     let mut calc = Calculation::new(Operand::GreaterThan);
     calc.add_value(expected.clone()).unwrap();
@@ -132,7 +134,7 @@ fn does_query_work_with_greater_than() {
 
 #[test]
 fn does_query_work_with_greater_than_equal() {
-    let (mut mtt, test_doc) = setup_range();
+    let (mut mtt, test_doc) = setup_range(COUNT);
     let expected = 2;
     let mut calc = Calculation::new(Operand::GreaterThanEqual);
     calc.add_value(expected.clone()).unwrap();

tests/support.rs

@@ -5,6 +5,19 @@ pub fn random_name() -> Name {
     Name::english(Uuid::new_v4().to_string().as_str())
 }
 
+pub fn setup_range(count: usize) -> (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)
+}
+
 pub struct TestDocument {
     doc_name: Name,
     field_names: Vec<Name>,

tests/update_test.rs

@@ -0,0 +1,130 @@
+mod support;
+
+use morethantext::{
+    CalcValue, Calculation, Field, FieldType, MoreThanText, Operand, Query, Records, Update,
+};
+use std::collections::HashSet;
+use support::{setup_range, TestDocument};
+use uuid::Uuid;
+
+#[test]
+fn is_it_possible_to_update_nothing() {
+    let count = 3;
+    let outside: i128 = (count + 2).try_into().unwrap();
+    let (mut mtt, test_doc) = setup_range(count);
+    let mut update = Update::new(test_doc.get_doc_name());
+    update.add_field(test_doc.get_field_name(0), 20);
+    let mut calc = Calculation::new(Operand::Equal);
+    calc.add_value(outside.clone()).unwrap();
+    calc.add_value(CalcValue::Existing(FieldType::Integer))
+        .unwrap();
+    update.get_query_mut().add(test_doc.get_field_name(0), calc);
+    let result = mtt.records(update).unwrap();
+    assert_eq!(result.len(), 0);
+}
+
+#[test]
+fn does_it_update_information() {
+    let mut mtt = MoreThanText::new();
+    let test_doc = TestDocument::new(vec![FieldType::Uuid, FieldType::StaticString]);
+    mtt.create_document(test_doc.get_docdef());
+    let field0 = Uuid::new_v4();
+    let field1 = "new";
+    let mut input: Vec<Field> = Vec::new();
+    input.push(field0.clone().into());
+    input.push("old".into());
+    test_doc.populate(&mut mtt, input);
+    let mut update = Update::new(test_doc.get_doc_name());
+    update.add_field(test_doc.get_field_name(1), field1);
+    let mut calc = Calculation::new(Operand::Equal);
+    calc.add_value(field0.clone()).unwrap();
+    calc.add_value(CalcValue::Existing(FieldType::Uuid))
+        .unwrap();
+    update.get_query_mut().add(test_doc.get_field_name(0), calc);
+    let tester = |result: Records| {
+        assert_eq!(result.len(), 1);
+        let rec = result.iter().last().unwrap();
+        assert_eq!(
+            rec.get(test_doc.get_field_name(0)).unwrap(),
+            field0.clone().into()
+        );
+        assert_eq!(rec.get(test_doc.get_field_name(1)).unwrap(), field1.into());
+    };
+    tester(mtt.records(update).unwrap());
+    tester(mtt.records(Query::new(test_doc.get_doc_name())).unwrap());
+}
+
+#[test]
+fn are_the_updates_limited_to_the_queried() {
+    let count = 3;
+    let choice = 1;
+    let changed = 20;
+    let (mut mtt, test_doc) = setup_range(count);
+    let mut update = Update::new(test_doc.get_doc_name());
+    update.add_field(test_doc.get_field_name(0), changed.clone());
+    let mut calc = Calculation::new(Operand::Equal);
+    calc.add_value(choice.clone()).unwrap();
+    calc.add_value(CalcValue::Existing(FieldType::Integer))
+        .unwrap();
+    update.get_query_mut().add(test_doc.get_field_name(0), calc);
+    let result = mtt.records(update).unwrap();
+    assert_eq!(result.len(), 1);
+    let rec = result.iter().last().unwrap();
+    assert_eq!(rec.get(test_doc.get_field_name(0)).unwrap(), changed.into());
+    let mut expected: HashSet<Field> = HashSet::new();
+    expected.insert(0.into());
+    expected.insert(2.into());
+    expected.insert(20.into());
+    let docs = mtt.records(Query::new(test_doc.get_doc_name())).unwrap();
+    for doc_data in docs.iter() {
+        let id = doc_data.get(test_doc.get_field_name(0)).unwrap();
+        expected.remove(&id);
+    }
+    assert_eq!(
+        expected.len(),
+        0,
+        "missed {:?} from docs: {:?}",
+        expected,
+        docs
+    );
+}
+
+#[test]
+fn can_multiple_documents_be_update() {
+    let count = 3;
+    let choice = 1;
+    let (mut mtt, test_doc) = setup_range(count);
+    let mut add_up = Calculation::new(Operand::Add);
+    add_up
+        .add_value(CalcValue::Existing(FieldType::Integer))
+        .unwrap();
+    add_up.add_value(20);
+    let mut update = Update::new(test_doc.get_doc_name());
+    update.add_field(test_doc.get_field_name(0), add_up);
+    let mut calc = Calculation::new(Operand::GreaterThanEqual);
+    calc.add_value(choice.clone()).unwrap();
+    calc.add_value(CalcValue::Existing(FieldType::Integer))
+        .unwrap();
+    update.get_query_mut().add(test_doc.get_field_name(0), calc);
+    let result = mtt.records(update).unwrap();
+    assert_eq!(result.len(), 2);
+    for rec in result.iter() {
+        assert!(rec.get(test_doc.get_field_name(0)).unwrap() > 10.into());
+    }
+    let mut expected: HashSet<Field> = HashSet::new();
+    expected.insert(2.into());
+    expected.insert(20.into());
+    expected.insert(21.into());
+    let docs = mtt.records(Query::new(test_doc.get_doc_name())).unwrap();
+    for doc_data in docs.iter() {
+        let id = doc_data.get(test_doc.get_field_name(0)).unwrap();
+        expected.remove(&id);
+    }
+    assert_eq!(
+        expected.len(),
+        0,
+        "missed {:?} from docs: {:?}",
+        expected,
+        docs
+    );
+}