redis 4.1.0.beta1 → 4.1.0

data/test/cluster_commands_on_geo_test.rb

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

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

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

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

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

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

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

data/test/cluster_commands_on_server_test.rb

@@ -1,221 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-# ruby -w -Itest test/cluster_commands_on_server_test.rb
-# @see https://redis.io/commands#server
-class TestClusterCommandsOnServer < Test::Unit::TestCase
-  include Helper::Cluster
-
-  def test_bgrewriteaof
-    assert_equal 'Background append only file rewriting started', redis.bgrewriteaof
-  end
-
-  def test_bgsave
-    redis_cluster_mock(bgsave: ->(*_) { '+OK' }) do |redis|
-      assert_equal 'OK', redis.bgsave
-    end
-
-    err_msg = 'ERR An AOF log rewriting in progress: '\
-              "can't BGSAVE right now. "\
-              'Use BGSAVE SCHEDULE in order to schedule a BGSAVE whenever possible.'
-
-    redis_cluster_mock(bgsave: ->(*_) { "-Error #{err_msg}" }) do |redis|
-      assert_raise(Redis::Cluster::CommandErrorCollection, 'Command error replied on any node') do
-        redis.bgsave
-      end
-    end
-  end
-
-  def test_client_kill
-    redis_cluster_mock(client: ->(*_) { '-Error ERR No such client' }) do |redis|
-      assert_raise(Redis::CommandError, 'ERR No such client') do
-        redis.client(:kill, '127.0.0.1:6379')
-      end
-    end
-
-    redis_cluster_mock(client: ->(*_) { '+OK' }) do |redis|
-      assert_equal 'OK', redis.client(:kill, '127.0.0.1:6379')
-    end
-  end
-
-  def test_client_list
-    a_client_info = redis.client(:list).first
-    actual = a_client_info.keys.sort
-    expected = %w[addr age cmd db events fd flags id idle multi name obl oll omem psub qbuf qbuf-free sub]
-    assert_equal expected, actual
-  end
-
-  def test_client_getname
-    redis.client(:setname, 'my-client-01')
-    assert_equal 'my-client-01', redis.client(:getname)
-  end
-
-  def test_client_pause
-    assert_equal 'OK', redis.client(:pause, 0)
-  end
-
-  def test_client_reply
-    target_version('3.2.0') do
-      assert_equal 'OK', redis.client(:reply, 'ON')
-    end
-  end
-
-  def test_client_setname
-    assert_equal 'OK', redis.client(:setname, 'my-client-01')
-  end
-
-  def test_command
-    assert_instance_of Array, redis.command
-  end
-
-  def test_command_count
-    assert_true(redis.command(:count) > 0)
-  end
-
-  def test_command_getkeys
-    assert_equal %w[a c e], redis.command(:getkeys, :mset, 'a', 'b', 'c', 'd', 'e', 'f')
-  end
-
-  def test_command_info
-    expected = [
-      ['get', 2, %w[readonly fast], 1, 1, 1],
-      ['set', -3, %w[write denyoom], 1, 1, 1],
-      ['eval', -3, %w[noscript movablekeys], 0, 0, 0]
-    ]
-    assert_equal expected, redis.command(:info, :get, :set, :eval)
-  end
-
-  def test_config_get
-    expected_keys = if version < '3.2.0'
-                      %w[hash-max-ziplist-entries list-max-ziplist-entries set-max-intset-entries zset-max-ziplist-entries]
-                    else
-                      %w[hash-max-ziplist-entries set-max-intset-entries zset-max-ziplist-entries]
-                    end
-
-    assert_equal expected_keys, redis.config(:get, '*max-*-entries*').keys.sort
-  end
-
-  def test_config_rewrite
-    redis_cluster_mock(config: ->(*_) { '-Error ERR Rewriting config file: Permission denied' }) do |redis|
-      assert_raise(Redis::Cluster::CommandErrorCollection, 'Command error replied on any node') do
-        redis.config(:rewrite)
-      end
-    end
-
-    redis_cluster_mock(config: ->(*_) { '+OK' }) do |redis|
-      assert_equal 'OK', redis.config(:rewrite)
-    end
-  end
-
-  def test_config_set
-    assert_equal 'OK', redis.config(:set, 'hash-max-ziplist-entries', 512)
-  end
-
-  def test_config_resetstat
-    assert_equal 'OK', redis.config(:resetstat)
-  end
-
-  def test_config_db_size
-    10.times { |i| redis.set("key#{i}", 1) }
-    assert_equal 10, redis.dbsize
-  end
-
-  def test_debug_object
-    # DEBUG OBJECT is a debugging command that should not be used by clients.
-  end
-
-  def test_debug_segfault
-    # DEBUG SEGFAULT performs an invalid memory access that crashes Redis.
-    # It is used to simulate bugs during the development.
-  end
-
-  def test_flushall
-    assert_equal 'OK', redis.flushall
-  end
-
-  def test_flushdb
-    assert_equal 'OK', redis.flushdb
-  end
-
-  def test_info
-    assert_equal({ 'cluster_enabled' => '1' }, redis.info(:cluster))
-  end
-
-  def test_lastsave
-    assert_instance_of Array, redis.lastsave
-  end
-
-  def test_memory_doctor
-    target_version('4.0.0') do
-      assert_instance_of String, redis.memory(:doctor)
-    end
-  end
-
-  def test_memory_help
-    target_version('4.0.0') do
-      assert_instance_of Array, redis.memory(:help)
-    end
-  end
-
-  def test_memory_malloc_stats
-    target_version('4.0.0') do
-      assert_instance_of String, redis.memory('malloc-stats')
-    end
-  end
-
-  def test_memory_purge
-    target_version('4.0.0') do
-      assert_equal 'OK', redis.memory(:purge)
-    end
-  end
-
-  def test_memory_stats
-    target_version('4.0.0') do
-      assert_instance_of Array, redis.memory(:stats)
-    end
-  end
-
-  def test_memory_usage
-    target_version('4.0.0') do
-      redis.set('key1', 'Hello World')
-      assert_equal 61, redis.memory(:usage, 'key1')
-    end
-  end
-
-  def test_monitor
-    # Add MONITOR command test
-  end
-
-  def test_role
-    assert_equal %w[master master master], redis.role.map(&:first)
-  end
-
-  def test_save
-    assert_equal 'OK', redis.save
-  end
-
-  def test_shutdown
-    assert_raise(Redis::Cluster::OrchestrationCommandNotSupported, 'SHUTDOWN command should be...') do
-      redis.shutdown
-    end
-  end
-
-  def test_slaveof
-    assert_raise(Redis::CommandError, 'ERR SLAVEOF not allowed in cluster mode.') do
-      redis.slaveof(:no, :one)
-    end
-  end
-
-  def test_slowlog
-    assert_instance_of Array, redis.slowlog(:get, 1)
-  end
-
-  def test_sync
-    # Internal command used for replication
-  end
-
-  def test_time
-    assert_instance_of Array, redis.time
-  end
-end