Copy test utils into integration tests

As a small side change it changes "supports_feature" to use zero-copy
deserialization to &str.

Author: Lorak-mmk

scylla/src/utils/test_utils.rs

@@ -44,15 +44,15 @@ pub(crate) async fn supports_feature(session: &Session, feature: &str) -> bool {
         return false;
     }
 
-    let (features,): (Option<String>,) = session
+    let result = session
         .query_unpaged("SELECT supported_features FROM system.local", ())
         .await
         .unwrap()
         .into_rows_result()
-        .unwrap()
-        .single_row()
         .unwrap();
 
+    let (features,): (Option<&str>,) = result.single_row().unwrap();
+
     features
         .unwrap_or_default()
         .split(',')

scylla/tests/integration/utils.rs

@@ -1,8 +1,14 @@
 use futures::Future;
+use scylla::frame::response::result::Row;
+use scylla::transport::session_builder::{GenericSessionBuilder, SessionBuilderKind};
+use scylla::Session;
 use std::collections::HashMap;
 use std::env;
 use std::net::SocketAddr;
+use std::num::NonZeroU32;
 use std::str::FromStr;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use scylla_proxy::{Node, Proxy, ProxyError, RunningProxy, ShardAwareness};
 
@@ -14,6 +20,23 @@ pub(crate) fn setup_tracing() {
         .try_init();
 }
 
+static UNIQUE_COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+#[allow(unused)]
+pub(crate) fn unique_keyspace_name() -> String {
+    let cnt = UNIQUE_COUNTER.fetch_add(1, Ordering::SeqCst);
+    let name = format!(
+        "test_rust_{}_{}",
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs(),
+        cnt
+    );
+    println!("Unique name: {}", name);
+    name
+}
+
 pub(crate) async fn test_with_3_node_cluster<F, Fut>(
     shard_awareness: ShardAwareness,
     test: F,
@@ -63,3 +86,90 @@ where
 
     running_proxy.finish().await
 }
+
+#[allow(unused)]
+pub(crate) async fn supports_feature(session: &Session, feature: &str) -> bool {
+    // Cassandra doesn't have a concept of features, so first detect
+    // if there is the `supported_features` column in system.local
+
+    let meta = session.get_cluster_data();
+    let system_local = meta
+        .get_keyspace_info()
+        .get("system")
+        .unwrap()
+        .tables
+        .get("local")
+        .unwrap();
+
+    if !system_local.columns.contains_key("supported_features") {
+        return false;
+    }
+
+    let result = session
+        .query_unpaged("SELECT supported_features FROM system.local", ())
+        .await
+        .unwrap()
+        .into_rows_result()
+        .unwrap();
+
+    let (features,): (Option<&str>,) = result.single_row().unwrap();
+
+    features
+        .unwrap_or_default()
+        .split(',')
+        .any(|f| f == feature)
+}
+
+#[allow(unused)]
+pub(crate) 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();
+
+    result.is_ok_and(|rows_result| rows_result.single_row::<Row>().is_ok())
+}
+
+// Creates a generic session builder based on conditional compilation configuration
+// For SessionBuilder of DefaultMode type, adds localhost to known hosts, as all of the tests
+// connect to localhost.
+#[allow(unused)]
+pub(crate) fn create_new_session_builder() -> GenericSessionBuilder<impl SessionBuilderKind> {
+    let session_builder = {
+        #[cfg(not(scylla_cloud_tests))]
+        {
+            use scylla::SessionBuilder;
+
+            let uri = std::env::var("SCYLLA_URI").unwrap_or_else(|_| "127.0.0.1:9042".to_string());
+
+            SessionBuilder::new().known_node(uri)
+        }
+
+        #[cfg(scylla_cloud_tests)]
+        {
+            use scylla::transport::session_builder::CloudMode;
+            use scylla::CloudSessionBuilder;
+            use std::path::Path;
+
+            std::env::var("CLOUD_CONFIG_PATH")
+                .map(|config_path| CloudSessionBuilder::new(Path::new(&config_path)))
+                .expect("Failed to initialize CloudSessionBuilder")
+                .expect("CLOUD_CONFIG_PATH environment variable is missing")
+        }
+    };
+
+    // The reason why we enable so long waiting for TracingInfo is... Cassandra. (Yes, again.)
+    // In Cassandra Java Driver, the wait time for tracing info is 10 seconds, so here we do the same.
+    // However, as Scylla usually gets TracingInfo ready really fast (our default interval is hence 3ms),
+    // we stick to a not-so-much-terribly-long interval here.
+    session_builder
+        .tracing_info_fetch_attempts(NonZeroU32::new(200).unwrap())
+        .tracing_info_fetch_interval(Duration::from_millis(50))
+}