redis 3.3.5 → 4.0.3

data/test/bitpos_test.rb

@@ -1,10 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-
-unless defined?(Enumerator)
-  Enumerator = Enumerable::Enumerator
-end
+require_relative "helper"
 
 class TestBitpos < Test::Unit::TestCase
 
@@ -13,48 +7,48 @@ class TestBitpos < Test::Unit::TestCase
   def test_bitpos_empty_zero
     target_version "2.9.11" do
       r.del "foo"
-      assert_equal 0, r.bitpos("foo", 0)
+      assert_equal(0, r.bitpos("foo", 0))
     end
   end
 
   def test_bitpos_empty_one
     target_version "2.9.11" do
       r.del "foo"
-      assert_equal -1, r.bitpos("foo", 1)
+      assert_equal(-1, r.bitpos("foo", 1))
     end
   end
 
   def test_bitpos_zero
     target_version "2.9.11" do
       r.set "foo", "\xff\xf0\x00"
-      assert_equal 12, r.bitpos("foo", 0)
+      assert_equal(12, r.bitpos("foo", 0))
     end
   end
 
   def test_bitpos_one
     target_version "2.9.11" do
       r.set "foo", "\x00\x0f\x00"
-      assert_equal 12, r.bitpos("foo", 1)
+      assert_equal(12, r.bitpos("foo", 1))
     end
   end
 
   def test_bitpos_zero_end_is_given
     target_version "2.9.11" do
       r.set "foo", "\xff\xff\xff"
-      assert_equal 24, r.bitpos("foo", 0)
-      assert_equal 24, r.bitpos("foo", 0, 0)
-      assert_equal -1, r.bitpos("foo", 0, 0, -1)
+      assert_equal(24, r.bitpos("foo", 0))
+      assert_equal(24, r.bitpos("foo", 0, 0))
+      assert_equal(-1, r.bitpos("foo", 0, 0, -1))
     end
   end
 
   def test_bitpos_one_intervals
     target_version "2.9.11" do
       r.set "foo", "\x00\xff\x00"
-      assert_equal 8,  r.bitpos("foo", 1, 0, -1)
-      assert_equal 8,  r.bitpos("foo", 1, 1, -1)
-      assert_equal -1, r.bitpos("foo", 1, 2, -1)
-      assert_equal -1, r.bitpos("foo", 1, 2, 200)
-      assert_equal 8,  r.bitpos("foo", 1, 1, 1)
+      assert_equal(8,  r.bitpos("foo", 1, 0, -1))
+      assert_equal(8,  r.bitpos("foo", 1, 1, -1))
+      assert_equal(-1, r.bitpos("foo", 1, 2, -1))
+      assert_equal(-1, r.bitpos("foo", 1, 2, 200))
+      assert_equal(8,  r.bitpos("foo", 1, 1, 1))
     end
   end
 

data/test/blocking_commands_test.rb

@@ -1,7 +1,5 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/blocking_commands"
+require_relative "helper"
+require_relative "lint/blocking_commands"
 
 class TestBlockingCommands < Test::Unit::TestCase
 
@@ -17,7 +15,7 @@ class TestBlockingCommands < Test::Unit::TestCase
       yield(r)
       t2 = Time.now
 
-      assert timeout == r.client.timeout
+      assert timeout == r._client.timeout
       assert delay <= (t2 - t1)
     end
   end

data/test/client_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestClient < Test::Unit::TestCase
 
@@ -56,4 +56,21 @@ class TestClient < Test::Unit::TestCase
 
     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

@@ -0,0 +1,38 @@
+# 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

@@ -0,0 +1,15 @@
+# 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

@@ -0,0 +1,77 @@
+# 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

@@ -0,0 +1,88 @@
+# 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

@@ -0,0 +1,147 @@
+# 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

@@ -0,0 +1,59 @@
+# 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

@@ -0,0 +1,36 @@
+# 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

@@ -0,0 +1,94 @@
+# 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