macros: add tests for {Ser,De}Value macros integration

As those macros are complex and feature many switches and flavors,
tests are added that verify that when a UDT struct is derived both
SerializeValue and DeserializeValue:
- attributes are parsed correctly and trait impls are generated without
  errors,
- after serialization and deserialization, the result is what is
  expected.

Author: wprzytula

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

@@ -1950,7 +1950,7 @@ impl From<UdtDeserializationErrorKind> for BuiltinDeserializationErrorKind {
 
 #[cfg(test)]
 #[path = "value_tests.rs"]
-pub(super) mod tests;
+pub(crate) mod tests;
 
 /// ```compile_fail
 ///

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

@@ -585,7 +585,7 @@ fn test_tuples() {
     );
 }
 
-fn udt_def_with_fields(
+pub(crate) fn udt_def_with_fields(
     fields: impl IntoIterator<Item = (impl Into<Cow<'static, str>>, ColumnType<'static>)>,
 ) -> ColumnType<'static> {
     ColumnType::UserDefinedType {
@@ -1044,7 +1044,7 @@ fn test_custom_type_parser() {
     assert_eq!(tup, SwappedPair("foo", 42));
 }
 
-fn deserialize<'frame, 'metadata, T>(
+pub(crate) fn deserialize<'frame, 'metadata, T>(
     typ: &'metadata ColumnType<'metadata>,
     bytes: &'frame Bytes,
 ) -> Result<T, DeserializationError>

scylla-cql/src/types/mod.rs

@@ -1,2 +1,5 @@
 pub mod deserialize;
 pub mod serialize;
+
+#[cfg(test)]
+mod types_tests;

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

@@ -1594,7 +1594,7 @@ mod doctests {
 }
 
 #[cfg(test)]
-mod tests {
+pub(crate) mod tests {
     use std::collections::BTreeMap;
 
     use crate::frame::response::result::{ColumnType, CqlValue};
@@ -1654,7 +1654,7 @@ mod tests {
         t.serialize(typ, writer).map(|_| ()).map(|()| ret)
     }
 
-    fn do_serialize<T: SerializeValue>(t: T, typ: &ColumnType) -> Vec<u8> {
+    pub(crate) fn do_serialize<T: SerializeValue>(t: T, typ: &ColumnType) -> Vec<u8> {
         do_serialize_result(t, typ).unwrap()
     }
 

scylla-cql/src/types/types_tests.rs

@@ -0,0 +1,152 @@
+mod derive_macros_integration {
+    mod value {
+        use bytes::Bytes;
+
+        use crate::frame::response::result::ColumnType;
+        use crate::types::deserialize::value::tests::{deserialize, udt_def_with_fields};
+        use crate::types::serialize::value::tests::do_serialize;
+
+        #[test]
+        fn derive_serialize_and_deserialize_value_loose_ordering() {
+            #[derive(
+                scylla_macros::DeserializeValue, scylla_macros::SerializeValue, PartialEq, Eq, Debug,
+            )]
+            #[scylla(crate = "crate")]
+            struct Udt<'a> {
+                a: &'a str,
+                #[scylla(skip)]
+                x: String,
+                #[scylla(allow_missing)]
+                b: Option<i32>,
+                #[scylla(default_when_null)]
+                c: i64,
+            }
+
+            let original_udt = Udt {
+                a: "The quick brown fox",
+                x: String::from("THIS SHOULD NOT BE (DE)SERIALIZED"),
+                b: Some(42),
+                c: 2137,
+            };
+
+            let tests = [
+                // All fields present
+                (
+                    udt_def_with_fields([
+                        ("a", ColumnType::Text),
+                        ("b", ColumnType::Int),
+                        ("c", ColumnType::BigInt),
+                    ]),
+                    Udt {
+                        x: String::new(),
+                        ..original_udt
+                    },
+                ),
+                //
+                // One field missing:
+                // - ignored during serialization,
+                // - default-initialized during deserialization.
+                (
+                    udt_def_with_fields([("a", ColumnType::Text), ("c", ColumnType::BigInt)]),
+                    Udt {
+                        x: String::new(),
+                        b: None,
+                        ..original_udt
+                    },
+                ),
+                //
+                // UDT fields switched - should still work.
+                (
+                    udt_def_with_fields([
+                        ("b", ColumnType::Int),
+                        ("a", ColumnType::Text),
+                        ("c", ColumnType::BigInt),
+                    ]),
+                    Udt {
+                        x: String::new(),
+                        ..original_udt
+                    },
+                ),
+            ];
+            for (typ, expected_udt) in tests {
+                let serialized_udt = Bytes::from(do_serialize(&original_udt, &typ));
+                let deserialized_udt = deserialize::<Udt<'_>>(&typ, &serialized_udt).unwrap();
+
+                assert_eq!(deserialized_udt, expected_udt);
+            }
+        }
+
+        #[test]
+        fn derive_serialize_and_deserialize_value_strict_ordering() {
+            #[derive(
+                scylla_macros::DeserializeValue, scylla_macros::SerializeValue, PartialEq, Eq, Debug,
+            )]
+            #[scylla(crate = "crate", flavor = "enforce_order")]
+            struct Udt<'a> {
+                #[scylla(allow_missing)]
+                #[scylla(default_when_null)]
+                a: &'a str,
+                #[scylla(skip)]
+                x: String,
+                #[scylla(allow_missing)]
+                b: Option<i32>,
+            }
+
+            let original_udt = Udt {
+                a: "The quick brown fox",
+                x: String::from("THIS SHOULD NOT BE (DE)SERIALIZED"),
+                b: Some(42),
+            };
+
+            let tests = [
+                // All fields present
+                (
+                    udt_def_with_fields([("a", ColumnType::Text), ("b", ColumnType::Int)]),
+                    Udt {
+                        x: String::new(),
+                        ..original_udt
+                    },
+                ),
+                //
+                // An excess field at the end of UDT
+                (
+                    udt_def_with_fields([
+                        ("a", ColumnType::Text),
+                        ("b", ColumnType::Int),
+                        ("d", ColumnType::Boolean),
+                    ]),
+                    Udt {
+                        x: String::new(),
+                        ..original_udt
+                    },
+                ),
+                //
+                // Missing non-required fields
+                (
+                    udt_def_with_fields([("a", ColumnType::Text)]),
+                    Udt {
+                        x: String::new(),
+                        b: None,
+                        ..original_udt
+                    },
+                ),
+                //
+                // An excess field at the end of UDT instead of non-required fields
+                (
+                    udt_def_with_fields([("d", ColumnType::Boolean)]),
+                    Udt {
+                        x: String::new(),
+                        a: "",
+                        b: None,
+                    },
+                ),
+            ];
+            for (typ, expected_udt) in tests {
+                let serialized_udt = Bytes::from(do_serialize(&original_udt, &typ));
+                let deserialized_udt = deserialize::<Udt<'_>>(&typ, &serialized_udt).unwrap();
+
+                assert_eq!(deserialized_udt, expected_udt);
+            }
+        }
+    }
+}