From 37ed3d513c7b0847af4c164c0285563df1a9db2c Mon Sep 17 00:00:00 2001
From: vladvildanov <divinez122@outlook.com>
Date: Wed, 2 Oct 2024 10:52:34 +0300
Subject: [PATCH 1/6] Fix bug with Redis Set commands returns List instead of
 Set in RESP2

---
 redis/_parsers/helpers.py           |  3 ++
 tests/test_asyncio/test_cluster.py  | 10 ++---
 tests/test_asyncio/test_commands.py | 10 ++---
 tests/test_cache.py                 |  2 +-
 tests/test_cluster.py               | 60 ++++++++++++++++++++++++++++-
 tests/test_commands.py              | 58 ++++++++++++++++++++++++++--
 6 files changed, 128 insertions(+), 15 deletions(-)

diff --git a/redis/_parsers/helpers.py b/redis/_parsers/helpers.py
index 7494c79210..50eab1aabb 100644
--- a/redis/_parsers/helpers.py
+++ b/redis/_parsers/helpers.py
@@ -785,6 +785,9 @@ def string_keys_to_dict(key_string, callback):
 
 
 _RedisCallbacksRESP2 = {
+    **string_keys_to_dict(
+        "SDIFF SINTER SMEMBERS SUNION", lambda r: r and set(r) or set()
+    ),
     **string_keys_to_dict(
         "ZDIFF ZINTER ZPOPMAX ZPOPMIN ZRANGE ZRANGEBYSCORE ZRANK ZREVRANGE "
         "ZREVRANGEBYSCORE ZREVRANK ZUNION",
diff --git a/tests/test_asyncio/test_cluster.py b/tests/test_asyncio/test_cluster.py
index e480db332b..e39a285b1c 100644
--- a/tests/test_asyncio/test_cluster.py
+++ b/tests/test_asyncio/test_cluster.py
@@ -1754,7 +1754,7 @@ async def test_cluster_sdiff(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "1", "2", "3")
         assert set(await r.sdiff("{foo}a", "{foo}b")) == {b"1", b"2", b"3"}
         await r.sadd("{foo}b", "2", "3")
-        assert await r.sdiff("{foo}a", "{foo}b") == [b"1"]
+        assert await r.sdiff("{foo}a", "{foo}b") == {b"1"}
 
     async def test_cluster_sdiffstore(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "1", "2", "3")
@@ -1762,18 +1762,18 @@ async def test_cluster_sdiffstore(self, r: RedisCluster) -> None:
         assert set(await r.smembers("{foo}c")) == {b"1", b"2", b"3"}
         await r.sadd("{foo}b", "2", "3")
         assert await r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 1
-        assert await r.smembers("{foo}c") == [b"1"]
+        assert await r.smembers("{foo}c") == {b"1"}
 
     async def test_cluster_sinter(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "1", "2", "3")
-        assert await r.sinter("{foo}a", "{foo}b") == []
+        assert await r.sinter("{foo}a", "{foo}b") == set()
         await r.sadd("{foo}b", "2", "3")
         assert set(await r.sinter("{foo}a", "{foo}b")) == {b"2", b"3"}
 
     async def test_cluster_sinterstore(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "1", "2", "3")
         assert await r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 0
-        assert await r.smembers("{foo}c") == []
+        assert await r.smembers("{foo}c") == set()
         await r.sadd("{foo}b", "2", "3")
         assert await r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 2
         assert set(await r.smembers("{foo}c")) == {b"2", b"3"}
@@ -1782,7 +1782,7 @@ async def test_cluster_smove(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "a1", "a2")
         await r.sadd("{foo}b", "b1", "b2")
         assert await r.smove("{foo}a", "{foo}b", "a1")
-        assert await r.smembers("{foo}a") == [b"a2"]
+        assert await r.smembers("{foo}a") == {b"a2"}
         assert set(await r.smembers("{foo}b")) == {b"b1", b"b2", b"a1"}
 
     async def test_cluster_sunion(self, r: RedisCluster) -> None:
diff --git a/tests/test_asyncio/test_commands.py b/tests/test_asyncio/test_commands.py
index 28c3094cdb..a8e8ed2cc1 100644
--- a/tests/test_asyncio/test_commands.py
+++ b/tests/test_asyncio/test_commands.py
@@ -1417,7 +1417,7 @@ async def test_sdiff(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
         assert set(await r.sdiff("a", "b")) == {b"1", b"2", b"3"}
         await r.sadd("b", "2", "3")
-        assert await r.sdiff("a", "b") == [b"1"]
+        assert await r.sdiff("a", "b") == {b"1"}
 
     @pytest.mark.onlynoncluster
     async def test_sdiffstore(self, r: redis.Redis):
@@ -1426,12 +1426,12 @@ async def test_sdiffstore(self, r: redis.Redis):
         assert set(await r.smembers("c")) == {b"1", b"2", b"3"}
         await r.sadd("b", "2", "3")
         assert await r.sdiffstore("c", "a", "b") == 1
-        assert await r.smembers("c") == [b"1"]
+        assert await r.smembers("c") == {b"1"}
 
     @pytest.mark.onlynoncluster
     async def test_sinter(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
-        assert await r.sinter("a", "b") == []
+        assert await r.sinter("a", "b") == set()
         await r.sadd("b", "2", "3")
         assert set(await r.sinter("a", "b")) == {b"2", b"3"}
 
@@ -1439,7 +1439,7 @@ async def test_sinter(self, r: redis.Redis):
     async def test_sinterstore(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
         assert await r.sinterstore("c", "a", "b") == 0
-        assert await r.smembers("c") == []
+        assert await r.smembers("c") == set()
         await r.sadd("b", "2", "3")
         assert await r.sinterstore("c", "a", "b") == 2
         assert set(await r.smembers("c")) == {b"2", b"3"}
@@ -1460,7 +1460,7 @@ async def test_smove(self, r: redis.Redis):
         await r.sadd("a", "a1", "a2")
         await r.sadd("b", "b1", "b2")
         assert await r.smove("a", "b", "a1")
-        assert await r.smembers("a") == [b"a2"]
+        assert await r.smembers("a") == {b"a2"}
         assert set(await r.smembers("b")) == {b"b1", b"b2", b"a1"}
 
     async def test_spop(self, r: redis.Redis):
diff --git a/tests/test_cache.py b/tests/test_cache.py
index 1803646094..67733dc9af 100644
--- a/tests/test_cache.py
+++ b/tests/test_cache.py
@@ -41,7 +41,7 @@ def r(request):
 
 @pytest.mark.skipif(HIREDIS_AVAILABLE, reason="PythonParser only")
 @pytest.mark.onlynoncluster
-# @skip_if_resp_version(2)
+@skip_if_resp_version(2)
 @skip_if_server_version_lt("7.4.0")
 class TestCache:
     @pytest.mark.parametrize(
diff --git a/tests/test_cluster.py b/tests/test_cluster.py
index c4b3188050..d8b927dcae 100644
--- a/tests/test_cluster.py
+++ b/tests/test_cluster.py
@@ -48,7 +48,7 @@
     skip_if_redis_enterprise,
     skip_if_server_version_lt,
     skip_unless_arch_bits,
-    wait_for_command,
+    wait_for_command, skip_if_resp_version,
 )
 
 default_host = "127.0.0.1"
@@ -284,6 +284,19 @@ def ok_response(connection, *args, **options):
             assert prev_primary.server_type == REPLICA
 
 
+@pytest.fixture()
+def r(request):
+    protocol = 2
+
+    if hasattr(request, "param"):
+        protocol = request.param.get("protocol", 2)
+    with _get_client(
+        redis.Redis,
+        request,
+        protocol=protocol,
+    ) as client:
+        yield client
+
 @pytest.mark.onlycluster
 class TestRedisClusterObj:
     """
@@ -1864,12 +1877,30 @@ def test_cluster_rpoplpush(self, r):
         assert r.lrange("{foo}b", 0, -1) == [b"a3", b"b1", b"b2", b"b3"]
 
     def test_cluster_sdiff(self, r):
+        r.sadd("{foo}a", "1", "2", "3")
+        assert set(r.sdiff("{foo}a", "{foo}b")) == {b"1", b"2", b"3"}
+        r.sadd("{foo}b", "2", "3")
+        assert r.sdiff("{foo}a", "{foo}b") == {b"1"}
+
+    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
+    @skip_if_resp_version(2)
+    def test_cluster_sdiff_resp3(self, r):
         r.sadd("{foo}a", "1", "2", "3")
         assert set(r.sdiff("{foo}a", "{foo}b")) == {b"1", b"2", b"3"}
         r.sadd("{foo}b", "2", "3")
         assert r.sdiff("{foo}a", "{foo}b") == [b"1"]
 
     def test_cluster_sdiffstore(self, r):
+        r.sadd("{foo}a", "1", "2", "3")
+        assert r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 3
+        assert set(r.smembers("{foo}c")) == {b"1", b"2", b"3"}
+        r.sadd("{foo}b", "2", "3")
+        assert r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 1
+        assert r.smembers("{foo}c") == {b"1"}
+
+    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
+    @skip_if_resp_version(2)
+    def test_cluster_sdiffstore_resp3(self, r):
         r.sadd("{foo}a", "1", "2", "3")
         assert r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 3
         assert set(r.smembers("{foo}c")) == {b"1", b"2", b"3"}
@@ -1878,12 +1909,30 @@ def test_cluster_sdiffstore(self, r):
         assert r.smembers("{foo}c") == [b"1"]
 
     def test_cluster_sinter(self, r):
+        r.sadd("{foo}a", "1", "2", "3")
+        assert r.sinter("{foo}a", "{foo}b") == set()
+        r.sadd("{foo}b", "2", "3")
+        assert set(r.sinter("{foo}a", "{foo}b")) == {b"2", b"3"}
+
+    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
+    @skip_if_resp_version(2)
+    def test_cluster_sinter_resp3(self, r):
         r.sadd("{foo}a", "1", "2", "3")
         assert r.sinter("{foo}a", "{foo}b") == []
         r.sadd("{foo}b", "2", "3")
         assert set(r.sinter("{foo}a", "{foo}b")) == {b"2", b"3"}
 
     def test_cluster_sinterstore(self, r):
+        r.sadd("{foo}a", "1", "2", "3")
+        assert r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 0
+        assert r.smembers("{foo}c") == set()
+        r.sadd("{foo}b", "2", "3")
+        assert r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 2
+        assert set(r.smembers("{foo}c")) == {b"2", b"3"}
+
+    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
+    @skip_if_resp_version(2)
+    def test_cluster_sinterstore_resp3(self, r):
         r.sadd("{foo}a", "1", "2", "3")
         assert r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 0
         assert r.smembers("{foo}c") == []
@@ -1892,6 +1941,15 @@ def test_cluster_sinterstore(self, r):
         assert set(r.smembers("{foo}c")) == {b"2", b"3"}
 
     def test_cluster_smove(self, r):
+        r.sadd("{foo}a", "a1", "a2")
+        r.sadd("{foo}b", "b1", "b2")
+        assert r.smove("{foo}a", "{foo}b", "a1")
+        assert r.smembers("{foo}a") == {b"a2"}
+        assert set(r.smembers("{foo}b")) == {b"b1", b"b2", b"a1"}
+
+    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
+    @skip_if_resp_version(2)
+    def test_cluster_smove_resp3(self, r):
         r.sadd("{foo}a", "a1", "a2")
         r.sadd("{foo}b", "b1", "b2")
         assert r.smove("{foo}a", "{foo}b", "a1")
diff --git a/tests/test_commands.py b/tests/test_commands.py
index 74e9c1c88e..a5c8c9545c 100644
--- a/tests/test_commands.py
+++ b/tests/test_commands.py
@@ -27,9 +27,21 @@
     skip_if_redis_enterprise,
     skip_if_server_version_gte,
     skip_if_server_version_lt,
-    skip_unless_arch_bits,
+    skip_unless_arch_bits, skip_if_resp_version,
 )
 
+@pytest.fixture()
+def r(request):
+    protocol = 2
+
+    if hasattr(request, "param"):
+        protocol = request.param.get("protocol", 2)
+    with _get_client(
+        redis.Redis,
+        request,
+        protocol=protocol,
+    ) as client:
+        yield client
 
 @pytest.fixture()
 def slowlog(request, r):
@@ -2246,6 +2258,15 @@ def test_scard(self, r):
 
     @pytest.mark.onlynoncluster
     def test_sdiff(self, r):
+        r.sadd("a", "1", "2", "3")
+        assert set(r.sdiff("a", "b")) == {b"1", b"2", b"3"}
+        r.sadd("b", "2", "3")
+        assert r.sdiff("a", "b") == {b"1"}
+
+    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
+    @pytest.mark.onlynoncluster
+    @skip_if_resp_version(2)
+    def test_sdiff_resp3(self, r):
         r.sadd("a", "1", "2", "3")
         assert set(r.sdiff("a", "b")) == {b"1", b"2", b"3"}
         r.sadd("b", "2", "3")
@@ -2258,10 +2279,30 @@ def test_sdiffstore(self, r):
         assert set(r.smembers("c")) == {b"1", b"2", b"3"}
         r.sadd("b", "2", "3")
         assert r.sdiffstore("c", "a", "b") == 1
-        assert r.smembers("c") == [b"1"]
+        assert r.smembers("c") == {b"1"}
+
+    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
+    @pytest.mark.onlynoncluster
+    @skip_if_resp_version(2)
+    def test_sdiffstore_resp3(self, r):
+        r.sadd("a", "1", "2", "3")
+        assert r.sdiffstore("c", "a", "b") == 3
+        assert set(r.smembers("c")) == {b"1", b"2", b"3"}
+        r.sadd("b", "2", "3")
+        assert r.sdiffstore("c", "a", "b") == 1
+        assert r.smembers("c") == {b"1"}
 
     @pytest.mark.onlynoncluster
     def test_sinter(self, r):
+        r.sadd("a", "1", "2", "3")
+        assert r.sinter("a", "b") == set()
+        r.sadd("b", "2", "3")
+        assert set(r.sinter("a", "b")) == {b"2", b"3"}
+
+    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
+    @pytest.mark.onlynoncluster
+    @skip_if_resp_version(2)
+    def test_sinter_resp3(self, r):
         r.sadd("a", "1", "2", "3")
         assert r.sinter("a", "b") == []
         r.sadd("b", "2", "3")
@@ -2278,6 +2319,17 @@ def test_sintercard(self, r):
 
     @pytest.mark.onlynoncluster
     def test_sinterstore(self, r):
+        r.sadd("a", "1", "2", "3")
+        assert r.sinterstore("c", "a", "b") == 0
+        assert r.smembers("c") == set()
+        r.sadd("b", "2", "3")
+        assert r.sinterstore("c", "a", "b") == 2
+        assert set(r.smembers("c")) == {b"2", b"3"}
+
+    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
+    @pytest.mark.onlynoncluster
+    @skip_if_resp_version(2)
+    def test_sinterstore_resp3(self, r):
         r.sadd("a", "1", "2", "3")
         assert r.sinterstore("c", "a", "b") == 0
         assert r.smembers("c") == []
@@ -2308,7 +2360,7 @@ def test_smove(self, r):
         r.sadd("a", "a1", "a2")
         r.sadd("b", "b1", "b2")
         assert r.smove("a", "b", "a1")
-        assert r.smembers("a") == [b"a2"]
+        assert r.smembers("a") == {b"a2"}
         assert set(r.smembers("b")) == {b"b1", b"b2", b"a1"}
 
     def test_spop(self, r):

From 33bae679af2506fe6c3dd1a4fb701451aa476e94 Mon Sep 17 00:00:00 2001
From: vladvildanov <divinez122@outlook.com>
Date: Wed, 2 Oct 2024 11:18:13 +0300
Subject: [PATCH 2/6] Removed fixture, codestyle fixes

---
 tests/test_cluster.py  | 26 +++++++-------------------
 tests/test_commands.py | 35 +++++++++++++++++------------------
 2 files changed, 24 insertions(+), 37 deletions(-)

diff --git a/tests/test_cluster.py b/tests/test_cluster.py
index d8b927dcae..e870e9bb73 100644
--- a/tests/test_cluster.py
+++ b/tests/test_cluster.py
@@ -46,9 +46,10 @@
     assert_resp_response,
     is_resp2_connection,
     skip_if_redis_enterprise,
+    skip_if_resp_version,
     skip_if_server_version_lt,
     skip_unless_arch_bits,
-    wait_for_command, skip_if_resp_version,
+    wait_for_command,
 )
 
 default_host = "127.0.0.1"
@@ -284,19 +285,6 @@ def ok_response(connection, *args, **options):
             assert prev_primary.server_type == REPLICA
 
 
-@pytest.fixture()
-def r(request):
-    protocol = 2
-
-    if hasattr(request, "param"):
-        protocol = request.param.get("protocol", 2)
-    with _get_client(
-        redis.Redis,
-        request,
-        protocol=protocol,
-    ) as client:
-        yield client
-
 @pytest.mark.onlycluster
 class TestRedisClusterObj:
     """
@@ -1876,13 +1864,13 @@ def test_cluster_rpoplpush(self, r):
         assert r.lrange("{foo}a", 0, -1) == [b"a1", b"a2"]
         assert r.lrange("{foo}b", 0, -1) == [b"a3", b"b1", b"b2", b"b3"]
 
+    @skip_if_resp_version(3)
     def test_cluster_sdiff(self, r):
         r.sadd("{foo}a", "1", "2", "3")
         assert set(r.sdiff("{foo}a", "{foo}b")) == {b"1", b"2", b"3"}
         r.sadd("{foo}b", "2", "3")
         assert r.sdiff("{foo}a", "{foo}b") == {b"1"}
 
-    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
     @skip_if_resp_version(2)
     def test_cluster_sdiff_resp3(self, r):
         r.sadd("{foo}a", "1", "2", "3")
@@ -1890,6 +1878,7 @@ def test_cluster_sdiff_resp3(self, r):
         r.sadd("{foo}b", "2", "3")
         assert r.sdiff("{foo}a", "{foo}b") == [b"1"]
 
+    @skip_if_resp_version(3)
     def test_cluster_sdiffstore(self, r):
         r.sadd("{foo}a", "1", "2", "3")
         assert r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 3
@@ -1898,7 +1887,6 @@ def test_cluster_sdiffstore(self, r):
         assert r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 1
         assert r.smembers("{foo}c") == {b"1"}
 
-    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
     @skip_if_resp_version(2)
     def test_cluster_sdiffstore_resp3(self, r):
         r.sadd("{foo}a", "1", "2", "3")
@@ -1908,13 +1896,13 @@ def test_cluster_sdiffstore_resp3(self, r):
         assert r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 1
         assert r.smembers("{foo}c") == [b"1"]
 
+    @skip_if_resp_version(3)
     def test_cluster_sinter(self, r):
         r.sadd("{foo}a", "1", "2", "3")
         assert r.sinter("{foo}a", "{foo}b") == set()
         r.sadd("{foo}b", "2", "3")
         assert set(r.sinter("{foo}a", "{foo}b")) == {b"2", b"3"}
 
-    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
     @skip_if_resp_version(2)
     def test_cluster_sinter_resp3(self, r):
         r.sadd("{foo}a", "1", "2", "3")
@@ -1922,6 +1910,7 @@ def test_cluster_sinter_resp3(self, r):
         r.sadd("{foo}b", "2", "3")
         assert set(r.sinter("{foo}a", "{foo}b")) == {b"2", b"3"}
 
+    @skip_if_resp_version(3)
     def test_cluster_sinterstore(self, r):
         r.sadd("{foo}a", "1", "2", "3")
         assert r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 0
@@ -1930,7 +1919,6 @@ def test_cluster_sinterstore(self, r):
         assert r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 2
         assert set(r.smembers("{foo}c")) == {b"2", b"3"}
 
-    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
     @skip_if_resp_version(2)
     def test_cluster_sinterstore_resp3(self, r):
         r.sadd("{foo}a", "1", "2", "3")
@@ -1940,6 +1928,7 @@ def test_cluster_sinterstore_resp3(self, r):
         assert r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 2
         assert set(r.smembers("{foo}c")) == {b"2", b"3"}
 
+    @skip_if_resp_version(3)
     def test_cluster_smove(self, r):
         r.sadd("{foo}a", "a1", "a2")
         r.sadd("{foo}b", "b1", "b2")
@@ -1947,7 +1936,6 @@ def test_cluster_smove(self, r):
         assert r.smembers("{foo}a") == {b"a2"}
         assert set(r.smembers("{foo}b")) == {b"b1", b"b2", b"a1"}
 
-    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
     @skip_if_resp_version(2)
     def test_cluster_smove_resp3(self, r):
         r.sadd("{foo}a", "a1", "a2")
diff --git a/tests/test_commands.py b/tests/test_commands.py
index a5c8c9545c..e4062f922c 100644
--- a/tests/test_commands.py
+++ b/tests/test_commands.py
@@ -25,23 +25,12 @@
     assert_resp_response_in,
     is_resp2_connection,
     skip_if_redis_enterprise,
+    skip_if_resp_version,
     skip_if_server_version_gte,
     skip_if_server_version_lt,
-    skip_unless_arch_bits, skip_if_resp_version,
+    skip_unless_arch_bits,
 )
 
-@pytest.fixture()
-def r(request):
-    protocol = 2
-
-    if hasattr(request, "param"):
-        protocol = request.param.get("protocol", 2)
-    with _get_client(
-        redis.Redis,
-        request,
-        protocol=protocol,
-    ) as client:
-        yield client
 
 @pytest.fixture()
 def slowlog(request, r):
@@ -2257,13 +2246,13 @@ def test_scard(self, r):
         assert r.scard("a") == 3
 
     @pytest.mark.onlynoncluster
+    @skip_if_resp_version(3)
     def test_sdiff(self, r):
         r.sadd("a", "1", "2", "3")
         assert set(r.sdiff("a", "b")) == {b"1", b"2", b"3"}
         r.sadd("b", "2", "3")
         assert r.sdiff("a", "b") == {b"1"}
 
-    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
     @pytest.mark.onlynoncluster
     @skip_if_resp_version(2)
     def test_sdiff_resp3(self, r):
@@ -2273,6 +2262,7 @@ def test_sdiff_resp3(self, r):
         assert r.sdiff("a", "b") == [b"1"]
 
     @pytest.mark.onlynoncluster
+    @skip_if_resp_version(3)
     def test_sdiffstore(self, r):
         r.sadd("a", "1", "2", "3")
         assert r.sdiffstore("c", "a", "b") == 3
@@ -2281,7 +2271,6 @@ def test_sdiffstore(self, r):
         assert r.sdiffstore("c", "a", "b") == 1
         assert r.smembers("c") == {b"1"}
 
-    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
     @pytest.mark.onlynoncluster
     @skip_if_resp_version(2)
     def test_sdiffstore_resp3(self, r):
@@ -2290,16 +2279,16 @@ def test_sdiffstore_resp3(self, r):
         assert set(r.smembers("c")) == {b"1", b"2", b"3"}
         r.sadd("b", "2", "3")
         assert r.sdiffstore("c", "a", "b") == 1
-        assert r.smembers("c") == {b"1"}
+        assert r.smembers("c") == [b"1"]
 
     @pytest.mark.onlynoncluster
+    @skip_if_resp_version(3)
     def test_sinter(self, r):
         r.sadd("a", "1", "2", "3")
         assert r.sinter("a", "b") == set()
         r.sadd("b", "2", "3")
         assert set(r.sinter("a", "b")) == {b"2", b"3"}
 
-    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
     @pytest.mark.onlynoncluster
     @skip_if_resp_version(2)
     def test_sinter_resp3(self, r):
@@ -2318,6 +2307,7 @@ def test_sintercard(self, r):
         assert r.sintercard(3, ["a", "b", "c"], limit=1) == 1
 
     @pytest.mark.onlynoncluster
+    @skip_if_resp_version(3)
     def test_sinterstore(self, r):
         r.sadd("a", "1", "2", "3")
         assert r.sinterstore("c", "a", "b") == 0
@@ -2326,7 +2316,6 @@ def test_sinterstore(self, r):
         assert r.sinterstore("c", "a", "b") == 2
         assert set(r.smembers("c")) == {b"2", b"3"}
 
-    @pytest.mark.parametrize("r", [{"protocol": 3}], indirect=True)
     @pytest.mark.onlynoncluster
     @skip_if_resp_version(2)
     def test_sinterstore_resp3(self, r):
@@ -2356,6 +2345,7 @@ def test_smismember(self, r):
         assert r.smismember("a", ["1", "4", "2", "3"]) == result_list
 
     @pytest.mark.onlynoncluster
+    @skip_if_resp_version(3)
     def test_smove(self, r):
         r.sadd("a", "a1", "a2")
         r.sadd("b", "b1", "b2")
@@ -2363,6 +2353,15 @@ def test_smove(self, r):
         assert r.smembers("a") == {b"a2"}
         assert set(r.smembers("b")) == {b"b1", b"b2", b"a1"}
 
+    @pytest.mark.onlynoncluster
+    @skip_if_resp_version(2)
+    def test_smove_resp3(self, r):
+        r.sadd("a", "a1", "a2")
+        r.sadd("b", "b1", "b2")
+        assert r.smove("a", "b", "a1")
+        assert r.smembers("a") == [b"a2"]
+        assert set(r.smembers("b")) == {b"b1", b"b2", b"a1"}
+
     def test_spop(self, r):
         s = [b"1", b"2", b"3"]
         r.sadd("a", *s)

From 5142d1fd25b774e281f1a6282a2f92ea4a5b2d59 Mon Sep 17 00:00:00 2001
From: vladvildanov <divinez122@outlook.com>
Date: Wed, 2 Oct 2024 11:34:56 +0300
Subject: [PATCH 3/6] Fixed tests for async

---
 tests/test_asyncio/test_commands.py | 51 +++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/tests/test_asyncio/test_commands.py b/tests/test_asyncio/test_commands.py
index a8e8ed2cc1..1eb7d1a8f7 100644
--- a/tests/test_asyncio/test_commands.py
+++ b/tests/test_asyncio/test_commands.py
@@ -24,6 +24,7 @@
     assert_resp_response,
     assert_resp_response_in,
     is_resp2_connection,
+    skip_if_resp_version,
     skip_if_server_version_gte,
     skip_if_server_version_lt,
     skip_unless_arch_bits,
@@ -1412,6 +1413,7 @@ async def test_scard(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
         assert await r.scard("a") == 3
 
+    @skip_if_resp_version(3)
     @pytest.mark.onlynoncluster
     async def test_sdiff(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
@@ -1419,6 +1421,15 @@ async def test_sdiff(self, r: redis.Redis):
         await r.sadd("b", "2", "3")
         assert await r.sdiff("a", "b") == {b"1"}
 
+    @skip_if_resp_version(2)
+    @pytest.mark.onlynoncluster
+    async def test_sdiff_resp3(self, r: redis.Redis):
+        await r.sadd("a", "1", "2", "3")
+        assert set(await r.sdiff("a", "b")) == {b"1", b"2", b"3"}
+        await r.sadd("b", "2", "3")
+        assert await r.sdiff("a", "b") == [b"1"]
+
+    @skip_if_resp_version(3)
     @pytest.mark.onlynoncluster
     async def test_sdiffstore(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
@@ -1428,6 +1439,17 @@ async def test_sdiffstore(self, r: redis.Redis):
         assert await r.sdiffstore("c", "a", "b") == 1
         assert await r.smembers("c") == {b"1"}
 
+    @skip_if_resp_version(2)
+    @pytest.mark.onlynoncluster
+    async def test_sdiffstore_resp3(self, r: redis.Redis):
+        await r.sadd("a", "1", "2", "3")
+        assert await r.sdiffstore("c", "a", "b") == 3
+        assert set(await r.smembers("c")) == {b"1", b"2", b"3"}
+        await r.sadd("b", "2", "3")
+        assert await r.sdiffstore("c", "a", "b") == 1
+        assert await r.smembers("c") == [b"1"]
+
+    @skip_if_resp_version(3)
     @pytest.mark.onlynoncluster
     async def test_sinter(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
@@ -1435,6 +1457,15 @@ async def test_sinter(self, r: redis.Redis):
         await r.sadd("b", "2", "3")
         assert set(await r.sinter("a", "b")) == {b"2", b"3"}
 
+    @skip_if_resp_version(2)
+    @pytest.mark.onlynoncluster
+    async def test_sinter_resp3(self, r: redis.Redis):
+        await r.sadd("a", "1", "2", "3")
+        assert await r.sinter("a", "b") == []
+        await r.sadd("b", "2", "3")
+        assert await r.sinter("a", "b") == [b"2", b"3"]
+
+    @skip_if_resp_version(3)
     @pytest.mark.onlynoncluster
     async def test_sinterstore(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
@@ -1444,6 +1475,16 @@ async def test_sinterstore(self, r: redis.Redis):
         assert await r.sinterstore("c", "a", "b") == 2
         assert set(await r.smembers("c")) == {b"2", b"3"}
 
+    @skip_if_resp_version(2)
+    @pytest.mark.onlynoncluster
+    async def test_sinterstore_resp3(self, r: redis.Redis):
+        await r.sadd("a", "1", "2", "3")
+        assert await r.sinterstore("c", "a", "b") == 0
+        assert await r.smembers("c") == []
+        await r.sadd("b", "2", "3")
+        assert await r.sinterstore("c", "a", "b") == 2
+        assert set(await r.smembers("c")) == {b"2", b"3"}
+
     async def test_sismember(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
         assert await r.sismember("a", "1")
@@ -1455,6 +1496,7 @@ async def test_smembers(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
         assert set(await r.smembers("a")) == {b"1", b"2", b"3"}
 
+    @skip_if_resp_version(3)
     @pytest.mark.onlynoncluster
     async def test_smove(self, r: redis.Redis):
         await r.sadd("a", "a1", "a2")
@@ -1463,6 +1505,15 @@ async def test_smove(self, r: redis.Redis):
         assert await r.smembers("a") == {b"a2"}
         assert set(await r.smembers("b")) == {b"b1", b"b2", b"a1"}
 
+    @skip_if_resp_version(2)
+    @pytest.mark.onlynoncluster
+    async def test_smove_resp3(self, r: redis.Redis):
+        await r.sadd("a", "a1", "a2")
+        await r.sadd("b", "b1", "b2")
+        assert await r.smove("a", "b", "a1")
+        assert await r.smembers("a") == [b"a2"]
+        assert set(await r.smembers("b")) == {b"b1", b"b2", b"a1"}
+
     async def test_spop(self, r: redis.Redis):
         s = [b"1", b"2", b"3"]
         await r.sadd("a", *s)

From ca85e6efa8258936ec59aa1eb3ba0396d2887fb1 Mon Sep 17 00:00:00 2001
From: vladvildanov <divinez122@outlook.com>
Date: Wed, 2 Oct 2024 11:54:12 +0300
Subject: [PATCH 4/6] Fixed asyncio cluster test cases

---
 tests/test_asyncio/test_cluster.py | 48 +++++++++++++++++++++++++++++-
 1 file changed, 47 insertions(+), 1 deletion(-)

diff --git a/tests/test_asyncio/test_cluster.py b/tests/test_asyncio/test_cluster.py
index e39a285b1c..2ac5fee333 100644
--- a/tests/test_asyncio/test_cluster.py
+++ b/tests/test_asyncio/test_cluster.py
@@ -33,6 +33,7 @@
     assert_resp_response,
     is_resp2_connection,
     skip_if_redis_enterprise,
+    skip_if_resp_version,
     skip_if_server_version_gte,
     skip_if_server_version_lt,
     skip_unless_arch_bits,
@@ -1750,12 +1751,21 @@ async def test_cluster_rpoplpush(self, r: RedisCluster) -> None:
         assert await r.lrange("{foo}a", 0, -1) == [b"a1", b"a2"]
         assert await r.lrange("{foo}b", 0, -1) == [b"a3", b"b1", b"b2", b"b3"]
 
+    @skip_if_resp_version(3)
     async def test_cluster_sdiff(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "1", "2", "3")
-        assert set(await r.sdiff("{foo}a", "{foo}b")) == {b"1", b"2", b"3"}
+        assert await r.sdiff("{foo}a", "{foo}b") == {b"1", b"2", b"3"}
         await r.sadd("{foo}b", "2", "3")
         assert await r.sdiff("{foo}a", "{foo}b") == {b"1"}
 
+    @skip_if_resp_version(2)
+    async def test_cluster_sdiff_resp3(self, r: RedisCluster) -> None:
+        await r.sadd("{foo}a", "1", "2", "3")
+        assert await r.sdiff("{foo}a", "{foo}b") == [b"1", b"2", b"3"]
+        await r.sadd("{foo}b", "2", "3")
+        assert await r.sdiff("{foo}a", "{foo}b") == [b"1"]
+
+    @skip_if_resp_version(3)
     async def test_cluster_sdiffstore(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "1", "2", "3")
         assert await r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 3
@@ -1764,12 +1774,30 @@ async def test_cluster_sdiffstore(self, r: RedisCluster) -> None:
         assert await r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 1
         assert await r.smembers("{foo}c") == {b"1"}
 
+    @skip_if_resp_version(2)
+    async def test_cluster_sdiffstore_resp3(self, r: RedisCluster) -> None:
+        await r.sadd("{foo}a", "1", "2", "3")
+        assert await r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 3
+        assert await r.smembers("{foo}c") == [b"1", b"2", b"3"]
+        await r.sadd("{foo}b", "2", "3")
+        assert await r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 1
+        assert await r.smembers("{foo}c") == [b"1"]
+
+    @skip_if_resp_version(3)
     async def test_cluster_sinter(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "1", "2", "3")
         assert await r.sinter("{foo}a", "{foo}b") == set()
         await r.sadd("{foo}b", "2", "3")
         assert set(await r.sinter("{foo}a", "{foo}b")) == {b"2", b"3"}
 
+    @skip_if_resp_version(2)
+    async def test_cluster_sinter_resp3(self, r: RedisCluster) -> None:
+        await r.sadd("{foo}a", "1", "2", "3")
+        assert await r.sinter("{foo}a", "{foo}b") == []
+        await r.sadd("{foo}b", "2", "3")
+        assert await r.sinter("{foo}a", "{foo}b") == [b"2", b"3"]
+
+    @skip_if_resp_version(3)
     async def test_cluster_sinterstore(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "1", "2", "3")
         assert await r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 0
@@ -1778,6 +1806,16 @@ async def test_cluster_sinterstore(self, r: RedisCluster) -> None:
         assert await r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 2
         assert set(await r.smembers("{foo}c")) == {b"2", b"3"}
 
+    @skip_if_resp_version(2)
+    async def test_cluster_sinterstore_resp3(self, r: RedisCluster) -> None:
+        await r.sadd("{foo}a", "1", "2", "3")
+        assert await r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 0
+        assert await r.smembers("{foo}c") == []
+        await r.sadd("{foo}b", "2", "3")
+        assert await r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 2
+        assert await r.smembers("{foo}c") == [b"2", b"3"]
+
+    @skip_if_resp_version(3)
     async def test_cluster_smove(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "a1", "a2")
         await r.sadd("{foo}b", "b1", "b2")
@@ -1785,6 +1823,14 @@ async def test_cluster_smove(self, r: RedisCluster) -> None:
         assert await r.smembers("{foo}a") == {b"a2"}
         assert set(await r.smembers("{foo}b")) == {b"b1", b"b2", b"a1"}
 
+    @skip_if_resp_version(2)
+    async def test_cluster_smove_resp3(self, r: RedisCluster) -> None:
+        await r.sadd("{foo}a", "a1", "a2")
+        await r.sadd("{foo}b", "b1", "b2")
+        assert await r.smove("{foo}a", "{foo}b", "a1")
+        assert await r.smembers("{foo}a") == [b"a2"]
+        assert await r.smembers("{foo}b") == [b"b1", b"b2", b"a1"]
+
     async def test_cluster_sunion(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "1", "2")
         await r.sadd("{foo}b", "2", "3")

From dcb071101c5c8f7b167b6f58d04cc094938a8832 Mon Sep 17 00:00:00 2001
From: vladvildanov <divinez122@outlook.com>
Date: Wed, 2 Oct 2024 16:12:55 +0300
Subject: [PATCH 5/6] Added Sets alignment for RESP2 and RESP3

---
 redis/_parsers/helpers.py           |  3 ++
 tests/test_asyncio/test_cluster.py  | 54 ++-----------------------
 tests/test_asyncio/test_commands.py | 61 +++--------------------------
 tests/test_cluster.py               | 60 ++++------------------------
 tests/test_commands.py              | 61 +++--------------------------
 5 files changed, 24 insertions(+), 215 deletions(-)

diff --git a/redis/_parsers/helpers.py b/redis/_parsers/helpers.py
index 50eab1aabb..6832100bb6 100644
--- a/redis/_parsers/helpers.py
+++ b/redis/_parsers/helpers.py
@@ -832,6 +832,9 @@ def string_keys_to_dict(key_string, callback):
 
 
 _RedisCallbacksRESP3 = {
+    **string_keys_to_dict(
+        "SDIFF SINTER SMEMBERS SUNION", lambda r: r and set(r) or set()
+    ),
     **string_keys_to_dict(
         "ZRANGE ZINTER ZPOPMAX ZPOPMIN ZRANGEBYSCORE ZREVRANGE ZREVRANGEBYSCORE "
         "ZUNION HGETALL XREADGROUP",
diff --git a/tests/test_asyncio/test_cluster.py b/tests/test_asyncio/test_cluster.py
index 2ac5fee333..f3b76b80c9 100644
--- a/tests/test_asyncio/test_cluster.py
+++ b/tests/test_asyncio/test_cluster.py
@@ -33,7 +33,6 @@
     assert_resp_response,
     is_resp2_connection,
     skip_if_redis_enterprise,
-    skip_if_resp_version,
     skip_if_server_version_gte,
     skip_if_server_version_lt,
     skip_unless_arch_bits,
@@ -1751,85 +1750,40 @@ async def test_cluster_rpoplpush(self, r: RedisCluster) -> None:
         assert await r.lrange("{foo}a", 0, -1) == [b"a1", b"a2"]
         assert await r.lrange("{foo}b", 0, -1) == [b"a3", b"b1", b"b2", b"b3"]
 
-    @skip_if_resp_version(3)
     async def test_cluster_sdiff(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "1", "2", "3")
         assert await r.sdiff("{foo}a", "{foo}b") == {b"1", b"2", b"3"}
         await r.sadd("{foo}b", "2", "3")
         assert await r.sdiff("{foo}a", "{foo}b") == {b"1"}
 
-    @skip_if_resp_version(2)
-    async def test_cluster_sdiff_resp3(self, r: RedisCluster) -> None:
-        await r.sadd("{foo}a", "1", "2", "3")
-        assert await r.sdiff("{foo}a", "{foo}b") == [b"1", b"2", b"3"]
-        await r.sadd("{foo}b", "2", "3")
-        assert await r.sdiff("{foo}a", "{foo}b") == [b"1"]
-
-    @skip_if_resp_version(3)
     async def test_cluster_sdiffstore(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "1", "2", "3")
         assert await r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 3
-        assert set(await r.smembers("{foo}c")) == {b"1", b"2", b"3"}
+        assert await r.smembers("{foo}c") == {b"1", b"2", b"3"}
         await r.sadd("{foo}b", "2", "3")
         assert await r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 1
         assert await r.smembers("{foo}c") == {b"1"}
 
-    @skip_if_resp_version(2)
-    async def test_cluster_sdiffstore_resp3(self, r: RedisCluster) -> None:
-        await r.sadd("{foo}a", "1", "2", "3")
-        assert await r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 3
-        assert await r.smembers("{foo}c") == [b"1", b"2", b"3"]
-        await r.sadd("{foo}b", "2", "3")
-        assert await r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 1
-        assert await r.smembers("{foo}c") == [b"1"]
-
-    @skip_if_resp_version(3)
     async def test_cluster_sinter(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "1", "2", "3")
         assert await r.sinter("{foo}a", "{foo}b") == set()
         await r.sadd("{foo}b", "2", "3")
-        assert set(await r.sinter("{foo}a", "{foo}b")) == {b"2", b"3"}
+        assert await r.sinter("{foo}a", "{foo}b") == {b"2", b"3"}
 
-    @skip_if_resp_version(2)
-    async def test_cluster_sinter_resp3(self, r: RedisCluster) -> None:
-        await r.sadd("{foo}a", "1", "2", "3")
-        assert await r.sinter("{foo}a", "{foo}b") == []
-        await r.sadd("{foo}b", "2", "3")
-        assert await r.sinter("{foo}a", "{foo}b") == [b"2", b"3"]
-
-    @skip_if_resp_version(3)
     async def test_cluster_sinterstore(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "1", "2", "3")
         assert await r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 0
         assert await r.smembers("{foo}c") == set()
         await r.sadd("{foo}b", "2", "3")
         assert await r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 2
-        assert set(await r.smembers("{foo}c")) == {b"2", b"3"}
-
-    @skip_if_resp_version(2)
-    async def test_cluster_sinterstore_resp3(self, r: RedisCluster) -> None:
-        await r.sadd("{foo}a", "1", "2", "3")
-        assert await r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 0
-        assert await r.smembers("{foo}c") == []
-        await r.sadd("{foo}b", "2", "3")
-        assert await r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 2
-        assert await r.smembers("{foo}c") == [b"2", b"3"]
+        assert await r.smembers("{foo}c") == {b"2", b"3"}
 
-    @skip_if_resp_version(3)
     async def test_cluster_smove(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "a1", "a2")
         await r.sadd("{foo}b", "b1", "b2")
         assert await r.smove("{foo}a", "{foo}b", "a1")
         assert await r.smembers("{foo}a") == {b"a2"}
-        assert set(await r.smembers("{foo}b")) == {b"b1", b"b2", b"a1"}
-
-    @skip_if_resp_version(2)
-    async def test_cluster_smove_resp3(self, r: RedisCluster) -> None:
-        await r.sadd("{foo}a", "a1", "a2")
-        await r.sadd("{foo}b", "b1", "b2")
-        assert await r.smove("{foo}a", "{foo}b", "a1")
-        assert await r.smembers("{foo}a") == [b"a2"]
-        assert await r.smembers("{foo}b") == [b"b1", b"b2", b"a1"]
+        assert await r.smembers("{foo}b") == {b"b1", b"b2", b"a1"}
 
     async def test_cluster_sunion(self, r: RedisCluster) -> None:
         await r.sadd("{foo}a", "1", "2")
diff --git a/tests/test_asyncio/test_commands.py b/tests/test_asyncio/test_commands.py
index 1eb7d1a8f7..f6ed07fab5 100644
--- a/tests/test_asyncio/test_commands.py
+++ b/tests/test_asyncio/test_commands.py
@@ -24,7 +24,6 @@
     assert_resp_response,
     assert_resp_response_in,
     is_resp2_connection,
-    skip_if_resp_version,
     skip_if_server_version_gte,
     skip_if_server_version_lt,
     skip_unless_arch_bits,
@@ -1413,59 +1412,29 @@ async def test_scard(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
         assert await r.scard("a") == 3
 
-    @skip_if_resp_version(3)
     @pytest.mark.onlynoncluster
     async def test_sdiff(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
-        assert set(await r.sdiff("a", "b")) == {b"1", b"2", b"3"}
+        assert await r.sdiff("a", "b") == {b"1", b"2", b"3"}
         await r.sadd("b", "2", "3")
         assert await r.sdiff("a", "b") == {b"1"}
 
-    @skip_if_resp_version(2)
-    @pytest.mark.onlynoncluster
-    async def test_sdiff_resp3(self, r: redis.Redis):
-        await r.sadd("a", "1", "2", "3")
-        assert set(await r.sdiff("a", "b")) == {b"1", b"2", b"3"}
-        await r.sadd("b", "2", "3")
-        assert await r.sdiff("a", "b") == [b"1"]
-
-    @skip_if_resp_version(3)
     @pytest.mark.onlynoncluster
     async def test_sdiffstore(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
         assert await r.sdiffstore("c", "a", "b") == 3
-        assert set(await r.smembers("c")) == {b"1", b"2", b"3"}
+        assert await r.smembers("c") == {b"1", b"2", b"3"}
         await r.sadd("b", "2", "3")
         assert await r.sdiffstore("c", "a", "b") == 1
         assert await r.smembers("c") == {b"1"}
 
-    @skip_if_resp_version(2)
-    @pytest.mark.onlynoncluster
-    async def test_sdiffstore_resp3(self, r: redis.Redis):
-        await r.sadd("a", "1", "2", "3")
-        assert await r.sdiffstore("c", "a", "b") == 3
-        assert set(await r.smembers("c")) == {b"1", b"2", b"3"}
-        await r.sadd("b", "2", "3")
-        assert await r.sdiffstore("c", "a", "b") == 1
-        assert await r.smembers("c") == [b"1"]
-
-    @skip_if_resp_version(3)
     @pytest.mark.onlynoncluster
     async def test_sinter(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
         assert await r.sinter("a", "b") == set()
         await r.sadd("b", "2", "3")
-        assert set(await r.sinter("a", "b")) == {b"2", b"3"}
+        assert await r.sinter("a", "b") == {b"2", b"3"}
 
-    @skip_if_resp_version(2)
-    @pytest.mark.onlynoncluster
-    async def test_sinter_resp3(self, r: redis.Redis):
-        await r.sadd("a", "1", "2", "3")
-        assert await r.sinter("a", "b") == []
-        await r.sadd("b", "2", "3")
-        assert await r.sinter("a", "b") == [b"2", b"3"]
-
-    @skip_if_resp_version(3)
     @pytest.mark.onlynoncluster
     async def test_sinterstore(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
@@ -1473,17 +1442,7 @@ async def test_sinterstore(self, r: redis.Redis):
         assert await r.smembers("c") == set()
         await r.sadd("b", "2", "3")
         assert await r.sinterstore("c", "a", "b") == 2
-        assert set(await r.smembers("c")) == {b"2", b"3"}
-
-    @skip_if_resp_version(2)
-    @pytest.mark.onlynoncluster
-    async def test_sinterstore_resp3(self, r: redis.Redis):
-        await r.sadd("a", "1", "2", "3")
-        assert await r.sinterstore("c", "a", "b") == 0
-        assert await r.smembers("c") == []
-        await r.sadd("b", "2", "3")
-        assert await r.sinterstore("c", "a", "b") == 2
-        assert set(await r.smembers("c")) == {b"2", b"3"}
+        assert await r.smembers("c") == {b"2", b"3"}
 
     async def test_sismember(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
@@ -1496,23 +1455,13 @@ async def test_smembers(self, r: redis.Redis):
         await r.sadd("a", "1", "2", "3")
         assert set(await r.smembers("a")) == {b"1", b"2", b"3"}
 
-    @skip_if_resp_version(3)
     @pytest.mark.onlynoncluster
     async def test_smove(self, r: redis.Redis):
         await r.sadd("a", "a1", "a2")
         await r.sadd("b", "b1", "b2")
         assert await r.smove("a", "b", "a1")
         assert await r.smembers("a") == {b"a2"}
-        assert set(await r.smembers("b")) == {b"b1", b"b2", b"a1"}
-
-    @skip_if_resp_version(2)
-    @pytest.mark.onlynoncluster
-    async def test_smove_resp3(self, r: redis.Redis):
-        await r.sadd("a", "a1", "a2")
-        await r.sadd("b", "b1", "b2")
-        assert await r.smove("a", "b", "a1")
-        assert await r.smembers("a") == [b"a2"]
-        assert set(await r.smembers("b")) == {b"b1", b"b2", b"a1"}
+        assert await r.smembers("b") == {b"b1", b"b2", b"a1"}
 
     async def test_spop(self, r: redis.Redis):
         s = [b"1", b"2", b"3"]
diff --git a/tests/test_cluster.py b/tests/test_cluster.py
index e870e9bb73..fe5852d1fb 100644
--- a/tests/test_cluster.py
+++ b/tests/test_cluster.py
@@ -46,7 +46,6 @@
     assert_resp_response,
     is_resp2_connection,
     skip_if_redis_enterprise,
-    skip_if_resp_version,
     skip_if_server_version_lt,
     skip_unless_arch_bits,
     wait_for_command,
@@ -1864,96 +1863,51 @@ def test_cluster_rpoplpush(self, r):
         assert r.lrange("{foo}a", 0, -1) == [b"a1", b"a2"]
         assert r.lrange("{foo}b", 0, -1) == [b"a3", b"b1", b"b2", b"b3"]
 
-    @skip_if_resp_version(3)
     def test_cluster_sdiff(self, r):
         r.sadd("{foo}a", "1", "2", "3")
-        assert set(r.sdiff("{foo}a", "{foo}b")) == {b"1", b"2", b"3"}
+        assert r.sdiff("{foo}a", "{foo}b") == {b"1", b"2", b"3"}
         r.sadd("{foo}b", "2", "3")
         assert r.sdiff("{foo}a", "{foo}b") == {b"1"}
 
-    @skip_if_resp_version(2)
-    def test_cluster_sdiff_resp3(self, r):
-        r.sadd("{foo}a", "1", "2", "3")
-        assert set(r.sdiff("{foo}a", "{foo}b")) == {b"1", b"2", b"3"}
-        r.sadd("{foo}b", "2", "3")
-        assert r.sdiff("{foo}a", "{foo}b") == [b"1"]
-
-    @skip_if_resp_version(3)
     def test_cluster_sdiffstore(self, r):
         r.sadd("{foo}a", "1", "2", "3")
         assert r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 3
-        assert set(r.smembers("{foo}c")) == {b"1", b"2", b"3"}
+        assert r.smembers("{foo}c") == {b"1", b"2", b"3"}
         r.sadd("{foo}b", "2", "3")
         assert r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 1
         assert r.smembers("{foo}c") == {b"1"}
 
-    @skip_if_resp_version(2)
-    def test_cluster_sdiffstore_resp3(self, r):
-        r.sadd("{foo}a", "1", "2", "3")
-        assert r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 3
-        assert set(r.smembers("{foo}c")) == {b"1", b"2", b"3"}
-        r.sadd("{foo}b", "2", "3")
-        assert r.sdiffstore("{foo}c", "{foo}a", "{foo}b") == 1
-        assert r.smembers("{foo}c") == [b"1"]
-
-    @skip_if_resp_version(3)
     def test_cluster_sinter(self, r):
         r.sadd("{foo}a", "1", "2", "3")
         assert r.sinter("{foo}a", "{foo}b") == set()
         r.sadd("{foo}b", "2", "3")
-        assert set(r.sinter("{foo}a", "{foo}b")) == {b"2", b"3"}
-
-    @skip_if_resp_version(2)
-    def test_cluster_sinter_resp3(self, r):
-        r.sadd("{foo}a", "1", "2", "3")
-        assert r.sinter("{foo}a", "{foo}b") == []
-        r.sadd("{foo}b", "2", "3")
-        assert set(r.sinter("{foo}a", "{foo}b")) == {b"2", b"3"}
+        assert r.sinter("{foo}a", "{foo}b") == {b"2", b"3"}
 
-    @skip_if_resp_version(3)
     def test_cluster_sinterstore(self, r):
         r.sadd("{foo}a", "1", "2", "3")
         assert r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 0
         assert r.smembers("{foo}c") == set()
         r.sadd("{foo}b", "2", "3")
         assert r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 2
-        assert set(r.smembers("{foo}c")) == {b"2", b"3"}
-
-    @skip_if_resp_version(2)
-    def test_cluster_sinterstore_resp3(self, r):
-        r.sadd("{foo}a", "1", "2", "3")
-        assert r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 0
-        assert r.smembers("{foo}c") == []
-        r.sadd("{foo}b", "2", "3")
-        assert r.sinterstore("{foo}c", "{foo}a", "{foo}b") == 2
-        assert set(r.smembers("{foo}c")) == {b"2", b"3"}
+        assert r.smembers("{foo}c") == {b"2", b"3"}
 
-    @skip_if_resp_version(3)
     def test_cluster_smove(self, r):
         r.sadd("{foo}a", "a1", "a2")
         r.sadd("{foo}b", "b1", "b2")
         assert r.smove("{foo}a", "{foo}b", "a1")
         assert r.smembers("{foo}a") == {b"a2"}
-        assert set(r.smembers("{foo}b")) == {b"b1", b"b2", b"a1"}
-
-    @skip_if_resp_version(2)
-    def test_cluster_smove_resp3(self, r):
-        r.sadd("{foo}a", "a1", "a2")
-        r.sadd("{foo}b", "b1", "b2")
-        assert r.smove("{foo}a", "{foo}b", "a1")
-        assert r.smembers("{foo}a") == [b"a2"]
-        assert set(r.smembers("{foo}b")) == {b"b1", b"b2", b"a1"}
+        assert r.smembers("{foo}b") == {b"b1", b"b2", b"a1"}
 
     def test_cluster_sunion(self, r):
         r.sadd("{foo}a", "1", "2")
         r.sadd("{foo}b", "2", "3")
-        assert set(r.sunion("{foo}a", "{foo}b")) == {b"1", b"2", b"3"}
+        assert r.sunion("{foo}a", "{foo}b") == {b"1", b"2", b"3"}
 
     def test_cluster_sunionstore(self, r):
         r.sadd("{foo}a", "1", "2")
         r.sadd("{foo}b", "2", "3")
         assert r.sunionstore("{foo}c", "{foo}a", "{foo}b") == 3
-        assert set(r.smembers("{foo}c")) == {b"1", b"2", b"3"}
+        assert r.smembers("{foo}c") == {b"1", b"2", b"3"}
 
     @skip_if_server_version_lt("6.2.0")
     def test_cluster_zdiff(self, r):
diff --git a/tests/test_commands.py b/tests/test_commands.py
index e4062f922c..4cad4c14b6 100644
--- a/tests/test_commands.py
+++ b/tests/test_commands.py
@@ -25,7 +25,6 @@
     assert_resp_response_in,
     is_resp2_connection,
     skip_if_redis_enterprise,
-    skip_if_resp_version,
     skip_if_server_version_gte,
     skip_if_server_version_lt,
     skip_unless_arch_bits,
@@ -2246,56 +2245,27 @@ def test_scard(self, r):
         assert r.scard("a") == 3
 
     @pytest.mark.onlynoncluster
-    @skip_if_resp_version(3)
     def test_sdiff(self, r):
         r.sadd("a", "1", "2", "3")
-        assert set(r.sdiff("a", "b")) == {b"1", b"2", b"3"}
+        assert r.sdiff("a", "b") == {b"1", b"2", b"3"}
         r.sadd("b", "2", "3")
         assert r.sdiff("a", "b") == {b"1"}
 
     @pytest.mark.onlynoncluster
-    @skip_if_resp_version(2)
-    def test_sdiff_resp3(self, r):
-        r.sadd("a", "1", "2", "3")
-        assert set(r.sdiff("a", "b")) == {b"1", b"2", b"3"}
-        r.sadd("b", "2", "3")
-        assert r.sdiff("a", "b") == [b"1"]
-
-    @pytest.mark.onlynoncluster
-    @skip_if_resp_version(3)
     def test_sdiffstore(self, r):
         r.sadd("a", "1", "2", "3")
         assert r.sdiffstore("c", "a", "b") == 3
-        assert set(r.smembers("c")) == {b"1", b"2", b"3"}
+        assert r.smembers("c") == {b"1", b"2", b"3"}
         r.sadd("b", "2", "3")
         assert r.sdiffstore("c", "a", "b") == 1
         assert r.smembers("c") == {b"1"}
 
     @pytest.mark.onlynoncluster
-    @skip_if_resp_version(2)
-    def test_sdiffstore_resp3(self, r):
-        r.sadd("a", "1", "2", "3")
-        assert r.sdiffstore("c", "a", "b") == 3
-        assert set(r.smembers("c")) == {b"1", b"2", b"3"}
-        r.sadd("b", "2", "3")
-        assert r.sdiffstore("c", "a", "b") == 1
-        assert r.smembers("c") == [b"1"]
-
-    @pytest.mark.onlynoncluster
-    @skip_if_resp_version(3)
     def test_sinter(self, r):
         r.sadd("a", "1", "2", "3")
         assert r.sinter("a", "b") == set()
         r.sadd("b", "2", "3")
-        assert set(r.sinter("a", "b")) == {b"2", b"3"}
-
-    @pytest.mark.onlynoncluster
-    @skip_if_resp_version(2)
-    def test_sinter_resp3(self, r):
-        r.sadd("a", "1", "2", "3")
-        assert r.sinter("a", "b") == []
-        r.sadd("b", "2", "3")
-        assert set(r.sinter("a", "b")) == {b"2", b"3"}
+        assert r.sinter("a", "b") == {b"2", b"3"}
 
     @pytest.mark.onlynoncluster
     @skip_if_server_version_lt("7.0.0")
@@ -2307,24 +2277,13 @@ def test_sintercard(self, r):
         assert r.sintercard(3, ["a", "b", "c"], limit=1) == 1
 
     @pytest.mark.onlynoncluster
-    @skip_if_resp_version(3)
     def test_sinterstore(self, r):
         r.sadd("a", "1", "2", "3")
         assert r.sinterstore("c", "a", "b") == 0
         assert r.smembers("c") == set()
         r.sadd("b", "2", "3")
         assert r.sinterstore("c", "a", "b") == 2
-        assert set(r.smembers("c")) == {b"2", b"3"}
-
-    @pytest.mark.onlynoncluster
-    @skip_if_resp_version(2)
-    def test_sinterstore_resp3(self, r):
-        r.sadd("a", "1", "2", "3")
-        assert r.sinterstore("c", "a", "b") == 0
-        assert r.smembers("c") == []
-        r.sadd("b", "2", "3")
-        assert r.sinterstore("c", "a", "b") == 2
-        assert set(r.smembers("c")) == {b"2", b"3"}
+        assert r.smembers("c") == {b"2", b"3"}
 
     def test_sismember(self, r):
         r.sadd("a", "1", "2", "3")
@@ -2345,22 +2304,12 @@ def test_smismember(self, r):
         assert r.smismember("a", ["1", "4", "2", "3"]) == result_list
 
     @pytest.mark.onlynoncluster
-    @skip_if_resp_version(3)
     def test_smove(self, r):
         r.sadd("a", "a1", "a2")
         r.sadd("b", "b1", "b2")
         assert r.smove("a", "b", "a1")
         assert r.smembers("a") == {b"a2"}
-        assert set(r.smembers("b")) == {b"b1", b"b2", b"a1"}
-
-    @pytest.mark.onlynoncluster
-    @skip_if_resp_version(2)
-    def test_smove_resp3(self, r):
-        r.sadd("a", "a1", "a2")
-        r.sadd("b", "b1", "b2")
-        assert r.smove("a", "b", "a1")
-        assert r.smembers("a") == [b"a2"]
-        assert set(r.smembers("b")) == {b"b1", b"b2", b"a1"}
+        assert r.smembers("b") == {b"b1", b"b2", b"a1"}
 
     def test_spop(self, r):
         s = [b"1", b"2", b"3"]

From 784ea60d6759962cf2b9a9acb5b0f54cb84e7b82 Mon Sep 17 00:00:00 2001
From: vladvildanov <divinez122@outlook.com>
Date: Wed, 2 Oct 2024 16:24:39 +0300
Subject: [PATCH 6/6] Updated doctests

---
 doctests/dt_set.py | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/doctests/dt_set.py b/doctests/dt_set.py
index 0c0562ac80..fc66410b45 100644
--- a/doctests/dt_set.py
+++ b/doctests/dt_set.py
@@ -58,11 +58,11 @@
 r.sadd("bikes:racing:usa", "bike:1", "bike:4")
 # HIDE_END
 res7 = r.sinter("bikes:racing:france", "bikes:racing:usa")
-print(res7)  # >>> ['bike:1']
+print(res7)  # >>> {'bike:1'}
 # STEP_END
 
 # REMOVE_START
-assert res7 == ["bike:1"]
+assert res7 == {"bike:1"}
 # REMOVE_END
 
 # STEP_START scard
@@ -83,12 +83,12 @@
 print(res9)  # >>> 3
 
 res10 = r.smembers("bikes:racing:france")
-print(res10)  # >>> ['bike:1', 'bike:2', 'bike:3']
+print(res10)  # >>> {'bike:1', 'bike:2', 'bike:3'}
 # STEP_END
 
 # REMOVE_START
 assert res9 == 3
-assert res10 == ['bike:1', 'bike:2', 'bike:3']
+assert res10 == {'bike:1', 'bike:2', 'bike:3'}
 # REMOVE_END
 
 # STEP_START smismember
@@ -109,11 +109,11 @@
 r.sadd("bikes:racing:usa", "bike:1", "bike:4")
 
 res13 = r.sdiff("bikes:racing:france", "bikes:racing:usa")
-print(res13)  # >>> ['bike:2', 'bike:3']
+print(res13)  # >>> {'bike:2', 'bike:3'}
 # STEP_END
 
 # REMOVE_START
-assert res13 == ['bike:2', 'bike:3']
+assert res13 == {'bike:2', 'bike:3'}
 r.delete("bikes:racing:france")
 r.delete("bikes:racing:usa")
 # REMOVE_END
@@ -124,27 +124,27 @@
 r.sadd("bikes:racing:italy", "bike:1", "bike:2", "bike:3", "bike:4")
 
 res13 = r.sinter("bikes:racing:france", "bikes:racing:usa", "bikes:racing:italy")
-print(res13)  # >>> ['bike:1']
+print(res13)  # >>> {'bike:1'}
 
 res14 = r.sunion("bikes:racing:france", "bikes:racing:usa", "bikes:racing:italy")
-print(res14)  # >>> ['bike:1', 'bike:2', 'bike:3', 'bike:4']
+print(res14)  # >>> {'bike:1', 'bike:2', 'bike:3', 'bike:4'}
 
 res15 = r.sdiff("bikes:racing:france", "bikes:racing:usa", "bikes:racing:italy")
-print(res15)  # >>> []
+print(res15)  # >>> {}
 
 res16 = r.sdiff("bikes:racing:usa", "bikes:racing:france")
-print(res16)  # >>> ['bike:4']
+print(res16)  # >>> {'bike:4'}
 
 res17 = r.sdiff("bikes:racing:france", "bikes:racing:usa")
-print(res17)  # >>> ['bike:2', 'bike:3']
+print(res17)  # >>> {'bike:2', 'bike:3'}
 # STEP_END
 
 # REMOVE_START
-assert res13 == ['bike:1']
-assert res14 == ['bike:1', 'bike:2', 'bike:3', 'bike:4']
-assert res15 == []
-assert res16 == ['bike:4']
-assert res17 == ['bike:2', 'bike:3']
+assert res13 == {'bike:1'}
+assert res14 == {'bike:1', 'bike:2', 'bike:3', 'bike:4'}
+assert res15 == {}
+assert res16 == {'bike:4'}
+assert res17 == {'bike:2', 'bike:3'}
 r.delete("bikes:racing:france")
 r.delete("bikes:racing:usa")
 r.delete("bikes:racing:italy")
@@ -160,7 +160,7 @@
 print(res19)  # >>> bike:3
 
 res20 = r.smembers("bikes:racing:france")
-print(res20)  # >>> ['bike:2', 'bike:4', 'bike:5']
+print(res20)  # >>> {'bike:2', 'bike:4', 'bike:5'}
 
 res21 = r.srandmember("bikes:racing:france")
 print(res21)  # >>> bike:4