Added document name to query.

src/action/message.rs

@@ -2,6 +2,7 @@ use super::{DocDef, Query, UserAction};
 use crate::{
     message::wrapper::{Addition, Delete, Records, Reply, Update},
     mtterror::MTTError,
+    name::NameType,
     queue::data_director::Register,
 };
 
@@ -23,6 +24,15 @@ pub enum MsgAction {
     Update(Update),
 }
 
+impl MsgAction {
+    fn doc_name(&self) -> NameType {
+        match self {
+            Self::Query(data) => data.doc_name(),
+            _ => NameType::None,
+        }
+    }
+}
+
 impl From<Addition> for MsgAction {
     fn from(value: Addition) -> Self {
         MsgAction::Addition(value)
@@ -128,10 +138,11 @@ mod msgactions {
 
     #[test]
     fn turn_query_into_action() {
-        let value = Query::new();
+        let name = Name::english(Uuid::new_v4().to_string().as_str());
+        let value = Query::new(name.clone());
         let result: MsgAction = value.into();
         match result {
-            MsgAction::Query(_) => {}
+            MsgAction::Query(data) => assert_eq!(data.doc_name(), name.into()),
             _ => unreachable!("Got {:?}: dhould have been query", result),
         }
     }

src/action/query.rs

@@ -1,19 +1,32 @@
+use super::Calculation;
 use crate::name::NameType;
 use std::collections::{HashMap, HashSet};
-use super::Calculation;
 
 #[derive(Clone, Debug)]
 pub struct Query {
+    doc_name: NameType,
     data: HashMap<NameType, Calculation>,
 }
 
 impl Query {
-    pub fn new() -> Self {
+    pub fn new<NT>(name: NT) -> Self
+    where
+        NT: Into<NameType>,
+    {
         Self {
+            doc_name: name.into(),
             data: HashMap::new(),
         }
     }
 
+    pub fn internal() -> Self {
+        Self::new(NameType::None)
+    }
+
+    pub fn doc_name(&self) -> NameType {
+        self.doc_name.clone()
+    }
+
     pub fn add<NT>(&mut self, name: NT, operation: Calculation)
     where
         NT: Into<NameType>,
@@ -45,9 +58,35 @@ impl Query {
 #[cfg(test)]
 mod queries {
     use super::*;
-    use crate::{action::{Field, Operand}, name::Name};
+    use crate::{
+        action::{Field, Operand},
+        name::Name,
+    };
     use uuid::Uuid;
 
+    #[test]
+    fn is_default_query_empty() {
+        let name = Name::english(Uuid::new_v4().to_string().as_str());
+        let qry = Query::new(name.clone());
+        let result = qry.doc_name();
+        assert_eq!(
+            result,
+            name.clone().into(),
+            "got {:?} should be {:?}",
+            result,
+            name
+        );
+        assert_eq!(qry.iter().count(), 0, "query should be empty");
+    }
+
+    #[test]
+    fn does_internal_queries_return_none() {
+        let qry = Query::internal();
+        let result = qry.doc_name();
+        assert_eq!(result, NameType::None, "got {:?} should be none", result);
+        assert_eq!(qry.iter().count(), 0, "query should be empty");
+    }
+
     #[test]
     fn holds_calculation_to_run_query() {
         let name = Name::english(Uuid::new_v4().to_string().as_str());
@@ -56,7 +95,7 @@ mod queries {
         while bad_data == data {
             bad_data = Uuid::new_v4();
         }
-        let mut query = Query::new();
+        let mut query = Query::new(Name::english("something"));
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value(data.clone()).unwrap();
         query.add(name.clone(), calc);

src/document/create.rs

@@ -4,9 +4,7 @@ use crate::{
         definition::{DocDef, DocFuncType},
         field::Field,
     },
-    message::wrapper::{
+    message::wrapper::{InternalRecord, InternalRecords, Message, Oid, Records, Reply, Update},
-        InternalRecord, InternalRecords, Message, Oid, Records, Reply, Update,
-    },
     mtterror::MTTError,
     name::NameType,
     queue::{
@@ -128,7 +126,7 @@ mod createdocs {
             MsgAction::Reply(_) => {}
             _ => unreachable!("got {:?}: should have been a reply.", result1.get_action()),
         }
-        let msg2 = Message::new(name, Query::new());
+        let msg2 = Message::new(name.clone(), Query::new(name.clone()));
         queue.send(msg2.clone());
         let result2 = rx.recv_timeout(TIMEOUT).unwrap();
         assert_eq!(result2.get_message_id(), msg2.get_message_id());
@@ -861,6 +859,10 @@ mod document_files {
             }
         }
 
+        fn doc_name(&self) -> Name {
+            self.docdef.get_document_names()[0].clone()
+        }
+
         fn get_docdef(&self) -> &DocDef {
             &self.docdef
         }
@@ -967,10 +969,10 @@ mod document_files {
         let queue = test_doc.get_queue();
         let msg_actions = [
             MsgAction::Addition(Addition::new()),
-            MsgAction::Delete(Delete::new(Query::new())),
+            MsgAction::Delete(Delete::new(Query::internal())),
-            MsgAction::Query(Query::new().into()),
+            MsgAction::Query(Query::internal().into()),
             MsgAction::Show,
-            MsgAction::Update(Update::new(Query::new())),
+            MsgAction::Update(Update::new(Query::internal())),
         ];
         for msg_action in msg_actions.iter() {
             let msg = Message::new(name.clone(), msg_action.clone());
@@ -1019,10 +1021,10 @@ mod document_files {
         let msg_actions = [
             MsgAction::Addition(Addition::new()),
             MsgAction::Create(DocDef::new(name.clone())),
-            MsgAction::Delete(Delete::new(Query::new())),
+            MsgAction::Delete(Delete::new(Query::internal())),
-            MsgAction::Query(Query::new().into()),
+            MsgAction::Query(Query::internal().into()),
             MsgAction::Show,
-            MsgAction::Update(Update::new(Query::new())),
+            MsgAction::Update(Update::new(Query::internal())),
         ];
         let mut msgs: HashMap<Uuid, MsgAction> = HashMap::new();
         for msg_action in msg_actions.iter() {
@@ -1064,7 +1066,7 @@ mod document_files {
         for item in data.iter() {
             test_doc.populate([item.clone()].to_vec());
         }
-        let msg = Message::new(doc_name.clone(), Query::new());
+        let msg = Message::new(doc_name.clone(), Query::new(doc_name.clone()));
         queue.send(msg.clone());
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         assert_eq!(
@@ -1143,7 +1145,7 @@ mod document_files {
         for item in data.iter() {
             test_doc.populate([item.clone()].to_vec());
         }
-        let msg = Message::new(doc_name.clone(), Delete::new(Query::new()));
+        let msg = Message::new(doc_name.clone(), Delete::new(Query::internal()));
         queue.send(msg.clone());
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         assert_eq!(
@@ -1189,7 +1191,7 @@ mod document_files {
         for item in data.iter() {
             test_doc.populate([item.clone()].to_vec());
         }
-        let mut update = Update::new(Query::new());
+        let mut update = Update::new(Query::internal());
         update
             .get_values_mut()
             .add_field(field_name.clone(), Uuid::nil());
@@ -1251,7 +1253,7 @@ mod document_files {
             }
         };
         testing(Message::new(doc_name.clone(), new_doc));
-        testing(Message::new(doc_name.clone(), Query::new()));
+        testing(Message::new(doc_name.clone(), Query::new(doc_name.clone())));
     }
 
     #[test]
@@ -1270,7 +1272,7 @@ mod document_files {
             queue.send(Message::new(doc_name.clone(), new_doc));
             test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         }
-        queue.send(Message::new(doc_name, Query::new()));
+        queue.send(Message::new(doc_name.clone(), Query::new(doc_name.clone())));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
         let mut entries: HashSet<i128> = (0..count).collect();
@@ -1375,6 +1377,7 @@ mod document_files {
     #[test]
     fn does_query_return_related_entries() {
         let mut test_doc = TestDocument::new([FieldType::Integer].to_vec());
+        let doc_name = test_doc.get_docdef().get_document_names()[0].clone();
         test_doc.start(standard_paths());
         let queue = test_doc.get_queue();
         let count = 5;
@@ -1386,7 +1389,7 @@ mod document_files {
         calc.add_value(expected.clone()).unwrap();
         calc.add_value(CalcValue::Existing(FieldType::Integer))
             .unwrap();
-        let mut query = Query::new();
+        let mut query = Query::new(doc_name);
         query.add(Name::english("field0"), calc);
         queue.send(Message::new(
             test_doc.get_docdef().get_document_names()[0].clone(),
@@ -1414,6 +1417,7 @@ mod document_files {
     #[test]
     fn does_query_work_with_greater_than() {
         let mut test_doc = TestDocument::new([FieldType::Integer].to_vec());
+        let doc_name = test_doc.get_docdef().get_document_names()[0].clone();
         test_doc.start(standard_paths());
         let queue = test_doc.get_queue();
         test_doc.populate([1.into()].to_vec());
@@ -1422,7 +1426,7 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Integer))
             .unwrap();
         calc.add_value(1).unwrap();
-        let mut query = Query::new();
+        let mut query = Query::new(doc_name);
         query.add(Name::english("field0"), calc);
         queue.send(Message::new(
             test_doc.get_docdef().get_document_names()[0].clone(),
@@ -1449,6 +1453,7 @@ mod document_files {
     #[test]
     fn gets_all_documents_in_query() {
         let mut test_doc = TestDocument::new([FieldType::Integer].to_vec());
+        let doc_name = test_doc.get_docdef().get_document_names()[0].clone();
         test_doc.start(standard_paths());
         let queue = test_doc.get_queue();
         let data = 1;
@@ -1462,7 +1467,7 @@ mod document_files {
         calc.add_value(data.clone()).unwrap();
         calc.add_value(CalcValue::Existing(FieldType::Integer))
             .unwrap();
-        let mut query = Query::new();
+        let mut query = Query::new(doc_name);
         query.add(Name::english("field0"), calc);
         queue.send(Message::new(
             test_doc.get_docdef().get_document_names()[0].clone(),
@@ -1501,7 +1506,7 @@ mod document_files {
         for value in values.iter() {
             doc.populate(value.clone());
         }
-        let mut query = Query::new();
+        let mut query = Query::new(doc.doc_name());
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value("a").unwrap();
         calc.add_value(CalcValue::Existing(FieldType::StaticString))
@@ -1550,7 +1555,7 @@ mod document_files {
         for value in values.iter() {
             doc.populate(value.clone());
         }
-        let mut query = Query::new();
+        let mut query = Query::new(doc.doc_name());
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value("a").unwrap();
         calc.add_value(CalcValue::Existing(FieldType::StaticString))
@@ -1596,7 +1601,7 @@ mod document_files {
         for value in values.iter() {
             doc.populate(value.clone());
         }
-        let mut query = Query::new();
+        let mut query = Query::new(doc.doc_name());
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value("a").unwrap();
         calc.add_value(CalcValue::Existing(FieldType::StaticString))
@@ -1632,7 +1637,7 @@ mod document_files {
         let queue = doc.get_queue();
         let rx = doc.get_receiver();
         let field_name = Name::english("wrong");
-        let mut query = Query::new();
+        let mut query = Query::new(doc.doc_name());
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value("something").unwrap();
         query.add(field_name.clone(), calc);
@@ -1659,7 +1664,7 @@ mod document_files {
         doc.populate([Uuid::nil().into()].to_vec());
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value("notUUID").unwrap();
-        let mut query = Query::new();
+        let mut query = Query::new(doc.doc_name());
         query.add(Name::english("field0"), calc);
         doc.send(query);
         let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@@ -1778,7 +1783,7 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Uuid))
             .unwrap();
         calc.add_value(Uuid::nil()).unwrap();
-        let mut query = Query::new();
+        let mut query = Query::internal();
         query.add(Name::english("field0"), calc);
         let mut update = Update::new(query);
         update
@@ -1806,7 +1811,7 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Uuid))
             .unwrap();
         calc.add_value(id.clone()).unwrap();
-        let mut query = Query::new();
+        let mut query = Query::internal();
         query.add(Name::english("field0"), calc);
         let mut update = Update::new(query);
         update
@@ -1829,7 +1834,7 @@ mod document_files {
             }
         };
         testing(Message::new(doc_name.clone(), update));
-        testing(Message::new(doc_name.clone(), Query::new()));
+        testing(Message::new(doc_name.clone(), Query::new(doc_name.clone())));
     }
 
     #[test]
@@ -1849,7 +1854,7 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Integer))
             .unwrap();
         calc.add_value(picked.clone()).unwrap();
-        let mut query = Query::new();
+        let mut query = Query::internal();
         query.add(Name::english("field0"), calc);
         let mut update = Update::new(query);
         update
@@ -1869,7 +1874,7 @@ mod document_files {
             _ => unreachable!("got {:?}: should have gotten a reply", action),
         }
         doc.get_queue()
-            .send(Message::new(doc_name.clone(), Query::new()));
+            .send(Message::new(doc_name.clone(), Query::new(doc_name.clone())));
         let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
         match action {
@@ -1913,7 +1918,7 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Integer))
             .unwrap();
         calc.add_value(picked.clone()).unwrap();
-        let mut query = Query::new();
+        let mut query = Query::internal();
         query.add(Name::english("field0"), calc);
         let mut update = Update::new(query);
         update
@@ -1935,7 +1940,7 @@ mod document_files {
             }
         };
         testing(Message::new(doc_name.clone(), update));
-        testing(Message::new(doc_name.clone(), Query::new()));
+        testing(Message::new(doc_name.clone(), Query::new(doc_name.clone())));
     }
 
     #[test]
@@ -1947,7 +1952,7 @@ mod document_files {
         let new = "new";
         let bad_name = Name::english("wrong");
         doc.populate([id.into(), old.into()].to_vec());
-        let mut update = Update::new(Query::new());
+        let mut update = Update::new(Query::internal());
         update.get_values_mut().add_field(bad_name.clone(), new);
         doc.send(update);
         let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@@ -1974,7 +1979,7 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Uuid))
             .unwrap();
         calc.add_value(id.clone()).unwrap();
-        let mut query = Query::new();
+        let mut query = Query::internal();
         query.add(Name::english("field0"), calc);
         let mut update = Update::new(query);
         update
@@ -2012,7 +2017,7 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Integer))
             .unwrap();
         calc.add_value(old.clone()).unwrap();
-        let mut query = Query::new();
+        let mut query = Query::internal();
         query.add(Name::english("field0"), calc);
         let mut update = Update::new(query);
         update.get_values_mut().add_field(&fname, new);
@@ -2099,7 +2104,7 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::StaticString))
             .unwrap();
         calc.add_value(old).unwrap();
-        let mut query = Query::new();
+        let mut query = Query::internal();
         query.add(Name::english("field0"), calc);
         let mut update = Update::new(query);
         update.get_values_mut().add_field(fname.clone(), new);
@@ -2158,7 +2163,7 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::StaticString))
             .unwrap();
         calc.add_value(data).unwrap();
-        let mut query = Query::new();
+        let mut query = Query::internal();
         query.add(&f1name, calc);
         let mut update = Update::new(query);
         update.get_values_mut().add_field(&f0name, holder.clone());
@@ -2172,7 +2177,7 @@ mod document_files {
             },
             _ => unreachable!("got {:?}: should have gotten an error", action),
         }
-        let query = Query::new();
+        let query = Query::new(doc.doc_name());
         doc.send(query);
         let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
@@ -2234,7 +2239,7 @@ mod document_files {
         calc.add_value(1).unwrap();
         calc.add_value(CalcValue::Existing(FieldType::Integer))
             .unwrap();
-        let mut query = Query::new();
+        let mut query = Query::new(doc.doc_name());
         query.add(&fname, calc);
         let delete = Delete::new(query.clone());
         doc.send(delete);
@@ -2270,7 +2275,7 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Integer))
             .unwrap();
         calc.add_value(1).unwrap();
-        let mut query = Query::new();
+        let mut query = Query::internal();
         query.add(field_name.clone(), calc);
         let delete = Delete::new(query);
         doc.send(delete);
@@ -2295,7 +2300,7 @@ mod document_files {
             .unwrap();
         doc.start(standard_paths());
         doc.populate([value.into()].to_vec());
-        doc.send(Delete::new(Query::new()));
+        doc.send(Delete::new(Query::internal()));
         doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let mut addition = Addition::new();
         addition.add_field(&fname, value.clone());
@@ -2317,7 +2322,7 @@ mod document_files {
             Include::Just(doc_name.clone().into()),
             Include::Just(Action::OnQuery),
         );
-        let mut update = Update::new(Query::new());
+        let mut update = Update::new(Query::internal());
         let mut calc = Calculation::new(Operand::Add);
         calc.add_value(CalcValue::Existing(FieldType::Integer))
             .unwrap();
@@ -2330,14 +2335,14 @@ mod document_files {
         let mut paths = standard_paths();
         paths.push(Path::new(
             Include::All,
-            Include::Just(doc_name.into()),
+            Include::Just(doc_name.clone().into()),
             Include::Just(Action::OnUpdate),
         ));
         doc.start(paths);
         doc.populate([0.into()].to_vec());
         for i in 0..5 {
             let expected: Field = i.try_into().unwrap();
-            doc.send(Query::new());
+            doc.send(Query::new(doc_name.clone()));
             let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
             let action = result.get_action();
             match action {
@@ -2373,7 +2378,7 @@ mod document_files {
         calc.add_value(CalcValue::Existing(FieldType::Integer))
             .unwrap();
         calc.add_value(1).unwrap();
-        let mut query = Query::new();
+        let mut query = Query::internal();
         query.add(Name::english("field0"), calc);
         let delete = Delete::new(query.clone());
         let path = Path::new(
@@ -2400,7 +2405,7 @@ mod document_files {
         );
         queue.send(trigger.clone());
         sleep(TIMEOUT);
-        let msg = Message::new(doc_name, Query::new());
+        let msg = Message::new(doc_name.clone(), Query::new(doc_name.clone()));
         queue.send(msg.clone());
         let mut result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         while result.get_message_id() != msg.get_message_id() {

src/document/definition.rs

@@ -540,7 +540,7 @@ mod docdefs {
                 Include::Just(docname.clone().into()),
                 Include::Just(Action::OnQuery),
             ),
-            DocFuncType::Trigger(Update::new(Query::new()).into()),
+            DocFuncType::Trigger(Update::new(Query::new(docname.clone())).into()),
         );
         let path_action = docdef.iter_routes().last().unwrap();
         let path = path_action.path();

src/document/session.rs

@@ -17,7 +17,7 @@ use std::{sync::mpsc::channel, time::Duration};
 pub struct Session;
 
 impl Session {
-    fn doc_names() -> Vec<Name> {
+    pub fn doc_names() -> Vec<Name> {
         let mut names = Vec::new();
         names.push(Name::english("session"));
         names
@@ -40,7 +40,7 @@ impl Session {
         docdef.set_default(&name_expire, calc.clone()).unwrap();
         docdef.add_index(&name_expire, IndexType::Index).unwrap();
 
-        let mut update = Update::new(Query::new());
+        let mut update = Update::new(Query::internal());
         update
             .get_values_mut()
             .add_field(name_expire.clone(), calc.clone());
@@ -52,7 +52,7 @@ impl Session {
         let query_action = DocFuncType::ExistingQuery(update.into());
         docdef.add_route(path, query_action);
 
-        let mut delete_qry = Query::new();
+        let mut delete_qry = Query::internal();
         let mut delete_calc = Calculation::new(Operand::LessThan);
         delete_calc.add_value(FieldType::DateTime).unwrap();
         delete_calc
@@ -264,7 +264,7 @@ mod sessions {
         addition.add_field(Name::english("expire"), timestamp);
         setup.send(Setup::message(addition));
         setup.recv().unwrap();
-        let mut query = Query::new();
+        let mut query = Query::new(Session::doc_names()[0].clone());
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value(CalcValue::Existing(FieldType::Uuid))
             .unwrap();
@@ -326,7 +326,7 @@ mod sessions {
         setup.recv().unwrap(); // Eat addition result.
         setup.send(gen_clock_message());
         sleep(TIMEOUT); // Allow time to react to message.
-        setup.send(Setup::message(Query::new()));
+        setup.send(Setup::message(Query::new(Session::doc_names()[0].clone())));
         let result = setup.recv().unwrap();
         let action = result.get_action();
         match action {

src/lib.rs

@@ -5,11 +5,11 @@ mod mtterror;
 mod name;
 mod queue;
 
-use action::{Action, CalcValue, Calculation, DocDef, Field, FieldType, MsgAction, Operand, Query, UserAction};
+use action::{
+    Action, CalcValue, Calculation, DocDef, Field, FieldType, MsgAction, Operand, Query, UserAction,
+};
 use document::{clock::Clock, create::CreateDoc, session::Session};
 use message::wrapper::{Addition, Message};
-pub use mtterror::MTTError;
-pub use name::{Name, NameType};
 use queue::{
     data_director::{Include, Path, RegMsg, Register},
     router::Queue,
@@ -17,6 +17,9 @@ use queue::{
 use std::sync::mpsc::{channel, Receiver};
 use uuid::Uuid;
 
+pub use mtterror::MTTError;
+pub use name::{Name, NameType};
+
 #[cfg(test)]
 mod support_tests {
     use std::time::Duration;
@@ -71,7 +74,7 @@ impl MoreThanText {
         let action = match session {
             Some(data) => match Uuid::try_from(data.as_str()) {
                 Ok(id) => {
-                    let mut query = Query::new();
+                    let mut query = Query::new(Session::doc_names()[0].clone());
                     let mut calc = Calculation::new(Operand::Equal);
                     calc.add_value(CalcValue::Existing(FieldType::Uuid))
                         .unwrap();

src/message/wrapper.rs

@@ -112,7 +112,7 @@ mod messages {
     #[test]
     fn can_the_document_be_an_id() {
         let document = Uuid::new_v4();
-        let msg = Message::new(document.clone(), Query::new());
+        let msg = Message::new(document.clone(), Query::new(document.clone()));
         match msg.document_id {
             NameType::ID(data) => assert_eq!(data, document),
             _ => unreachable!("should have been an id"),
@@ -125,7 +125,8 @@ mod messages {
 
     #[test]
     fn do_messages_contain_routes() {
-        let mut msg = Message::new(Name::english("whatever"), Query::new());
+        let name = Name::english("whatever");
+        let mut msg = Message::new(name.clone(), Query::new(name.clone()));
         let default_route = msg.get_route();
         match default_route.msg_id {
             Include::Just(_) => unreachable!("should defalt to all"),
@@ -165,7 +166,7 @@ mod messages {
     fn is_the_message_id_random() {
         let mut ids: Vec<Uuid> = Vec::new();
         for _ in 0..5 {
-            let msg = Message::new(Name::english("tester"), Query::new());
+            let msg = Message::new(Name::english("tester"), Query::new(Name::english("test")));
             let id = msg.get_message_id().clone();
             assert!(!ids.contains(&id), "{:?} containts  {}", ids, id);
             ids.push(id);
@@ -175,7 +176,7 @@ mod messages {
     #[test]
     fn can_make_reply_message() {
         let name = Name::english("testing");
-        let msg = Message::new(name.clone(), Query::new());
+        let msg = Message::new(name.clone(), Query::new(name.clone()));
         let responce = Reply::new();
         let reply = msg.response(responce);
         assert_eq!(reply.get_message_id(), msg.get_message_id());
@@ -192,7 +193,7 @@ mod messages {
     #[test]
     fn can_make_error_message() {
         let name = Name::english("testing");
-        let msg = Message::new(name.clone(), Query::new());
+        let msg = Message::new(name.clone(), Query::new(name.clone()));
         let err_msg = Uuid::new_v4().to_string();
         let result = msg.response(MTTError::DocumentNotFound(err_msg.clone()));
         assert_eq!(result.get_message_id(), msg.get_message_id());
@@ -212,7 +213,7 @@ mod messages {
     #[test]
     fn can_make_a_response_message() {
         let doc_id = Uuid::new_v4();
-        let msg = Message::new(doc_id.clone(), Query::new());
+        let msg = Message::new(doc_id.clone(), Query::new(doc_id.clone()));
         let data = Uuid::new_v4().to_string();
         let result1 = msg.response(MTTError::DocumentNotFound(data.clone()));
         let result2 = msg.response(Reply::new());
@@ -330,7 +331,6 @@ mod additions {
     }
 }
 
-
 #[allow(dead_code)]
 #[derive(Clone, Debug)]
 pub struct Operation {

src/queue/router.rs

@@ -137,7 +137,7 @@ mod routers {
     fn can_pass_message() {
         let setup = Setup::new();
         let router = setup.get_router();
-        let msg = Message::new(Name::english("task"), Query::new());
+        let msg = Message::new(Name::english("task"), Query::new(Name::english("task")));
         router.send(msg.clone());
         let result = setup.recv().unwrap();
         assert_eq!(result.get_message_id(), msg.get_message_id());
@@ -154,7 +154,10 @@ mod routers {
             receivers.insert(id, rx);
         }
         for (id, recv) in receivers.iter() {
-            let msg = Message::new(Name::english(id.to_string().as_str()), Query::new());
+            let msg = Message::new(
+                Name::english(id.to_string().as_str()),
+                Query::new(Name::english(id.to_string().as_str())),
+            );
             router.forward(id, msg.clone());
             let result = recv.recv_timeout(TIMEOUT).unwrap();
             assert_eq!(result.get_message_id(), msg.get_message_id());
@@ -188,7 +191,7 @@ mod routers {
         router.remove_sender(&removed);
         let router = setup.get_router();
         let removed_recv = receivers.remove(&removed).unwrap();
-        router.forward(&removed, Message::new(NameType::None, Query::new()));
+        router.forward(&removed, Message::new(NameType::None, Query::internal()));
         match removed_recv.recv_timeout(TIMEOUT) {
             Err(err) => match err {
                 RecvTimeoutError::Disconnected => {}
@@ -209,7 +212,10 @@ mod routers {
             _ => unreachable!("got {:?}, should have been register", action),
         }
         for (id, recv) in receivers.iter() {
-            let msg = Message::new(Name::english(id.to_string().as_str()), Query::new());
+            let msg = Message::new(
+                Name::english(id.to_string().as_str()),
+                Query::new(Name::english(id.to_string().as_str())),
+            );
             router.forward(id, msg.clone());
             let result = recv.recv_timeout(TIMEOUT).unwrap();
             assert_eq!(result.get_message_id(), msg.get_message_id());