redis 4.0.2 → 4.0.3

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

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