Removed document id from message.

src/document/clock.rs

@@ -26,17 +26,11 @@ impl Clock {
         vec![Name::english("clock")]
     }
 
-    /*
-    fn get_name() -> Name {
-        Name::english("clock")
-    }
-    */
-
     fn gen_message() -> Message {
-        Message::new(
-            Clock::doc_names()[0].clone(),
-            MsgAction::OnUpdate(Records::new(Clock::doc_names(), Names::new())),
-        )
+        Message::new(MsgAction::OnUpdate(Records::new(
+            Clock::doc_names(),
+            Names::new(),
+        )))
     }
 
     pub fn get_path() -> Path {
@@ -52,7 +46,7 @@ impl Clock {
         let (tx, rx) = channel();
         let id = queue.add_sender(tx);
         let reg_msg = Register::new(id, RegMsg::AddDocName(Clock::doc_names()));
-        let msg = Message::new(NameType::None, reg_msg.clone());
+        let msg = Message::new(reg_msg.clone());
         queue.send(msg);
         rx.recv().unwrap();
         spawn(move || {
@@ -94,7 +88,7 @@ mod clocks {
             id.clone(),
             RegMsg::AddRoute(Path::new(Include::All, Include::All, Include::All)),
         );
-        queue.send(Message::new(NameType::None, request));
+        queue.send(Message::new(request));
         rx.recv_timeout(TIMEOUT).unwrap();
         let mut holder: Vec<Message> = Vec::new();
         let start = Utc::now();
@@ -106,7 +100,7 @@ mod clocks {
         assert!((end - start) > TimeDelta::seconds(1));
         assert!((end - start) < TimeDelta::seconds(2));
         let reg_request = Register::new(id, RegMsg::GetNameID(Clock::doc_names()[0].clone()));
-        queue.send(Message::new(NameType::None, reg_request));
+        queue.send(Message::new(reg_request));
         rx.recv_timeout(TIMEOUT).unwrap();
         for msg in holder.iter() {
             let action = msg.get_action();

src/document/create.rs

@@ -44,7 +44,7 @@ impl CreateDoc {
         let id = queue.add_sender(tx);
         for route in routes.iter() {
             let regmsg = Register::new(id.clone(), RegMsg::AddRoute(route.clone()));
-            queue.send(Message::new(NameType::None, regmsg));
+            queue.send(Message::new(regmsg));
             rx.recv().unwrap();
         }
         let doc = CreateDoc::new(queue, rx);
@@ -96,7 +96,7 @@ mod createdocs {
         fn register_paths(&self, paths: Vec<Path>) {
             for path in paths.iter() {
                 let regmsg = Register::new(self.rx_id.clone(), RegMsg::AddRoute(path.clone()));
-                self.queue.send(Message::new(NameType::None, regmsg));
+                self.queue.send(Message::new(regmsg));
                 self.rx.recv_timeout(TIMEOUT).unwrap();
             }
         }
@@ -114,7 +114,7 @@ mod createdocs {
         let queue = doc_creator.get_queue();
         let rx = doc_creator.get_receiver();
         let name = Name::english("project");
-        let msg1 = Message::new(NameType::None, MsgAction::Create(DocDef::new(name.clone())));
+        let msg1 = Message::new(MsgAction::Create(DocDef::new(name.clone())));
         queue.send(msg1.clone());
         let result1 = rx.recv_timeout(TIMEOUT).unwrap();
         assert_eq!(
@@ -127,7 +127,7 @@ mod createdocs {
             MsgAction::Reply(_) => {}
             _ => unreachable!("got {:?}: should have been a reply.", result1.get_action()),
         }
-        let msg2 = Message::new(name.clone(), Query::new(name.clone()));
+        let msg2 = Message::new(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());
@@ -150,8 +150,8 @@ mod createdocs {
         let queue = doc_creator.get_queue();
         let rx = doc_creator.get_receiver();
         let name = Name::english("duplicate");
-        let msg1 = Message::new(NameType::None, MsgAction::Create(DocDef::new(name.clone())));
-        let msg2 = Message::new(NameType::None, MsgAction::Create(DocDef::new(name.clone())));
+        let msg1 = Message::new(MsgAction::Create(DocDef::new(name.clone())));
+        let msg2 = Message::new(MsgAction::Create(DocDef::new(name.clone())));
         queue.send(msg1.clone());
         queue.send(msg2.clone());
         let result = rx.recv_timeout(TIMEOUT).unwrap();
@@ -920,20 +920,17 @@ mod document_files {
         where
             A: Into<MsgAction>,
         {
-            let msg = Message::new(self.docdef.get_document_names()[0].clone(), action);
+            let msg = Message::new(action);
             self.queue.send(msg);
         }
 
         fn start(&mut self, routes: Vec<Path>) {
-            let msg = Message::new(
-                self.docdef.get_document_names()[0].clone(),
-                self.docdef.clone(),
-            );
+            let msg = Message::new(self.docdef.clone());
             DocumentFile::start(self.queue.clone(), msg);
             for route in routes.iter() {
                 let request =
                     Register::new(self.sender_id.clone(), RegMsg::AddRoute(route.clone()));
-                let add_route = Message::new(NameType::None, request);
+                let add_route = Message::new(request);
                 self.queue.send(add_route);
                 self.rx.recv().unwrap();
             }
@@ -982,7 +979,7 @@ mod document_files {
         let alt = Name::english("alternate");
         test_doc.start(standard_paths());
         let docdef = DocDef::new(alt);
-        let msg = Message::new(name.clone(), docdef);
+        let msg = Message::new(docdef);
         test_doc.get_queue().send(msg);
         match test_doc.get_receiver().recv_timeout(TIMEOUT) {
             Ok(msg) => unreachable!("should not receive: {:?}", msg),
@@ -1008,7 +1005,7 @@ mod document_files {
             MsgAction::Update(Update::new(name.clone())),
         ];
         for msg_action in msg_actions.iter() {
-            let msg = Message::new(name.clone(), msg_action.clone());
+            let msg = Message::new(msg_action.clone());
             queue.send(msg.clone());
             let result = match test_doc.get_receiver().recv_timeout(TIMEOUT) {
                 Ok(data) => data.clone(),
@@ -1048,7 +1045,7 @@ mod document_files {
             test_doc.get_sender_id(),
             RegMsg::AddDocName([alt.clone()].to_vec()),
         );
-        let setup = Message::new(NameType::None, reg_msg.clone());
+        let setup = Message::new(reg_msg.clone());
         queue.send(setup);
         test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let msg_actions = [
@@ -1061,7 +1058,7 @@ mod document_files {
         ];
         let mut msgs: HashMap<Uuid, MsgAction> = HashMap::new();
         for msg_action in msg_actions.iter() {
-            let msg = Message::new(alt.clone(), msg_action.clone());
+            let msg = Message::new(msg_action.clone());
             msgs.insert(msg.get_message_id().clone(), msg_action.clone());
             queue.send(msg);
         }
@@ -1099,7 +1096,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(doc_name.clone()));
+        let msg = Message::new(Query::new(doc_name.clone()));
         queue.send(msg.clone());
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         assert_eq!(
@@ -1138,7 +1135,7 @@ mod document_files {
         test_doc.start(routes);
         let mut add = Addition::new(doc_name.clone());
         add.add_field(field_name.clone(), data.clone());
-        let msg = Message::new(doc_name.clone(), add);
+        let msg = Message::new(add);
         queue.send(msg.clone());
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         assert_eq!(
@@ -1178,7 +1175,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(doc_name.clone()));
+        let msg = Message::new(Delete::new(doc_name.clone()));
         queue.send(msg.clone());
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         assert_eq!(
@@ -1228,7 +1225,7 @@ mod document_files {
         update
             .get_values_mut()
             .add_field(field_name.clone(), Uuid::nil());
-        let msg = Message::new(doc_name.clone(), update);
+        let msg = Message::new(update);
         queue.send(msg.clone());
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         assert_eq!(
@@ -1285,8 +1282,8 @@ mod document_files {
                 ),
             }
         };
-        testing(Message::new(doc_name.clone(), new_doc));
-        testing(Message::new(doc_name.clone(), Query::new(doc_name.clone())));
+        testing(Message::new(new_doc));
+        testing(Message::new(Query::new(doc_name.clone())));
     }
 
     #[test]
@@ -1302,10 +1299,10 @@ mod document_files {
         for i in 0..count {
             let mut new_doc = Addition::new(doc_name.clone());
             new_doc.add_field(name.clone(), i);
-            queue.send(Message::new(doc_name.clone(), new_doc));
+            queue.send(Message::new(new_doc));
             test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         }
-        queue.send(Message::new(doc_name.clone(), Query::new(doc_name.clone())));
+        queue.send(Message::new(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();
@@ -1345,10 +1342,7 @@ mod document_files {
         let name = Name::english("bad");
         let mut addition = Addition::new(test_doc.doc_name());
         addition.add_field(name.clone(), "doesn't matter");
-        queue.send(Message::new(
-            test_doc.get_docdef().get_document_names()[0].clone(),
-            addition,
-        ));
+        queue.send(Message::new(addition));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         match result.get_action() {
             MsgAction::Error(err) => match err.error_id() {
@@ -1366,10 +1360,7 @@ mod document_files {
         let queue = test_doc.get_queue();
         let mut addition = Addition::new(test_doc.doc_name());
         addition.add_field(Name::english("field0"), "string");
-        queue.send(Message::new(
-            test_doc.get_docdef().get_document_names()[0].clone(),
-            addition,
-        ));
+        queue.send(Message::new(addition));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         match result.get_action() {
             MsgAction::Error(err) => match err.error_id() {
@@ -1390,10 +1381,7 @@ mod document_files {
         let queue = test_doc.get_queue();
         let mut addition = Addition::new(test_doc.doc_name());
         addition.add_field(Name::english("field0"), 1);
-        queue.send(Message::new(
-            test_doc.get_docdef().get_document_names()[0].clone(),
-            addition,
-        ));
+        queue.send(Message::new(addition));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         match result.get_action() {
             MsgAction::Error(err) => match err.error_id() {
@@ -1421,10 +1409,7 @@ mod document_files {
             .unwrap();
         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(),
-            query,
-        ));
+        queue.send(Message::new(query));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
         match action {
@@ -1458,10 +1443,7 @@ mod document_files {
         calc.add_value(1).unwrap();
         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(),
-            query,
-        ));
+        queue.send(Message::new(query));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
         match action {
@@ -1499,10 +1481,7 @@ mod document_files {
             .unwrap();
         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(),
-            query,
-        ));
+        queue.send(Message::new(query));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
         match action {
@@ -1671,7 +1650,7 @@ mod document_files {
         let mut calc = Calculation::new(Operand::Equal);
         calc.add_value("something").unwrap();
         query.add(field_name.clone(), calc);
-        let msg = Message::new(doc_name, query);
+        let msg = Message::new(query);
         queue.send(msg);
         let result = rx.recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
@@ -1722,7 +1701,7 @@ mod document_files {
         let queue = test_doc.get_queue();
         let rx = test_doc.get_receiver();
         let new_doc = Addition::new(doc_name.clone());
-        let msg = Message::new(doc_name, new_doc);
+        let msg = Message::new(new_doc);
         queue.send(msg);
         let result = rx.recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
@@ -1750,7 +1729,7 @@ mod document_files {
         let queue = test_doc.get_queue();
         let rx = test_doc.get_receiver();
         let new_doc = Addition::new(doc_name.clone());
-        let msg = Message::new(doc_name, new_doc);
+        let msg = Message::new(new_doc);
         queue.send(msg);
         let result = rx.recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
@@ -1779,7 +1758,7 @@ mod document_files {
         let rx = test_doc.get_receiver();
         let mut new_doc = Addition::new(doc_name.clone());
         new_doc.add_field(&field_name, Uuid::nil());
-        let msg = Message::new(doc_name, new_doc);
+        let msg = Message::new(new_doc);
         queue.send(msg);
         let result = rx.recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
@@ -1863,8 +1842,8 @@ mod document_files {
                 _ => unreachable!("got {:?}: should have gotten a reply", action),
             }
         };
-        testing(Message::new(doc_name.clone(), update));
-        testing(Message::new(doc_name.clone(), Query::new(doc_name.clone())));
+        testing(Message::new(update));
+        testing(Message::new(Query::new(doc_name.clone())));
     }
 
     #[test]
@@ -1890,7 +1869,7 @@ mod document_files {
         update
             .get_values_mut()
             .add_field(Name::english("field1"), new);
-        doc.get_queue().send(Message::new(doc_name.clone(), update));
+        doc.get_queue().send(Message::new(update));
         let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
         match action {
@@ -1904,7 +1883,7 @@ mod document_files {
             _ => unreachable!("got {:?}: should have gotten a reply", action),
         }
         doc.get_queue()
-            .send(Message::new(doc_name.clone(), Query::new(doc_name.clone())));
+            .send(Message::new(Query::new(doc_name.clone())));
         let result = doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let action = result.get_action();
         match action {
@@ -1969,8 +1948,8 @@ mod document_files {
                 _ => unreachable!("got {:?}: should have gotten a reply", action),
             }
         };
-        testing(Message::new(doc_name.clone(), update));
-        testing(Message::new(doc_name.clone(), Query::new(doc_name.clone())));
+        testing(Message::new(update));
+        testing(Message::new(Query::new(doc_name.clone())));
     }
 
     #[test]
@@ -2428,13 +2407,13 @@ mod document_files {
         for item in 1..3 {
             doc.populate([item.into()].to_vec());
         }
-        let trigger = Message::new(
-            Name::english("clock"),
-            MsgAction::OnUpdate(Records::new(Clock::doc_names(), Names::new())),
-        );
+        let trigger = Message::new(MsgAction::OnUpdate(Records::new(
+            Clock::doc_names(),
+            Names::new(),
+        )));
         queue.send(trigger.clone());
         sleep(TIMEOUT);
-        let msg = Message::new(doc_name.clone(), Query::new(doc_name.clone()));
+        let msg = Message::new(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/session.rs

@@ -65,7 +65,7 @@ impl Session {
 
         let (tx, rx) = channel();
         let sender_id = queue.add_sender(tx);
-        let msg = Message::new(NameType::None, docdef);
+        let msg = Message::new(docdef);
         let msg_id = msg.get_message_id().clone();
         let path = Path::new(
             Include::Just(msg_id),
@@ -132,7 +132,7 @@ mod sessions {
             ];
             for path in paths.iter() {
                 let reg = Register::new(id.clone(), RegMsg::AddRoute(path.clone()));
-                queue.send(Message::new(NameType::None, reg));
+                queue.send(Message::new(reg));
                 rx.recv_timeout(TIMEOUT).unwrap();
             }
             Self {
@@ -146,7 +146,7 @@ mod sessions {
         where
             A: Into<MsgAction>,
         {
-            Message::new(Session::doc_names()[0].clone(), action)
+            Message::new(action)
         }
 
         fn recv(&self) -> Result<Message, RecvTimeoutError> {
@@ -159,7 +159,7 @@ mod sessions {
 
         fn send_registry_message(&self, msg: RegMsg) {
             let request = Register::new(self.sender_id.clone(), msg);
-            self.queue.send(Message::new(NameType::None, request));
+            self.queue.send(Message::new(request));
         }
     }
 

src/lib.rs

@@ -92,7 +92,7 @@ impl MoreThanText {
             None => new_session,
         };
         let doc_name = Name::english("session");
-        let msg = Message::new(doc_name.clone(), action.clone());
+        let msg = Message::new(action.clone());
         let msg_id = msg.get_message_id();
         let path = Path::new(
             Include::Just(msg_id.clone()),

src/message/wrapper.rs

@@ -1,3 +1,4 @@
+use super::MessageAction;
 use crate::{
     action::{CalcValue, Field, FieldType, MsgAction, Operand, Query, Reply},
     mtterror::{ErrorID, MTTError},
@@ -9,19 +10,30 @@ use std::{
     collections::{HashMap, HashSet},
     time::Duration,
 };
-use super::MessageAction;
 use uuid::Uuid;
 
 #[derive(Clone, Debug)]
 pub struct Message {
     msg_id: Uuid,
-    document_id: NameType,
+    // document_id: NameType,
     action: MsgAction,
     route: Route,
     // session: Option<?>
 }
 
 impl Message {
+    pub fn new<A>(action: A) -> Self
+    where
+        A: Into<MsgAction>,
+    {
+        Self {
+            msg_id: Uuid::new_v4(),
+            action: action.into(),
+            route: Route::default(),
+        }
+    }
+
+    /*
     pub fn new<D, A>(doc_id: D, action: A) -> Self
     where
         D: Into<NameType>,
@@ -34,6 +46,7 @@ impl Message {
             route: Route::default(),
         }
     }
+    */
 
     pub fn get_message_id(&self) -> &Uuid {
         &self.msg_id
@@ -65,7 +78,6 @@ impl Message {
     {
         Self {
             msg_id: self.msg_id.clone(),
-            document_id: self.document_id.clone(),
             action: action.into(),
             route: Route::default(),
         }
@@ -78,7 +90,6 @@ impl Message {
     {
         Self {
             msg_id: self.msg_id.clone(),
-            document_id: doc_id.into(),
             action: action.into(),
             route: Route::default(),
         }
@@ -94,14 +105,7 @@ mod messages {
     fn can_the_document_be_a_named_reference() {
         let dts = [Name::english("one"), Name::english("two")];
         for document in dts.into_iter() {
-            let msg = Message::new(
-                document.clone(),
-                MsgAction::Create(DocDef::new(document.clone())),
-            );
-            match &msg.document_id {
-                NameType::Name(data) => assert_eq!(data, &document),
-                _ => unreachable!("should have been a string id"),
-            }
+            let msg = Message::new(MsgAction::Create(DocDef::new(document.clone())));
             match msg.get_action() {
                 MsgAction::Create(_) => {}
                 _ => unreachable!("should have been a create document"),
@@ -112,11 +116,7 @@ mod messages {
     #[test]
     fn can_the_document_be_an_id() {
         let document = Uuid::new_v4();
-        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"),
-        }
+        let msg = Message::new(Query::new(document.clone()));
         match msg.get_action() {
             MsgAction::Query(_) => {}
             _ => unreachable!("should have been an access query"),
@@ -126,7 +126,7 @@ mod messages {
     #[test]
     fn do_messages_contain_routes() {
         let name = Name::english("whatever");
-        let mut msg = Message::new(name.clone(), Query::new(name.clone()));
+        let mut msg = Message::new(Query::new(name.clone()));
         let default_route = msg.get_route();
         match default_route.msg_id {
             Include::Just(_) => unreachable!("should defalt to all"),
@@ -166,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(Name::english("test")));
+            let msg = Message::new(Query::new(Name::english("test")));
             let id = msg.get_message_id().clone();
             assert!(!ids.contains(&id), "{:?} containts  {}", ids, id);
             ids.push(id);
@@ -176,14 +176,10 @@ mod messages {
     #[test]
     fn can_make_reply_message() {
         let name = Name::english("testing");
-        let msg = Message::new(name.clone(), Query::new(name.clone()));
+        let msg = Message::new(Query::new(name.clone()));
         let responce = Reply::new(Name::english("something"));
         let reply = msg.response(responce);
         assert_eq!(reply.get_message_id(), msg.get_message_id());
-        match &reply.document_id {
-            NameType::Name(data) => assert_eq!(data, &name),
-            _ => unreachable!("should have been a name"),
-        }
         match reply.get_action() {
             MsgAction::Reply(_) => {}
             _ => unreachable!("should have been a reply"),
@@ -193,14 +189,10 @@ mod messages {
     #[test]
     fn can_make_error_message() {
         let name = Name::english("testing");
-        let msg = Message::new(name.clone(), Query::new(name.clone()));
+        let msg = Message::new(Query::new(name.clone()));
         let err_msg = Uuid::new_v4().to_string();
         let result = msg.response(MTTError::new(NameType::None, ErrorID::DocumentNotFound));
         assert_eq!(result.get_message_id(), msg.get_message_id());
-        match &result.document_id {
-            NameType::Name(data) => assert_eq!(data, &name),
-            _ => unreachable!("should have been a name"),
-        }
         match result.get_action() {
             MsgAction::Error(data) => match data.error_id() {
                 ErrorID::DocumentNotFound => {}
@@ -213,14 +205,12 @@ mod messages {
     #[test]
     fn can_make_a_response_message() {
         let doc_id = Uuid::new_v4();
-        let msg = Message::new(doc_id.clone(), Query::new(doc_id.clone()));
+        let msg = Message::new(Query::new(doc_id.clone()));
         let data = Uuid::new_v4().to_string();
         let result1 = msg.response(MTTError::new(NameType::None, ErrorID::DocumentNotFound));
         let result2 = msg.response(Reply::new(NameType::None));
         assert_eq!(result1.get_message_id(), msg.get_message_id());
         assert_eq!(result2.get_message_id(), msg.get_message_id());
-        assert_eq!(result1.document_id, msg.document_id);
-        assert_eq!(result2.document_id, msg.document_id);
         let action1 = result1.get_action();
         match action1 {
             MsgAction::Error(err) => match err.error_id() {

src/queue/router.rs

@@ -36,9 +36,7 @@ impl Router {
 
     fn remove_sender(&mut self, id: &Uuid) {
         let action = Register::new(Uuid::nil(), RegMsg::RemoveSender(id.clone()));
-        self.doc_registry
-            .send(Message::new(NameType::None, action))
-            .unwrap();
+        self.doc_registry.send(Message::new(action)).unwrap();
         self.senders.remove(id);
     }
 
@@ -137,7 +135,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(Name::english("task")));
+        let msg = Message::new(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,10 +152,7 @@ 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(Name::english(id.to_string().as_str())),
-            );
+            let msg = Message::new(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());
@@ -191,7 +186,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::internal()));
+        router.forward(&removed, Message::new(Query::internal()));
         match removed_recv.recv_timeout(TIMEOUT) {
             Err(err) => match err {
                 RecvTimeoutError::Disconnected => {}
@@ -212,10 +207,7 @@ 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(Name::english(id.to_string().as_str())),
-            );
+            let msg = Message::new(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());
@@ -276,7 +268,7 @@ mod queues {
 
         fn send_reg_msg(&self, msg: RegMsg) {
             let reg_msg = Register::new(self.rx_id.clone(), msg);
-            self.test_mod.send(Message::new(NameType::None, reg_msg));
+            self.test_mod.send(Message::new(reg_msg));
         }
 
         fn recv(&self) -> Result<Message, RecvTimeoutError> {