Replaced session id with SessionEntry.

src/message.rs

@@ -1,7 +1,7 @@
 use crate::{
     action::{Field, MsgAction},
     name::NameType,
-    queue::data_director::{Include, Path, Route},
+    queue::data_director::{Include, Path, Route, SessionEntry},
 };
 use uuid::Uuid;
 
@@ -41,7 +41,7 @@ pub struct Message {
     msg_id: MessageID,
     action: MsgAction,
     route: Route,
-    session: Field,
+    session: SessionEntry,
 }
 
 impl Message {
@@ -58,10 +58,15 @@ impl Message {
         output
     }
 
+    pub fn session_id(&self) -> &Field {
+        self.session.id()
+    }
+
     pub fn set_session<F>(&self, session: F) -> Self
     where
         F: Into<Field>,
     {
+        /*
         let sess_id = match session.into() {
             Field::Uuid(data) => Field::Uuid(data.clone()),
             Field::StaticString(data) => match Uuid::try_from(data) {
@@ -70,8 +75,10 @@ impl Message {
             },
             _ => Field::None,
         };
+        */
         let mut output = self.clone();
-        output.session = sess_id;
+        // output.session = sess_id;
+        output.session = SessionEntry::new(session);
         output
     }
 
@@ -115,7 +122,7 @@ impl Default for Message {
             msg_id: MessageID::new(),
             action: MsgAction::None,
             route: Route::default(),
-            session: Field::None,
+            session: SessionEntry::new(Field::None),
         }
     }
 }
@@ -141,7 +148,7 @@ mod messages {
             MsgAction::None => {}
             _ => panic!("should have been no action"),
         }
-        assert_eq!(msg.session, Field::None);
+        assert_eq!(msg.session_id(), &Field::None);
     }
 
     #[test]
@@ -150,11 +157,11 @@ mod messages {
         let qry = Query::new(doc_name.clone());
         let msg = Message::new(qry);
         let expected: NameType = doc_name.into();
-        match msg.action {
+        match &msg.action {
             MsgAction::Query(data) => assert_eq!(data.doc_name(), &expected),
             _ => unreachable!("should have been a query"),
         }
-        match msg.session {
+        match msg.session_id() {
             Field::None => {}
             _ => unreachable!("should have been none"),
         }
@@ -175,25 +182,16 @@ mod messages {
         let qry = Query::new(doc_name.clone());
         let sess_id: Field = Uuid::new_v4().into();
         let msg = Message::new(qry).set_session(sess_id.clone());
-        assert_eq!(msg.session, sess_id);
+        assert_eq!(msg.session_id(), &sess_id);
     }
 
     #[test]
     fn can_session_be_set_by_string() {
         let doc_name = Name::english("string");
         let qry = Query::new(doc_name.clone());
-        let sess_id = Uuid::new_v4();
+        let sess_id: Field = Uuid::new_v4().to_string().into();
-        let msg = Message::new(qry).set_session(sess_id.to_string());
+        let msg = Message::new(qry).set_session(sess_id.clone());
-        assert_eq!(msg.session, sess_id.into());
+        assert_eq!(msg.session_id(), &sess_id);
-    }
-
-    #[test]
-    fn does_garbage_return_none() {
-        let doc_name = Name::english("garbage");
-        let qry = Query::new(doc_name.clone());
-        let sess_id = "not a uuid";
-        let msg = Message::new(qry).set_session(sess_id);
-        assert_eq!(msg.session, Field::None);
     }
 
     #[test]
@@ -202,16 +200,7 @@ mod messages {
         let qry = Query::new(doc_name.clone());
         let sess_id = Uuid::new_v4();
         let msg = Message::new(qry).set_session(sess_id.clone());
-        assert_eq!(msg.session, sess_id.into());
+        assert_eq!(msg.session_id(), &sess_id.into());
-    }
-
-    #[test]
-    fn does_wrong_field_type_return_none() {
-        let doc_name = Name::english("uuid");
-        let qry = Query::new(doc_name.clone());
-        let sess_id = FieldType::DateTime.get_default();
-        let msg = Message::new(qry).set_session(sess_id.clone());
-        assert_eq!(msg.session, Field::None);
     }
 
     #[test]

src/queue/data_director.rs

@@ -1,5 +1,4 @@
 use super::SenderID;
-use chrono::{DateTime, Utc};
 use crate::{
     action::{Action, Field, MsgAction},
     message::{Message, MessageAction, MessageID},
@@ -7,6 +6,7 @@ use crate::{
     name::{Name, NameID, NameType, Names},
     queue::router::Queue,
 };
+use chrono::{DateTime, Utc};
 use std::{
     collections::{HashMap, HashSet},
     sync::mpsc::Receiver,
@@ -487,7 +487,7 @@ mod route_storeage {
 }
 
 #[derive(Clone, Debug)]
-struct SessionEntry {
+pub struct SessionEntry {
     id: Field,
     expire_time: DateTime<Utc>,
 }
@@ -495,14 +495,17 @@ struct SessionEntry {
 impl SessionEntry {
     const EXPIRE_IN: Duration = Duration::from_hours(1);
 
-    fn new(id: Field) -> Self {
+    pub fn new<F>(id: F) -> Self
+    where
+        F: Into<Field>,
+    {
         Self {
-            id: id,
+            id: id.into(),
             expire_time: Utc::now() + SessionEntry::EXPIRE_IN,
         }
     }
 
-    fn id(&self) -> &Field {
+    pub fn id(&self) -> &Field {
         &self.id
     }
 
@@ -528,13 +531,23 @@ mod session_entries {
         let entry = SessionEntry::new(id.clone());
         let end = Utc::now() + SessionEntry::EXPIRE_IN;
         assert_eq!(entry.id(), &id);
-        assert!(start < entry.expire_time, "{:?} should have been after {:?}", entry.expire_time, start);
+        assert!(
-        assert!(end > entry.expire_time, "{:?} should have been after {:?}", entry.expire_time, end);
+            start < entry.expire_time,
+            "{:?} should have been after {:?}",
+            entry.expire_time,
+            start
+        );
+        assert!(
+            end > entry.expire_time,
+            "{:?} should have been after {:?}",
+            entry.expire_time,
+            end
+        );
     }
 
     #[test]
     fn can_determine_if_entry_expired() {
-        let mut entry = SessionEntry::new(Uuid::nil().into());
+        let mut entry = SessionEntry::new(Uuid::nil());
         let data = Utc::now();
         entry.expire_time = data + Duration::from_secs(1);
         assert!(!entry.is_expired(), "entry should not be expired");
@@ -544,13 +557,23 @@ mod session_entries {
 
     #[test]
     fn can_expiration_be_reset() {
-        let mut entry = SessionEntry::new(Uuid::nil().into());
+        let mut entry = SessionEntry::new(Uuid::nil());
         entry.expire_time = Utc::now();
         let start = Utc::now() + SessionEntry::EXPIRE_IN;
         entry.extend();
         let end = Utc::now() + SessionEntry::EXPIRE_IN;
-        assert!(start < entry.expire_time, "{:?} should have been after {:?}", entry.expire_time, start);
+        assert!(
-        assert!(end > entry.expire_time, "{:?} should have been after {:?}", entry.expire_time, end);
+            start < entry.expire_time,
+            "{:?} should have been after {:?}",
+            entry.expire_time,
+            start
+        );
+        assert!(
+            end > entry.expire_time,
+            "{:?} should have been after {:?}",
+            entry.expire_time,
+            end
+        );
     }
 }
 
@@ -633,8 +656,18 @@ mod sessions {
         let end = Utc::now() + SessionEntry::EXPIRE_IN;
         assert_eq!(result.id(), data.id());
         let entry = sess.entries.get(data.id()).unwrap();
-        assert!(start < entry.expire_time, "{:?} should have been after {:?}", entry.expire_time, start);
+        assert!(
-        assert!(end > entry.expire_time, "{:?} should have been after {:?}", entry.expire_time, end);
+            start < entry.expire_time,
+            "{:?} should have been after {:?}",
+            entry.expire_time,
+            start
+        );
+        assert!(
+            end > entry.expire_time,
+            "{:?} should have been after {:?}",
+            entry.expire_time,
+            end
+        );
     }
 
     #[test]
@@ -697,8 +730,18 @@ mod sessions {
         sess.entries.get_mut(&lose.id).unwrap().expire_time = Utc::now() - SessionEntry::EXPIRE_IN;
         let keep = sess.get(&Field::None);
         sess.expire();
-        assert_eq!(sess.entries.len(), 1, "should only contain one entry, had {:?}", sess.entries);
+        assert_eq!(
-        assert!(sess.entries.contains_key(&keep.id), "had {:?}, expected {:?}", sess.entries.keys(), &keep.id)
+            sess.entries.len(),
+            1,
+            "should only contain one entry, had {:?}",
+            sess.entries
+        );
+        assert!(
+            sess.entries.contains_key(&keep.id),
+            "had {:?}, expected {:?}",
+            sess.entries.keys(),
+            &keep.id
+        )
     }
 }