Moved the index update tests to lib testing.

src/document/create.rs

@@ -118,7 +118,7 @@ impl Index {
             }
         };
         if self.unique && oids.len() > 0 {
-            let err = MTTError::new(ErrorID::IndexEntryAlreadyExists);
+            let err = MTTError::new(ErrorID::IndexEntryAlreadyExists(field.clone()));
             return Err(err);
         } else {
             oids.insert(oid);
@@ -160,7 +160,7 @@ impl Index {
         if self.unique {
             match self.data.get(field) {
                 Some(_) => {
-                    let err = MTTError::new(ErrorID::IndexEntryAlreadyExists);
+                    let err = MTTError::new(ErrorID::IndexEntryAlreadyExists(field.clone()));
                     return Err(err);
                 }
                 None => {}
@@ -327,7 +327,7 @@ mod indexes {
             Err(err) => {
                 let err_id = err.get_error_ids().back().unwrap();
                 match err_id {
-                    ErrorID::IndexEntryAlreadyExists => {}
+                    ErrorID::IndexEntryAlreadyExists(data) => assert_eq!(data, &field),
                     _ => unreachable!("got {:?}: should have been duplicate field", err),
                 }
             }
@@ -355,7 +355,7 @@ mod indexes {
         match index.validate(&field) {
             Ok(_) => unreachable!("should have gotten a duplication error"),
             Err(err) => match err.get_error_ids().back().unwrap() {
-                ErrorID::IndexEntryAlreadyExists => {}
+                ErrorID::IndexEntryAlreadyExists(data) => assert_eq!(data, &field),
                 _ => unreachable!("got {:?}: should have been duplicate field", err),
             },
         }
@@ -1846,7 +1846,6 @@ mod document_files {
             _ => unreachable!("got {:?}: should have gotten an error", action),
         }
     }
-    */
 
     #[test]
     fn does_update_maintain_unique_fields() {
@@ -1892,7 +1891,7 @@ mod document_files {
         let action = result.get_action();
         match action {
             MsgAction::Error(err) => match err.get_error_ids().back().unwrap() {
-                ErrorID::IndexEntryAlreadyExists => {}
+                ErrorID::IndexEntryAlreadyExists(_) => {}
                 _ => unreachable!("got {:?}: should have gotten incorrect file type", err),
             },
             _ => unreachable!("got {:?}: should have gotten an error", action),
@@ -1979,7 +1978,7 @@ mod document_files {
         let action = result.get_action();
         match action {
             MsgAction::Error(err) => match err.get_error_ids().back().unwrap() {
-                ErrorID::IndexEntryAlreadyExists => {}
+                ErrorID::IndexEntryAlreadyExists(_) => {}
                 _ => unreachable!("got {:?}: should have gotten an missing field", err),
             },
             _ => unreachable!("got {:?}: should have gotten an error", action),
@@ -2020,7 +2019,7 @@ mod document_files {
         let action = result.get_action();
         match action {
             MsgAction::Error(err) => match err.get_error_ids().back().unwrap() {
-                ErrorID::IndexEntryAlreadyExists => {}
+                ErrorID::IndexEntryAlreadyExists(_) => {}
                 _ => unreachable!("got {:?}: should have gotten field duplicate", err),
             },
             _ => unreachable!("got {:?}: should have gotten an error", action),
@@ -2046,6 +2045,7 @@ mod document_files {
         }
         assert!(ids.is_empty(), "did not find {:?}", ids);
     }
+    */
 
     #[test]
     fn can_calculate_field_values() {

src/mtterror.rs

@@ -19,7 +19,7 @@ pub enum ErrorID {
     FieldMissingData,
     FieldNameAlreadyExists,
     FieldTypeExpected(FieldType),
-    IndexEntryAlreadyExists,
+    IndexEntryAlreadyExists(Field),
     InvalidFieldName(Name),
     NameAlreadyExists,
     NameLanguageNotUnique,

tests/update_test.rs

@@ -1,7 +1,8 @@
 mod support;
 
 use morethantext::{
-    CalcValue, Calculation, ErrorID, Field, FieldType, MTTError, MoreThanText, Name, Operand, Query, Records, Update,
+    Addition, CalcValue, Calculation, ErrorID, Field, FieldType, IndexType, MTTError, MoreThanText,
+    Name, Operand, Query, Records, Update,
 };
 use std::collections::HashSet;
 use support::{setup_range, TestDocument};
@@ -136,7 +137,8 @@ fn does_update_error_on_a_bad_query() {
     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))
+    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);
@@ -154,9 +156,12 @@ fn does_update_error_on_a_bad_field_name() {
     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))
+    qry_calc
+        .add_value(CalcValue::Existing(FieldType::Integer))
         .unwrap();
-    update.get_query_mut().add(test_doc.get_field_name(0), qry_calc);
+    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()));
@@ -171,9 +176,12 @@ fn does_update_error_on_a_bad_field_type() {
     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))
+    qry_calc
+        .add_value(CalcValue::Existing(FieldType::Integer))
         .unwrap();
-    update.get_query_mut().add(test_doc.get_field_name(0), qry_calc);
+    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()));
@@ -181,3 +189,100 @@ fn does_update_error_on_a_bad_field_type() {
     let result = mtt.records(update).unwrap_err();
     assert_eq!(result.to_string(), expected.to_string());
 }
+
+#[test]
+fn does_update_maintain_unique_index() {
+    let mut mtt = MoreThanText::new();
+    let test_doc = TestDocument::new(vec![FieldType::StaticString]);
+    let mut docdef = test_doc.get_docdef();
+    docdef.add_index(&test_doc.get_field_name(0), IndexType::Unique);
+    mtt.create_document(docdef);
+    let old_data = "old";
+    let new_data = "new";
+    test_doc.populate(&mut mtt, vec![old_data]);
+    let mut update = Update::new(test_doc.get_doc_name());
+    update.add_field(test_doc.get_field_name(0), new_data);
+    mtt.records(update).unwrap();
+    let result = mtt.records(Query::new(test_doc.get_doc_name())).unwrap();
+    assert_eq!(result.len(), 1);
+    let rec = result.iter().last().unwrap();
+    assert_eq!(
+        rec.get(test_doc.get_field_name(0)).unwrap(),
+        new_data.into()
+    );
+    let mut add_new = Addition::new(test_doc.get_doc_name());
+    add_new.add_field(test_doc.get_field_name(0), new_data);
+    let mut err = MTTError::new(ErrorID::IndexEntryAlreadyExists(new_data.into()));
+    err.add_parent(ErrorID::Field(test_doc.get_field_name(0).into()));
+    err.add_parent(ErrorID::Document(test_doc.get_doc_name().into()));
+    let error = mtt.records(add_new).unwrap_err();
+    assert_eq!(error.to_string(), err.to_string());
+    let mut add_old = Addition::new(test_doc.get_doc_name());
+    add_old.add_field(test_doc.get_field_name(0), old_data);
+    let result = mtt.records(add_old).unwrap();
+    assert_eq!(result.len(), 1);
+    let add_rec = result.iter().last().unwrap();
+    assert_eq!(
+        add_rec.get(test_doc.get_field_name(0)).unwrap(),
+        old_data.into()
+    );
+}
+
+#[test]
+fn does_index_remain_unchanged_on_update_failure() {
+    let mut mtt = MoreThanText::new();
+    let test_doc = TestDocument::new(vec![FieldType::StaticString, FieldType::StaticString]);
+    let mut docdef = test_doc.get_docdef();
+    docdef.add_index(&test_doc.get_field_name(0), IndexType::Unique);
+    mtt.create_document(docdef);
+    let id = "one";
+    test_doc.populate(&mut mtt, vec!["one", "data"]);
+    let mut update = Update::new(test_doc.get_doc_name());
+    update.add_field(test_doc.get_field_name(0), "two");
+    update.add_field(test_doc.get_field_name(1), 2);
+    mtt.records(update).unwrap_err();
+    let mut add = Addition::new(test_doc.get_doc_name());
+    add.add_field(test_doc.get_field_name(0), id);
+    add.add_field(test_doc.get_field_name(1), "something");
+    let mut err = MTTError::new(ErrorID::IndexEntryAlreadyExists(id.into()));
+    err.add_parent(ErrorID::Field(test_doc.get_field_name(0).into()));
+    err.add_parent(ErrorID::Document(test_doc.get_doc_name().into()));
+    let error = mtt.records(add).unwrap_err();
+    assert_eq!(error.to_string(), err.to_string());
+}
+
+#[test]
+#[ignore = "requires session to hold language information"]
+fn does_update_error_when_it_overrides_unique_index() {
+    let count = 3;
+    let mut mtt = MoreThanText::new();
+    let test_doc = TestDocument::new(vec![FieldType::Integer]);
+    let mut docdef = test_doc.get_docdef();
+    docdef.add_index(&test_doc.get_field_name(0), IndexType::Unique);
+    mtt.create_document(docdef);
+    let mut input: Vec<Vec<i128>> = Vec::new();
+    for i in 0..count {
+        input.push(vec![i]);
+    }
+    test_doc.populate_multiple(&mut mtt, input);
+    let new_data = 5;
+    let mut update = Update::new(test_doc.get_doc_name());
+    update.add_field(test_doc.get_field_name(0), new_data.clone());
+    let mut err = MTTError::new(ErrorID::IndexEntryAlreadyExists(new_data.into()));
+    err.add_parent(ErrorID::Field(test_doc.get_field_name(0).into()));
+    err.add_parent(ErrorID::Document(test_doc.get_doc_name().into()));
+    let result = mtt.records(update).unwrap_err();
+    assert_eq!(result.to_string(), err.to_string());
+    for i in 0..count {
+        let mut calc = Calculation::new(Operand::Equal);
+        calc.add_value(i.clone()).unwrap();
+        calc.add_value(CalcValue::Existing(FieldType::Integer))
+            .unwrap();
+        let mut qry = Query::new(test_doc.get_doc_name());
+        qry.add(test_doc.get_field_name(0), calc);
+        let holder = mtt.records(qry).unwrap();
+        assert_eq!(holder.len(), 1);
+        let rec = holder.iter().last().unwrap();
+        assert_eq!(rec.get(test_doc.get_field_name(0)).unwrap(), i.into());
+    }
+}