Moved session tests to client.

tests/session_test.rs

@@ -7,18 +7,33 @@ use morethantext::{
 use std::time::Duration;
 use uuid::Uuid;
 
+const DELAY: Duration = Duration::from_hours(1);
+
 fn doc_name() -> Name {
     Name::english("session")
 }
 
+fn id_name() -> Name {
+    Name::english("id")
+}
+
+fn expire_name() -> Name {
+    Name::english("expire")
+}
+
+fn lang_name() -> Name {
+    Name::english("language")
+}
+
 fn get_session(mtt: &mut MoreThanText, id: &Uuid) -> Result<Record, MTTError> {
+    let client = mtt.client();
     let mut qry = Query::new(doc_name());
     let mut calc = Calculation::new(Operand::Equal);
     calc.add_value(CalcValue::Existing(FieldType::Uuid))
         .unwrap();
     calc.add_value(id.clone()).unwrap();
     qry.add(Name::english("id"), calc.clone());
-    match mtt.records(qry) {
+    match client.records(qry) {
         Ok(data) => Ok(data.iter().last().unwrap()),
         Err(err) => Err(err),
     }
@@ -28,9 +43,9 @@ fn get_session(mtt: &mut MoreThanText, id: &Uuid) -> Result<Record, MTTError> {
 fn are_session_ids_unique() {
     let mut mtt = MoreThanText::new();
     let count = 10;
-    let mut result: Vec<Uuid> = Vec::new();
+    let mut result: Vec<String> = Vec::new();
     for _ in 0..count {
-        let id = mtt.validate_session(None, None);
+        let id = mtt.client().session_id();
         assert!(!result.contains(&id), "found {} in {:?}", id, result);
         result.push(id);
     }
@@ -38,56 +53,68 @@ fn are_session_ids_unique() {
 
 #[test]
 fn bad_session_id_returns_new_id() {
-    let mut mtt = MoreThanText::new();
+    let id = "stuff".to_string();
-    let id1 = mtt.validate_session(Some("stuff".to_string()), None);
+    let result = MoreThanText::new().client().session_id();
-    let id2 = mtt.validate_session(Some("stuff".to_string()), None);
+    assert_ne!(result, id);
-    assert_ne!(id1, id2);
 }
 
 #[test]
-fn creates_new_session_if_bad_or_expired() {
+fn creates_new_session_if_missing_or_expired() {
-    let mut mtt = MoreThanText::new();
+    let id = Uuid::nil().to_string();
-    let id1 = mtt.validate_session(Some(Uuid::nil().to_string()), None);
+    let result = MoreThanText::new()
-    let id2 = mtt.validate_session(Some(Uuid::nil().to_string()), None);
+        .client_with_session(id.clone(), None)
-    assert_ne!(id1, id2);
+        .session_id();
+    assert_ne!(result, id);
 }
 
 #[test]
 fn returns_same_session_id_when_valid() {
     let mut mtt = MoreThanText::new();
-    let id = mtt.validate_session(None, None);
+    let expected = mtt.client().session_id();
-    let result = mtt.validate_session(Some(id.to_string()), None);
+    let result = mtt.client_with_session(expected.clone(), None).session_id();
-    assert_eq!(result, id);
+    assert_eq!(result, expected);
 }
 
 #[test]
 fn is_expiration_date_set_in_the_future() {
-    let mut mtt = MoreThanText::new();
+    let mut test_env = TestMoreThanText::new();
-    let start_time = Utc::now() + Duration::from_hours(1);
+    let path = Path::new(
-    let id = mtt.validate_session(None, None);
+        Include::All,
-    let end_time = Utc::now() + Duration::from_hours(1);
+        Include::Just(doc_name().into()),
-    let rec = get_session(&mut mtt, &id).unwrap();
+        Include::Just(Action::OnAddition),
-    let holder = rec.get(Name::english("expire")).unwrap();
+    );
-    match holder {
+    test_env.register_channel(vec![path]);
-        Field::DateTime(data) => {
+    let start_time = Utc::now() + DELAY;
-            assert!(data > start_time, "expire should be after {:?}", start_time);
+    let id = test_env.get_morethantext().client();
-            assert!(data < end_time, "expire should be before {:?}", end_time);
+    let end_time = Utc::now() + DELAY;
-        }
+    let result = test_env.get_trigger_records(Action::OnAddition);
-        _ => unreachable!("got {:?} should have been date time", holder),
+    let rec = result.iter().last().unwrap();
-    };
+    let expire = rec.get(&expire_name()).unwrap();
+    assert!(
+        expire > start_time.into(),
+        "{:?} should be after {:?}",
+        expire,
+        start_time
+    );
+    assert!(
+        expire < end_time.into(),
+        "{:?} should be after {:?}",
+        expire,
+        end_time
+    );
 }
 
 #[test]
-fn are_session_ids_unique_on_update() {
+fn are_session_ids_unique_in_storage() {
     let mut mtt = MoreThanText::new();
-    let id_name = Name::english("id");
+    let client = mtt.client();
-    let id = mtt.validate_session(None, None);
+    let id: Uuid = mtt.client().session_id().try_into().unwrap();
     let mut addition = Addition::new(doc_name());
-    addition.add_field(id_name.clone(), id);
+    addition.add_field(id_name(), id);
     let mut error = MTTError::new(ErrorID::IndexEntryAlreadyExists(id.into()));
-    error.add_parent(ErrorID::Field(id_name.into()));
+    error.add_parent(ErrorID::Field(id_name().into()));
-    error.add_parent(ErrorID::Document(Name::english("session").into()));
+    error.add_parent(ErrorID::Document(doc_name().into()));
-    match mtt.records(addition) {
+    match client.records(addition) {
         Ok(data) => unreachable!("got {:?} should have been error", data),
         Err(err) => assert_eq!(err.to_string(), error.to_string()),
     }
@@ -95,49 +122,47 @@ fn are_session_ids_unique_on_update() {
 
 #[test]
 fn does_expire_updates_on_query() {
-    let id_name = Name::english("id");
-    let expire_name = Name::english("expire");
     let mut test_env = TestMoreThanText::new();
     let mut mtt = test_env.get_morethantext();
-    let id = mtt.validate_session(None, None);
+    let id = mtt.client().session_id();
     let path = Path::new(
         Include::All,
         Include::Just(doc_name().into()),
         Include::Just(Action::OnUpdate),
     );
     test_env.register_channel(vec![path]);
-    let start_time: Field = (Utc::now() + Duration::from_secs(3600)).into();
+    let start_time = Utc::now() + DELAY;
-    mtt.validate_session(Some(id.to_string()), None);
+    mtt.client_with_session(id, None);
-    let end_time: Field = (Utc::now() + Duration::from_secs(3601)).into();
     let result = test_env.get_trigger_records(Action::OnUpdate);
-    assert_eq!(result.len(), 1);
     let rec = result.iter().last().unwrap();
-    assert_eq!(rec.get(&id_name).unwrap(), id.into());
+    let expire = rec.get(&expire_name()).unwrap();
-    let data = rec.get(&expire_name).unwrap();
+    assert!(
-    assert!(data > start_time, "expire should be after {:?}", start_time);
+        expire > start_time.into(),
-    assert!(data < end_time, "expire should be before {:?}", end_time);
+        "{:?} should be after {:?}",
+        expire,
+        start_time
+    );
 }
 
 #[test]
 fn are_expired_sessions_removed() {
-    let id_name = Name::english("id");
     let mut test_env = TestMoreThanText::new();
-    let mut mtt = test_env.get_morethantext();
+    let client = test_env.get_morethantext().client();
-    for _ in 0..5 {
+    let id: Uuid = test_env
-        mtt.validate_session(None, None);
+        .get_morethantext()
-    }
+        .client()
-    let id = mtt.validate_session(None, None);
+        .session_id()
-    let mut update = Update::new(doc_name());
+        .try_into()
+        .unwrap();
     let mut calc = Calculation::new(Operand::Equal);
     calc.add_value(CalcValue::Existing(FieldType::Uuid))
         .unwrap();
     calc.add_value(id.clone()).unwrap();
-    update.get_query_mut().add(id_name.clone(), calc.clone());
+    let mut update = Update::new(doc_name());
     let expire = Utc::now() - Duration::from_secs(10);
-    update
+    update.get_query_mut().add(id_name(), calc.clone());
-        .get_values_mut()
+    update.get_values_mut().add_field(expire_name(), expire);
-        .add_field(Name::english("expire"), expire);
+    client.records(update).unwrap();
-    mtt.records(update).unwrap();
     let path = Path::new(
         Include::All,
         Include::Just(doc_name().into()),
@@ -146,9 +171,9 @@ fn are_expired_sessions_removed() {
     test_env.register_channel(vec![path]);
     test_env.send_time_pulse();
     let result = test_env.get_trigger_records(Action::OnDelete);
-    assert_eq!(result.len(), 1, "incorrect number of records");
+    assert_eq!(result.len(), 1, "incorrect number of records\n{:?}", result);
     let rec = result.iter().last().unwrap();
-    assert_eq!(rec.get(id_name).unwrap(), id.into());
+    assert_eq!(rec.get(id_name()).unwrap(), id.into());
 }
 
 #[test]
@@ -163,7 +188,7 @@ fn is_english_the_default_language() {
         Include::Just(Action::OnAddition),
     );
     test_env.register_channel(vec![path]);
-    let id = mtt.validate_session(None, None);
+    mtt.client();
     let result = test_env.get_trigger_records(Action::OnAddition);
     assert_eq!(result.len(), 1, "incorrect number of records");
     let rec = result.iter().last().unwrap();
@@ -182,7 +207,7 @@ fn can_language_be_assigned() {
         Include::Just(Action::OnAddition),
     );
     test_env.register_channel(vec![path]);
-    let id = mtt.validate_session(None, Some(lang.clone()));
+    mtt.client_with_language(lang.clone());
     let result = test_env.get_trigger_records(Action::OnAddition);
     assert_eq!(result.len(), 1, "incorrect number of records");
     let rec = result.iter().last().unwrap();
@@ -196,14 +221,14 @@ fn does_not_change_language() {
     let jlang = Language::from_639_1("ja").unwrap();
     let mut test_env = TestMoreThanText::new();
     let mut mtt = test_env.get_morethantext();
-    let id = mtt.validate_session(None, Some(jlang.clone()));
+    let id = mtt.client_with_language(jlang.clone()).session_id();
     let path = Path::new(
         Include::All,
         Include::Just(doc_name().into()),
         Include::Just(Action::OnUpdate),
     );
     test_env.register_channel(vec![path]);
-    mtt.validate_session(Some(id.to_string()), Some(elang.clone()));
+    mtt.client_with_session(id, Some(elang));
     let result = test_env.get_trigger_records(Action::OnUpdate);
     assert_eq!(result.len(), 1, "incorrect number of records");
     let rec = result.iter().last().unwrap();