redis 4.0.1 → 4.0.3

data/test/cluster_commands_on_server_test.rb

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

data/test/cluster_commands_on_sets_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require_relative 'lint/sets'
+
+# ruby -w -Itest test/cluster_commands_on_sets_test.rb
+# @see https://redis.io/commands#set
+class TestClusterCommandsOnSets < Test::Unit::TestCase
+  include Helper::Cluster
+  include Lint::Sets
+
+  def test_sdiff
+    assert_raise(Redis::CommandError) { super }
+  end
+
+  def test_sdiffstore
+    assert_raise(Redis::CommandError) { super }
+  end
+
+  def test_sinter
+    assert_raise(Redis::CommandError) { super }
+  end
+
+  def test_sinterstore
+    assert_raise(Redis::CommandError) { super }
+  end
+
+  def test_smove
+    assert_raise(Redis::CommandError) { super }
+  end
+
+  def test_sunion
+    assert_raise(Redis::CommandError) { super }
+  end
+
+  def test_sunionstore
+    assert_raise(Redis::CommandError) { super }
+  end
+end

data/test/cluster_commands_on_sorted_sets_test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require_relative 'lint/sorted_sets'
+
+# ruby -w -Itest test/cluster_commands_on_sorted_sets_test.rb
+# @see https://redis.io/commands#sorted_set
+class TestClusterCommandsOnSortedSets < Test::Unit::TestCase
+  include Helper::Cluster
+  include Lint::SortedSets
+
+  def test_zinterstore
+    assert_raise(Redis::CommandError) { super }
+  end
+
+  def test_zinterstore_with_aggregate
+    assert_raise(Redis::CommandError) { super }
+  end
+
+  def test_zinterstore_with_weights
+    assert_raise(Redis::CommandError) { super }
+  end
+
+  def test_zunionstore
+    assert_raise(Redis::CommandError) { super }
+  end
+
+  def test_zunionstore_with_aggregate
+    assert_raise(Redis::CommandError) { super }
+  end
+
+  def test_zunionstore_with_weights
+    assert_raise(Redis::CommandError) { super }
+  end
+end

data/test/cluster_commands_on_streams_test.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+# ruby -w -Itest test/cluster_commands_on_streams_test.rb
+# @see https://redis.io/commands#stream
+class TestClusterCommandsOnStreams < Test::Unit::TestCase
+  include Helper::Cluster
+
+  MIN_REDIS_VERSION = '4.9.0'
+  ENTRY_ID_FORMAT = /\d+-\d+/
+
+  def setup
+    super
+    add_some_entries_to_streams_without_hashtag
+    add_some_entries_to_streams_with_hashtag
+  end
+
+  def add_some_entries_to_streams_without_hashtag
+    target_version(MIN_REDIS_VERSION) do
+      redis.xadd('stream1', '*', 'name', 'John', 'surname', 'Connor')
+      redis.xadd('stream1', '*', 'name', 'Sarah', 'surname', 'Connor')
+      redis.xadd('stream1', '*', 'name', 'Miles', 'surname', 'Dyson')
+      redis.xadd('stream1', '*', 'name', 'Peter', 'surname', 'Silberman')
+    end
+  end
+
+  def add_some_entries_to_streams_with_hashtag
+    target_version(MIN_REDIS_VERSION) do
+      redis.xadd('{stream}1', '*', 'name', 'John', 'surname', 'Connor')
+      redis.xadd('{stream}1', '*', 'name', 'Sarah', 'surname', 'Connor')
+      redis.xadd('{stream}1', '*', 'name', 'Miles', 'surname', 'Dyson')
+      redis.xadd('{stream}1', '*', 'name', 'Peter', 'surname', 'Silberman')
+    end
+  end
+
+  def assert_stream_entry(actual, expected_name, expected_surname)
+    actual_key = actual.keys.first
+    actual_values = actual[actual_key]
+
+    assert_match ENTRY_ID_FORMAT, actual_key
+    assert_equal expected_name, actual_values['name']
+    assert_equal expected_surname, actual_values['surname']
+  end
+
+  def assert_stream_pending(actual, expected_size_of_group, expected_consumer_name, expected_size_of_consumer)
+    assert_equal expected_size_of_group, actual[:size]
+    assert_match ENTRY_ID_FORMAT, actual[:min_entry_id]
+    assert_match ENTRY_ID_FORMAT, actual[:max_entry_id]
+    assert_equal({ expected_consumer_name => expected_size_of_consumer }, actual[:consumers])
+  end
+
+  # TODO: Remove this helper method when we implement streams interfaces
+  def hashify_stream_entries(reply)
+    reply.map do |entry_id, values|
+      [entry_id, Hash[values.each_slice(2).to_a]]
+    end.to_h
+  end
+
+  # TODO: Remove this helper method when we implement streams interfaces
+  def hashify_streams(reply)
+    reply.map do |stream_key, entries|
+      [stream_key, hashify_stream_entries(entries)]
+    end.to_h
+  end
+
+  # TODO: Remove this helper method when we implement streams interfaces
+  def hashify_stream_pendings(reply)
+    {
+      size: reply.first,
+      min_entry_id: reply[1],
+      max_entry_id: reply[2],
+      consumers: Hash[reply[3]]
+    }
+  end
+
+  def test_xadd
+    target_version(MIN_REDIS_VERSION) do
+      assert_match ENTRY_ID_FORMAT, redis.xadd('mystream', '*', 'type', 'T-800', 'model', '101')
+      assert_match ENTRY_ID_FORMAT, redis.xadd('my{stream}', '*', 'type', 'T-1000')
+    end
+  end
+
+  def test_xrange
+    target_version(MIN_REDIS_VERSION) do
+      actual = redis.xrange('stream1', '-', '+', 'COUNT', 1)
+      actual = hashify_stream_entries(actual) # TODO: Remove this step when we implement streams interfaces
+      assert_stream_entry(actual, 'John', 'Connor')
+
+      actual = redis.xrange('{stream}1', '-', '+', 'COUNT', 1)
+      actual = hashify_stream_entries(actual) # TODO: Remove this step when we implement streams interfaces
+      assert_stream_entry(actual, 'John', 'Connor')
+    end
+  end
+
+  def test_xrevrange
+    target_version(MIN_REDIS_VERSION) do
+      actual = redis.xrevrange('stream1', '+', '-', 'COUNT', 1)
+      actual = hashify_stream_entries(actual) # TODO: Remove this step when we implement streams interfaces
+      assert_stream_entry(actual, 'Peter', 'Silberman')
+
+      actual = redis.xrevrange('{stream}1', '+', '-', 'COUNT', 1)
+      actual = hashify_stream_entries(actual) # TODO: Remove this step when we implement streams interfaces
+      assert_stream_entry(actual, 'Peter', 'Silberman')
+    end
+  end
+
+  def test_xlen
+    target_version(MIN_REDIS_VERSION) do
+      assert_equal 4, redis.xlen('stream1')
+      assert_equal 4, redis.xlen('{stream}1')
+    end
+  end
+
+  def test_xread
+    target_version(MIN_REDIS_VERSION) do
+      # non blocking without hashtag
+      actual = redis.xread('COUNT', 1, 'STREAMS', 'stream1', 0)
+      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
+      assert_equal 'stream1', actual.keys.first
+      assert_stream_entry(actual['stream1'], 'John', 'Connor')
+
+      # blocking without hashtag
+      actual = redis.xread('COUNT', 1, 'BLOCK', 1, 'STREAMS', 'stream1', 0)
+      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
+      assert_equal 'stream1', actual.keys.first
+      assert_stream_entry(actual['stream1'], 'John', 'Connor')
+
+      # non blocking with hashtag
+      actual = redis.xread('COUNT', 1, 'STREAMS', '{stream}1', 0)
+      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
+      assert_equal '{stream}1', actual.keys.first
+      assert_stream_entry(actual['{stream}1'], 'John', 'Connor')
+
+      # blocking with hashtag
+      actual = redis.xread('COUNT', 1, 'BLOCK', 1, 'STREAMS', '{stream}1', 0)
+      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
+      assert_equal '{stream}1', actual.keys.first
+      assert_stream_entry(actual['{stream}1'], 'John', 'Connor')
+    end
+  end
+
+  def test_xreadgroup
+    target_version(MIN_REDIS_VERSION) do
+      # non blocking without hashtag
+      redis.xgroup('create', 'stream1', 'mygroup1', '$')
+      add_some_entries_to_streams_without_hashtag
+      actual = redis.xreadgroup('GROUP', 'mygroup1', 'T-1000', 'COUNT', 1, 'STREAMS', 'stream1', '>')
+      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
+      assert_equal 'stream1', actual.keys.first
+      assert_stream_entry(actual['stream1'], 'John', 'Connor')
+
+      # blocking without hashtag
+      redis.xgroup('create', 'stream1', 'mygroup2', '$')
+      add_some_entries_to_streams_without_hashtag
+      actual = redis.xreadgroup('GROUP', 'mygroup2', 'T-800', 'COUNT', 1, 'BLOCK', 1, 'STREAMS', 'stream1', '>')
+      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
+      assert_equal 'stream1', actual.keys.first
+      assert_stream_entry(actual['stream1'], 'John', 'Connor')
+
+      # non blocking with hashtag
+      redis.xgroup('create', '{stream}1', 'mygroup3', '$')
+      add_some_entries_to_streams_with_hashtag
+      actual = redis.xreadgroup('GROUP', 'mygroup3', 'T-1000', 'COUNT', 1, 'STREAMS', '{stream}1', '>')
+      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
+      assert_equal '{stream}1', actual.keys.first
+      assert_stream_entry(actual['{stream}1'], 'John', 'Connor')
+
+      # blocking with hashtag
+      redis.xgroup('create', '{stream}1', 'mygroup4', '$')
+      add_some_entries_to_streams_with_hashtag
+      actual = redis.xreadgroup('GROUP', 'mygroup4', 'T-800', 'COUNT', 1, 'BLOCK', 1, 'STREAMS', '{stream}1', '>')
+      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
+      assert_equal '{stream}1', actual.keys.first
+      assert_stream_entry(actual['{stream}1'], 'John', 'Connor')
+    end
+  end
+
+  def test_xpending
+    target_version(MIN_REDIS_VERSION) do
+      redis.xgroup('create', 'stream1', 'mygroup1', '$')
+      add_some_entries_to_streams_without_hashtag
+      redis.xreadgroup('GROUP', 'mygroup1', 'T-800', 'COUNT', 1, 'STREAMS', 'stream1', '>')
+      actual = redis.xpending('stream1', 'mygroup1')
+      actual = hashify_stream_pendings(actual) # TODO: Remove this step when we implement streams interfaces
+      assert_stream_pending(actual, 1, 'T-800', '1')
+
+      redis.xgroup('create', '{stream}1', 'mygroup2', '$')
+      add_some_entries_to_streams_with_hashtag
+      redis.xreadgroup('GROUP', 'mygroup2', 'T-800', 'COUNT', 1, 'STREAMS', '{stream}1', '>')
+      actual = redis.xpending('{stream}1', 'mygroup2')
+      actual = hashify_stream_pendings(actual) # TODO: Remove this step when we implement streams interfaces
+      assert_stream_pending(actual, 1, 'T-800', '1')
+    end
+  end
+end