treewide: switch tests to use the new framework

This is a large commit which goes over all existing tests that haven't
been migrated in previous commits and adjusts them to use the new
deserialization framework.

There were lots of changes to be made, but they are mostly independent
from each other and very simple.

Author: wprzytula

scylla/src/history.rs

@@ -469,8 +469,8 @@ mod tests {
     use crate::test_utils::create_new_session_builder;
     use assert_matches::assert_matches;
     use chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime, Utc};
-    use futures::StreamExt;
-    use scylla_cql::Consistency;
+    use futures::StreamExt as _;
+    use scylla_cql::{frame::response::result::Row, Consistency};
 
     // Set a single time for all timestamps within StructuredHistory.
     // HistoryCollector sets the timestamp to current time which changes with each test.
@@ -917,7 +917,7 @@ mod tests {
     #[tokio::test]
     async fn successful_query_history() {
         setup_tracing();
-        let session = create_new_session_builder().build_legacy().await.unwrap();
+        let session = create_new_session_builder().build().await.unwrap();
 
         let mut query = Query::new("SELECT * FROM system.local");
         let history_collector = Arc::new(HistoryCollector::new());
@@ -984,7 +984,7 @@ mod tests {
     #[tokio::test]
     async fn failed_query_history() {
         setup_tracing();
-        let session = create_new_session_builder().build_legacy().await.unwrap();
+        let session = create_new_session_builder().build().await.unwrap();
 
         let mut query = Query::new("This isnt even CQL");
         let history_collector = Arc::new(HistoryCollector::new());
@@ -1021,7 +1021,7 @@ mod tests {
     #[tokio::test]
     async fn iterator_query_history() {
         setup_tracing();
-        let session = create_new_session_builder().build_legacy().await.unwrap();
+        let session = create_new_session_builder().build().await.unwrap();
         let ks = unique_keyspace_name();
         session
         .query_unpaged(format!("CREATE KEYSPACE {} WITH REPLICATION = {{'class' : 'NetworkTopologyStrategy', 'replication_factor' : 1}}", ks), &[])
@@ -1045,7 +1045,12 @@ mod tests {
         let history_collector = Arc::new(HistoryCollector::new());
         iter_query.set_history_listener(history_collector.clone());
 
-        let mut rows_iterator = session.query_iter(iter_query, ()).await.unwrap();
+        let mut rows_iterator = session
+            .query_iter(iter_query, ())
+            .await
+            .unwrap()
+            .rows_stream::<Row>()
+            .unwrap();
         while let Some(_row) = rows_iterator.next().await {
             // Receive rows...
         }

scylla/src/transport/authenticate_test.rs

@@ -16,7 +16,7 @@ async fn authenticate_superuser() {
     let session = crate::SessionBuilder::new()
         .known_node(uri)
         .user("cassandra", "cassandra")
-        .build_legacy()
+        .build()
         .await
         .unwrap();
     let ks = unique_keyspace_name();
@@ -75,7 +75,7 @@ async fn custom_authentication() {
     let session = crate::SessionBuilder::new()
         .known_node(uri)
         .authenticator_provider(Arc::new(CustomAuthenticatorProvider))
-        .build_legacy()
+        .build()
         .await
         .unwrap();
     let ks = unique_keyspace_name();

scylla/src/transport/caching_session.rs

@@ -460,7 +460,12 @@ mod tests {
             .unwrap()
             .into_stream();
 
-        let rows = iter.try_collect::<Vec<_>>().await.unwrap().len();
+        let rows = iter
+            .into_stream()
+            .try_collect::<Vec<_>>()
+            .await
+            .unwrap()
+            .len();
 
         assert_eq!(1, rows);
         assert_eq!(1, session.cache.len());

scylla/src/transport/connection.rs

@@ -2447,7 +2447,7 @@ mod tests {
             // Preparation phase
             let session = SessionBuilder::new()
                 .known_node_addr(addr)
-                .build_legacy()
+                .build()
                 .await
                 .unwrap();
             session.query_unpaged(format!("CREATE KEYSPACE IF NOT EXISTS {} WITH REPLICATION = {{'class' : 'NetworkTopologyStrategy', 'replication_factor' : 1}}", ks.clone()), &[]).await.unwrap();
@@ -2543,7 +2543,7 @@ mod tests {
             // Preparation phase
             let session = SessionBuilder::new()
                 .known_node_addr(addr)
-                .build_legacy()
+                .build()
                 .await
                 .unwrap();
             session.query_unpaged(format!("CREATE KEYSPACE IF NOT EXISTS {} WITH REPLICATION = {{'class' : 'NetworkTopologyStrategy', 'replication_factor' : 1}}", ks.clone()), &[]).await.unwrap();
@@ -2618,9 +2618,10 @@ mod tests {
                 .query_unpaged("SELECT p, v FROM t")
                 .await
                 .unwrap()
-                .into_legacy_result()
+                .into_rows_result()
                 .unwrap()
-                .rows_typed::<(i32, Vec<u8>)>()
+                .unwrap()
+                .rows::<(i32, Vec<u8>)>()
                 .unwrap()
                 .collect::<Result<Vec<_>, _>>()
                 .unwrap();

scylla/src/transport/cql_collections_test.rs

@@ -1,20 +1,22 @@
-use crate::cql_to_rust::FromCqlVal;
+use crate::transport::session::Session;
+use scylla_cql::types::deserialize::value::DeserializeValue;
+
+use crate::frame::response::result::CqlValue;
 use crate::test_utils::{create_new_session_builder, setup_tracing};
 use crate::utils::test_utils::unique_keyspace_name;
-use crate::{frame::response::result::CqlValue, LegacySession};
 use scylla_cql::types::serialize::value::SerializeValue;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 
-async fn connect() -> LegacySession {
-    let session = create_new_session_builder().build_legacy().await.unwrap();
+async fn connect() -> Session {
+    let session = create_new_session_builder().build().await.unwrap();
     let ks = unique_keyspace_name();
     session.query_unpaged(format!("CREATE KEYSPACE IF NOT EXISTS {} WITH REPLICATION = {{'class' : 'NetworkTopologyStrategy', 'replication_factor' : 1}}", ks), &[]).await.unwrap();
     session.use_keyspace(ks, false).await.unwrap();
 
     session
 }
 
-async fn create_table(session: &LegacySession, table_name: &str, value_type: &str) {
+async fn create_table(session: &Session, table_name: &str, value_type: &str) {
     session
         .query_unpaged(
             format!(
@@ -28,13 +30,13 @@ async fn create_table(session: &LegacySession, table_name: &str, value_type: &st
 }
 
 async fn insert_and_select<InsertT, SelectT>(
-    session: &LegacySession,
+    session: &Session,
     table_name: &str,
     to_insert: &InsertT,
     expected: &SelectT,
 ) where
     InsertT: SerializeValue,
-    SelectT: FromCqlVal<Option<CqlValue>> + PartialEq + std::fmt::Debug,
+    SelectT: for<'r> DeserializeValue<'r, 'r> + PartialEq + std::fmt::Debug,
 {
     session
         .query_unpaged(
@@ -48,7 +50,10 @@ async fn insert_and_select<InsertT, SelectT>(
         .query_unpaged(format!("SELECT val FROM {} WHERE p = 0", table_name), ())
         .await
         .unwrap()
-        .single_row_typed::<(SelectT,)>()
+        .into_rows_result()
+        .unwrap()
+        .unwrap()
+        .single_row::<(SelectT,)>()
         .unwrap()
         .0;
 
@@ -58,7 +63,7 @@ async fn insert_and_select<InsertT, SelectT>(
 #[tokio::test]
 async fn test_cql_list() {
     setup_tracing();
-    let session: LegacySession = connect().await;
+    let session: Session = connect().await;
 
     let table_name: &str = "test_cql_list_tab";
     create_table(&session, table_name, "list<int>").await;
@@ -91,7 +96,7 @@ async fn test_cql_list() {
 #[tokio::test]
 async fn test_cql_set() {
     setup_tracing();
-    let session: LegacySession = connect().await;
+    let session: Session = connect().await;
 
     let table_name: &str = "test_cql_set_tab";
     create_table(&session, table_name, "set<int>").await;
@@ -155,7 +160,7 @@ async fn test_cql_set() {
 #[tokio::test]
 async fn test_cql_map() {
     setup_tracing();
-    let session: LegacySession = connect().await;
+    let session: Session = connect().await;
 
     let table_name: &str = "test_cql_map_tab";
     create_table(&session, table_name, "map<int, int>").await;
@@ -206,7 +211,7 @@ async fn test_cql_map() {
 #[tokio::test]
 async fn test_cql_tuple() {
     setup_tracing();
-    let session: LegacySession = connect().await;
+    let session: Session = connect().await;
 
     let table_name: &str = "test_cql_tuple_tab";
     create_table(&session, table_name, "tuple<int, int, text>").await;