DeserializeValue: default_when_null tests

New tests are added for both flavours that show how the attribute
allows for successful deserialization when the field contains null and
the corresponding Rust type expects non-null value.

scylla-cql/src/types/deserialize/value.rs

@@ -2454,6 +2454,11 @@ pub(super) mod tests {
             self
         }
 
+        fn null_field(mut self) -> Self {
+            append_null(&mut self.buf);
+            self
+        }
+
         fn finalize(&self) -> Bytes {
             make_bytes(&self.buf)
         }
@@ -2482,6 +2487,7 @@ pub(super) mod tests {
             x: String,
             #[scylla(allow_missing)]
             b: Option<i32>,
+            #[scylla(default_when_null)]
             c: i64,
         }
 
@@ -2510,6 +2516,30 @@ pub(super) mod tests {
             );
         }
 
+        // The last two UDT field are missing in serialized form - it should treat it
+        // as if there were nulls at the end.
+        {
+            let udt = UdtSerializer::new()
+                .field("The quick brown fox".as_bytes())
+                .finalize();
+            let typ = udt_def_with_fields([
+                ("a", ColumnType::Text),
+                ("b", ColumnType::Int),
+                ("c", ColumnType::BigInt),
+            ]);
+
+            let udt = deserialize::<Udt<'_>>(&typ, &udt).unwrap();
+            assert_eq!(
+                udt,
+                Udt {
+                    a: "The quick brown fox",
+                    x: String::new(),
+                    b: None,
+                    c: 0,
+                }
+            );
+        }
+
         // UDT fields switched - should still work.
         {
             let udt = UdtSerializer::new()
@@ -2535,6 +2565,25 @@ pub(super) mod tests {
             );
         }
 
+        // Only field 'a' is present
+        {
+            let udt = UdtSerializer::new()
+                .field("The quick brown fox".as_bytes())
+                .finalize();
+            let typ = udt_def_with_fields([("a", ColumnType::Text), ("c", ColumnType::BigInt)]);
+
+            let udt = deserialize::<Udt<'_>>(&typ, &udt).unwrap();
+            assert_eq!(
+                udt,
+                Udt {
+                    a: "The quick brown fox",
+                    x: String::new(),
+                    b: None,
+                    c: 0,
+                }
+            );
+        }
+
         // Wrong column type
         {
             let typ = udt_def_with_fields([("a", ColumnType::Text)]);
@@ -2553,6 +2602,7 @@ pub(super) mod tests {
         #[derive(scylla_macros::DeserializeValue, PartialEq, Eq, Debug)]
         #[scylla(crate = "crate", enforce_order, forbid_excess_udt_fields)]
         struct Udt<'a> {
+            #[scylla(default_when_null)]
             a: &'a str,
             #[scylla(skip)]
             x: String,
@@ -2638,6 +2688,25 @@ pub(super) mod tests {
                 }
             );
         }
+
+        // The first field is null, but `default_when_null` prevents failure.
+        {
+            let udt = UdtSerializer::new()
+                .null_field()
+                .field(&42i32.to_be_bytes())
+                .finalize();
+            let typ = udt_def_with_fields([("a", ColumnType::Text), ("b", ColumnType::Int)]);
+
+            let udt = deserialize::<Udt<'_>>(&typ, &udt).unwrap();
+            assert_eq!(
+                udt,
+                Udt {
+                    a: "",
+                    x: String::new(),
+                    b: Some(42),
+                }
+            );
+        }
     }
 
     #[test]
@@ -3305,6 +3374,7 @@ pub(super) mod tests {
                 x: String,
                 #[scylla(allow_missing)]
                 b: Option<i32>,
+                #[scylla(default_when_null)]
                 c: bool,
             }