test: metadata does not bound deserialized values

This commit introduced a test, whose goal is to assert in compile time
(by satisfying the borrow checker) that deserialized values are not
bound by the lifetime of the metadata (the column type).

Author: wprzytula

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

@@ -1,5 +1,6 @@
 use assert_matches::assert_matches;
 use bytes::{BufMut, Bytes, BytesMut};
+use scylla_macros::DeserializeValue;
 use uuid::Uuid;
 
 use std::borrow::Cow;
@@ -1960,3 +1961,76 @@ fn test_udt_errors() {
         }
     }
 }
+
+#[test]
+fn metadata_does_not_bound_deserialized_values() {
+    /* It's important to understand what is a _deserialized value_. It's not just
+     * an implementor of DeserializeValue; there are some implementors of DeserializeValue
+     * who are not yet final values, but partially deserialized types that support further
+     * deserialization - _value deserializers_, such as `ListlikeIterator` or `UdtIterator`.
+     * _Value deserializers_, because they still need to deserialize some value, are naturally
+     * bound by 'metadata lifetime. However, _values_ are completely deserialized, so they
+     * should not be bound by 'metadata - only by 'frame. This test asserts that.
+     */
+
+    // We don't care about the actual deserialized data - all `Err`s is OK.
+    // This test's goal is only to compile, asserting that lifetimes are correct.
+    let bytes = Bytes::new();
+
+    // By this binding, we require that the deserialized values live longer than metadata.
+    let _decoded_results = {
+        // Metadata's lifetime is limited to this scope.
+
+        // blob
+        let blob_typ = ColumnType::Blob;
+        let decoded_blob_res = deserialize::<&[u8]>(&blob_typ, &bytes);
+
+        // str
+        let str_typ = ColumnType::Ascii;
+        let decoded_str_res = deserialize::<&str>(&str_typ, &bytes);
+
+        // list
+        let list_typ = ColumnType::List(Box::new(ColumnType::Ascii));
+        let decoded_vec_str_res = deserialize::<Vec<&str>>(&list_typ, &bytes);
+        let decoded_vec_string_res = deserialize::<Vec<String>>(&list_typ, &bytes);
+
+        // set
+        let set_typ = ColumnType::Set(Box::new(ColumnType::Ascii));
+        let decoded_set_str_res = deserialize::<HashSet<&str>>(&set_typ, &bytes);
+        let decoded_set_string_res = deserialize::<HashSet<String>>(&set_typ, &bytes);
+
+        // map
+        let map_typ = ColumnType::Map(Box::new(ColumnType::Ascii), Box::new(ColumnType::Int));
+        let decoded_map_str_int_res = deserialize::<HashMap<&str, i32>>(&map_typ, &bytes);
+
+        // UDT
+        let udt_typ = ColumnType::UserDefinedType {
+            type_name: "udt".into(),
+            keyspace: "ks".into(),
+            field_types: vec![
+                ("bytes".into(), ColumnType::Blob),
+                ("text".into(), ColumnType::Text),
+            ],
+        };
+        #[derive(DeserializeValue)]
+        #[scylla(crate=crate)]
+        struct Udt<'frame> {
+            #[allow(dead_code)]
+            bytes: &'frame [u8],
+            #[allow(dead_code)]
+            text: &'frame str,
+        }
+        let decoded_udt_res = deserialize::<Udt>(&udt_typ, &bytes);
+
+        (
+            decoded_blob_res,
+            decoded_str_res,
+            decoded_vec_str_res,
+            decoded_vec_string_res,
+            decoded_set_str_res,
+            decoded_set_string_res,
+            decoded_map_str_int_res,
+            decoded_udt_res,
+        )
+    };
+}