From 43aa53fc492af4390104e2092493176b6ee036f3 Mon Sep 17 00:00:00 2001 From: Jeff Baskin Date: Tue, 3 Mar 2026 13:00:26 -0500 Subject: [PATCH] Moved the index update tests to lib testing. --- src/document/create.rs | 16 +++--- src/mtterror.rs | 2 +- tests/update_test.rs | 117 ++++++++++++++++++++++++++++++++++++++--- 3 files changed, 120 insertions(+), 15 deletions(-) diff --git a/src/document/create.rs b/src/document/create.rs index b02ad45..cb3f013 100644 --- a/src/document/create.rs +++ b/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() { diff --git a/src/mtterror.rs b/src/mtterror.rs index 8b5d381..19443b1 100644 --- a/src/mtterror.rs +++ b/src/mtterror.rs @@ -19,7 +19,7 @@ pub enum ErrorID { FieldMissingData, FieldNameAlreadyExists, FieldTypeExpected(FieldType), - IndexEntryAlreadyExists, + IndexEntryAlreadyExists(Field), InvalidFieldName(Name), NameAlreadyExists, NameLanguageNotUnique, diff --git a/tests/update_test.rs b/tests/update_test.rs index c3d63f5..d8a167a 100644 --- a/tests/update_test.rs +++ b/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::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()); + } +}