Upgrade redis-rs dependency. (#994)

* ++redis-rs.

* Fix transactions not being routed.

Transactions without user routing were routed to a random node, and so almost by default caused a MOVED error and slot refresh.
`req_packed_commands` finds the right routing for the transaction.

* Fix python exception tests.

Longer error messages are shortened by pytest, so we need to use match instead of asserting over the string.

glide-core/src/client/mod.rs

@@ -7,6 +7,7 @@ use crate::connection_request::{
 use crate::scripts_container::get_script;
 use futures::FutureExt;
 use logger_core::log_info;
+use redis::aio::ConnectionLike;
 use redis::cluster_async::ClusterConnection;
 use redis::cluster_routing::{RoutingInfo, SingleNodeRoutingInfo};
 use redis::RedisResult;
@@ -206,14 +207,12 @@ impl Client {
                     client.send_pipeline(pipeline, offset, 1).await
                 }
 
-                ClientWrapper::Cluster { ref mut client } => {
-                    let route = match routing {
-                        Some(RoutingInfo::SingleNode(route)) => route,
-                        _ => SingleNodeRoutingInfo::Random,
-                    };
-
-                    client.route_pipeline(pipeline, offset, 1, route).await
-                }
+                ClientWrapper::Cluster { ref mut client } => match routing {
+                    Some(RoutingInfo::SingleNode(route)) => {
+                        client.route_pipeline(pipeline, offset, 1, route).await
+                    }
+                    _ => client.req_packed_commands(pipeline, offset, 1).await,
+                },
             }?;
 
             Self::get_transaction_values(pipeline, values, command_count, offset)

glide-core/tests/test_client.rs

@@ -7,8 +7,10 @@ mod utilities;
 pub(crate) mod shared_client_tests {
     use super::*;
     use glide_core::client::Client;
-    use redis::RedisConnectionInfo;
-    use redis::Value;
+    use redis::{
+        cluster_routing::{MultipleNodeRoutingInfo, RoutingInfo},
+        FromRedisValue, InfoDict, RedisConnectionInfo, Value,
+    };
     use rstest::rstest;
     use utilities::cluster::*;
     use utilities::BackingServer;
@@ -75,6 +77,85 @@ pub(crate) mod shared_client_tests {
         });
     }
 
+    #[rstest]
+    #[timeout(SHORT_CLUSTER_TEST_TIMEOUT)]
+    fn test_pipeline_is_not_routed() {
+        // This test checks that a transaction without user routing isn't routed to a random node before reaching its target.
+        // This is tested by checking how many requests each node has received - one of the 6 nodes should have more requests than the others.
+        block_on_all(async {
+            let mut test_basics = setup_test_basics(
+                true,
+                TestConfiguration {
+                    use_tls: false,
+                    shared_server: true,
+                    ..Default::default()
+                },
+            )
+            .await;
+
+            // reset stats on all connections
+            let mut cmd = redis::cmd("CONFIG");
+            cmd.arg("RESETSTAT");
+            let _ = test_basics
+                .client
+                .send_command(
+                    &cmd,
+                    Some(RoutingInfo::MultiNode((
+                        MultipleNodeRoutingInfo::AllNodes,
+                        None,
+                    ))),
+                )
+                .await
+                .unwrap();
+
+            // Send a keyed transaction
+            let key = generate_random_string(6);
+            let mut pipe = redis::pipe();
+            pipe.cmd("GET").arg(key);
+            pipe.atomic();
+            let _ = test_basics
+                .client
+                .send_transaction(&pipe, None)
+                .await
+                .unwrap();
+
+            // Gather info from each server
+            let mut cmd = redis::cmd("INFO");
+            cmd.arg("STATS");
+            let values = test_basics
+                .client
+                .send_command(
+                    &cmd,
+                    Some(RoutingInfo::MultiNode((
+                        MultipleNodeRoutingInfo::AllNodes,
+                        None,
+                    ))),
+                )
+                .await
+                .unwrap();
+
+            let mut values: Vec<_> = match values {
+                Value::Map(map) => map.into_iter().filter_map(|(_, value)| {
+                    InfoDict::from_owned_redis_value(value)
+                        .unwrap()
+                        .get::<u32>("total_commands_processed")
+                }),
+
+                _ => panic!("Expected map, got `{values:?}`"),
+            }
+            .collect();
+
+            // Check that all nodes except for one has processed the same number of commands.
+            values.sort();
+            assert_eq!(values.len(), 6);
+            assert_eq!(values[0], values[1]);
+            assert_eq!(values[1], values[2]);
+            assert_eq!(values[2], values[3]);
+            assert_eq!(values[3], values[4]);
+            assert_eq!(values[4] + 3, values[5]); // + MULTI, GET, EXEC
+        });
+    }
+
     #[rstest]
     #[timeout(SHORT_CLUSTER_TEST_TIMEOUT)]
     fn test_resp_support(#[values(false, true)] use_cluster: bool, #[values(2, 3)] protocol: i64) {

python/python/tests/test_async_client.py

@@ -173,14 +173,13 @@ async def test_can_connect_with_auth_requirepass(
                 ["CONFIG", "SET", "requirepass", password]
             )
 
-            with pytest.raises(ClosingError) as e:
+            with pytest.raises(ClosingError, match="NOAUTH"):
                 # Creation of a new client without password should fail
                 await create_client(
                     request,
                     is_cluster,
                     addresses=redis_client.config.addresses,
                 )
-            assert "NOAUTH" in str(e)
 
             auth_client = await create_client(
                 request,

python/python/tests/test_transaction.py

@@ -164,9 +164,8 @@ async def test_transaction_with_different_slots(self, redis_client: TRedisClient
         )
         transaction.set("key1", "value1")
         transaction.set("key2", "value2")
-        with pytest.raises(RequestError) as e:
+        with pytest.raises(RequestError, match="CrossSlot"):
             await redis_client.exec(transaction)
-        assert "Moved" in str(e)
 
     @pytest.mark.parametrize("cluster_mode", [True, False])
     @pytest.mark.parametrize("protocol", [ProtocolVersion.RESP2, ProtocolVersion.RESP3])