serde: Add test for empty_string_as_none with absent field

crates/ruma-serde/Cargo.toml

@@ -23,3 +23,4 @@ serde_json = { version = "1.0.61", features = ["raw_value"] }
 
 [dev-dependencies]
 matches = "0.1.8"
+ruma-identifiers = { path = "../ruma-identifiers" }

crates/ruma-serde/tests/empty_strings.rs

@@ -1,33 +1,106 @@
-use serde::{Deserialize, Serialize};
+mod string {
-use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
+    use serde::{Deserialize, Serialize};
+    use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
 
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-struct StringStruct {
+    struct StringStruct {
-    #[serde(
+        #[serde(
-        deserialize_with = "ruma_serde::empty_string_as_none",
+            default,
-        serialize_with = "ruma_serde::none_as_empty_string"
+            deserialize_with = "ruma_serde::empty_string_as_none",
-    )]
+            serialize_with = "ruma_serde::none_as_empty_string"
-    x: Option<String>,
+        )]
+        x: Option<String>,
+    }
+
+    #[test]
+    fn none_se() {
+        let decoded = StringStruct { x: None };
+        let encoded = json!({ "x": "" });
+        assert_eq!(to_json_value(decoded).unwrap(), encoded);
+    }
+
+    #[test]
+    fn some_se() {
+        let decoded = StringStruct { x: Some("foo".into()) };
+        let encoded = json!({ "x": "foo" });
+        assert_eq!(to_json_value(decoded).unwrap(), encoded);
+    }
+
+    #[test]
+    fn absent_de() {
+        let encoded = json!({});
+        let decoded = StringStruct { x: None };
+        assert_eq!(from_json_value::<StringStruct>(encoded).unwrap(), decoded);
+    }
+
+    #[test]
+    fn empty_de() {
+        let encoded = json!({ "x": "" });
+        let decoded = StringStruct { x: None };
+        assert_eq!(from_json_value::<StringStruct>(encoded).unwrap(), decoded);
+    }
+
+    #[test]
+    fn some_de() {
+        let encoded = json!({ "x": "foo" });
+        let decoded = StringStruct { x: Some("foo".into()) };
+        assert_eq!(from_json_value::<StringStruct>(encoded).unwrap(), decoded);
+    }
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
+mod user {
-struct NoneStruct {
+    use ruma_identifiers::{user_id, UserId};
-    #[serde(skip_serializing_if = "Option::is_none")]
+    use serde::{Deserialize, Serialize};
-    x: Option<String>,
+    use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
-}
 
-#[test]
+    const CARL: &str = "@carl:example.com";
-fn empty_se() {
-    let string = StringStruct { x: None };
-    let none = NoneStruct { x: None };
-    assert_eq!(to_json_value(string).unwrap(), json!({"x": ""}));
-    assert_eq!(to_json_value(none).unwrap(), json!({}));
-}
 
-#[test]
+    fn carl() -> UserId {
-fn empty_de() {
+        user_id!("@carl:example.com")
-    let string = StringStruct { x: None };
+    }
-    let none = NoneStruct { x: None };
+
-    assert_eq!(from_json_value::<StringStruct>(json!({"x": ""})).unwrap(), string);
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    assert_eq!(from_json_value::<NoneStruct>(json!({})).unwrap(), none);
+    struct User {
+        #[serde(
+            default,
+            deserialize_with = "ruma_serde::empty_string_as_none",
+            serialize_with = "ruma_serde::none_as_empty_string"
+        )]
+        x: Option<UserId>,
+    }
+
+    #[test]
+    fn none_se() {
+        let decoded = User { x: None };
+        let encoded = json!({ "x": "" });
+        assert_eq!(to_json_value(decoded).unwrap(), encoded);
+    }
+
+    #[test]
+    fn some_se() {
+        let decoded = User { x: Some(carl()) };
+        let encoded = json!({ "x": CARL });
+        assert_eq!(to_json_value(decoded).unwrap(), encoded);
+    }
+
+    #[test]
+    fn absent_de() {
+        let encoded = json!({});
+        let decoded = User { x: None };
+        assert_eq!(from_json_value::<User>(encoded).unwrap(), decoded);
+    }
+
+    #[test]
+    fn empty_de() {
+        let encoded = json!({ "x": "" });
+        let decoded = User { x: None };
+        assert_eq!(from_json_value::<User>(encoded).unwrap(), decoded);
+    }
+
+    #[test]
+    fn some_de() {
+        let encoded = json!({ "x": CARL });
+        let decoded = User { x: Some(carl()) };
+        assert_eq!(from_json_value::<User>(encoded).unwrap(), decoded);
+    }
 }