diff --git a/src/message.rs b/src/message.rs
index 6f0756a..fe43dca 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -1350,14 +1350,23 @@ impl DocDef {
     }
 
     fn set_unique(&mut self, field_name: &str) -> Result<(), MTTError> {
-        let setting = self.get_field_mut(field_name).unwrap();
+        let setting = match self.get_field_mut(field_name) {
+            Ok(data) => data,
+            Err(err) => return Err(err),
+        };
         setting.set_unique();
         Ok(())
     }
 
     fn use_unique_value(&mut self, field_name: &str, field: Field) -> Result<(), MTTError> {
-        let setting = self.get_field_mut(field_name).unwrap();
-        setting.use_unique_value(field);
+        let setting = match self.get_field_mut(field_name) {
+            Ok(data) => data,
+            Err(err) => return Err(err),
+        };
+        match setting.check(Some(field.clone())) {
+            Ok(data) => setting.use_unique_value(field),
+            Err(err) => return Err(err),
+        }
         Ok(())
     }
 
@@ -1470,6 +1479,50 @@ mod docdefs {
             },
         }
     }
+
+    #[test]
+    fn does_set_unique_error_on_bad_field_name() {
+        let mut docdef = DocDef::new();
+        let field_name = "bad";
+        match docdef.set_unique(field_name) {
+            Ok(data) => unreachable!("got {:?}, should be an error", data),
+            Err(err) => match err {
+                MTTError::DocumentFieldNotFound(data) => assert_eq!(data, field_name),
+                _ => unreachable!("got {:?}: should have been field not found", err),
+            },
+        }
+    }
+
+    #[test]
+    fn does_set_unique_value_error_on_bad_field_name() {
+        let mut docdef = DocDef::new();
+        let field_name = "wrong";
+        match docdef.use_unique_value(field_name, "".into()) {
+            Ok(data) => unreachable!("got {:?}, should be an error", data),
+            Err(err) => match err {
+                MTTError::DocumentFieldNotFound(data) => assert_eq!(data, field_name),
+                _ => unreachable!("got {:?}: should have been field not found", err),
+            },
+        }
+    }
+
+    #[test]
+    fn does_set_unique_value_error_on_bad_field_type() {
+        let mut docdef = DocDef::new();
+        let field_name = "unique";
+        docdef.add_field(field_name.to_string(), FieldType::Uuid);
+        docdef.set_unique(field_name).unwrap();
+        match docdef.use_unique_value(field_name, "".into()) {
+            Ok(data) => unreachable!("got {:?}, should be an error", data),
+            Err(err) => match err {
+                MTTError::DocumentFieldWrongDataType(expected, got) => {
+                    assert_eq!(expected, FieldType::Uuid);
+                    assert_eq!(got, FieldType::StaticString);
+                }
+                _ => unreachable!("got {:?}: should have been field not found", err),
+            },
+        }
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -2702,6 +2755,30 @@ mod document_files {
             _ => unreachable!("got {:?}: should have gotten an error", action),
         }
     }
+
+    fn unique_value_remains_available_if_failure_occurs() {
+        let (mut docdef, doc_name) = create_docdef([FieldType::Uuid, FieldType::Uuid].to_vec());
+        docdef.set_unique("field0");
+        let (queue, rx) = test_doc(doc_name.as_str(), docdef, standard_routes());
+        let field0 = Uuid::new_v4();
+        let mut bad_addition = Addition::new();
+        bad_addition.add_field("field0".to_string(), field0.clone());
+        bad_addition.add_field("field1".to_string(), "");
+        let msg = Message::new(doc_name.clone(), bad_addition.clone());
+        queue.send(msg).unwrap();
+        rx.recv_timeout(TIMEOUT).unwrap();
+        let mut good_addition = Addition::new();
+        good_addition.add_field("field0".to_string(), field0.clone());
+        good_addition.add_field("field1".to_string(), field0.clone());
+        let msg = Message::new(doc_name.clone(), bad_addition.clone());
+        queue.send(msg).unwrap();
+        let result = rx.recv_timeout(TIMEOUT).unwrap();
+        let action = result.get_action();
+        match action {
+            MsgAction::Reply(_) => {}
+            _ => unreachable!("got {:?}: should have gotten a reply", action),
+        }
+    }
 }
 
 #[cfg(test)]