Moved query operand tests to lib lest.

tests/query_test.rs

@@ -0,0 +1,151 @@
+mod support;
+
+use morethantext::{CalcValue, Calculation, Field, FieldType, MoreThanText, Operand, Query};
+use std::collections::HashSet;
+use support::TestDocument;
+
+const COUNT: usize = 5;
+
+fn setup_range() -> (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();
+    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();
+    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();
+    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();
+    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();
+    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();
+    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);
+}