RubyGems - redis - Versions diffs - 3.3.5 → 4.1.0 - Mend

redis 3.3.5 → 4.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (126) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +54 -2
data/README.md +77 -76
data/lib/redis.rb +779 -63
data/lib/redis/client.rb +41 -20
data/lib/redis/cluster.rb +286 -0
data/lib/redis/cluster/command.rb +81 -0
data/lib/redis/cluster/command_loader.rb +34 -0
data/lib/redis/cluster/key_slot_converter.rb +72 -0
data/lib/redis/cluster/node.rb +104 -0
data/lib/redis/cluster/node_key.rb +35 -0
data/lib/redis/cluster/node_loader.rb +37 -0
data/lib/redis/cluster/option.rb +77 -0
data/lib/redis/cluster/slot.rb +69 -0
data/lib/redis/cluster/slot_loader.rb +49 -0
data/lib/redis/connection.rb +2 -2
data/lib/redis/connection/command_helper.rb +2 -8
data/lib/redis/connection/hiredis.rb +2 -2
data/lib/redis/connection/ruby.rb +13 -30
data/lib/redis/connection/synchrony.rb +12 -4
data/lib/redis/distributed.rb +32 -12
data/lib/redis/errors.rb +46 -0
data/lib/redis/hash_ring.rb +20 -64
data/lib/redis/pipeline.rb +9 -7
data/lib/redis/version.rb +1 -1
metadata +53 -196
data/.gitignore +0 -16
data/.travis.yml +0 -89
data/.travis/Gemfile +0 -11
data/.yardopts +0 -3
data/Gemfile +0 -4
data/Rakefile +0 -87
data/benchmarking/logging.rb +0 -71
data/benchmarking/pipeline.rb +0 -51
data/benchmarking/speed.rb +0 -21
data/benchmarking/suite.rb +0 -24
data/benchmarking/worker.rb +0 -71
data/examples/basic.rb +0 -15
data/examples/consistency.rb +0 -114
data/examples/dist_redis.rb +0 -43
data/examples/incr-decr.rb +0 -17
data/examples/list.rb +0 -26
data/examples/pubsub.rb +0 -37
data/examples/sentinel.rb +0 -41
data/examples/sentinel/start +0 -49
data/examples/sets.rb +0 -36
data/examples/unicorn/config.ru +0 -3
data/examples/unicorn/unicorn.rb +0 -20
data/redis.gemspec +0 -44
data/test/bitpos_test.rb +0 -69
data/test/blocking_commands_test.rb +0 -42
data/test/client_test.rb +0 -59
data/test/command_map_test.rb +0 -30
data/test/commands_on_hashes_test.rb +0 -21
data/test/commands_on_hyper_log_log_test.rb +0 -21
data/test/commands_on_lists_test.rb +0 -20
data/test/commands_on_sets_test.rb +0 -77
data/test/commands_on_sorted_sets_test.rb +0 -137
data/test/commands_on_strings_test.rb +0 -101
data/test/commands_on_value_types_test.rb +0 -133
data/test/connection_handling_test.rb +0 -277
data/test/connection_test.rb +0 -57
data/test/distributed_blocking_commands_test.rb +0 -46
data/test/distributed_commands_on_hashes_test.rb +0 -10
data/test/distributed_commands_on_hyper_log_log_test.rb +0 -33
data/test/distributed_commands_on_lists_test.rb +0 -22
data/test/distributed_commands_on_sets_test.rb +0 -83
data/test/distributed_commands_on_sorted_sets_test.rb +0 -18
data/test/distributed_commands_on_strings_test.rb +0 -59
data/test/distributed_commands_on_value_types_test.rb +0 -95
data/test/distributed_commands_requiring_clustering_test.rb +0 -164
data/test/distributed_connection_handling_test.rb +0 -23
data/test/distributed_internals_test.rb +0 -79
data/test/distributed_key_tags_test.rb +0 -52
data/test/distributed_persistence_control_commands_test.rb +0 -26
data/test/distributed_publish_subscribe_test.rb +0 -92
data/test/distributed_remote_server_control_commands_test.rb +0 -66
data/test/distributed_scripting_test.rb +0 -102
data/test/distributed_sorting_test.rb +0 -20
data/test/distributed_test.rb +0 -58
data/test/distributed_transactions_test.rb +0 -32
data/test/encoding_test.rb +0 -18
data/test/error_replies_test.rb +0 -59
data/test/fork_safety_test.rb +0 -65
data/test/helper.rb +0 -232
data/test/helper_test.rb +0 -24
data/test/internals_test.rb +0 -417
data/test/lint/blocking_commands.rb +0 -150
data/test/lint/hashes.rb +0 -162
data/test/lint/hyper_log_log.rb +0 -60
data/test/lint/lists.rb +0 -143
data/test/lint/sets.rb +0 -140
data/test/lint/sorted_sets.rb +0 -316
data/test/lint/strings.rb +0 -260
data/test/lint/value_types.rb +0 -122
data/test/persistence_control_commands_test.rb +0 -26
data/test/pipelining_commands_test.rb +0 -242
data/test/publish_subscribe_test.rb +0 -282
data/test/remote_server_control_commands_test.rb +0 -118
data/test/scanning_test.rb +0 -413
data/test/scripting_test.rb +0 -78
data/test/sentinel_command_test.rb +0 -80
data/test/sentinel_test.rb +0 -255
data/test/sorting_test.rb +0 -59
data/test/ssl_test.rb +0 -73
data/test/support/connection/hiredis.rb +0 -1
data/test/support/connection/ruby.rb +0 -1
data/test/support/connection/synchrony.rb +0 -17
data/test/support/redis_mock.rb +0 -130
data/test/support/ssl/gen_certs.sh +0 -31
data/test/support/ssl/trusted-ca.crt +0 -25
data/test/support/ssl/trusted-ca.key +0 -27
data/test/support/ssl/trusted-cert.crt +0 -81
data/test/support/ssl/trusted-cert.key +0 -28
data/test/support/ssl/untrusted-ca.crt +0 -26
data/test/support/ssl/untrusted-ca.key +0 -27
data/test/support/ssl/untrusted-cert.crt +0 -82
data/test/support/ssl/untrusted-cert.key +0 -28
data/test/support/wire/synchrony.rb +0 -24
data/test/support/wire/thread.rb +0 -5
data/test/synchrony_driver.rb +0 -88
data/test/test.conf.erb +0 -9
data/test/thread_safety_test.rb +0 -62
data/test/transactions_test.rb +0 -264
data/test/unknown_commands_test.rb +0 -14
data/test/url_param_test.rb +0 -138

data/test/publish_subscribe_test.rb DELETED

@@ -1,282 +0,0 @@
-# encoding: UTF-8
-require File.expand_path("helper", File.dirname(__FILE__))
-class TestPublishSubscribe < Test::Unit::TestCase
-  include Helper::Client
-  class TestError < StandardError
-  end
-  def test_subscribe_and_unsubscribe
-    @subscribed = false
-    @unsubscribed = false
-    wire = Wire.new do
-      r.subscribe("foo") do |on|
-        on.subscribe do |channel, total|
-          @subscribed = true
-          @t1 = total
-        end
-        on.message do |channel, message|
-          if message == "s1"
-            r.unsubscribe
-            @message = message
-          end
-        end
-        on.unsubscribe do |channel, total|
-          @unsubscribed = true
-          @t2 = total
-        end
-      end
-    end
-    # Wait until the subscription is active before publishing
-    Wire.pass while !@subscribed
-    Redis.new(OPTIONS).publish("foo", "s1")
-    wire.join
-    assert @subscribed
-    assert_equal 1, @t1
-    assert @unsubscribed
-    assert_equal 0, @t2
-    assert_equal "s1", @message
-  end
-  def test_psubscribe_and_punsubscribe
-    @subscribed = false
-    @unsubscribed = false
-    wire = Wire.new do
-      r.psubscribe("f*") do |on|
-        on.psubscribe do |pattern, total|
-          @subscribed = true
-          @t1 = total
-        end
-        on.pmessage do |pattern, channel, message|
-          if message == "s1"
-            r.punsubscribe
-            @message = message
-          end
-        end
-        on.punsubscribe do |pattern, total|
-          @unsubscribed = true
-          @t2 = total
-        end
-      end
-    end
-    # Wait until the subscription is active before publishing
-    Wire.pass while !@subscribed
-    Redis.new(OPTIONS).publish("foo", "s1")
-    wire.join
-    assert @subscribed
-    assert_equal 1, @t1
-    assert @unsubscribed
-    assert_equal 0, @t2
-    assert_equal "s1", @message
-  end
-  def test_pubsub_with_numpat_subcommand
-    target_version("2.8.0") do
-      @subscribed = false
-      wire = Wire.new do
-        r.psubscribe("f*") do |on|
-          on.psubscribe { |channel, total| @subscribed = true }
-          on.pmessage   { |pattern, channel, message| r.punsubscribe }
-        end
-      end
-      Wire.pass while !@subscribed
-      redis = Redis.new(OPTIONS)
-      numpat_result = redis.pubsub(:numpat)
-      redis.publish("foo", "s1")
-      wire.join
-      assert_equal redis.pubsub(:numpat), 0
-      assert_equal numpat_result, 1
-    end
-  end
-  def test_pubsub_with_channels_and_numsub_subcommnads
-    target_version("2.8.0") do
-      @subscribed = false
-      wire = Wire.new do
-        r.subscribe("foo") do |on|
-          on.subscribe { |channel, total| @subscribed = true }
-          on.message   { |channel, message| r.unsubscribe }
-        end
-      end
-      Wire.pass while !@subscribed
-      redis = Redis.new(OPTIONS)
-      channels_result = redis.pubsub(:channels)
-      numsub_result   = redis.pubsub(:numsub, 'foo', 'boo')
-      redis.publish("foo", "s1")
-      wire.join
-      assert_equal channels_result, ['foo']
-      assert_equal numsub_result, ['foo', 1, 'boo', 0]
-    end
-  end
-  def test_subscribe_connection_usable_after_raise
-    @subscribed = false
-    wire = Wire.new do
-      begin
-        r.subscribe("foo") do |on|
-          on.subscribe do |channel, total|
-            @subscribed = true
-          end
-          on.message do |channel, message|
-            raise TestError
-          end
-        end
-      rescue TestError
-      end
-    end
-    # Wait until the subscription is active before publishing
-    Wire.pass while !@subscribed
-    Redis.new(OPTIONS).publish("foo", "s1")
-    wire.join
-    assert_equal "PONG", r.ping
-  end
-  def test_psubscribe_connection_usable_after_raise
-    @subscribed = false
-    wire = Wire.new do
-      begin
-        r.psubscribe("f*") do |on|
-          on.psubscribe do |pattern, total|
-            @subscribed = true
-          end
-          on.pmessage do |pattern, channel, message|
-            raise TestError
-          end
-        end
-      rescue TestError
-      end
-    end
-    # Wait until the subscription is active before publishing
-    Wire.pass while !@subscribed
-    Redis.new(OPTIONS).publish("foo", "s1")
-    wire.join
-    assert_equal "PONG", r.ping
-  end
-  def test_subscribe_within_subscribe
-    @channels = []
-    wire = Wire.new do
-      r.subscribe("foo") do |on|
-        on.subscribe do |channel, total|
-          @channels << channel
-          r.subscribe("bar") if channel == "foo"
-          r.unsubscribe if channel == "bar"
-        end
-      end
-    end
-    wire.join
-    assert_equal ["foo", "bar"], @channels
-  end
-  def test_other_commands_within_a_subscribe
-    assert_raise Redis::CommandError do
-      r.subscribe("foo") do |on|
-        on.subscribe do |channel, total|
-          r.set("bar", "s2")
-        end
-      end
-    end
-  end
-  def test_subscribe_without_a_block
-    assert_raise LocalJumpError do
-      r.subscribe("foo")
-    end
-  end
-  def test_unsubscribe_without_a_subscribe
-    assert_raise RuntimeError do
-      r.unsubscribe
-    end
-    assert_raise RuntimeError do
-      r.punsubscribe
-    end
-  end
-  def test_subscribe_past_a_timeout
-    # For some reason, a thread here doesn't reproduce the issue.
-    sleep = %{sleep #{OPTIONS[:timeout] * 2}}
-    publish = %{ruby -rsocket -e 't=TCPSocket.new("127.0.0.1",#{OPTIONS[:port]});t.write("publish foo bar\\r\\n");t.read(4);t.close'}
-    cmd = [sleep, publish].join("; ")
-    IO.popen(cmd, "r+") do |pipe|
-      received = false
-      r.subscribe "foo" do |on|
-        on.message do |channel, message|
-          received = true
-          r.unsubscribe
-        end
-      end
-      assert received
-    end
-  end
-  def test_subscribe_with_timeout
-    received = false
-    assert_raise Redis::TimeoutError do
-      r.subscribe_with_timeout(1, "foo")  do |on|
-        on.message do |channel, message|
-          received = true
-        end
-      end
-    end
-    assert !received
-  end
-  def test_psubscribe_with_timeout
-    received = false
-    assert_raise Redis::TimeoutError do
-      r.psubscribe_with_timeout(1, "f*")  do |on|
-        on.message do |channel, message|
-          received = true
-        end
-      end
-    end
-    assert !received
-  end
-end

data/test/remote_server_control_commands_test.rb DELETED

@@ -1,118 +0,0 @@
-# encoding: UTF-8
-require File.expand_path("helper", File.dirname(__FILE__))
-class TestRemoteServerControlCommands < Test::Unit::TestCase
-  include Helper::Client
-  def test_info
-    keys = [
-     "redis_version",
-     "uptime_in_seconds",
-     "uptime_in_days",
-     "connected_clients",
-     "used_memory",
-     "total_connections_received",
-     "total_commands_processed",
-    ]
-    info = r.info
-    keys.each do |k|
-      msg = "expected #info to include #{k}"
-      assert info.keys.include?(k), msg
-    end
-  end
-  def test_info_commandstats
-    target_version "2.5.7" do
-      r.config(:resetstat)
-      r.ping
-      result = r.info(:commandstats)
-      assert_equal "1", result["ping"]["calls"]
-    end
-  end
-  def test_monitor_redis_lt_2_5_0
-    return unless version < "2.5.0"
-    log = []
-    wire = Wire.new do
-      Redis.new(OPTIONS).monitor do |line|
-        log << line
-        break if log.size == 3
-      end
-    end
-    Wire.pass while log.empty? # Faster than sleep
-    r.set "foo", "s1"
-    wire.join
-    assert log[-1][%q{(db 15) "set" "foo" "s1"}]
-  end
-  def test_monitor_redis_gte_2_5_0
-    return unless version >= "2.5.0"
-    log = []
-    wire = Wire.new do
-      Redis.new(OPTIONS).monitor do |line|
-        log << line
-        break if line =~ /set/
-      end
-    end
-    Wire.pass while log.empty? # Faster than sleep
-    r.set "foo", "s1"
-    wire.join
-    assert log[-1] =~ /\b15\b.* "set" "foo" "s1"/
-  end
-  def test_monitor_returns_value_for_break
-    result = r.monitor do |line|
-      break line
-    end
-    assert_equal "OK", result
-  end
-  def test_echo
-    assert_equal "foo bar baz\n", r.echo("foo bar baz\n")
-  end
-  def test_debug
-    r.set "foo", "s1"
-    assert r.debug(:object, "foo").kind_of?(String)
-  end
-  def test_object
-    r.lpush "list", "value"
-    assert_equal 1, r.object(:refcount, "list")
-    encoding = r.object(:encoding, "list")
-    assert "ziplist" == encoding || "quicklist" == encoding, "Wrong encoding for list"
-    assert r.object(:idletime, "list").kind_of?(Integer)
-  end
-  def test_sync
-    redis_mock(:sync => lambda { "+OK" }) do |redis|
-      assert_equal "OK", redis.sync
-    end
-  end
-  def test_slowlog
-    r.slowlog(:reset)
-    result = r.slowlog(:len)
-    assert_equal 0, result
-  end
-end

data/test/scanning_test.rb DELETED

@@ -1,413 +0,0 @@
-# encoding: UTF-8
-require File.expand_path("helper", File.dirname(__FILE__))
-unless defined?(Enumerator)
-  Enumerator = Enumerable::Enumerator
-end
-class TestScanning < Test::Unit::TestCase
-  include Helper::Client
-  def test_scan_basic
-    target_version "2.7.105" do
-      r.debug :populate, 1000
-      cursor = 0
-      all_keys   = []
-      loop {
-        cursor, keys = r.scan cursor
-        all_keys += keys
-        break if cursor == "0"
-      }
-      assert_equal 1000, all_keys.uniq.size
-    end
-  end
-  def test_scan_count
-    target_version "2.7.105" do
-      r.debug :populate, 1000
-      cursor = 0
-      all_keys   = []
-      loop {
-        cursor, keys = r.scan cursor, :count => 5
-        all_keys += keys
-        break if cursor == "0"
-      }
-      assert_equal 1000, all_keys.uniq.size
-    end
-  end
-  def test_scan_match
-    target_version "2.7.105" do
-      r.debug :populate, 1000
-      cursor = 0
-      all_keys   = []
-      loop {
-        cursor, keys = r.scan cursor, :match => "key:1??"
-        all_keys += keys
-        break if cursor == "0"
-      }
-      assert_equal 100, all_keys.uniq.size
-    end
-  end
-  def test_scan_each_enumerator
-    target_version "2.7.105" do
-      r.debug :populate, 1000
-      scan_enumerator = r.scan_each
-      assert_equal true, scan_enumerator.is_a?(::Enumerator)
-      keys_from_scan = scan_enumerator.to_a.uniq
-      all_keys = r.keys "*"
-      assert all_keys.sort == keys_from_scan.sort
-    end
-  end
-  def test_scan_each_enumerator_match
-    target_version "2.7.105" do
-      r.debug :populate, 1000
-      keys_from_scan = r.scan_each(:match => "key:1??").to_a.uniq
-      all_keys = r.keys "key:1??"
-      assert all_keys.sort == keys_from_scan.sort
-    end
-  end
-  def test_scan_each_block
-    target_version "2.7.105" do
-      r.debug :populate, 100
-      keys_from_scan   = []
-      r.scan_each {|key|
-        keys_from_scan << key
-      }
-      all_keys = r.keys "*"
-      assert all_keys.sort == keys_from_scan.uniq.sort
-    end
-  end
-  def test_scan_each_block_match
-    target_version "2.7.105" do
-      r.debug :populate, 100
-      keys_from_scan   = []
-      r.scan_each(:match => "key:1?") {|key|
-        keys_from_scan << key
-      }
-      all_keys = r.keys "key:1?"
-      assert all_keys.sort == keys_from_scan.uniq.sort
-    end
-  end
-  def test_sscan_with_encoding
-    target_version "2.7.105" do
-      [:intset, :hashtable].each do |enc|
-        r.del "set"
-        prefix = ""
-        prefix = "ele:" if enc == :hashtable
-        elements = []
-        100.times { |j| elements << "#{prefix}#{j}" }
-        r.sadd "set", elements
-        assert_equal enc.to_s, r.object("encoding", "set")
-        cursor = 0
-        all_keys   = []
-        loop {
-          cursor, keys = r.sscan "set", cursor
-          all_keys += keys
-          break if cursor == "0"
-        }
-        assert_equal 100, all_keys.uniq.size
-      end
-    end
-  end
-  def test_sscan_each_enumerator
-    target_version "2.7.105" do
-      elements = []
-      100.times { |j| elements << "ele:#{j}" }
-      r.sadd "set", elements
-      scan_enumerator = r.sscan_each("set")
-      assert_equal true, scan_enumerator.is_a?(::Enumerator)
-      keys_from_scan = scan_enumerator.to_a.uniq
-      all_keys = r.smembers("set")
-      assert all_keys.sort == keys_from_scan.sort
-    end
-  end
-  def test_sscan_each_enumerator_match
-    target_version "2.7.105" do
-      elements = []
-      100.times { |j| elements << "ele:#{j}" }
-      r.sadd "set", elements
-      keys_from_scan = r.sscan_each("set", :match => "ele:1?").to_a.uniq
-      all_keys = r.smembers("set").grep(/^ele:1.$/)
-      assert all_keys.sort == keys_from_scan.sort
-    end
-  end
-  def test_sscan_each_enumerator_block
-    target_version "2.7.105" do
-      elements = []
-      100.times { |j| elements << "ele:#{j}" }
-      r.sadd "set", elements
-      keys_from_scan = []
-      r.sscan_each("set") do |key|
-        keys_from_scan << key
-      end
-      all_keys = r.smembers("set")
-      assert all_keys.sort == keys_from_scan.uniq.sort
-    end
-  end
-  def test_sscan_each_enumerator_block_match
-    target_version "2.7.105" do
-      elements = []
-      100.times { |j| elements << "ele:#{j}" }
-      r.sadd "set", elements
-      keys_from_scan = []
-      r.sscan_each("set", :match => "ele:1?") do |key|
-        keys_from_scan << key
-      end
-      all_keys = r.smembers("set").grep(/^ele:1.$/)
-      assert all_keys.sort == keys_from_scan.uniq.sort
-    end
-  end
-  def test_hscan_with_encoding
-    target_version "2.7.105" do
-      [:ziplist, :hashtable].each do |enc|
-        r.del "set"
-        count = 1000
-        count = 30 if enc == :ziplist
-        elements = []
-        count.times { |j| elements << "key:#{j}" << j.to_s }
-        r.hmset "hash", *elements
-        assert_equal enc.to_s, r.object("encoding", "hash")
-        cursor = 0
-        all_key_values   = []
-        loop {
-          cursor, key_values = r.hscan "hash", cursor
-          all_key_values.concat key_values
-          break if cursor == "0"
-        }
-        keys2 = []
-        all_key_values.each do |k, v|
-          assert_equal "key:#{v}", k
-          keys2 << k
-        end
-        assert_equal count, keys2.uniq.size
-      end
-    end
-  end
-  def test_hscan_each_enumerator
-    target_version "2.7.105" do
-      count = 1000
-      elements = []
-      count.times { |j| elements << "key:#{j}" << j.to_s }
-      r.hmset "hash", *elements
-      scan_enumerator = r.hscan_each("hash")
-      assert_equal true, scan_enumerator.is_a?(::Enumerator)
-      keys_from_scan = scan_enumerator.to_a.uniq
-      all_keys = r.hgetall("hash").to_a
-      assert all_keys.sort == keys_from_scan.sort
-    end
-  end
-  def test_hscan_each_enumerator_match
-    target_version "2.7.105" do
-      count = 100
-      elements = []
-      count.times { |j| elements << "key:#{j}" << j.to_s }
-      r.hmset "hash", *elements
-      keys_from_scan = r.hscan_each("hash", :match => "key:1?").to_a.uniq
-      all_keys = r.hgetall("hash").to_a.select{|k,v| k =~ /^key:1.$/}
-      assert all_keys.sort == keys_from_scan.sort
-    end
-  end
-  def test_hscan_each_block
-    target_version "2.7.105" do
-      count = 1000
-      elements = []
-      count.times { |j| elements << "key:#{j}" << j.to_s }
-      r.hmset "hash", *elements
-      keys_from_scan = []
-      r.hscan_each("hash") do |field, value|
-        keys_from_scan << [field, value]
-      end
-      all_keys = r.hgetall("hash").to_a
-      assert all_keys.sort == keys_from_scan.uniq.sort
-    end
-  end
-  def test_hscan_each_block_match
-    target_version "2.7.105" do
-      count = 1000
-      elements = []
-      count.times { |j| elements << "key:#{j}" << j.to_s }
-      r.hmset "hash", *elements
-      keys_from_scan = []
-      r.hscan_each("hash", :match => "key:1?") do |field, value|
-        keys_from_scan << [field, value]
-      end
-      all_keys = r.hgetall("hash").to_a.select{|k,v| k =~ /^key:1.$/}
-      assert all_keys.sort == keys_from_scan.uniq.sort
-    end
-  end
-  def test_zscan_with_encoding
-    target_version "2.7.105" do
-      [:ziplist, :skiplist].each do |enc|
-        r.del "zset"
-        count = 1000
-        count = 30 if enc == :ziplist
-        elements = []
-        count.times { |j| elements << j << "key:#{j}" }
-        r.zadd "zset", elements
-        assert_equal enc.to_s, r.object("encoding", "zset")
-        cursor = 0
-        all_key_scores   = []
-        loop {
-          cursor, key_scores = r.zscan "zset", cursor
-          all_key_scores.concat  key_scores
-          break if cursor == "0"
-        }
-        keys2 = []
-        all_key_scores.each do |k, v|
-          assert_equal true, v.is_a?(Float)
-          assert_equal "key:#{Integer(v)}", k
-          keys2 << k
-        end
-        assert_equal count, keys2.uniq.size
-      end
-    end
-  end
-  def test_zscan_each_enumerator
-    target_version "2.7.105" do
-      count = 1000
-      elements = []
-      count.times { |j| elements << j << "key:#{j}" }
-      r.zadd "zset", elements
-      scan_enumerator = r.zscan_each "zset"
-      assert_equal true, scan_enumerator.is_a?(::Enumerator)
-      scores_from_scan = scan_enumerator.to_a.uniq
-      member_scores = r.zrange("zset", 0, -1, :with_scores => true)
-      assert member_scores.sort == scores_from_scan.sort
-    end
-  end
-  def test_zscan_each_enumerator_match
-    target_version "2.7.105" do
-      count = 1000
-      elements = []
-      count.times { |j| elements << j << "key:#{j}" }
-      r.zadd "zset", elements
-      scores_from_scan = r.zscan_each("zset", :match => "key:1??").to_a.uniq
-      member_scores = r.zrange("zset", 0, -1, :with_scores => true)
-      filtered_members = member_scores.select{|k,s| k =~ /^key:1..$/}
-      assert filtered_members.sort == scores_from_scan.sort
-    end
-  end
-  def test_zscan_each_block
-    target_version "2.7.105" do
-      count = 1000
-      elements = []
-      count.times { |j| elements << j << "key:#{j}" }
-      r.zadd "zset", elements
-      scores_from_scan = []
-      r.zscan_each("zset") do |member, score|
-        scores_from_scan << [member, score]
-      end
-      member_scores = r.zrange("zset", 0, -1, :with_scores => true)
-      assert member_scores.sort == scores_from_scan.sort
-    end
-  end
-  def test_zscan_each_block_match
-    target_version "2.7.105" do
-      count = 1000
-      elements = []
-      count.times { |j| elements << j << "key:#{j}" }
-      r.zadd "zset", elements
-      scores_from_scan = []
-      r.zscan_each("zset", :match => "key:1??") do |member, score|
-        scores_from_scan << [member, score]
-      end
-      member_scores = r.zrange("zset", 0, -1, :with_scores => true)
-      filtered_members = member_scores.select{|k,s| k =~ /^key:1..$/}
-      assert filtered_members.sort == scores_from_scan.sort
-    end
-  end
-end