From 8d0b149b319ca7f06c7c17b6472141f46f2d2d83 Mon Sep 17 00:00:00 2001 From: Jeff Baskin Date: Fri, 27 Feb 2026 12:22:57 -0500 Subject: [PATCH] Moved missing fields add test to lib. --- src/document/create.rs | 4 +-- tests/add_test.rs | 32 ++++++++++++++++-------- tests/support.rs | 39 ++++++++++++++++++++++++++++- tests/support_test.rs | 56 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 117 insertions(+), 14 deletions(-) create mode 100644 tests/support_test.rs diff --git a/src/document/create.rs b/src/document/create.rs index b278c06..dcce513 100644 --- a/src/document/create.rs +++ b/src/document/create.rs @@ -500,8 +500,6 @@ impl DocumentFile { }; let mut holder = InternalRecord::new(); - - let mut field_ids = self.docdef.get_field_ids(); for (name, value) in addition.iter() { let field_id = match self.docdef.get_field_id(name) { @@ -1187,7 +1185,6 @@ mod document_files { _ => unreachable!("got {:?}: should have been an error", result.get_action()), } } - */ #[test] fn errors_on_missing_fields() { @@ -1206,6 +1203,7 @@ mod document_files { _ => unreachable!("got {:?}: should have been an error", result.get_action()), } } + */ #[test] fn does_query_return_related_entries() { diff --git a/tests/add_test.rs b/tests/add_test.rs index aad94cd..b83ac83 100644 --- a/tests/add_test.rs +++ b/tests/add_test.rs @@ -5,7 +5,7 @@ use morethantext::{ ErrorID, MTTError, MoreThanText, Name, }; use std::collections::HashSet; -use support::random_name; +use support::{random_name, TestDocument}; use uuid::Uuid; #[test] @@ -72,16 +72,28 @@ fn does_it_error_on_bad_field_name() { #[test] fn does_it_error_on_bad_field_type() { let mut mtt = MoreThanText::new(); - let doc_name = Name::english("holder"); - let field_name = Name::english("wrong"); - let mut docdef = DocDef::new(doc_name.clone()); - docdef.add_field(field_name.clone(), FieldType::Uuid); - mtt.create_document(docdef); - let mut add = Addition::new(doc_name.clone()); - add.add_field(field_name.clone(), "something"); + let test_doc = TestDocument::new(vec![FieldType::Uuid]); + mtt.create_document(test_doc.get_docdef()); + let mut add = Addition::new(test_doc.get_doc_name().clone()); + add.add_field(test_doc.get_field_name(0), "something"); let mut expected = MTTError::new(ErrorID::FieldTypeExpected(FieldType::Uuid)); - expected.add_parent(ErrorID::Field(field_name.clone().into())); - expected.add_parent(ErrorID::Document(doc_name.clone().into())); + 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(add).unwrap_err(); + assert_eq!(result.to_string(), expected.to_string()); +} + +#[test] +#[ignore = "requires session to store language preference"] +fn does_it_error_on_missing_fields() { + let mut mtt = MoreThanText::new(); + let test_doc = TestDocument::new(vec![FieldType::Integer, FieldType::Integer]); + mtt.create_document(test_doc.get_docdef()); + let mut add = Addition::new(test_doc.get_doc_name().clone()); + add.add_field(test_doc.get_field_name(0), 1); + let mut expected = MTTError::new(ErrorID::FieldInvalidNone); + 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(add).unwrap_err(); assert_eq!(result.to_string(), expected.to_string()); } diff --git a/tests/support.rs b/tests/support.rs index 648cf19..7e87a1d 100644 --- a/tests/support.rs +++ b/tests/support.rs @@ -1,6 +1,43 @@ -use morethantext::Name; +use morethantext::{DocDef, FieldType, Name}; use uuid::Uuid; pub fn random_name() -> Name { Name::english(Uuid::new_v4().to_string().as_str()) } + +pub struct TestDocument { + doc_name: Name, + field_names: Vec, + field_types: Vec, +} + +impl TestDocument { + pub fn new(fields: Vec) -> Self { + let mut fnames = Vec::new(); + for i in 0..fields.len() { + let name = Name::english(format!("field{}", i).as_str()); + fnames.push(name); + } + Self { + doc_name: random_name(), + field_names: fnames, + field_types: fields, + } + } + + pub fn get_doc_name(&self) -> &Name { + &self.doc_name + } + + pub fn get_docdef(&self) -> DocDef { + let mut output = DocDef::new(self.doc_name.clone()); + for i in 0..self.field_types.len() { + output.add_field(self.field_names[i].clone(), self.field_types[i].clone()); + } + output + } + + pub fn get_field_name(&self, position: usize) -> Name { + self.field_names[position].clone() + } +} diff --git a/tests/support_test.rs b/tests/support_test.rs new file mode 100644 index 0000000..2b1ceb8 --- /dev/null +++ b/tests/support_test.rs @@ -0,0 +1,56 @@ +mod support; + +use morethantext::{FieldType, Name}; +use support::TestDocument; + +#[test] +fn are_document_names_unique() { + let test_doc1 = TestDocument::new(Vec::new()); + let test_doc2 = TestDocument::new(Vec::new()); + assert_ne!(test_doc1.get_doc_name(), test_doc2.get_doc_name()); +} + +#[test] +fn does_test_doc_create_docdef() { + let test_doc = TestDocument::new(Vec::new()); + let expected = vec![test_doc.get_doc_name().clone()]; + let docdef = test_doc.get_docdef(); + assert_eq!(docdef.get_document_names(), &expected); +} + +#[test] +fn can_fields_be_created() { + let count = 5; + let mut expected_fields = Vec::new(); + for i in 0..count { + let name = Name::english(format!("field{}", i).as_str()); + expected_fields.push(name); + } + let ftypes = [FieldType::Uuid, FieldType::Integer]; + for ftype in ftypes.iter() { + let mut input = Vec::new(); + for i in 0..count { + input.push(ftype.clone()); + } + let test_doc = TestDocument::new(input); + for i in 0..count { + assert_eq!(test_doc.get_field_name(i), expected_fields[i]); + } + let docdef = test_doc.get_docdef(); + for name in expected_fields.iter() { + docdef.validate(name, &ftype.get_default()).unwrap(); + } + } +} + +#[test] +fn can_field_types_be_varied() { + let field_types = vec![FieldType::Uuid, FieldType::Integer]; + let test_doc = TestDocument::new(field_types.clone()); + let docdef = test_doc.get_docdef(); + for i in 0..field_types.len() { + docdef + .validate(test_doc.get_field_name(i), &field_types[i].get_default()) + .unwrap(); + } +}