Clean up test supoort enterprise environments

tests/conftest.py

@@ -120,10 +120,10 @@ def pytest_addoption(parser):
 def _get_info(redis_url):
     client = redis.Redis.from_url(redis_url)
     info = client.info()
-    cmds = [command.upper() for command in client.command().keys()]
-    if "dping" in cmds:
+    try:
+        client.execute_command("DPING")
         info["enterprise"] = True
-    else:
+    except redis.ResponseError:
         info["enterprise"] = False
     client.connection_pool.disconnect()
     return info

tests/test_cluster.py

@@ -629,6 +629,7 @@ def test_get_node_from_key(self, r):
             assert replica.server_type == REPLICA
             assert replica in slot_nodes
 
+    @skip_if_redis_enterprise()
     def test_not_require_full_coverage_cluster_down_error(self, r):
         """
         When require_full_coverage is set to False (default client config) and not
@@ -840,11 +841,13 @@ def test_cluster_pubsub_numsub(self, r):
         channels = [(b"foo", 1), (b"bar", 2), (b"baz", 3)]
         assert r.pubsub_numsub("foo", "bar", "baz", target_nodes="all") == channels
 
+    @skip_if_redis_enterprise()
     def test_cluster_myid(self, r):
         node = r.get_random_node()
         myid = r.cluster_myid(node)
         assert len(myid) == 40
 
+    @skip_if_redis_enterprise()
     def test_cluster_slots(self, r):
         mock_all_nodes_resp(r, default_cluster_slots)
         cluster_slots = r.cluster_slots()
@@ -853,17 +856,20 @@ def test_cluster_slots(self, r):
         assert cluster_slots.get((0, 8191)) is not None
         assert cluster_slots.get((0, 8191)).get("primary") == ("127.0.0.1", 7000)
 
+    @skip_if_redis_enterprise()
     def test_cluster_addslots(self, r):
         node = r.get_random_node()
         mock_node_resp(node, "OK")
         assert r.cluster_addslots(node, 1, 2, 3) is True
 
     @skip_if_server_version_lt("7.0.0")
+    @skip_if_redis_enterprise()
     def test_cluster_addslotsrange(self, r):
         node = r.get_random_node()
         mock_node_resp(node, "OK")
         assert r.cluster_addslotsrange(node, 1, 5)
 
+    @skip_if_redis_enterprise()
     def test_cluster_countkeysinslot(self, r):
         node = r.nodes_manager.get_node_from_slot(1)
         mock_node_resp(node, 2)
@@ -873,6 +879,7 @@ def test_cluster_count_failure_report(self, r):
         mock_all_nodes_resp(r, 0)
         assert r.cluster_count_failure_report("node_0") == 0
 
+    @skip_if_redis_enterprise()
     def test_cluster_delslots(self):
         cluster_slots = [
             [
@@ -897,12 +904,14 @@ def test_cluster_delslots(self):
         assert node1.redis_connection.connection.read_response.called
 
     @skip_if_server_version_lt("7.0.0")
+    @skip_if_redis_enterprise()
     def test_cluster_delslotsrange(self, r):
         node = r.get_random_node()
         mock_node_resp(node, "OK")
         r.cluster_addslots(node, 1, 2, 3, 4, 5)
         assert r.cluster_delslotsrange(1, 5)
 
+    @skip_if_redis_enterprise()
     def test_cluster_failover(self, r):
         node = r.get_random_node()
         mock_node_resp(node, "OK")
@@ -912,20 +921,24 @@ def test_cluster_failover(self, r):
         with pytest.raises(RedisError):
             r.cluster_failover(node, "FORCT")
 
+    @skip_if_redis_enterprise()
     def test_cluster_info(self, r):
         info = r.cluster_info()
         assert isinstance(info, dict)
         assert info["cluster_state"] == "ok"
 
+    @skip_if_redis_enterprise()
     def test_cluster_keyslot(self, r):
         mock_all_nodes_resp(r, 12182)
         assert r.cluster_keyslot("foo") == 12182
 
+    @skip_if_redis_enterprise()
     def test_cluster_meet(self, r):
         node = r.get_default_node()
         mock_node_resp(node, "OK")
         assert r.cluster_meet("127.0.0.1", 6379) is True
 
+    @skip_if_redis_enterprise()
     def test_cluster_nodes(self, r):
         response = (
             "c8253bae761cb1ecb2b61857d85dfe455a0fec8b 172.17.0.7:7006 "
@@ -954,6 +967,7 @@ def test_cluster_nodes(self, r):
             == "c8253bae761cb1ecb2b61857d85dfe455a0fec8b"
         )
 
+    @skip_if_redis_enterprise()
     def test_cluster_replicate(self, r):
         node = r.get_random_node()
         all_replicas = r.get_replicas()
@@ -966,6 +980,7 @@ def test_cluster_replicate(self, r):
         else:
             assert results is True
 
+    @skip_if_redis_enterprise()
     def test_cluster_reset(self, r):
         mock_all_nodes_resp(r, "OK")
         assert r.cluster_reset() is True
@@ -974,6 +989,7 @@ def test_cluster_reset(self, r):
         for res in all_results.values():
             assert res is True
 
+    @skip_if_redis_enterprise()
     def test_cluster_save_config(self, r):
         node = r.get_random_node()
         all_nodes = r.get_nodes()
@@ -983,20 +999,23 @@ def test_cluster_save_config(self, r):
         for res in all_results.values():
             assert res is True
 
+    @skip_if_redis_enterprise()
     def test_cluster_get_keys_in_slot(self, r):
         response = [b"{foo}1", b"{foo}2"]
         node = r.nodes_manager.get_node_from_slot(12182)
         mock_node_resp(node, response)
         keys = r.cluster_get_keys_in_slot(12182, 4)
         assert keys == response
 
+    @skip_if_redis_enterprise()
     def test_cluster_set_config_epoch(self, r):
         mock_all_nodes_resp(r, "OK")
         assert r.cluster_set_config_epoch(3) is True
         all_results = r.cluster_set_config_epoch(3, target_nodes="all")
         for res in all_results.values():
             assert res is True
 
+    @skip_if_redis_enterprise()
     def test_cluster_setslot(self, r):
         node = r.get_random_node()
         mock_node_resp(node, "OK")
@@ -1014,6 +1033,7 @@ def test_cluster_setslot_stable(self, r):
         assert r.cluster_setslot_stable(12182) is True
         assert node.redis_connection.connection.read_response.called
 
+    @skip_if_redis_enterprise()
     def test_cluster_replicas(self, r):
         response = [
             b"01eca22229cf3c652b6fca0d09ff6941e0d2e3 "
@@ -1045,6 +1065,7 @@ def test_cluster_links(self, r):
         for i in range(0, len(res) - 1, 2):
             assert res[i][3] == res[i + 1][3]
 
+    @skip_if_redis_enterprise()
     def test_readonly(self):
         r = get_mocked_redis_client(host=default_host, port=default_port)
         mock_all_nodes_resp(r, "OK")
@@ -1055,6 +1076,7 @@ def test_readonly(self):
         for replica in r.get_replicas():
             assert replica.redis_connection.connection.read_response.called
 
+    @skip_if_redis_enterprise()
     def test_readwrite(self):
         r = get_mocked_redis_client(host=default_host, port=default_port)
         mock_all_nodes_resp(r, "OK")
@@ -1065,6 +1087,7 @@ def test_readwrite(self):
         for replica in r.get_replicas():
             assert replica.redis_connection.connection.read_response.called
 
+    @skip_if_redis_enterprise()
     def test_bgsave(self, r):
         assert r.bgsave()
         sleep(0.3)
@@ -1149,10 +1172,12 @@ def test_memory_usage(self, r):
         assert isinstance(r.memory_usage("foo"), int)
 
     @skip_if_server_version_lt("4.0.0")
+    @skip_if_redis_enterprise()
     def test_memory_malloc_stats(self, r):
         assert r.memory_malloc_stats()
 
     @skip_if_server_version_lt("4.0.0")
+    @skip_if_redis_enterprise()
     def test_memory_stats(self, r):
         # put a key into the current db to make sure that "db.<current-db>"
         # has data
@@ -1174,6 +1199,7 @@ def test_memory_doctor(self, r):
         with pytest.raises(NotImplementedError):
             r.memory_doctor()
 
+    @skip_if_redis_enterprise()
     def test_lastsave(self, r):
         node = r.get_primaries()[0]
         assert isinstance(r.lastsave(target_nodes=node), datetime.datetime)
@@ -1216,6 +1242,7 @@ def test_client_pause(self, r):
             r.client_pause(timeout="not an integer", target_nodes=node)
 
     @skip_if_server_version_lt("6.2.0")
+    @skip_if_redis_enterprise()
     def test_client_unpause(self, r):
         assert r.client_unpause()
 

tests/test_command_parser.py

@@ -2,7 +2,7 @@
 
 from redis.commands import CommandsParser
 
-from .conftest import skip_if_server_version_lt
+from .conftest import skip_if_redis_enterprise, skip_if_server_version_lt
 
 
 class TestCommandsParser:
@@ -21,6 +21,7 @@ def test_get_keys_predetermined_key_location(self, r):
         assert commands_parser.get_keys(r, *args3) == ["foo", "bar", "foobar"]
 
     @pytest.mark.filterwarnings("ignore:ResponseError")
+    @skip_if_redis_enterprise()
     def test_get_moveable_keys(self, r):
         commands_parser = CommandsParser(r)
         args1 = [