morethantext/tests/update_test.rs

mod support;

use morethantext::{
    Addition, CalcValue, Calculation, ErrorID, Field, FieldType, IndexType, MTTError, MoreThanText,
    Name, Operand, Query, Records, Update,
};
use std::collections::HashSet;
use support::{setup_range, TestDocument};
use uuid::Uuid;

#[test]
fn is_it_possible_to_update_nothing() {
    let count = 3;
    let outside: i128 = (count + 2).try_into().unwrap();
    let (mut mtt, test_doc) = setup_range(count);
    let mut update = Update::new(test_doc.get_doc_name());
    update.add_field(test_doc.get_field_name(0), 20);
    let mut calc = Calculation::new(Operand::Equal);
    calc.add_value(outside.clone()).unwrap();
    calc.add_value(CalcValue::Existing(FieldType::Integer))
        .unwrap();
    update.get_query_mut().add(test_doc.get_field_name(0), calc);
    let result = mtt.records(update).unwrap();
    assert_eq!(result.len(), 0);
}

#[test]
fn does_it_update_information() {
    let mut mtt = MoreThanText::new();
    let test_doc = TestDocument::new(vec![FieldType::Uuid, FieldType::StaticString]);
    mtt.create_document(test_doc.get_docdef());
    let field0 = Uuid::new_v4();
    let field1 = "new";
    let mut input: Vec<Field> = Vec::new();
    input.push(field0.clone().into());
    input.push("old".into());
    test_doc.populate(&mut mtt, input);
    let mut update = Update::new(test_doc.get_doc_name());
    update.add_field(test_doc.get_field_name(1), field1);
    let mut calc = Calculation::new(Operand::Equal);
    calc.add_value(field0.clone()).unwrap();
    calc.add_value(CalcValue::Existing(FieldType::Uuid))
        .unwrap();
    update.get_query_mut().add(test_doc.get_field_name(0), calc);
    let tester = |result: Records| {
        assert_eq!(result.len(), 1);
        let rec = result.iter().last().unwrap();
        assert_eq!(
            rec.get(test_doc.get_field_name(0)).unwrap(),
            field0.clone().into()
        );
        assert_eq!(rec.get(test_doc.get_field_name(1)).unwrap(), field1.into());
    };
    tester(mtt.records(update).unwrap());
    tester(mtt.records(Query::new(test_doc.get_doc_name())).unwrap());
}

#[test]
fn are_the_updates_limited_to_the_queried() {
    let count = 3;
    let choice = 1;
    let changed = 20;
    let (mut mtt, test_doc) = setup_range(count);
    let mut update = Update::new(test_doc.get_doc_name());
    update.add_field(test_doc.get_field_name(0), changed.clone());
    let mut calc = Calculation::new(Operand::Equal);
    calc.add_value(choice.clone()).unwrap();
    calc.add_value(CalcValue::Existing(FieldType::Integer))
        .unwrap();
    update.get_query_mut().add(test_doc.get_field_name(0), calc);
    let result = mtt.records(update).unwrap();
    assert_eq!(result.len(), 1);
    let rec = result.iter().last().unwrap();
    assert_eq!(rec.get(test_doc.get_field_name(0)).unwrap(), changed.into());
    let mut expected: HashSet<Field> = HashSet::new();
    expected.insert(0.into());
    expected.insert(2.into());
    expected.insert(20.into());
    let docs = mtt.records(Query::new(test_doc.get_doc_name())).unwrap();
    for doc_data in docs.iter() {
        let id = doc_data.get(test_doc.get_field_name(0)).unwrap();
        expected.remove(&id);
    }
    assert_eq!(
        expected.len(),
        0,
        "missed {:?} from docs: {:?}",
        expected,
        docs
    );
}

#[test]
fn can_multiple_documents_be_update() {
    let count = 3;
    let choice = 1;
    let (mut mtt, test_doc) = setup_range(count);
    let mut add_up = Calculation::new(Operand::Add);
    add_up
        .add_value(CalcValue::Existing(FieldType::Integer))
        .unwrap();
    add_up.add_value(20);
    let mut update = Update::new(test_doc.get_doc_name());
    update.add_field(test_doc.get_field_name(0), add_up);
    let mut calc = Calculation::new(Operand::GreaterThanEqual);
    calc.add_value(choice.clone()).unwrap();
    calc.add_value(CalcValue::Existing(FieldType::Integer))
        .unwrap();
    update.get_query_mut().add(test_doc.get_field_name(0), calc);
    let result = mtt.records(update).unwrap();
    assert_eq!(result.len(), 2);
    for rec in result.iter() {
        assert!(rec.get(test_doc.get_field_name(0)).unwrap() > 10.into());
    }
    let mut expected: HashSet<Field> = HashSet::new();
    expected.insert(2.into());
    expected.insert(20.into());
    expected.insert(21.into());
    let docs = mtt.records(Query::new(test_doc.get_doc_name())).unwrap();
    for doc_data in docs.iter() {
        let id = doc_data.get(test_doc.get_field_name(0)).unwrap();
        expected.remove(&id);
    }
    assert_eq!(
        expected.len(),
        0,
        "missed {:?} from docs: {:?}",
        expected,
        docs
    );
}

#[test]
fn does_update_error_on_a_bad_query() {
    let (mut mtt, test_doc) = setup_range(1);
    let bad_name = Name::japanese("正しくない");
    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))
        .unwrap();
    update.get_query_mut().add(bad_name.clone(), qry_calc);
    update.add_field(test_doc.get_field_name(0), 5);
    let mut expected = MTTError::new(ErrorID::NameNotFound(bad_name.clone().into()));
    expected.add_parent(ErrorID::Field(bad_name.into()));
    expected.add_parent(ErrorID::Document(test_doc.get_doc_name().into()));
    let result = mtt.records(update).unwrap_err();
    assert_eq!(result.to_string(), expected.to_string());
}

#[test]
fn does_update_error_on_a_bad_field_name() {
    let (mut mtt, test_doc) = setup_range(1);
    let bad_name = Name::japanese("正しくない");
    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))
        .unwrap();
    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()));
    expected.add_parent(ErrorID::Document(test_doc.get_doc_name().into()));
    let result = mtt.records(update).unwrap_err();
    assert_eq!(result.to_string(), expected.to_string());
}

#[test]
fn does_update_error_on_a_bad_field_type() {
    let (mut mtt, test_doc) = setup_range(1);
    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))
        .unwrap();
    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()));
    expected.add_parent(ErrorID::Document(test_doc.get_doc_name().into()));
    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<i128>> = 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());
    }
}