Fixed test

Author: barshaul

redis/asyncio/cluster.py

@@ -110,10 +110,10 @@ class RedisCluster(AbstractRedis, AbstractRedisCluster, AsyncRedisClusterCommand
     :param startup_nodes:
         | :class:`~.ClusterNode` to used as a startup node
     :param require_full_coverage:
-        | When set to ``False``: the client will not require a full coverage of the
-          slots. However, if not all slots are covered, and at least one node has
-          ``cluster-require-full-coverage`` set to ``yes``, the server will throw a
-          :class:`~.ClusterDownError` for some key-based commands.
+        | When set to ``False``: the client will not require a full coverage of
+          the slots. However, if not all slots are covered, and at least one node
+          has ``cluster-require-full-coverage`` set to ``yes``, the server will throw
+          a :class:`~.ClusterDownError` for some key-based commands.
         | When set to ``True``: all slots must be covered to construct the cluster
           client. If not all slots are covered, :class:`~.RedisClusterException` will be
           thrown.

tests/test_asyncio/test_cluster.py

@@ -249,63 +249,70 @@ async def test_startup_nodes(self) -> None:
                 ]
             )
 
-    async def test_cluster_get_set_retry_object(self, request):
+    async def test_cluster_set_get_retry_object(self, request: FixtureRequest):
         retry = Retry(NoBackoff(), 2)
         url = request.config.getoption("--redis-url")
-        r = await RedisCluster.from_url(url, retry=retry)
-        assert r.get_retry()._retries == retry._retries
-        assert isinstance(r.get_retry()._backoff, NoBackoff)
-        for node in r.get_nodes():
-            n_retry = node.connection_kwargs.get("retry")
-            assert n_retry is not None
-            assert n_retry._retries == retry._retries
-            assert isinstance(n_retry._backoff, NoBackoff)
-        # Change retry policy
-        new_retry = Retry(ExponentialBackoff(), 3)
-        r.set_retry(new_retry)
-        assert r.get_retry()._retries == new_retry._retries
-        assert isinstance(r.get_retry()._backoff, ExponentialBackoff)
-        for node in r.get_nodes():
-            n_retry = node.connection_kwargs.get("retry")
-            assert n_retry is not None
-            assert n_retry._retries == new_retry._retries
-            assert isinstance(n_retry._backoff, ExponentialBackoff)
-
-    async def test_cluster_retry_object(self, request) -> None:
+        async with RedisCluster.from_url(url, retry=retry) as r:
+            assert r.get_retry()._retries == retry._retries
+            assert isinstance(r.get_retry()._backoff, NoBackoff)
+            for node in r.get_nodes():
+                n_retry = node.connection_kwargs.get("retry")
+                assert n_retry is not None
+                assert n_retry._retries == retry._retries
+                assert isinstance(n_retry._backoff, NoBackoff)
+            # Change retry policy
+            new_retry = Retry(ExponentialBackoff(), 3)
+            r.set_retry(new_retry)
+            assert r.get_retry()._retries == new_retry._retries
+            assert isinstance(r.get_retry()._backoff, ExponentialBackoff)
+            for node in r.get_nodes():
+                n_retry = node.connection_kwargs.get("retry")
+                assert n_retry is not None
+                assert n_retry._retries == new_retry._retries
+                assert isinstance(n_retry._backoff, ExponentialBackoff)
+
+    async def test_cluster_retry_object(self, request: FixtureRequest) -> None:
         url = request.config.getoption("--redis-url")
-        rc_default = await RedisCluster.from_url(url)
-        # Test default retry
-        retry = rc_default.connection_kwargs.get("retry")
-        assert isinstance(retry, Retry)
-        assert retry._retries == 3
-        assert isinstance(retry._backoff, type(get_default_backoff()))
-        assert rc_default.get_node("127.0.0.1", 16379).connection_kwargs.get(
-            "retry"
-        ) == rc_default.get_node("127.0.0.1", 16380).connection_kwargs.get("retry")
-
-        # Test custom retry
+        async with RedisCluster.from_url(url) as rc_default:
+            # Test default retry
+            retry = rc_default.connection_kwargs.get("retry")
+            assert isinstance(retry, Retry)
+            assert retry._retries == 3
+            assert isinstance(retry._backoff, type(get_default_backoff()))
+            assert rc_default.get_node("127.0.0.1", 16379).connection_kwargs.get(
+                "retry"
+            ) == rc_default.get_node("127.0.0.1", 16380).connection_kwargs.get("retry")
+
         retry = Retry(ExponentialBackoff(10, 5), 5)
-        rc_custom_retry = await RedisCluster.from_url(url, retry=retry)
-        assert (
-            rc_custom_retry.get_node("127.0.0.1", 16379).connection_kwargs.get("retry")
-            == retry
-        )
+        async with RedisCluster.from_url(url, retry=retry) as rc_custom_retry:
+            # Test custom retry
+            assert (
+                rc_custom_retry.get_node("127.0.0.1", 16379).connection_kwargs.get(
+                    "retry"
+                )
+                == retry
+            )
 
-        # Test no connection retries
-        rc_no_retries = await RedisCluster.from_url(
+        async with RedisCluster.from_url(
             url, connection_error_retry_attempts=0
-        )
-        assert (
-            rc_no_retries.get_node("127.0.0.1", 16379).connection_kwargs.get("retry")
-            is None
-        )
-        rc_no_retries = await RedisCluster.from_url(url, retry=Retry(NoBackoff(), 0))
-        assert (
-            rc_no_retries.get_node("127.0.0.1", 16379)
-            .connection_kwargs.get("retry")
-            ._retries
-            == 0
-        )
+        ) as rc_no_retries:
+            # Test no connection retries
+            assert (
+                rc_no_retries.get_node("127.0.0.1", 16379).connection_kwargs.get(
+                    "retry"
+                )
+                is None
+            )
+
+        async with RedisCluster.from_url(
+            url, retry=Retry(NoBackoff(), 0)
+        ) as rc_no_retries:
+            assert (
+                rc_no_retries.get_node("127.0.0.1", 16379)
+                .connection_kwargs.get("retry")
+                ._retries
+                == 0
+            )
 
     async def test_empty_startup_nodes(self) -> None:
         """

tests/test_cluster.py

@@ -365,7 +365,7 @@ def test_handling_cluster_failover_to_a_replica(self, r):
         key = "key"
         r.set("key", "value")
         primary = r.get_node_from_key(key, replica=False)
-        assert r.get("key") == "value"
+        assert str_if_bytes(r.get("key")) == "value"
         # Get the current output of cluster slots
         cluster_slots = primary.redis_connection.execute_command("CLUSTER SLOTS")
         replica_host = ""