Finished moving tests into lib test.

src/action.rs

@@ -10,7 +10,7 @@ mod show;
 mod update;
 mod user;
 
-pub use crate::document::{DocDef, Field, FieldType, IndexType, Record, Records};
+pub use crate::document::{DocDef, DocFuncType, Field, FieldType, IndexType, Record, Records};
 pub use action_type::Action;
 pub use addition::Addition;
 pub use calculation::{CalcValue, Calculation, Operand};

src/document.rs

@@ -9,7 +9,7 @@ use record::{InternalRecord, InternalRecords, Oid};
 
 pub use clock::Clock;
 pub use create::{CreateDoc, IndexType};
-pub use definition::DocDef;
+pub use definition::{DocDef, DocFuncType};
 pub use field::{Field, FieldType};
 pub use record::{Record, Records};
 pub use session::Session;

tests/trigger_test.rs

@@ -0,0 +1,160 @@
+mod support;
+
+use morethantext::{
+    Action, CalcValue, Calculation, Delete, DocFuncType, FieldType, Include, MoreThanText, Name,
+    Operand, Path, Query, TestMoreThanText, Update,
+};
+use support::TestDocument;
+
+#[test]
+fn can_a_trigger_cause_an_update() {
+    let data0 = 0;
+    let data1 = 0;
+    let data1_expected = 1;
+    let mut mtt = MoreThanText::new();
+    let test_doc = TestDocument::new(vec![FieldType::Integer, FieldType::Integer]);
+    let mut calc = Calculation::new(Operand::Add);
+    calc.add_value(CalcValue::Existing(FieldType::Integer))
+        .unwrap();
+    calc.add_value(1).unwrap();
+    let mut update = Update::new(test_doc.get_doc_name());
+    update.add_field(test_doc.get_field_name(1), calc);
+    let path = Path::new(
+        Include::All,
+        Include::Just(test_doc.get_doc_name().into()),
+        Include::Just(Action::OnQuery),
+    );
+    let function = DocFuncType::ExistingQuery(update.into());
+    let mut docdef = test_doc.get_docdef();
+    docdef.add_route(path, function);
+    mtt.create_document(docdef);
+    test_doc.populate(&mut mtt, vec![data0.clone(), data1.clone()]);
+    let first_qry = mtt.records(Query::new(test_doc.get_doc_name())).unwrap();
+    assert_eq!(first_qry.len(), 1);
+    let first_rec = first_qry.iter().last().unwrap();
+    assert_eq!(
+        first_rec.get(test_doc.get_field_name(0)).unwrap(),
+        data0.clone().into()
+    );
+    assert_eq!(
+        first_rec.get(test_doc.get_field_name(1)).unwrap(),
+        data1.clone().into()
+    );
+    let second_qry = mtt.records(Query::new(test_doc.get_doc_name())).unwrap();
+    assert_eq!(second_qry.len(), 1);
+    let second_rec = second_qry.iter().last().unwrap();
+    assert_eq!(
+        second_rec.get(test_doc.get_field_name(0)).unwrap(),
+        data0.clone().into()
+    );
+    assert_eq!(
+        second_rec.get(test_doc.get_field_name(1)).unwrap(),
+        data1_expected.clone().into(),
+        "not updated"
+    );
+}
+
+#[test]
+fn can_trigger_update_specific_record() {
+    let count = 3;
+    let selected = 1; // must be greater than or equal to 0 and less than count
+    let initial_data = 0;
+    let expected = 1;
+    let mut input: Vec<Vec<i128>> = Vec::new();
+    for i in 0..count {
+        input.push(vec![i.clone(), initial_data.clone()]);
+    }
+    let mut mtt = MoreThanText::new();
+    let test_doc = TestDocument::new(vec![FieldType::Integer, FieldType::Integer]);
+    let mut calc = Calculation::new(Operand::Add);
+    calc.add_value(CalcValue::Existing(FieldType::Integer))
+        .unwrap();
+    calc.add_value(1).unwrap();
+    let mut update = Update::new(test_doc.get_doc_name());
+    update.add_field(test_doc.get_field_name(1), calc);
+    let path = Path::new(
+        Include::All,
+        Include::Just(test_doc.get_doc_name().into()),
+        Include::Just(Action::OnQuery),
+    );
+    let function = DocFuncType::ExistingQuery(update.into());
+    let mut docdef = test_doc.get_docdef();
+    docdef.add_route(path, function);
+    mtt.create_document(docdef);
+    test_doc.populate_multiple(&mut mtt, input);
+    let mut qry_calc = Calculation::new(Operand::Equal);
+    qry_calc
+        .add_value(CalcValue::Existing(FieldType::Integer))
+        .unwrap();
+    qry_calc.add_value(selected.clone()).unwrap();
+    let mut qry = Query::new(test_doc.get_doc_name());
+    qry.add(test_doc.get_field_name(0), qry_calc);
+    let first_result = mtt.records(qry).unwrap();
+    assert_eq!(first_result.len(), 1);
+    let first_rec = first_result.iter().last().unwrap();
+    assert_eq!(
+        first_rec.get(test_doc.get_field_name(0)).unwrap(),
+        selected.clone().into()
+    );
+    assert_eq!(
+        first_rec.get(test_doc.get_field_name(1)).unwrap(),
+        initial_data.clone().into()
+    );
+    let second_result = mtt.records(Query::new(test_doc.get_doc_name())).unwrap();
+    assert_eq!(second_result.len(), count.try_into().unwrap());
+    for rec in second_result.iter() {
+        if rec.get(test_doc.get_field_name(0)).unwrap() == selected.clone().into() {
+            assert_eq!(
+                rec.get(test_doc.get_field_name(1)).unwrap(),
+                expected.clone().into()
+            );
+        } else {
+            assert_eq!(
+                rec.get(test_doc.get_field_name(1)).unwrap(),
+                initial_data.clone().into()
+            );
+        }
+    }
+}
+
+#[test]
+fn can_a_trigger_from_another_document_be_used() {
+    let count = 3;
+    let selected = 1; // must be greater than or equal to 0 and less than count
+    let mut input: Vec<Vec<i128>> = Vec::new();
+    for i in 0..count {
+        input.push(vec![i]);
+    }
+    let test_env = TestMoreThanText::new();
+    let mut mtt = test_env.get_morethantext();
+    let test_doc = TestDocument::new(vec![FieldType::Integer]);
+    let mut calc = Calculation::new(Operand::Equal);
+    calc.add_value(CalcValue::Existing(FieldType::Integer))
+        .unwrap();
+    calc.add_value(1).unwrap();
+    let mut delete = Delete::new(test_doc.get_doc_name());
+    delete.get_query_mut().add(test_doc.get_field_name(0), calc);
+    let path = Path::new(
+        Include::All,
+        Include::Just(Name::english("clock").into()),
+        Include::Just(Action::OnUpdate),
+    );
+    let function = DocFuncType::Trigger(delete.into());
+    let mut docdef = test_doc.get_docdef();
+    docdef.add_route(path, function);
+    mtt.create_document(docdef);
+    test_doc.populate_multiple(&mut mtt, input);
+    test_env.send_time_pulse();
+    let result = mtt.records(Query::new(test_doc.get_doc_name())).unwrap();
+    assert_eq!(
+        result.len(),
+        (count - 1).try_into().unwrap(),
+        "wrong number of records"
+    );
+    for rec in result.iter() {
+        assert!(
+            rec.get(test_doc.get_field_name(0)).unwrap() != selected.clone().into(),
+            "did not remove selected"
+        );
+    }
+}