redis 4.0.3 → 4.5.0

data/test/blocking_commands_test.rb

@@ -1,40 +0,0 @@
-require_relative "helper"
-require_relative "lint/blocking_commands"
-
-class TestBlockingCommands < Test::Unit::TestCase
-
-  include Helper::Client
-  include Lint::BlockingCommands
-
-  def assert_takes_longer_than_client_timeout
-    timeout = OPTIONS[:timeout]
-    delay = timeout * 2
-
-    mock(:delay => delay) do |r|
-      t1 = Time.now
-      yield(r)
-      t2 = Time.now
-
-      assert timeout == r._client.timeout
-      assert delay <= (t2 - t1)
-    end
-  end
-
-  def test_blpop_disable_client_timeout
-    assert_takes_longer_than_client_timeout do |r|
-      assert_equal ["foo", "0"], r.blpop("foo")
-    end
-  end
-
-  def test_brpop_disable_client_timeout
-    assert_takes_longer_than_client_timeout do |r|
-      assert_equal ["foo", "0"], r.brpop("foo")
-    end
-  end
-
-  def test_brpoplpush_disable_client_timeout
-    assert_takes_longer_than_client_timeout do |r|
-      assert_equal "0", r.brpoplpush("foo", "bar")
-    end
-  end
-end

data/test/client_test.rb

@@ -1,76 +0,0 @@
-require_relative "helper"
-
-class TestClient < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_call
-    result = r.call("PING")
-    assert_equal result, "PONG"
-  end
-
-  def test_call_with_arguments
-    result = r.call("SET", "foo", "bar")
-    assert_equal result, "OK"
-  end
-
-  def test_call_integers
-    result = r.call("INCR", "foo")
-    assert_equal result, 1
-  end
-
-  def test_call_raise
-    assert_raises(Redis::CommandError) do
-      r.call("INCR")
-    end
-  end
-
-  def test_queue_commit
-    r.queue("SET", "foo", "bar")
-    r.queue("GET", "foo")
-    result = r.commit
-
-    assert_equal result, ["OK", "bar"]
-  end
-
-  def test_commit_raise
-    r.queue("SET", "foo", "bar")
-    r.queue("INCR")
-
-    assert_raise(Redis::CommandError) do
-      r.commit
-    end
-  end
-
-  def test_queue_after_error
-    r.queue("SET", "foo", "bar")
-    r.queue("INCR")
-
-    assert_raise(Redis::CommandError) do
-      r.commit
-    end
-
-    r.queue("SET",  "foo", "bar")
-    r.queue("INCR", "baz")
-    result = r.commit
-
-    assert_equal result, ["OK", 1]
-  end
-
-  def test_client_with_custom_connector
-    custom_connector = Class.new(Redis::Client::Connector) do
-      def resolve
-        @options[:host] = '127.0.0.5'
-        @options[:port] = '999'
-        @options
-      end
-    end
-
-    assert_raise_message(
-      'Error connecting to Redis on 127.0.0.5:999 (Errno::ECONNREFUSED)'
-    ) do
-      new_redis = _new_client(connector: custom_connector)
-      new_redis.ping
-    end
-  end
-end

data/test/cluster_abnormal_state_test.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-# ruby -w -Itest test/cluster_abnormal_state_test.rb
-class TestClusterAbnormalState < Test::Unit::TestCase
-  include Helper::Cluster
-
-  def test_the_state_of_cluster_down
-    redis_cluster_down do
-      assert_raise(Redis::CommandError, 'CLUSTERDOWN Hash slot not served') do
-        redis.set('key1', 1)
-      end
-
-      assert_equal 'fail', redis.cluster(:info).fetch('cluster_state')
-    end
-  end
-
-  def test_the_state_of_cluster_failover
-    redis_cluster_failover do
-      100.times do |i|
-        assert_equal 'OK', r.set("key#{i}", i)
-      end
-
-      100.times do |i|
-        assert_equal i.to_s, r.get("key#{i}")
-      end
-
-      assert_equal 'ok', redis.cluster(:info).fetch('cluster_state')
-    end
-  end
-
-  def test_raising_error_when_nodes_are_not_cluster_mode
-    assert_raise(Redis::CannotConnectError, 'Redis client could not connect to any cluster nodes') do
-      build_another_client(cluster: %W[redis://127.0.0.1:#{PORT}])
-    end
-  end
-end

data/test/cluster_blocking_commands_test.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-require_relative 'lint/blocking_commands'
-
-# ruby -w -Itest test/cluster_blocking_commands_test.rb
-class TestClusterBlockingCommands < Test::Unit::TestCase
-  include Helper::Cluster
-  include Lint::BlockingCommands
-
-  def mock(options = {}, &blk)
-    commands = build_mock_commands(options)
-    redis_cluster_mock(commands, &blk)
-  end
-end

data/test/cluster_client_internals_test.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-# ruby -w -Itest test/cluster_client_internals_test.rb
-class TestClusterClientInternals < Test::Unit::TestCase
-  include Helper::Cluster
-
-  def test_handle_multiple_servers
-    100.times { |i| redis.set(i.to_s, "hogehoge#{i}") }
-    100.times { |i| assert_equal "hogehoge#{i}", redis.get(i.to_s) }
-  end
-
-  def test_info_of_cluster_mode_is_enabled
-    assert_equal '1', redis.info['cluster_enabled']
-  end
-
-  def test_unknown_commands_does_not_work_by_default
-    assert_raise(Redis::CommandError) do
-      redis.not_yet_implemented_command('boo', 'foo')
-    end
-  end
-
-  def test_with_reconnect
-    assert_equal('Hello World', redis.with_reconnect { 'Hello World' })
-  end
-
-  def test_without_reconnect
-    assert_equal('Hello World', redis.without_reconnect { 'Hello World' })
-  end
-
-  def test_connected?
-    assert_equal true, redis.connected?
-  end
-
-  def test_close
-    assert_equal true, redis.close
-  end
-
-  def test_disconnect!
-    assert_equal true, redis.disconnect!
-  end
-
-  def test_asking
-    assert_equal 'OK', redis.asking
-  end
-
-  def test_id
-    expected = 'redis://127.0.0.1:7000/0 '\
-               'redis://127.0.0.1:7001/0 '\
-               'redis://127.0.0.1:7002/0'
-    assert_equal expected, redis.id
-  end
-
-  def test_inspect
-    expected = "#<Redis client v#{Redis::VERSION} for "\
-               'redis://127.0.0.1:7000/0 '\
-               'redis://127.0.0.1:7001/0 '\
-               'redis://127.0.0.1:7002/0>'
-
-    assert_equal expected, redis.inspect
-  end
-
-  def test_dup
-    assert_instance_of Redis, redis.dup
-  end
-
-  def test_connection
-    expected = [
-      { host: '127.0.0.1', port: 7000, db: 0, id: 'redis://127.0.0.1:7000/0', location: '127.0.0.1:7000' },
-      { host: '127.0.0.1', port: 7001, db: 0, id: 'redis://127.0.0.1:7001/0', location: '127.0.0.1:7001' },
-      { host: '127.0.0.1', port: 7002, db: 0, id: 'redis://127.0.0.1:7002/0', location: '127.0.0.1:7002' }
-    ]
-
-    assert_equal expected, redis.connection
-  end
-end

data/test/cluster_client_key_hash_tags_test.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-# ruby -w -Itest test/cluster_client_key_hash_tags_test.rb
-class TestClusterClientKeyHashTags < Test::Unit::TestCase
-  include Helper::Cluster
-
-  def build_described_class
-    option = Redis::Cluster::Option.new(cluster: ['redis://127.0.0.1:7000'])
-    node = Redis::Cluster::Node.new(option.per_node_key)
-    details = Redis::Cluster::CommandLoader.load(node)
-    Redis::Cluster::Command.new(details)
-  end
-
-  def test_key_extraction
-    described_class = build_described_class
-
-    assert_equal 'dogs:1', described_class.extract_first_key(%w[get dogs:1])
-    assert_equal 'user1000', described_class.extract_first_key(%w[get {user1000}.following])
-    assert_equal 'user1000', described_class.extract_first_key(%w[get {user1000}.followers])
-    assert_equal 'foo{}{bar}', described_class.extract_first_key(%w[get foo{}{bar}])
-    assert_equal '{bar', described_class.extract_first_key(%w[get foo{{bar}}zap])
-    assert_equal 'bar', described_class.extract_first_key(%w[get foo{bar}{zap}])
-
-    assert_equal '', described_class.extract_first_key([:get, ''])
-    assert_equal '', described_class.extract_first_key([:get, nil])
-    assert_equal '', described_class.extract_first_key([:get])
-
-    assert_equal '', described_class.extract_first_key([:set, '', 1])
-    assert_equal '', described_class.extract_first_key([:set, nil, 1])
-    assert_equal '', described_class.extract_first_key([:set])
-
-    # Keyless commands
-    assert_equal '', described_class.extract_first_key([:auth, 'password'])
-    assert_equal '', described_class.extract_first_key(%i[client kill])
-    assert_equal '', described_class.extract_first_key(%i[cluster addslots])
-    assert_equal '', described_class.extract_first_key(%i[command])
-    assert_equal '', described_class.extract_first_key(%i[command count])
-    assert_equal '', described_class.extract_first_key(%i[config get])
-    assert_equal '', described_class.extract_first_key(%i[debug segfault])
-    assert_equal '', described_class.extract_first_key([:echo, 'Hello World'])
-    assert_equal '', described_class.extract_first_key([:flushall, 'ASYNC'])
-    assert_equal '', described_class.extract_first_key([:flushdb, 'ASYNC'])
-    assert_equal '', described_class.extract_first_key([:info, 'cluster'])
-    assert_equal '', described_class.extract_first_key(%i[memory doctor])
-    assert_equal '', described_class.extract_first_key([:ping, 'Hi'])
-    assert_equal '', described_class.extract_first_key([:psubscribe, 'channel'])
-    assert_equal '', described_class.extract_first_key([:pubsub, 'channels', '*'])
-    assert_equal '', described_class.extract_first_key([:publish, 'channel', 'Hi'])
-    assert_equal '', described_class.extract_first_key([:punsubscribe, 'channel'])
-    assert_equal '', described_class.extract_first_key([:subscribe, 'channel'])
-    assert_equal '', described_class.extract_first_key([:unsubscribe, 'channel'])
-    assert_equal '', described_class.extract_first_key(%w[script exists sha1 sha1])
-    assert_equal '', described_class.extract_first_key([:select, 1])
-    assert_equal '', described_class.extract_first_key([:shutdown, 'SAVE'])
-    assert_equal '', described_class.extract_first_key([:slaveof, '127.0.0.1', 6379])
-    assert_equal '', described_class.extract_first_key([:slowlog, 'get', 2])
-    assert_equal '', described_class.extract_first_key([:swapdb, 0, 1])
-    assert_equal '', described_class.extract_first_key([:wait, 1, 0])
-
-    # 2nd argument is not a key
-    assert_equal 'key1', described_class.extract_first_key([:eval, 'script', 2, 'key1', 'key2', 'first', 'second'])
-    assert_equal '', described_class.extract_first_key([:eval, 'return 0', 0])
-    assert_equal 'key1', described_class.extract_first_key([:evalsha, 'sha1', 2, 'key1', 'key2', 'first', 'second'])
-    assert_equal '', described_class.extract_first_key([:evalsha, 'return 0', 0])
-    assert_equal 'key1', described_class.extract_first_key([:migrate, '127.0.0.1', 6379, 'key1', 0, 5000])
-    assert_equal 'key1', described_class.extract_first_key([:memory, :usage, 'key1'])
-    assert_equal 'key1', described_class.extract_first_key([:object, 'refcount', 'key1'])
-    assert_equal 'mystream', described_class.extract_first_key([:xread, 'COUNT', 2, 'STREAMS', 'mystream', 0])
-    assert_equal 'mystream', described_class.extract_first_key([:xreadgroup, 'GROUP', 'mygroup', 'Bob', 'COUNT', 2, 'STREAMS', 'mystream', '>'])
-  end
-
-  def test_whether_the_command_effect_is_readonly_or_not
-    described_class = build_described_class
-
-    assert_equal true,  described_class.should_send_to_master?([:set])
-    assert_equal false, described_class.should_send_to_slave?([:set])
-
-    assert_equal false, described_class.should_send_to_master?([:get])
-    assert_equal true,  described_class.should_send_to_slave?([:get])
-
-    target_version('3.2.0') do
-      assert_equal false, described_class.should_send_to_master?([:info])
-      assert_equal false, described_class.should_send_to_slave?([:info])
-    end
-  end
-end

data/test/cluster_client_options_test.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-# ruby -w -Itest test/cluster_client_options_test.rb
-class TestClusterClientOptions < Test::Unit::TestCase
-  include Helper::Cluster
-
-  def test_option_class
-    option = Redis::Cluster::Option.new(cluster: %w[rediss://127.0.0.1:7000], replica: true)
-    assert_equal({ '127.0.0.1:7000' => { url: 'rediss://127.0.0.1:7000' } }, option.per_node_key)
-    assert_equal true, option.secure?
-    assert_equal true, option.use_replica?
-
-    option = Redis::Cluster::Option.new(cluster: %w[redis://127.0.0.1:7000], replica: false)
-    assert_equal({ '127.0.0.1:7000' => { url: 'redis://127.0.0.1:7000' } }, option.per_node_key)
-    assert_equal false, option.secure?
-    assert_equal false, option.use_replica?
-
-    option = Redis::Cluster::Option.new(cluster: %w[redis://127.0.0.1:7000])
-    assert_equal({ '127.0.0.1:7000' => { url: 'redis://127.0.0.1:7000' } }, option.per_node_key)
-    assert_equal false, option.secure?
-    assert_equal false, option.use_replica?
-  end
-
-  def test_client_accepts_valid_node_configs
-    nodes = ['redis://127.0.0.1:7000',
-             'redis://127.0.0.1:7001',
-             { host: '127.0.0.1', port: '7002' },
-             { 'host' => '127.0.0.1', port: 7003 },
-             'redis://127.0.0.1:7004',
-             'redis://127.0.0.1:7005']
-
-    assert_nothing_raised do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_accepts_valid_options
-    assert_nothing_raised do
-      build_another_client(timeout: 1.0)
-    end
-  end
-
-  def test_client_ignores_invalid_options
-    assert_nothing_raised do
-      build_another_client(invalid_option: true)
-    end
-  end
-
-  def test_client_works_even_if_so_many_unavailable_nodes_specified
-    nodes = (6001..7005).map { |port| "redis://127.0.0.1:#{port}" }
-    redis = build_another_client(cluster: nodes)
-
-    assert_equal 'PONG', redis.ping
-  end
-
-  def test_client_does_not_accept_db_specified_url
-    assert_raise(Redis::CannotConnectError, 'Could not connect to any nodes') do
-      build_another_client(cluster: ['redis://127.0.0.1:7000/1/namespace'])
-    end
-
-    assert_raise(Redis::CannotConnectError, 'Could not connect to any nodes') do
-      build_another_client(cluster: [{ host: '127.0.0.1', port: '7000' }], db: 1)
-    end
-  end
-
-  def test_client_does_not_accept_unconnectable_node_url_only
-    nodes = ['redis://127.0.0.1:7006']
-
-    assert_raise(Redis::CannotConnectError, 'Could not connect to any nodes') do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_accepts_unconnectable_node_url_included
-    nodes = ['redis://127.0.0.1:7000', 'redis://127.0.0.1:7006']
-
-    assert_nothing_raised(Redis::CannotConnectError, 'Could not connect to any nodes') do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_http_scheme_url
-    nodes = ['http://127.0.0.1:80']
-
-    assert_raise(Redis::InvalidClientOptionError, "invalid uri scheme 'http'") do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_blank_included_config
-    nodes = ['']
-
-    assert_raise(Redis::InvalidClientOptionError, "invalid uri scheme ''") do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_bool_included_config
-    nodes = [true]
-
-    assert_raise(Redis::InvalidClientOptionError, "invalid uri scheme ''") do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_nil_included_config
-    nodes = [nil]
-
-    assert_raise(Redis::InvalidClientOptionError, "invalid uri scheme ''") do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_array_included_config
-    nodes = [[]]
-
-    assert_raise(Redis::InvalidClientOptionError, "invalid uri scheme ''") do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_empty_hash_included_config
-    nodes = [{}]
-
-    assert_raise(Redis::InvalidClientOptionError, 'Redis option of `cluster` must includes `:host` and `:port` keys') do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_object_included_config
-    nodes = [Object.new]
-
-    assert_raise(Redis::InvalidClientOptionError, 'Redis Cluster node config must includes String or Hash') do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_not_array_config
-    nodes = :not_array
-
-    assert_raise(Redis::InvalidClientOptionError, 'Redis Cluster node config must be Array') do
-      build_another_client(cluster: nodes)
-    end
-  end
-end

data/test/cluster_client_pipelining_test.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-# ruby -w -Itest test/cluster_client_pipelining_test.rb
-class TestClusterClientPipelining < Test::Unit::TestCase
-  include Helper::Cluster
-
-  def test_pipelining_with_a_hash_tag
-    p1 = p2 = p3 = p4 = p5 = p6 = nil
-
-    redis.pipelined do |r|
-      r.set('{Presidents.of.USA}:1', 'George Washington')
-      r.set('{Presidents.of.USA}:2', 'John Adams')
-      r.set('{Presidents.of.USA}:3', 'Thomas Jefferson')
-      r.set('{Presidents.of.USA}:4', 'James Madison')
-      r.set('{Presidents.of.USA}:5', 'James Monroe')
-      r.set('{Presidents.of.USA}:6', 'John Quincy Adams')
-
-      p1 = r.get('{Presidents.of.USA}:1')
-      p2 = r.get('{Presidents.of.USA}:2')
-      p3 = r.get('{Presidents.of.USA}:3')
-      p4 = r.get('{Presidents.of.USA}:4')
-      p5 = r.get('{Presidents.of.USA}:5')
-      p6 = r.get('{Presidents.of.USA}:6')
-    end
-
-    [p1, p2, p3, p4, p5, p6].each do |actual|
-      assert_true actual.is_a?(Redis::Future)
-    end
-
-    assert_equal('George Washington', p1.value)
-    assert_equal('John Adams',        p2.value)
-    assert_equal('Thomas Jefferson',  p3.value)
-    assert_equal('James Madison',     p4.value)
-    assert_equal('James Monroe',      p5.value)
-    assert_equal('John Quincy Adams', p6.value)
-  end
-
-  def test_pipelining_without_hash_tags
-    assert_raise(Redis::Cluster::CrossSlotPipeliningError) do
-      redis.pipelined do
-        redis.set(:a, 1)
-        redis.set(:b, 2)
-        redis.set(:c, 3)
-        redis.set(:d, 4)
-        redis.set(:e, 5)
-        redis.set(:f, 6)
-
-        redis.get(:a)
-        redis.get(:b)
-        redis.get(:c)
-        redis.get(:d)
-        redis.get(:e)
-        redis.get(:f)
-      end
-    end
-  end
-end

data/test/cluster_client_replicas_test.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-# ruby -w -Itest test/cluster_client_replicas_test.rb
-class TestClusterClientReplicas < Test::Unit::TestCase
-  include Helper::Cluster
-
-  def test_client_can_command_with_replica
-    r = build_another_client(replica: true)
-
-    100.times do |i|
-      assert_equal 'OK', r.set("key#{i}", i)
-    end
-
-    100.times do |i|
-      assert_equal i.to_s, r.get("key#{i}")
-    end
-  end
-
-  def test_client_can_flush_with_replica
-    r = build_another_client(replica: true)
-
-    assert_equal 'OK', r.flushall
-    assert_equal 'OK', r.flushdb
-  end
-
-  def test_some_reference_commands_are_sent_to_slaves_if_needed
-    r = build_another_client(replica: true)
-
-    5.times { |i| r.set("key#{i}", i) }
-
-    assert_equal %w[key0 key1 key2 key3 key4], r.keys
-    assert_equal 5, r.dbsize
-  end
-end

data/test/cluster_client_slots_test.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-# ruby -w -Itest test/cluster_client_slots_test.rb
-class TestClusterClientSlots < Test::Unit::TestCase
-  include Helper::Cluster
-
-  def test_slot_class
-    slot = Redis::Cluster::Slot.new('127.0.0.1:7000' => 1..10)
-
-    assert_equal false, slot.exists?(0)
-    assert_equal true, slot.exists?(1)
-    assert_equal true, slot.exists?(10)
-    assert_equal false, slot.exists?(11)
-
-    assert_equal nil, slot.find_node_key_of_master(0)
-    assert_equal nil, slot.find_node_key_of_slave(0)
-    assert_equal '127.0.0.1:7000', slot.find_node_key_of_master(1)
-    assert_equal '127.0.0.1:7000', slot.find_node_key_of_slave(1)
-    assert_equal '127.0.0.1:7000', slot.find_node_key_of_master(10)
-    assert_equal '127.0.0.1:7000', slot.find_node_key_of_slave(10)
-    assert_equal nil, slot.find_node_key_of_master(11)
-    assert_equal nil, slot.find_node_key_of_slave(11)
-
-    assert_equal nil, slot.put(1, '127.0.0.1:7001')
-  end
-
-  def test_slot_class_with_node_flags_and_replicas
-    slot = Redis::Cluster::Slot.new({ '127.0.0.1:7000' => 1..10, '127.0.0.1:7001' => 1..10 },
-                                    { '127.0.0.1:7000' => 'master', '127.0.0.1:7001' => 'slave' },
-                                    true)
-
-    assert_equal false, slot.exists?(0)
-    assert_equal true, slot.exists?(1)
-    assert_equal true, slot.exists?(10)
-    assert_equal false, slot.exists?(11)
-
-    assert_equal nil, slot.find_node_key_of_master(0)
-    assert_equal nil, slot.find_node_key_of_slave(0)
-    assert_equal '127.0.0.1:7000', slot.find_node_key_of_master(1)
-    assert_equal '127.0.0.1:7001', slot.find_node_key_of_slave(1)
-    assert_equal '127.0.0.1:7000', slot.find_node_key_of_master(10)
-    assert_equal '127.0.0.1:7001', slot.find_node_key_of_slave(10)
-    assert_equal nil, slot.find_node_key_of_master(11)
-    assert_equal nil, slot.find_node_key_of_slave(11)
-
-    assert_equal nil, slot.put(1, '127.0.0.1:7002')
-  end
-
-  def test_slot_class_with_node_flags_and_without_replicas
-    slot = Redis::Cluster::Slot.new({ '127.0.0.1:7000' => 1..10, '127.0.0.1:7001' => 1..10 },
-                                    { '127.0.0.1:7000' => 'master', '127.0.0.1:7001' => 'slave' },
-                                    false)
-
-    assert_equal false, slot.exists?(0)
-    assert_equal true, slot.exists?(1)
-    assert_equal true, slot.exists?(10)
-    assert_equal false, slot.exists?(11)
-
-    assert_equal nil, slot.find_node_key_of_master(0)
-    assert_equal nil, slot.find_node_key_of_slave(0)
-    assert_equal '127.0.0.1:7000', slot.find_node_key_of_master(1)
-    assert_equal '127.0.0.1:7000', slot.find_node_key_of_slave(1)
-    assert_equal '127.0.0.1:7000', slot.find_node_key_of_master(10)
-    assert_equal '127.0.0.1:7000', slot.find_node_key_of_slave(10)
-    assert_equal nil, slot.find_node_key_of_master(11)
-    assert_equal nil, slot.find_node_key_of_slave(11)
-
-    assert_equal nil, slot.put(1, '127.0.0.1:7002')
-  end
-
-  def test_slot_class_with_empty_slots
-    slot = Redis::Cluster::Slot.new({})
-
-    assert_equal false, slot.exists?(0)
-    assert_equal false, slot.exists?(1)
-
-    assert_equal nil, slot.find_node_key_of_master(0)
-    assert_equal nil, slot.find_node_key_of_slave(0)
-    assert_equal nil, slot.find_node_key_of_master(1)
-    assert_equal nil, slot.find_node_key_of_slave(1)
-
-    assert_equal nil, slot.put(1, '127.0.0.1:7001')
-  end
-
-  def test_redirection_when_slot_is_resharding
-    100.times { |i| redis.set("{key}#{i}", i) }
-
-    redis_cluster_resharding(12539, src: '127.0.0.1:7002', dest: '127.0.0.1:7000') do
-      100.times { |i| assert_equal i.to_s, redis.get("{key}#{i}") }
-    end
-  end
-end