diff --git a/src/message.rs b/src/message.rs
index b153e61..bf9f5ca 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -1674,13 +1674,18 @@ impl CreateDoc {
 
     fn start(mut queue: Queue) {
         let (tx, rx) = channel();
-        let routes = [RouteRequest::new(
+        let routes = [Path::new(
             Include::All,
             Include::All,
             Include::Some(Action::Create),
         )]
         .to_vec();
-        //let id = queue.register(tx, "document".to_string(), routes).unwrap();
+        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));
+            rx.recv().unwrap();
+        }
         let doc = CreateDoc::new(queue, rx);
         spawn(move || {
             doc.listen();
@@ -3816,9 +3821,16 @@ impl DocumentFile {
         let name = docdef.get_document_name();
         let id = queue.add_sender(tx);
         let reg_msg = Register::new(id, RegMsg::AddDocName(name.clone()));
-        let msg = Message::new(NameType::None, reg_msg.clone());
-        queue.send(msg.clone()).unwrap();
-        rx.recv().unwrap();
+        let rmsg = msg.response(reg_msg.clone());
+        queue.send(rmsg.clone()).unwrap();
+        let name_result = rx.recv().unwrap();
+        match name_result.get_action() {
+            MsgAction::Register(data) => match data.get_msg() {
+                RegMsg::Error(err) => queue.send(msg.response(err.clone())).unwrap(),
+                _ => {}
+            },
+            _ => unreachable!("should return registration"),
+        }
         let routes = [
             Path::new(
                 Include::All,
@@ -3848,7 +3860,7 @@ impl DocumentFile {
         ];
         for route in routes.iter() {
             let request = reg_msg.response(RegMsg::AddRoute(route.clone()));
-            let add_route = msg.response(request);
+            let add_route = rmsg.response(request);
             queue.send(add_route).unwrap();
             rx.recv().unwrap();
         }
@@ -4257,6 +4269,7 @@ mod document_files {
         test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
         let msg_actions = [
             MsgAction::Addition(Addition::new()),
+            MsgAction::Create(DocDef::new(name.clone())),
             MsgAction::Delete(Delete::new()),
             MsgAction::Query(Query::new()),
             MsgAction::Show,
@@ -5263,34 +5276,38 @@ mod createdocs {
     use super::support_test::TIMEOUT;
     use super::*;
 
-    fn setup_create_doc(routes: Vec<RouteRequest>) -> (Queue, Receiver<Message>) {
+    fn setup_create_doc() -> (Queue, Receiver<Message>) {
+        let routes = [
+            Path::new(Include::All, Include::All, Include::Some(Action::Reply)),
+            Path::new(Include::All, Include::All, Include::Some(Action::Records)),
+            Path::new(Include::All, Include::All, Include::Some(Action::Error)),
+        ]
+        .to_vec();
         let mut queue = Queue::new();
         let (tx, rx) = channel();
-        /*
-        queue
-            .register(tx, Uuid::new_v4().to_string(), routes)
-            .unwrap();
-        */
+        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));
+            rx.recv_timeout(TIMEOUT).unwrap();
+        }
         CreateDoc::start(queue.clone());
         (queue, rx)
     }
 
     #[test]
-    #[ignore]
     fn create_document_creation() {
         let name = Name::english("project");
-        let routes = [RouteRequest::new(
-            Include::All,
-            Include::All,
-            Include::Some(Action::Reply),
-        )]
-        .to_vec();
-        let (queue, rx) = setup_create_doc(routes);
-        let msg1 = Message::new(name.clone(), MsgAction::Create(DocDef::new(name.clone())));
+        let (queue, rx) = setup_create_doc();
+        let msg1 = Message::new(NameType::None, MsgAction::Create(DocDef::new(name.clone())));
         queue.send(msg1.clone()).unwrap();
         let result1 = rx.recv_timeout(TIMEOUT).unwrap();
-        assert_eq!(result1.get_message_id(), msg1.get_message_id());
-        assert_eq!(result1.get_document_id(), msg1.get_document_id());
+        assert_eq!(
+            result1.get_message_id(),
+            msg1.get_message_id(),
+            "received {:?} from create message.",
+            rx
+        );
         match result1.get_action() {
             MsgAction::Reply(_) => {}
             _ => unreachable!("got {:?}: should have been a reply.", result1.get_action()),
@@ -5301,32 +5318,26 @@ mod createdocs {
         assert_eq!(result2.get_message_id(), msg2.get_message_id());
         assert_eq!(result2.get_document_id(), msg2.get_document_id());
         match result2.get_action() {
-            MsgAction::Reply(_) => {}
+            MsgAction::Records(data) => assert_eq!(data.len(), 0),
             _ => unreachable!("got {:?}: should have been a reply.", result1.get_action()),
         }
     }
 
     #[test]
-    #[ignore]
     fn does_duplicates_generate_error() {
         let name = Name::english("duplicate");
-        let routes = [
-            RouteRequest::new(Include::All, Include::All, Include::Some(Action::Reply)),
-            RouteRequest::new(Include::All, Include::All, Include::Some(Action::Error)),
-        ]
-        .to_vec();
-        let (queue, rx) = setup_create_doc(routes);
-        let msg = Message::new(name.clone(), MsgAction::Create(DocDef::new(name.clone())));
-        queue.send(msg.clone()).unwrap();
+        let (queue, rx) = setup_create_doc();
+        let msg1 = Message::new(NameType::None, MsgAction::Create(DocDef::new(name.clone())));
+        let msg2 = Message::new(NameType::None, MsgAction::Create(DocDef::new(name.clone())));
+        queue.send(msg1.clone()).unwrap();
         rx.recv_timeout(TIMEOUT).unwrap();
-        queue.send(msg.clone()).unwrap();
+        queue.send(msg2.clone()).unwrap();
         let result = rx.recv_timeout(TIMEOUT).unwrap();
-        assert_eq!(result.get_message_id(), msg.get_message_id());
-        assert_eq!(result.get_document_id(), msg.get_document_id());
+        assert_eq!(result.get_message_id(), msg2.get_message_id());
         match result.get_action() {
             MsgAction::Error(err) => match err {
-                MTTError::DocumentAlreadyExists(data) => assert_eq!(data, &name.to_string()),
-                _ => unreachable!("got {:?}: should have been a reply.", err),
+                MTTError::NameDuplicate(data) => assert_eq!(data, &name),
+                _ => unreachable!("got {:?}: should have been a duplicate name", err),
             },
             _ => unreachable!("got {:?}: should have been a reply.", result.get_action()),
         }