Added Sets alignment for RESP2 and RESP3

Author: vladvildanov

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",

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")

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,77 +1412,37 @@ 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")
         assert await r.sinterstore("c", "a", "b") == 0
         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"]

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):