302 lines
11 KiB
Rust
302 lines
11 KiB
Rust
mod support;
|
|
|
|
use morethantext::{
|
|
CalcValue, Calculation, DocDef, ErrorID, Field, FieldType, IndexType, MTTError, MoreThanText,
|
|
Name, Operand, Query,
|
|
};
|
|
use std::collections::HashSet;
|
|
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);
|
|
let mut query = Query::new(test_doc.get_doc_name());
|
|
let result = mtt.records(query).unwrap();
|
|
assert_eq!(result.len(), 5, "got {:?}", result);
|
|
let mut holder: HashSet<Field> = HashSet::new();
|
|
for rec in result.iter() {
|
|
holder.insert(rec.get(test_doc.get_field_name(0)).unwrap());
|
|
}
|
|
assert_eq!(holder.len(), COUNT, "got {:?}", holder);
|
|
for i in 0..COUNT {
|
|
let data: i128 = i.try_into().unwrap();
|
|
holder.remove(&data.into());
|
|
}
|
|
assert_eq!(holder.len(), 0, "got {:?}", holder);
|
|
}
|
|
|
|
#[test]
|
|
fn does_query_pull_specific_information() {
|
|
let (mut mtt, test_doc) = setup_range(COUNT);
|
|
let expected = 3;
|
|
let mut calc = Calculation::new(Operand::Equal);
|
|
calc.add_value(expected.clone()).unwrap();
|
|
calc.add_value(CalcValue::Existing(FieldType::Integer))
|
|
.unwrap();
|
|
let mut query = Query::new(test_doc.get_doc_name());
|
|
query.add(test_doc.get_field_name(0), calc);
|
|
let result = mtt.records(query).unwrap();
|
|
assert_eq!(result.len(), 1);
|
|
let rec = result.iter().last().unwrap();
|
|
assert_eq!(
|
|
rec.get(test_doc.get_field_name(0)).unwrap(),
|
|
expected.into()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn does_query_work_with_less_than() {
|
|
let (mut mtt, test_doc) = setup_range(COUNT);
|
|
let expected = 2;
|
|
let mut calc = Calculation::new(Operand::LessThan);
|
|
calc.add_value(expected.clone()).unwrap();
|
|
calc.add_value(CalcValue::Existing(FieldType::Integer))
|
|
.unwrap();
|
|
let mut query = Query::new(test_doc.get_doc_name());
|
|
query.add(test_doc.get_field_name(0), calc);
|
|
let result = mtt.records(query).unwrap();
|
|
assert_eq!(result.len(), 2, "got {:?}", result);
|
|
let mut holder: HashSet<Field> = HashSet::new();
|
|
for rec in result.iter() {
|
|
holder.insert(rec.get(test_doc.get_field_name(0)).unwrap());
|
|
}
|
|
assert_eq!(holder.len(), 2, "got {:?}", holder);
|
|
for i in 3..COUNT {
|
|
let data: i128 = i.try_into().unwrap();
|
|
holder.remove(&data.into());
|
|
}
|
|
assert_eq!(holder.len(), 0, "got {:?}", holder);
|
|
}
|
|
|
|
#[test]
|
|
fn does_query_work_with_less_than_equal() {
|
|
let (mut mtt, test_doc) = setup_range(COUNT);
|
|
let expected = 2;
|
|
let mut calc = Calculation::new(Operand::LessThanEqual);
|
|
calc.add_value(expected.clone()).unwrap();
|
|
calc.add_value(CalcValue::Existing(FieldType::Integer))
|
|
.unwrap();
|
|
let mut query = Query::new(test_doc.get_doc_name());
|
|
query.add(test_doc.get_field_name(0), calc);
|
|
let result = mtt.records(query).unwrap();
|
|
assert_eq!(result.len(), 3, "got {:?}", result);
|
|
let mut holder: HashSet<Field> = HashSet::new();
|
|
for rec in result.iter() {
|
|
holder.insert(rec.get(test_doc.get_field_name(0)).unwrap());
|
|
}
|
|
assert_eq!(holder.len(), 3, "got {:?}", holder);
|
|
for i in 2..COUNT {
|
|
let data: i128 = i.try_into().unwrap();
|
|
holder.remove(&data.into());
|
|
}
|
|
assert_eq!(holder.len(), 0, "got {:?}", holder);
|
|
}
|
|
|
|
#[test]
|
|
fn does_query_work_with_greater_than() {
|
|
let (mut mtt, test_doc) = setup_range(COUNT);
|
|
let expected = 2;
|
|
let mut calc = Calculation::new(Operand::GreaterThan);
|
|
calc.add_value(expected.clone()).unwrap();
|
|
calc.add_value(CalcValue::Existing(FieldType::Integer))
|
|
.unwrap();
|
|
let mut query = Query::new(test_doc.get_doc_name());
|
|
query.add(test_doc.get_field_name(0), calc);
|
|
let result = mtt.records(query).unwrap();
|
|
assert_eq!(result.len(), 2, "got {:?}", result);
|
|
let mut holder: HashSet<Field> = HashSet::new();
|
|
for rec in result.iter() {
|
|
holder.insert(rec.get(test_doc.get_field_name(0)).unwrap());
|
|
}
|
|
assert_eq!(holder.len(), 2, "got {:?}", holder);
|
|
for i in 0..2 {
|
|
holder.remove(&i.into());
|
|
}
|
|
assert_eq!(holder.len(), 0, "got {:?}", holder);
|
|
}
|
|
|
|
#[test]
|
|
fn does_query_work_with_greater_than_equal() {
|
|
let (mut mtt, test_doc) = setup_range(COUNT);
|
|
let expected = 2;
|
|
let mut calc = Calculation::new(Operand::GreaterThanEqual);
|
|
calc.add_value(expected.clone()).unwrap();
|
|
calc.add_value(CalcValue::Existing(FieldType::Integer))
|
|
.unwrap();
|
|
let mut query = Query::new(test_doc.get_doc_name());
|
|
query.add(test_doc.get_field_name(0), calc);
|
|
let result = mtt.records(query).unwrap();
|
|
assert_eq!(result.len(), 3, "got {:?}", result);
|
|
let mut holder: HashSet<Field> = HashSet::new();
|
|
for rec in result.iter() {
|
|
holder.insert(rec.get(test_doc.get_field_name(0)).unwrap());
|
|
}
|
|
assert_eq!(holder.len(), 3, "got {:?}", holder);
|
|
for i in 0..3 {
|
|
holder.remove(&i.into());
|
|
}
|
|
assert_eq!(holder.len(), 0, "got {:?}", holder);
|
|
}
|
|
|
|
#[test]
|
|
fn can_query_use_multiple_fields() {
|
|
let mut mtt = MoreThanText::new();
|
|
let test_doc = TestDocument::new(vec![FieldType::StaticString, FieldType::StaticString]);
|
|
mtt.create_document(test_doc.get_docdef()).unwrap();
|
|
let input = vec![
|
|
vec!["a", "a"],
|
|
vec!["a", "b"],
|
|
vec!["b", "a"],
|
|
vec!["b", "b"],
|
|
];
|
|
test_doc.populate_multiple(&mut mtt, input);
|
|
let mut calc1 = Calculation::new(Operand::Equal);
|
|
calc1.add_value("a").unwrap();
|
|
calc1
|
|
.add_value(CalcValue::Existing(FieldType::StaticString))
|
|
.unwrap();
|
|
let mut calc2 = Calculation::new(Operand::Equal);
|
|
calc2.add_value("b").unwrap();
|
|
calc2
|
|
.add_value(CalcValue::Existing(FieldType::StaticString))
|
|
.unwrap();
|
|
let mut query = Query::new(test_doc.get_doc_name());
|
|
query.add(test_doc.get_field_name(0), calc1);
|
|
query.add(test_doc.get_field_name(1), calc2);
|
|
let results = mtt.records(query).unwrap();
|
|
assert_eq!(results.len(), 1, "got {:?}", results);
|
|
let rec = results.iter().last().unwrap();
|
|
assert_eq!(rec.get(test_doc.get_field_name(0)).unwrap(), "a".into());
|
|
assert_eq!(rec.get(test_doc.get_field_name(1)).unwrap(), "b".into());
|
|
}
|
|
|
|
#[test]
|
|
fn can_query_use_multiple_indexed_fields() {
|
|
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::Index)
|
|
.unwrap();
|
|
docdef
|
|
.add_index(&test_doc.get_field_name(1), IndexType::Index)
|
|
.unwrap();
|
|
mtt.create_document(docdef).unwrap();
|
|
let input = vec![
|
|
vec!["a", "a"],
|
|
vec!["a", "b"],
|
|
vec!["b", "a"],
|
|
vec!["b", "b"],
|
|
];
|
|
test_doc.populate_multiple(&mut mtt, input);
|
|
let mut calc1 = Calculation::new(Operand::Equal);
|
|
calc1.add_value("a").unwrap();
|
|
calc1
|
|
.add_value(CalcValue::Existing(FieldType::StaticString))
|
|
.unwrap();
|
|
let mut calc2 = Calculation::new(Operand::Equal);
|
|
calc2.add_value("b").unwrap();
|
|
calc2
|
|
.add_value(CalcValue::Existing(FieldType::StaticString))
|
|
.unwrap();
|
|
let mut query = Query::new(test_doc.get_doc_name());
|
|
query.add(test_doc.get_field_name(0), calc1);
|
|
query.add(test_doc.get_field_name(1), calc2);
|
|
let results = mtt.records(query).unwrap();
|
|
assert_eq!(results.len(), 1, "got {:?}", results);
|
|
let rec = results.iter().last().unwrap();
|
|
assert_eq!(rec.get(test_doc.get_field_name(0)).unwrap(), "a".into());
|
|
assert_eq!(rec.get(test_doc.get_field_name(1)).unwrap(), "b".into());
|
|
}
|
|
|
|
#[test]
|
|
fn can_query_use_multiple_mixed_index_fields() {
|
|
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::Index)
|
|
.unwrap();
|
|
mtt.create_document(docdef).unwrap();
|
|
let input = vec![
|
|
vec!["a", "a"],
|
|
vec!["a", "b"],
|
|
vec!["b", "a"],
|
|
vec!["b", "b"],
|
|
];
|
|
test_doc.populate_multiple(&mut mtt, input);
|
|
let mut calc1 = Calculation::new(Operand::Equal);
|
|
calc1.add_value("a").unwrap();
|
|
calc1
|
|
.add_value(CalcValue::Existing(FieldType::StaticString))
|
|
.unwrap();
|
|
let mut calc2 = Calculation::new(Operand::Equal);
|
|
calc2.add_value("b").unwrap();
|
|
calc2
|
|
.add_value(CalcValue::Existing(FieldType::StaticString))
|
|
.unwrap();
|
|
let mut query = Query::new(test_doc.get_doc_name());
|
|
query.add(test_doc.get_field_name(0), calc1);
|
|
query.add(test_doc.get_field_name(1), calc2);
|
|
let results = mtt.records(query).unwrap();
|
|
assert_eq!(results.len(), 1, "got {:?}", results);
|
|
let rec = results.iter().last().unwrap();
|
|
assert_eq!(rec.get(test_doc.get_field_name(0)).unwrap(), "a".into());
|
|
assert_eq!(rec.get(test_doc.get_field_name(1)).unwrap(), "b".into());
|
|
}
|
|
|
|
#[test]
|
|
fn does_it_error_on_bad_field_name() {
|
|
let mut mtt = MoreThanText::new();
|
|
let doc_name = Name::english("holder");
|
|
let field_name = Name::english("missing");
|
|
let docdef = DocDef::new(doc_name.clone());
|
|
mtt.create_document(docdef);
|
|
let mut calc = Calculation::new(Operand::Equal);
|
|
calc.add_value("a").unwrap();
|
|
calc.add_value(CalcValue::Existing(FieldType::StaticString))
|
|
.unwrap();
|
|
let mut qry = Query::new(doc_name.clone());
|
|
qry.add(field_name.clone(), calc);
|
|
let mut expected = MTTError::new(ErrorID::NameNotFound(field_name.clone().into()));
|
|
expected.add_parent(ErrorID::Field(field_name.clone().into()));
|
|
expected.add_parent(ErrorID::Document(doc_name.clone().into()));
|
|
let result = mtt.records(qry).unwrap_err();
|
|
assert_eq!(result.to_string(), expected.to_string());
|
|
}
|
|
|
|
#[test]
|
|
fn does_it_error_on_bad_field_type() {
|
|
let mut mtt = MoreThanText::new();
|
|
let test_doc = TestDocument::new(vec![FieldType::Uuid]);
|
|
mtt.create_document(test_doc.get_docdef());
|
|
let mut calc = Calculation::new(Operand::Equal);
|
|
calc.add_value("a").unwrap();
|
|
calc.add_value(CalcValue::Existing(FieldType::StaticString))
|
|
.unwrap();
|
|
let mut qry = Query::new(test_doc.get_doc_name());
|
|
qry.add(test_doc.get_field_name(0), calc);
|
|
let mut expected = MTTError::new(ErrorID::FieldTypeExpected(FieldType::Uuid));
|
|
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(qry).unwrap_err();
|
|
assert_eq!(result.to_string(), expected.to_string());
|
|
}
|