morethantext/tests/query_test.rs

mod support;

use morethantext::{
    Action, CalcValue, Calculation, DocDef, ErrorID, Field, FieldType, Include, IndexType,
    MTTError, MoreThanText, Name, Operand, Path, Query, TestMoreThanText,
};
use std::collections::HashSet;
use support::{setup_range, TestDocument};

const COUNT: usize = 5;

#[test]
fn does_empty_query_get_all_documents() {
    let (test_env, test_doc) = setup_range(COUNT);
    let mut mtt = test_env.get_morethantext();
    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 (test_env, test_doc) = setup_range(COUNT);
    let mut mtt = test_env.get_morethantext();
    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 (test_env, test_doc) = setup_range(COUNT);
    let mut mtt = test_env.get_morethantext();
    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 (test_env, test_doc) = setup_range(COUNT);
    let mut mtt = test_env.get_morethantext();
    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 (test_env, test_doc) = setup_range(COUNT);
    let mut mtt = test_env.get_morethantext();
    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 (test_env, test_doc) = setup_range(COUNT);
    let mut mtt = test_env.get_morethantext();
    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());
}

#[test]
fn does_query_send_on_query_message() {
    let selected = 2;
    let (mut test_env, test_doc) = setup_range(3);
    let mut mtt = test_env.get_morethantext();
    test_env.register_channel(vec![Path::new(
        Include::All,
        Include::Just(test_doc.get_doc_name().into()),
        Include::Just(Action::OnQuery),
    )]);
    let mut calc = Calculation::new(Operand::Equal);
    calc.add_value(selected.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 query_result = mtt.records(qry).unwrap();
    let trigger_result = test_env.get_trigger_records(Action::OnQuery);
    assert_eq!(trigger_result.len(), query_result.len());
    assert_eq!(
        trigger_result
            .iter()
            .last()
            .unwrap()
            .get(test_doc.get_field_name(0))
            .unwrap(),
        query_result
            .iter()
            .last()
            .unwrap()
            .get(test_doc.get_field_name(0))
            .unwrap()
    );
}