integration: add test for nested shorter tuples

This is similar to the existing test for shorter tuples, but:
1) it tests nested tuples to ensure that the logic works recursively,
2) it uses SerializeValueWithFakeType to create the shorter tuple
   representation, instead of using the `ALTER TABLE` trick.

Co-authored-by: Karol Baryła <[email protected]>

Author: wprzytula

scylla/tests/integration/types/cql_collections.rs

@@ -1,6 +1,6 @@
 use crate::utils::{
-    DeserializeOwnedValue, PerformDDL, create_new_session_builder, setup_tracing,
-    unique_keyspace_name,
+    DeserializeOwnedValue, PerformDDL, SerializeValueWithFakeType, create_new_session_builder,
+    setup_tracing, unique_keyspace_name,
 };
 use scylla::cluster::metadata::NativeType;
 use scylla::deserialize::value::DeserializeValue;
@@ -303,6 +303,46 @@ async fn test_alter_column_add_field_to_tuple() {
         .unwrap();
 }
 
+#[tokio::test]
+async fn test_cql_tuple_db_repr_shorter_than_metadata() {
+    use ColumnType::*;
+    use NativeType::*;
+
+    setup_tracing();
+    let session: Session = connect().await;
+
+    {
+        let table_name: &str = "test_cql_shorter_tuple_tab";
+        create_table(
+            &session,
+            table_name,
+            "tuple<tuple<int, text, int>, int, tuple<int>>",
+        )
+        .await;
+
+        // We craft a tuple that is shorter in DB representation than in metadata,
+        // and also contains another nested tuple with the same property.
+        // In order to do that, we use SerializeValueWithFakeType to lie about the type
+        // the value is being serialized to, so that tuple serialization logic does not complain.
+        let inner_tuple: (i32, String) = (1, "Ala".to_owned());
+        let inner_tuple_ser =
+            SerializeValueWithFakeType::new(inner_tuple, Tuple(vec![Native(Int), Native(Text)]));
+        let tuple: (SerializeValueWithFakeType<_>, i32) = (inner_tuple_ser, 2);
+        let tuple_ser = SerializeValueWithFakeType::new(
+            tuple,
+            Tuple(vec![Tuple(vec![Native(Int), Native(Text)]), Native(Int)]),
+        );
+        // The expected deserialized tuple has None for the missing elements.
+        let tuple_deser = ((1, "Ala".to_owned(), None::<i32>), 2, None::<(i32,)>);
+        insert_and_select(&session, table_name, &tuple_ser, &tuple_deser).await;
+    }
+
+    session
+        .ddl(format!("DROP KEYSPACE {}", session.get_keyspace().unwrap()))
+        .await
+        .unwrap();
+}
+
 // TODO: Remove this ignore when vector type is supported in ScyllaDB
 #[cfg_attr(not(cassandra_tests), ignore)]
 #[tokio::test]