Completed field default settings.

src/message.rs

@@ -1240,17 +1240,40 @@ impl DocDef {
         }
     }
 
-    fn use_default_function(&mut self, field_name: &str) {
+    fn get_field_mut(&mut self, field_name: &str) -> Result<&mut FieldSetting, MTTError> {
-        let setting = self.fields.get_mut(field_name).unwrap();
+        match self.fields.get_mut(field_name) {
-        setting.set_default(DefaultSetting::FieldType);
+            Some(data) => Ok(data),
+            None => return Err(MTTError::DocumentFieldNotFound(field_name.to_string())),
+        }
     }
 
-    fn set_default_value<F>(&mut self, field_name: &str, value: F)
+    fn use_default_function(&mut self, field_name: &str) -> Result<(), MTTError> {
+        let setting = match self.get_field_mut(field_name) {
+            Ok(data) => data,
+            Err(err) => return Err(err),
+        };
+        setting.set_default(DefaultSetting::FieldType);
+        Ok(())
+    }
+
+    fn set_default_value<F>(&mut self, field_name: &str, value: F) -> Result<(), MTTError>
     where
         F: Into<Field>,
     {
-        let setting = self.fields.get_mut(field_name).unwrap();
+        let setting = match self.get_field_mut(field_name) {
-        setting.set_default(DefaultSetting::Value(value.into()));
+            Ok(data) => data,
+            Err(err) => return Err(err),
+        };
+        let data = value.into();
+        if setting.get_type() == &data.get_type() {
+            setting.set_default(DefaultSetting::Value(data));
+            Ok(())
+        } else {
+            Err(MTTError::DocumentFieldWrongDataType(
+                setting.get_type().clone(),
+                data.get_type(),
+            ))
+        }
     }
 
     fn iter(&self) -> impl Iterator<Item = (&String, &FieldSetting)> {
@@ -1311,6 +1334,49 @@ mod docdefs {
             _ => unreachable!("got {:?}: should have been field type", dset),
         }
     }
+
+    #[test]
+    fn does_set_default_function_error_on_bad_field_name() {
+        let mut docdef = DocDef::new();
+        let field_name = Uuid::new_v4().to_string();
+        match docdef.use_default_function(field_name.as_str()) {
+            Ok(_) => unreachable!("should be an error"),
+            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_default_value_error_on_bad_field_name() {
+        let mut docdef = DocDef::new();
+        let field_name = Uuid::new_v4().to_string();
+        match docdef.set_default_value(field_name.as_str(), Uuid::nil()) {
+            Ok(_) => unreachable!("should be an error"),
+            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_default_value_error_on_bad_field_type() {
+        let mut docdef = DocDef::new();
+        let name = "defaultvalue";
+        docdef.add_field(name.to_string(), FieldType::Uuid);
+        match docdef.set_default_value(name, "") {
+            Ok(_) => unreachable!("should be an error"),
+            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)]
@@ -2177,6 +2243,30 @@ mod document_files {
             _ => unreachable!("got {:?}: should have gotten a reply", action),
         }
     }
+
+    #[test]
+    fn can_default_values_be_overridden() {
+        let doc_name = "override";
+        let mut docdef = create_docdef([FieldType::Uuid].to_vec());
+        docdef.use_default_function("field0");
+        let (queue, rx) = test_doc(doc_name, docdef, standard_routes());
+        let mut new_doc = Addition::new();
+        new_doc.add_field("field0".to_string(), Uuid::nil());
+        let msg = Message::new(doc_name, new_doc);
+        queue.send(msg).unwrap();
+        let result = rx.recv_timeout(TIMEOUT).unwrap();
+        let action = result.get_action();
+        match action {
+            MsgAction::Reply(docs) => {
+                assert_eq!(docs.len(), 1);
+                let expected: Field = Uuid::nil().into();
+                for doc in docs.iter() {
+                    assert_eq!(doc.get_field("field0").unwrap(), &expected);
+                }
+            }
+            _ => unreachable!("got {:?}: should have gotten a reply", action),
+        }
+    }
 }
 
 #[cfg(test)]