redis 3.3.5 → 4.0.3

data/test/cluster_client_transactions_test.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+# ruby -w -Itest test/cluster_client_transactions_test.rb
+class TestClusterClientTransactions < Test::Unit::TestCase
+  include Helper::Cluster
+
+  def test_transaction_with_hash_tag
+    rc1 = redis
+    rc2 = build_another_client
+
+    rc1.multi do |cli|
+      100.times { |i| cli.set("{key}#{i}", i) }
+    end
+
+    100.times { |i| assert_equal i.to_s, rc1.get("{key}#{i}") }
+    100.times { |i| assert_equal i.to_s, rc2.get("{key}#{i}") }
+  end
+
+  def test_transaction_without_hash_tag
+    rc1 = redis
+    rc2 = build_another_client
+
+    assert_raise(Redis::Cluster::CrossSlotPipeliningError) do
+      rc1.multi do |cli|
+        100.times { |i| cli.set("key#{i}", i) }
+      end
+    end
+
+    100.times { |i| assert_equal nil, rc1.get("key#{i}") }
+    100.times { |i| assert_equal nil, rc2.get("key#{i}") }
+  end
+
+  def test_transaction_with_replicas
+    rc1 = build_another_client(replica: true)
+    rc2 = build_another_client(replica: true)
+
+    rc1.multi do |cli|
+      100.times { |i| cli.set("{key}#{i}", i) }
+    end
+
+    sleep 0.1
+
+    100.times { |i| assert_equal i.to_s, rc1.get("{key}#{i}") }
+    100.times { |i| assert_equal i.to_s, rc2.get("{key}#{i}") }
+  end
+
+  def test_transaction_with_watch
+    rc1 = redis
+    rc2 = build_another_client
+
+    rc1.set('{key}1', 100)
+    rc1.watch('{key}1')
+
+    rc2.set('{key}1', 200)
+    val = rc1.get('{key}1').to_i
+    val += 1
+
+    rc1.multi do |cli|
+      cli.set('{key}1', val)
+      cli.set('{key}2', 300)
+    end
+
+    assert_equal '200', rc1.get('{key}1')
+    assert_equal '200', rc2.get('{key}1')
+
+    assert_equal nil, rc1.get('{key}2')
+    assert_equal nil, rc2.get('{key}2')
+  end
+end

data/test/cluster_commands_on_cluster_test.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+# ruby -w -Itest test/cluster_commands_on_cluster_test.rb
+# @see https://redis.io/commands#cluster
+class TestClusterCommandsOnCluster < Test::Unit::TestCase
+  include Helper::Cluster
+
+  def test_cluster_addslots
+    assert_raise(Redis::Cluster::OrchestrationCommandNotSupported, 'CLUSTER ADDSLOTS command should be...') do
+      redis.cluster(:addslots, 0, 1, 2)
+    end
+  end
+
+  def test_cluster_count_failure_reports
+    assert_raise(Redis::CommandError, 'ERR Unknown node unknown-node-id') do
+      redis.cluster('count-failure-reports', 'unknown-node-id')
+    end
+
+    node_id = redis.cluster(:nodes).first.fetch('node_id')
+    assert_true(redis.cluster('count-failure-reports', node_id) >= 0)
+  end
+
+  def test_cluster_countkeysinslot
+    assert_true(redis.cluster(:countkeysinslot, 0) >= 0)
+    assert_true(redis.cluster(:countkeysinslot, 16383) >= 0)
+
+    assert_raise(Redis::CommandError, 'ERR Invalid slot') do
+      redis.cluster(:countkeysinslot, -1)
+    end
+
+    assert_raise(Redis::CommandError, 'ERR Invalid slot') do
+      redis.cluster(:countkeysinslot, 16384)
+    end
+  end
+
+  def test_cluster_delslots
+    assert_raise(Redis::Cluster::OrchestrationCommandNotSupported, 'CLUSTER DELSLOTS command should be...') do
+      redis.cluster(:delslots, 0, 1, 2)
+    end
+  end
+
+  def test_cluster_failover
+    assert_raise(Redis::Cluster::OrchestrationCommandNotSupported, 'CLUSTER FAILOVER command should be...') do
+      redis.cluster(:failover, 'FORCE')
+    end
+  end
+
+  def test_cluster_forget
+    assert_raise(Redis::Cluster::OrchestrationCommandNotSupported, 'CLUSTER FORGET command should be...') do
+      redis.cluster(:forget, 'unknown-node-id')
+    end
+  end
+
+  def test_cluster_getkeysinslot
+    assert_instance_of Array, redis.cluster(:getkeysinslot, 0, 3)
+  end
+
+  def test_cluster_info
+    info = redis.cluster(:info)
+
+    assert_equal '3', info.fetch('cluster_size')
+  end
+
+  def test_cluster_keyslot
+    assert_equal Redis::Cluster::KeySlotConverter.convert('hogehoge'), redis.cluster(:keyslot, 'hogehoge')
+    assert_equal Redis::Cluster::KeySlotConverter.convert('12345'), redis.cluster(:keyslot, '12345')
+    assert_equal Redis::Cluster::KeySlotConverter.convert('foo'), redis.cluster(:keyslot, 'boo{foo}woo')
+    assert_equal Redis::Cluster::KeySlotConverter.convert('antirez.is.cool'), redis.cluster(:keyslot, 'antirez.is.cool')
+    assert_equal Redis::Cluster::KeySlotConverter.convert(''), redis.cluster(:keyslot, '')
+  end
+
+  def test_cluster_meet
+    assert_raise(Redis::Cluster::OrchestrationCommandNotSupported, 'CLUSTER MEET command should be...') do
+      redis.cluster(:meet, '127.0.0.1', 11211)
+    end
+  end
+
+  def test_cluster_nodes
+    cluster_nodes = redis.cluster(:nodes)
+    sample_node = cluster_nodes.first
+
+    assert_equal 6, cluster_nodes.length
+    assert_equal true, sample_node.key?('node_id')
+    assert_equal true, sample_node.key?('ip_port')
+    assert_equal true, sample_node.key?('flags')
+    assert_equal true, sample_node.key?('master_node_id')
+    assert_equal true, sample_node.key?('ping_sent')
+    assert_equal true, sample_node.key?('pong_recv')
+    assert_equal true, sample_node.key?('config_epoch')
+    assert_equal true, sample_node.key?('link_state')
+    assert_equal true, sample_node.key?('slots')
+  end
+
+  def test_cluster_replicate
+    assert_raise(Redis::Cluster::OrchestrationCommandNotSupported, 'CLUSTER REPLICATE command should be...') do
+      redis.cluster(:replicate)
+    end
+  end
+
+  def test_cluster_reset
+    assert_raise(Redis::Cluster::OrchestrationCommandNotSupported, 'CLUSTER RESET command should be...') do
+      redis.cluster(:reset)
+    end
+  end
+
+  def test_cluster_saveconfig
+    assert_equal 'OK', redis.cluster(:saveconfig)
+  end
+
+  def test_cluster_set_config_epoch
+    assert_raise(Redis::Cluster::OrchestrationCommandNotSupported, 'CLUSTER SET-CONFIG-EPOCH command should be...') do
+      redis.cluster('set-config-epoch')
+    end
+  end
+
+  def test_cluster_setslot
+    assert_raise(Redis::Cluster::OrchestrationCommandNotSupported, 'CLUSTER SETSLOT command should be...') do
+      redis.cluster(:setslot)
+    end
+  end
+
+  def test_cluster_slaves
+    cluster_nodes = redis.cluster(:nodes)
+
+    sample_master_node_id = cluster_nodes.find { |n| n.fetch('master_node_id') == '-' }.fetch('node_id')
+    sample_slave_node_id = cluster_nodes.find { |n| n.fetch('master_node_id') != '-' }.fetch('node_id')
+
+    assert_equal 'slave', redis.cluster(:slaves, sample_master_node_id).first.fetch('flags').first
+    assert_raise(Redis::CommandError, 'ERR The specified node is not a master') do
+      redis.cluster(:slaves, sample_slave_node_id)
+    end
+  end
+
+  def test_cluster_slots
+    slots = redis.cluster(:slots)
+    sample_slot = slots.first
+
+    assert_equal 3, slots.length
+    assert_equal true, sample_slot.key?('start_slot')
+    assert_equal true, sample_slot.key?('end_slot')
+    assert_equal true, sample_slot.key?('master')
+    assert_equal true, sample_slot.fetch('master').key?('ip')
+    assert_equal true, sample_slot.fetch('master').key?('port')
+    assert_equal true, sample_slot.fetch('master').key?('node_id')
+    assert_equal true, sample_slot.key?('replicas')
+    assert_equal true, sample_slot.fetch('replicas').is_a?(Array)
+    assert_equal true, sample_slot.fetch('replicas').first.key?('ip')
+    assert_equal true, sample_slot.fetch('replicas').first.key?('port')
+    assert_equal true, sample_slot.fetch('replicas').first.key?('node_id')
+  end
+
+  def test_readonly
+    assert_raise(Redis::Cluster::OrchestrationCommandNotSupported, 'READONLY command should be...') do
+      redis.readonly
+    end
+  end
+
+  def test_readwrite
+    assert_raise(Redis::Cluster::OrchestrationCommandNotSupported, 'READWRITE command should be...') do
+      redis.readwrite
+    end
+  end
+end

data/test/cluster_commands_on_connection_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+# ruby -w -Itest test/cluster_commands_on_connection_test.rb
+# @see https://redis.io/commands#connection
+class TestClusterCommandsOnConnection < Test::Unit::TestCase
+  include Helper::Cluster
+
+  def test_auth
+    redis_cluster_mock(auth: ->(*_) { '+OK' }) do |redis|
+      assert_equal 'OK', redis.auth('my-password-123')
+    end
+  end
+
+  def test_echo
+    assert_equal 'hogehoge', redis.echo('hogehoge')
+  end
+
+  def test_ping
+    assert_equal 'hogehoge', redis.ping('hogehoge')
+  end
+
+  def test_quit
+    redis2 = build_another_client
+    assert_equal 'OK', redis2.quit
+  end
+
+  def test_select
+    assert_raise(Redis::CommandError, 'ERR SELECT is not allowed in cluster mode') do
+      redis.select(1)
+    end
+  end
+
+  def test_swapdb
+    assert_raise(Redis::CommandError, 'ERR SWAPDB is not allowed in cluster mode') do
+      redis.swapdb(1, 2)
+    end
+  end
+end

data/test/cluster_commands_on_geo_test.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+# ruby -w -Itest test/cluster_commands_on_geo_test.rb
+# @see https://redis.io/commands#geo
+class TestClusterCommandsOnGeo < Test::Unit::TestCase
+  include Helper::Cluster
+
+  MIN_REDIS_VERSION = '3.2.0'
+
+  def add_sicily
+    redis.geoadd('Sicily',
+                 13.361389, 38.115556, 'Palermo',
+                 15.087269, 37.502669, 'Catania')
+  end
+
+  def test_geoadd
+    target_version(MIN_REDIS_VERSION) do
+      assert_equal 2, add_sicily
+    end
+  end
+
+  def test_geohash
+    target_version(MIN_REDIS_VERSION) do
+      add_sicily
+      assert_equal %w[sqc8b49rny0 sqdtr74hyu0], redis.geohash('Sicily', %w[Palermo Catania])
+    end
+  end
+
+  def test_geopos
+    target_version(MIN_REDIS_VERSION) do
+      add_sicily
+      expected = [%w[13.36138933897018433 38.11555639549629859],
+                  %w[15.08726745843887329 37.50266842333162032],
+                  nil]
+      assert_equal expected, redis.geopos('Sicily', %w[Palermo Catania NonExisting])
+    end
+  end
+
+  def test_geodist
+    target_version(MIN_REDIS_VERSION) do
+      add_sicily
+      assert_equal '166274.1516', redis.geodist('Sicily', 'Palermo', 'Catania')
+      assert_equal '166.2742', redis.geodist('Sicily', 'Palermo', 'Catania', 'km')
+      assert_equal '103.3182', redis.geodist('Sicily', 'Palermo', 'Catania', 'mi')
+    end
+  end
+
+  def test_georadius
+    target_version(MIN_REDIS_VERSION) do
+      add_sicily
+
+      expected = [%w[Palermo 190.4424], %w[Catania 56.4413]]
+      assert_equal expected, redis.georadius('Sicily', 15, 37, 200, 'km', 'WITHDIST')
+
+      expected = [['Palermo', %w[13.36138933897018433 38.11555639549629859]],
+                  ['Catania', %w[15.08726745843887329 37.50266842333162032]]]
+      assert_equal expected, redis.georadius('Sicily', 15, 37, 200, 'km', 'WITHCOORD')
+
+      expected = [['Palermo', '190.4424', %w[13.36138933897018433 38.11555639549629859]],
+                  ['Catania', '56.4413', %w[15.08726745843887329 37.50266842333162032]]]
+      assert_equal expected, redis.georadius('Sicily', 15, 37, 200, 'km', 'WITHDIST', 'WITHCOORD')
+    end
+  end
+
+  def test_georadiusbymember
+    target_version(MIN_REDIS_VERSION) do
+      redis.geoadd('Sicily', 13.583333, 37.316667, 'Agrigento')
+      add_sicily
+      assert_equal %w[Agrigento Palermo], redis.georadiusbymember('Sicily', 'Agrigento', 100, 'km')
+    end
+  end
+end

data/test/cluster_commands_on_hashes_test.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require_relative 'lint/hashes'
+
+# ruby -w -Itest test/cluster_commands_on_hashes_test.rb
+# @see https://redis.io/commands#hash
+class TestClusterCommandsOnHashes < Test::Unit::TestCase
+  include Helper::Cluster
+  include Lint::Hashes
+end

data/test/cluster_commands_on_hyper_log_log_test.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require_relative 'lint/hyper_log_log'
+
+# ruby -w -Itest test/cluster_commands_on_hyper_log_log_test.rb
+# @see https://redis.io/commands#hyperloglog
+class TestClusterCommandsOnHyperLogLog < Test::Unit::TestCase
+  include Helper::Cluster
+  include Lint::HyperLogLog
+
+  def test_pfmerge
+    assert_raise Redis::CommandError do
+      super
+    end
+  end
+end

data/test/cluster_commands_on_keys_test.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+# ruby -w -Itest test/cluster_commands_on_keys_test.rb
+# @see https://redis.io/commands#generic
+class TestClusterCommandsOnKeys < Test::Unit::TestCase
+  include Helper::Cluster
+
+  def set_some_keys
+    redis.set('key1', 'Hello')
+    redis.set('key2', 'World')
+
+    redis.set('{key}1', 'Hello')
+    redis.set('{key}2', 'World')
+  end
+
+  def test_del
+    set_some_keys
+
+    assert_raise(Redis::CommandError, "CROSSSLOT Keys in request don't hash to the same slot") do
+      redis.del('key1', 'key2')
+    end
+
+    assert_equal 2, redis.del('{key}1', '{key}2')
+  end
+
+  def test_migrate
+    redis.set('mykey', 1)
+
+    assert_raise(Redis::CommandError, 'ERR Target instance replied with error: MOVED 14687 127.0.0.1:7002') do
+      # We cannot move between cluster nodes.
+      redis.migrate('mykey', host: '127.0.0.1', port: 7000)
+    end
+
+    redis_cluster_mock(migrate: ->(*_) { '-IOERR error or timeout writing to target instance' }) do |redis|
+      assert_raise(Redis::CommandError, 'IOERR error or timeout writing to target instance') do
+        redis.migrate('mykey', host: '127.0.0.1', port: 11211)
+      end
+    end
+
+    redis_cluster_mock(migrate: ->(*_) { '+OK' }) do |redis|
+      assert_equal 'OK', redis.migrate('mykey', host: '127.0.0.1', port: 6379)
+    end
+  end
+
+  def test_object
+    redis.lpush('mylist', 'Hello World')
+    assert_equal 1, redis.object('refcount', 'mylist')
+    expected_encoding = version < '3.2.0' ? 'ziplist' : 'quicklist'
+    assert_equal expected_encoding, redis.object('encoding', 'mylist')
+    expected_instance_type = RUBY_VERSION < '2.4.0' ? Fixnum : Integer
+    assert_instance_of expected_instance_type, redis.object('idletime', 'mylist')
+
+    redis.set('foo', 1000)
+    assert_equal 'int', redis.object('encoding', 'foo')
+
+    redis.set('bar', '1000bar')
+    assert_equal 'embstr', redis.object('encoding', 'bar')
+  end
+
+  def test_randomkey
+    set_some_keys
+    assert_true redis.randomkey.is_a?(String)
+  end
+
+  def test_rename
+    set_some_keys
+
+    assert_raise(Redis::CommandError, "CROSSSLOT Keys in request don't hash to the same slot") do
+      redis.rename('key1', 'key3')
+    end
+
+    assert_equal 'OK', redis.rename('{key}1', '{key}3')
+  end
+
+  def test_renamenx
+    set_some_keys
+
+    assert_raise(Redis::CommandError, "CROSSSLOT Keys in request don't hash to the same slot") do
+      redis.renamenx('key1', 'key2')
+    end
+
+    assert_equal false, redis.renamenx('{key}1', '{key}2')
+  end
+
+  def test_sort
+    redis.lpush('mylist', 3)
+    redis.lpush('mylist', 1)
+    redis.lpush('mylist', 5)
+    redis.lpush('mylist', 2)
+    redis.lpush('mylist', 4)
+    assert_equal %w[1 2 3 4 5], redis.sort('mylist')
+  end
+
+  def test_touch
+    target_version('3.2.1') do
+      set_some_keys
+      assert_equal 1, redis.touch('key1')
+      assert_equal 1, redis.touch('key2')
+      assert_equal 1, redis.touch('key1', 'key2')
+      assert_equal 2, redis.touch('{key}1', '{key}2')
+    end
+  end
+
+  def test_unlink
+    target_version('4.0.0') do
+      set_some_keys
+      assert_raise(Redis::CommandError, "CROSSSLOT Keys in request don't hash to the same slot") do
+        redis.unlink('key1', 'key2', 'key3')
+      end
+      assert_equal 2, redis.unlink('{key}1', '{key}2', '{key}3')
+    end
+  end
+
+  def test_wait
+    set_some_keys
+    assert_equal 1, redis.wait(1, 0)
+  end
+
+  def test_scan
+    set_some_keys
+
+    cursor = 0
+    all_keys = []
+    loop do
+      cursor, keys = redis.scan(cursor, match: '{key}*')
+      all_keys += keys
+      break if cursor == '0'
+    end
+
+    assert_equal 2, all_keys.uniq.size
+  end
+end

data/test/cluster_commands_on_lists_test.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require_relative 'lint/lists'
+
+# ruby -w -Itest test/cluster_commands_on_lists_test.rb
+# @see https://redis.io/commands#list
+class TestClusterCommandsOnLists < Test::Unit::TestCase
+  include Helper::Cluster
+  include Lint::Lists
+
+  def test_rpoplpush
+    assert_raise(Redis::CommandError) { super }
+  end
+end

data/test/cluster_commands_on_pub_sub_test.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+# ruby -w -Itest test/cluster_commands_on_pub_sub_test.rb
+# @see https://redis.io/commands#pubsub
+class TestClusterCommandsOnPubSub < Test::Unit::TestCase
+  include Helper::Cluster
+
+  def test_publish_subscribe_unsubscribe_pubsub
+    sub_cnt = 0
+    messages = {}
+
+    wire = Wire.new do
+      redis.subscribe('channel1', 'channel2') do |on|
+        on.subscribe { |_c, t| sub_cnt = t }
+        on.unsubscribe { |_c, t| sub_cnt = t }
+        on.message do |c, msg|
+          messages[c] = msg
+          # FIXME: blocking occurs when `unsubscribe` method was called with channel arguments
+          redis.unsubscribe if messages.size == 2
+        end
+      end
+    end
+
+    Wire.pass until sub_cnt == 2
+
+    publisher = build_another_client
+
+    assert_equal %w[channel1 channel2], publisher.pubsub(:channels)
+    assert_equal %w[channel1 channel2], publisher.pubsub(:channels, 'cha*')
+    assert_equal [], publisher.pubsub(:channels, 'chachacha*')
+    assert_equal({}, publisher.pubsub(:numsub))
+    assert_equal({ 'channel1' => 1, 'channel2' => 1, 'channel3' => 0 },
+                 publisher.pubsub(:numsub, 'channel1', 'channel2', 'channel3'))
+    assert_equal 0, publisher.pubsub(:numpat)
+
+    publisher.publish('channel1', 'one')
+    publisher.publish('channel2', 'two')
+
+    wire.join
+
+    assert_equal({ 'channel1' => 'one', 'channel2' => 'two' }, messages.sort.to_h)
+
+    assert_equal [], publisher.pubsub(:channels)
+    assert_equal [], publisher.pubsub(:channels, 'cha*')
+    assert_equal [], publisher.pubsub(:channels, 'chachacha*')
+    assert_equal({}, publisher.pubsub(:numsub))
+    assert_equal({ 'channel1' => 0, 'channel2' => 0, 'channel3' => 0 },
+                 publisher.pubsub(:numsub, 'channel1', 'channel2', 'channel3'))
+    assert_equal 0, publisher.pubsub(:numpat)
+  end
+
+  def test_publish_psubscribe_punsubscribe_pubsub
+    sub_cnt = 0
+    messages = {}
+
+    wire = Wire.new do
+      redis.psubscribe('cha*', 'her*') do |on|
+        on.psubscribe { |_c, t| sub_cnt = t }
+        on.punsubscribe { |_c, t| sub_cnt = t }
+        on.pmessage do |_ptn, chn, msg|
+          messages[chn] = msg
+          # FIXME: blocking occurs when `unsubscribe` method was called with channel arguments
+          redis.punsubscribe if messages.size == 3
+        end
+      end
+    end
+
+    Wire.pass until sub_cnt == 2
+
+    publisher = build_another_client
+
+    assert_equal [], publisher.pubsub(:channels)
+    assert_equal [], publisher.pubsub(:channels, 'cha*')
+    assert_equal [], publisher.pubsub(:channels, 'her*')
+    assert_equal [], publisher.pubsub(:channels, 'guc*')
+    assert_equal({}, publisher.pubsub(:numsub))
+    assert_equal({ 'channel1' => 0, 'channel2' => 0, 'hermes3' => 0, 'gucci4' => 0 },
+                 publisher.pubsub(:numsub, 'channel1', 'channel2', 'hermes3', 'gucci4'))
+    assert_equal 2, publisher.pubsub(:numpat)
+
+    publisher.publish('chanel1', 'one')
+    publisher.publish('chanel2', 'two')
+    publisher.publish('hermes3', 'three')
+    publisher.publish('gucci4', 'four')
+
+    wire.join
+
+    assert_equal({ 'chanel1' => 'one', 'chanel2' => 'two', 'hermes3' => 'three' }, messages.sort.to_h)
+
+    assert_equal [], publisher.pubsub(:channels)
+    assert_equal [], publisher.pubsub(:channels, 'cha*')
+    assert_equal [], publisher.pubsub(:channels, 'her*')
+    assert_equal [], publisher.pubsub(:channels, 'guc*')
+    assert_equal({}, publisher.pubsub(:numsub))
+    assert_equal({ 'channel1' => 0, 'channel2' => 0, 'hermes3' => 0, 'gucci4' => 0 },
+                 publisher.pubsub(:numsub, 'channel1', 'channel2', 'hermes3', 'gucci4'))
+    assert_equal 0, publisher.pubsub(:numpat)
+  end
+end

data/test/cluster_commands_on_scripting_test.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+# ruby -w -Itest test/cluster_commands_on_scripting_test.rb
+# @see https://redis.io/commands#scripting
+class TestClusterCommandsOnScripting < Test::Unit::TestCase
+  include Helper::Cluster
+
+  def test_eval
+    script = 'return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}'
+    argv = %w[first second]
+
+    keys = %w[key1 key2]
+    assert_raise(Redis::CommandError, "CROSSSLOT Keys in request don't hash to the same slot") do
+      redis.eval(script, keys: keys, argv: argv)
+    end
+
+    keys = %w[{key}1 {key}2]
+    expected = %w[{key}1 {key}2 first second]
+    assert_equal expected, redis.eval(script, keys: keys, argv: argv)
+  end
+
+  def test_evalsha
+    sha = redis.script(:load, 'return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}')
+    expected = %w[{key}1 {key}2 first second]
+    assert_equal expected, redis.evalsha(sha, keys: %w[{key}1 {key}2], argv: %w[first second])
+  end
+
+  def test_script_debug
+    target_version('3.2.0') do
+      assert_equal 'OK', redis.script(:debug, 'yes')
+      assert_equal 'OK', redis.script(:debug, 'no')
+    end
+  end
+
+  def test_script_exists
+    sha = redis.script(:load, 'return 1')
+    assert_equal true, redis.script(:exists, sha)
+    assert_equal false, redis.script(:exists, 'unknownsha')
+  end
+
+  def test_script_flush
+    assert_equal 'OK', redis.script(:flush)
+  end
+
+  def test_script_kill
+    redis_cluster_mock(kill: -> { '+OK' }) do |redis|
+      assert_equal 'OK', redis.script(:kill)
+    end
+  end
+
+  def test_script_load
+    assert_equal 'e0e1f9fabfc9d4800c877a703b823ac0578ff8db', redis.script(:load, 'return 1')
+  end
+end