caching_session: modernize tests

Adjusts the CachingSession tests to use the new deserialization
interface.

Co-authored-by: Wojciech Przytuła <[email protected]>

Author: piodul

scylla/src/transport/caching_session.rs

@@ -314,22 +314,22 @@ where
 mod tests {
     use crate::query::Query;
     use crate::statement::PagingState;
-    use crate::test_utils::{
-        create_new_session_builder, scylla_supports_tablets_legacy, setup_tracing,
-    };
+    use crate::test_utils::{create_new_session_builder, scylla_supports_tablets, setup_tracing};
     use crate::transport::partitioner::PartitionerName;
+    use crate::transport::session::Session;
     use crate::utils::test_utils::unique_keyspace_name;
     use crate::{
         batch::{Batch, BatchStatement},
         prepared_statement::PreparedStatement,
-        LegacyCachingSession, LegacySession,
+        CachingSession,
     };
     use futures::TryStreamExt;
+    use scylla_cql::frame::response::result::Row;
     use std::collections::BTreeSet;
 
-    async fn new_for_test(with_tablet_support: bool) -> LegacySession {
+    async fn new_for_test(with_tablet_support: bool) -> Session {
         let session = create_new_session_builder()
-            .build_legacy()
+            .build()
             .await
             .expect("Could not create session");
         let ks = unique_keyspace_name();
@@ -338,7 +338,7 @@ mod tests {
             "CREATE KEYSPACE IF NOT EXISTS {ks}
         WITH REPLICATION = {{'class' : 'NetworkTopologyStrategy', 'replication_factor' : 1}}"
         );
-        if !with_tablet_support && scylla_supports_tablets_legacy(&session).await {
+        if !with_tablet_support && scylla_supports_tablets(&session).await {
             create_ks += " AND TABLETS = {'enabled': false}";
         }
 
@@ -366,8 +366,8 @@ mod tests {
         session
     }
 
-    async fn create_caching_session() -> LegacyCachingSession {
-        let session = LegacyCachingSession::from(new_for_test(true).await, 2);
+    async fn create_caching_session() -> CachingSession {
+        let session = CachingSession::from(new_for_test(true).await, 2);
 
         // Add a row, this makes it easier to check if the caching works combined with the regular execute fn on Session
         session
@@ -428,17 +428,20 @@ mod tests {
             .execute_unpaged("select * from test_table", &[])
             .await
             .unwrap();
+        let result_rows = result.into_rows_result().unwrap().unwrap();
 
         assert_eq!(1, session.cache.len());
-        assert_eq!(1, result.rows_num().unwrap());
+        assert_eq!(1, result_rows.rows_num());
 
         let result = session
             .execute_unpaged("select * from test_table", &[])
             .await
             .unwrap();
 
+        let result_rows = result.into_rows_result().unwrap().unwrap();
+
         assert_eq!(1, session.cache.len());
-        assert_eq!(1, result.rows_num().unwrap());
+        assert_eq!(1, result_rows.rows_num());
     }
 
     /// Checks that caching works with execute_iter
@@ -452,7 +455,10 @@ mod tests {
         let iter = session
             .execute_iter("select * from test_table", &[])
             .await
-            .unwrap();
+            .unwrap()
+            .rows_stream::<Row>()
+            .unwrap()
+            .into_stream();
 
         let rows = iter.try_collect::<Vec<_>>().await.unwrap().len();
 
@@ -474,18 +480,21 @@ mod tests {
             .unwrap();
 
         assert_eq!(1, session.cache.len());
-        assert_eq!(1, result.rows_num().unwrap());
+        assert_eq!(1, result.into_rows_result().unwrap().unwrap().rows_num());
     }
 
     async fn assert_test_batch_table_rows_contain(
-        sess: &LegacyCachingSession,
+        sess: &CachingSession,
         expected_rows: &[(i32, i32)],
     ) {
         let selected_rows: BTreeSet<(i32, i32)> = sess
             .execute_unpaged("SELECT a, b FROM test_batch_table", ())
             .await
             .unwrap()
-            .rows_typed::<(i32, i32)>()
+            .into_rows_result()
+            .unwrap()
+            .unwrap()
+            .rows::<(i32, i32)>()
             .unwrap()
             .map(|r| r.unwrap())
             .collect();
@@ -524,18 +533,18 @@ mod tests {
             }
         }
 
-        let _session: LegacyCachingSession<std::collections::hash_map::RandomState> =
-            LegacyCachingSession::from(new_for_test(true).await, 2);
-        let _session: LegacyCachingSession<CustomBuildHasher> =
-            LegacyCachingSession::from(new_for_test(true).await, 2);
-        let _session: LegacyCachingSession<CustomBuildHasher> =
-            LegacyCachingSession::with_hasher(new_for_test(true).await, 2, Default::default());
+        let _session: CachingSession<std::collections::hash_map::RandomState> =
+            CachingSession::from(new_for_test(true).await, 2);
+        let _session: CachingSession<CustomBuildHasher> =
+            CachingSession::from(new_for_test(true).await, 2);
+        let _session: CachingSession<CustomBuildHasher> =
+            CachingSession::with_hasher(new_for_test(true).await, 2, Default::default());
     }
 
     #[tokio::test]
     async fn test_batch() {
         setup_tracing();
-        let session: LegacyCachingSession = create_caching_session().await;
+        let session: CachingSession = create_caching_session().await;
 
         session
             .execute_unpaged(
@@ -658,8 +667,7 @@ mod tests {
     #[tokio::test]
     async fn test_parameters_caching() {
         setup_tracing();
-        let session: LegacyCachingSession =
-            LegacyCachingSession::from(new_for_test(true).await, 100);
+        let session: CachingSession = CachingSession::from(new_for_test(true).await, 100);
 
         session
             .execute_unpaged("CREATE TABLE tbl (a int PRIMARY KEY, b int)", ())
@@ -695,7 +703,11 @@ mod tests {
             .execute_unpaged("SELECT b, WRITETIME(b) FROM tbl", ())
             .await
             .unwrap()
-            .rows_typed_or_empty::<(i32, i64)>()
+            .into_rows_result()
+            .unwrap()
+            .unwrap()
+            .rows::<(i32, i64)>()
+            .unwrap()
             .collect::<Result<Vec<_>, _>>()
             .unwrap();
 
@@ -712,8 +724,7 @@ mod tests {
         }
 
         // This test uses CDC which is not yet compatible with Scylla's tablets.
-        let session: LegacyCachingSession =
-            LegacyCachingSession::from(new_for_test(false).await, 100);
+        let session: CachingSession = CachingSession::from(new_for_test(false).await, 100);
 
         session
             .execute_unpaged(

scylla/src/utils/test_utils.rs

@@ -1,6 +1,8 @@
+use scylla_cql::frame::response::result::Row;
+
 #[cfg(test)]
 use crate::transport::session_builder::{GenericSessionBuilder, SessionBuilderKind};
-use crate::LegacySession;
+use crate::{LegacySession, Session};
 #[cfg(test)]
 use std::{num::NonZeroU32, time::Duration};
 use std::{
@@ -106,6 +108,23 @@ pub async fn scylla_supports_tablets_legacy(session: &LegacySession) -> bool {
     result.single_row().is_ok()
 }
 
+pub async fn scylla_supports_tablets(session: &Session) -> bool {
+    let result = session
+        .query_unpaged(
+            "select column_name from system_schema.columns where
+                keyspace_name = 'system_schema'
+                and table_name = 'scylla_keyspaces'
+                and column_name = 'initial_tablets'",
+            &[],
+        )
+        .await
+        .unwrap()
+        .into_rows_result()
+        .unwrap();
+
+    result.map_or(false, |rows_result| rows_result.single_row::<Row>().is_ok())
+}
+
 #[cfg(test)]
 pub(crate) fn setup_tracing() {
     let _ = tracing_subscriber::fmt::fmt()