add version check with mutex to skip tests in runtime

Signed-off-by: Adar Ovadia <adarov@amazon.com>

Author: Adar Ovadia

.github/workflows/redis-rs.yml

@@ -67,14 +67,7 @@ jobs:
             - name: Test
               # TODO remove the concurrency limit after we fix test flakyness.
               run: |
-                  smallest_version=$(printf "%s\n" "${{ matrix.engine.version }}" "8.0" | sort -V | head -n1)
-                  # Sort versions and get the smallest version between the current version and 8.0, if the version is small than 8.0, skip the test.
-                  if [[ "8.0" == "$smallest_version" ]]; then
-                      cargo test --release --features valkey-gte-8 -- --test-threads=1 | tee ../test-results.xml
-                  else
-                      cargo test --release -- --test-threads=1 | tee ../test-results.xml
-                  fi
-                      
+                  cargo test --release -- --test-threads=1 | tee ../test-results.xml
                   echo "### Tests passed :v:" >> $GITHUB_STEP_SUMMARY
               working-directory: ./glide-core/redis-rs/redis/src
 

glide-core/redis-rs/redis/Cargo.toml

@@ -99,6 +99,8 @@ uuid = { version = "1.6.1", optional = true }
 
 telemetrylib = { path = "../../telemetry" }
 
+lazy_static = "1"
+
 [features]
 default = [
     "acl",
@@ -153,7 +155,6 @@ bigdecimal = ["dep:bigdecimal"]
 num-bigint = []
 uuid = ["dep:uuid"]
 disable-client-setinfo = []
-valkey-gte-8 = []
 
 # Deprecated features
 tls = ["tls-native-tls"] # use "tls-native-tls" instead

glide-core/redis-rs/redis/tests/test_cluster_async.rs

@@ -2,6 +2,92 @@
 #![cfg(feature = "cluster-async")]
 mod support;
 
+use std::cell::Cell;
+use tokio::sync::Mutex;
+
+use lazy_static::lazy_static;
+
+lazy_static! {
+    static ref CLUSTER_VERSION: Mutex<Cell<usize>> = Mutex::<Cell<usize>>::default();
+}
+
+/// Check if the current cluster version is less than `min_version`.
+/// At first, the func check for the Valkey version and if none exists, then the Redis version is checked.
+async fn engine_version_less_than(min_version: &str) -> bool {
+    let test_version = crate::get_cluster_version().await;
+    let min_version_usize = crate::version_to_usize(min_version).unwrap();
+    if test_version < min_version_usize {
+        println!(
+            "The engine version is {:?}, which is lower than {:?}",
+            test_version, min_version
+        );
+        return true;
+    }
+    return false;
+}
+
+/// Static function to get the engine version. When version looks like 8.0.0 -> 80000 and 12.0.1 -> 120001.
+async fn get_cluster_version() -> usize {
+    let cluster_version = CLUSTER_VERSION.lock().await;
+    if cluster_version.get() == 0 {
+        let cluster = crate::support::TestClusterContext::new(3, 0);
+
+        let mut connection = cluster.async_connection(None).await;
+
+        let cmd = redis::cmd("INFO");
+        let info = connection
+            .route_command(
+                &cmd,
+                redis::cluster_routing::RoutingInfo::SingleNode(
+                    redis::cluster_routing::SingleNodeRoutingInfo::Random,
+                ),
+            )
+            .await
+            .unwrap();
+
+        let info_result = redis::from_owned_redis_value::<String>(info).unwrap();
+
+        cluster_version.set(
+            parse_version_from_info(info_result.clone())
+                .expect(format!("Invalid version string in INFO : {info_result}").as_str()),
+        );
+    }
+    return cluster_version.get();
+}
+
+fn parse_version_from_info(info: String) -> Option<usize> {
+    // check for valkey_version
+    if let Some(version) = info
+        .lines()
+        .find_map(|line| line.strip_prefix("valkey_version:"))
+    {
+        return version_to_usize(version);
+    }
+
+    // check for redis_version if no valkey_version was found
+    if let Some(version) = info
+        .lines()
+        .find_map(|line| line.strip_prefix("redis_version:"))
+    {
+        return version_to_usize(version);
+    }
+    None
+}
+
+/// Takes a version string (e.g., 8.2.1) and converts it to a usize (e.g., 80201)
+/// version 12.10.0 will became 121000
+fn version_to_usize(version: &str) -> Option<usize> {
+    version
+        .split('.')
+        .enumerate()
+        .map(|(index, part)| {
+            part.parse::<usize>()
+                .ok()
+                .map(|num| num * 10_usize.pow(2 * (2 - index) as u32))
+        })
+        .sum()
+}
+
 #[cfg(test)]
 mod cluster_async {
     use std::{
@@ -35,7 +121,6 @@ mod cluster_async {
     };
 
     use crate::support::*;
-
     use tokio::sync::mpsc;
     fn broken_pipe_error() -> RedisError {
         RedisError::from(std::io::Error::new(
@@ -121,9 +206,13 @@ mod cluster_async {
         .unwrap();
     }
 
-    #[cfg(feature = "valkey-gte-8")]
     #[tokio::test]
     async fn test_routing_by_slot_to_replica_with_az_affinity_strategy_to_half_replicas() {
+        // Skip test if version is less then Valkey 8.0
+        if crate::engine_version_less_than("8.0").await {
+            return;
+        }
+
         let replica_num: u16 = 4;
         let primaries_num: u16 = 3;
         let replicas_num_in_client_az = replica_num / 2;
@@ -213,9 +302,13 @@ mod cluster_async {
         );
     }
 
-    #[cfg(feature = "valkey-gte-8")]
     #[tokio::test]
     async fn test_routing_by_slot_to_replica_with_az_affinity_strategy_to_all_replicas() {
+        // Skip test if version is less then Valkey 8.0
+        if crate::engine_version_less_than("8.0").await {
+            return;
+        }
+
         let replica_num: u16 = 4;
         let primaries_num: u16 = 3;
         let cluster =