redis 4.0.1 → 4.0.3

data/test/distributed_commands_on_strings_test.rb

@@ -66,4 +66,14 @@ class TestDistributedCommandsOnStrings < Test::Unit::TestCase
       end
     end
   end
+
+  def test_mapped_mget_in_a_pipeline_returns_hash
+    assert_raise Redis::Distributed::CannotDistribute do
+      super
+    end
+  end
+
+  def test_bitfield
+    # Not implemented yet
+  end
 end

data/test/distributed_commands_on_value_types_test.rb

@@ -38,6 +38,42 @@ class TestDistributedCommandsOnValueTypes < Test::Unit::TestCase
     assert_equal [], r.keys("*").sort
   end
 
+  def test_unlink
+    target_version "4.0.0" do
+      r.set "foo", "s1"
+      r.set "bar", "s2"
+      r.set "baz", "s3"
+
+      assert_equal ["bar", "baz", "foo"], r.keys("*").sort
+
+      assert_equal 1, r.unlink("foo")
+
+      assert_equal ["bar", "baz"], r.keys("*").sort
+
+      assert_equal 2, r.unlink("bar", "baz")
+
+      assert_equal [], r.keys("*").sort
+    end
+  end
+
+  def test_unlink_with_array_argument
+    target_version "4.0.0" do
+      r.set "foo", "s1"
+      r.set "bar", "s2"
+      r.set "baz", "s3"
+
+      assert_equal ["bar", "baz", "foo"], r.keys("*").sort
+
+      assert_equal 1, r.unlink(["foo"])
+
+      assert_equal ["bar", "baz"], r.keys("*").sort
+
+      assert_equal 2, r.unlink(["bar", "baz"])
+
+      assert_equal [], r.keys("*").sort
+    end
+  end
+
   def test_randomkey
     assert_raise Redis::Distributed::CannotDistribute do
       r.randomkey

data/test/helper.rb

@@ -1,4 +1,5 @@
 require "test/unit"
+require "mocha/test_unit"
 require "logger"
 require "stringio"
 
@@ -12,39 +13,12 @@ require_relative "../lib/redis/connection/#{ENV["DRIVER"]}"
 
 require_relative "support/redis_mock"
 require_relative "support/connection/#{ENV["DRIVER"]}"
+require_relative 'support/cluster/orchestrator'
 
 PORT    = 6381
 OPTIONS = {:port => PORT, :db => 15, :timeout => Float(ENV["TIMEOUT"] || 0.1)}
 NODES   = ["redis://127.0.0.1:#{PORT}/15"]
 
-def init(redis)
-  begin
-    redis.select 14
-    redis.flushdb
-    redis.select 15
-    redis.flushdb
-    redis
-  rescue Redis::CannotConnectError
-    puts <<-EOS
-
-      Cannot connect to Redis.
-
-      Make sure Redis is running on localhost, port #{PORT}.
-      This testing suite connects to the database 15.
-
-      Try this once:
-
-        $ make clean
-
-      Then run the build again:
-
-        $ make
-
-    EOS
-    exit 1
-  end
-end
-
 def driver(*drivers, &blk)
   if drivers.map(&:to_s).include?(ENV["DRIVER"])
     class_eval(&blk)
@@ -133,6 +107,32 @@ module Helper
       @redis.quit if @redis
     end
 
+    def init(redis)
+      redis.select 14
+      redis.flushdb
+      redis.select 15
+      redis.flushdb
+      redis
+    rescue Redis::CannotConnectError
+      puts <<-MSG
+
+        Cannot connect to Redis.
+
+        Make sure Redis is running on localhost, port #{PORT}.
+        This testing suite connects to the database 15.
+
+        Try this once:
+
+          $ make clean
+
+        Then run the build again:
+
+          $ make
+
+      MSG
+      exit 1
+    end
+
     def redis_mock(commands, options = {}, &blk)
       RedisMock.start(commands, options) do |port|
         yield _new_client(options.merge(:port => port))
@@ -156,16 +156,16 @@ module Helper
         yield
       end
     end
+
+    def version
+      Version.new(redis.info['redis_version'])
+    end
   end
 
   module Client
 
     include Generic
 
-    def version
-      Version.new(redis.info["redis_version"])
-    end
-
     private
 
     def _format_options(options)
@@ -198,4 +198,148 @@ module Helper
       Redis::Distributed.new(NODES, _format_options(options).merge(:driver => ENV["conn"]))
     end
   end
+
+  module Cluster
+    include Generic
+
+    DEFAULT_HOST = '127.0.0.1'
+    DEFAULT_PORTS = (7000..7005).freeze
+
+    ClusterSlotsRawReply = lambda { |host, port|
+      # @see https://redis.io/topics/protocol
+      <<-REPLY.delete(' ')
+        *1\r
+        *4\r
+        :0\r
+        :16383\r
+        *3\r
+        $#{host.size}\r
+        #{host}\r
+        :#{port}\r
+        $40\r
+        649fa246273043021a05f547a79478597d3f1dc5\r
+        *3\r
+        $#{host.size}\r
+        #{host}\r
+        :#{port}\r
+        $40\r
+        649fa246273043021a05f547a79478597d3f1dc5\r
+      REPLY
+    }
+
+    ClusterNodesRawReply = lambda { |host, port|
+      line = "649fa246273043021a05f547a79478597d3f1dc5 #{host}:#{port}@17000 "\
+             'myself,master - 0 1530797742000 1 connected 0-16383'
+      "$#{line.size}\r\n#{line}\r\n"
+    }
+
+    def init(redis)
+      redis.flushall
+      redis
+    rescue Redis::CannotConnectError
+      puts <<-MSG
+
+        Cannot connect to Redis Cluster.
+
+        Make sure Redis is running on localhost, port #{DEFAULT_PORTS}.
+
+        Try this once:
+
+          $ make stop_cluster
+
+        Then run the build again:
+
+          $ make
+
+      MSG
+      exit 1
+    end
+
+    def build_another_client(options = {})
+      _new_client(options)
+    end
+
+    def redis_cluster_mock(commands, options = {})
+      host = DEFAULT_HOST
+      port = nil
+
+      cluster_subcommands = if commands.key?(:cluster)
+                              commands.delete(:cluster)
+                                      .map { |k, v| [k.to_s.downcase, v] }
+                                      .to_h
+                            else
+                              {}
+                            end
+
+      commands[:cluster] = lambda { |subcommand, *args|
+        if cluster_subcommands.key?(subcommand)
+          cluster_subcommands[subcommand].call(*args)
+        else
+          case subcommand
+          when 'slots' then ClusterSlotsRawReply.call(host, port)
+          when 'nodes' then ClusterNodesRawReply.call(host, port)
+          else '+OK'
+          end
+        end
+      }
+
+      commands[:command] = ->(*_) { "*0\r\n" }
+
+      RedisMock.start(commands, options) do |po|
+        port = po
+        scheme = options[:ssl] ? 'rediss' : 'redis'
+        nodes = %W[#{scheme}://#{host}:#{port}]
+        yield _new_client(options.merge(cluster: nodes))
+      end
+    end
+
+    def redis_cluster_down
+      trib = ClusterOrchestrator.new(_default_nodes)
+      trib.down
+      yield
+    ensure
+      trib.rebuild
+      trib.close
+    end
+
+    def redis_cluster_failover
+      trib = ClusterOrchestrator.new(_default_nodes)
+      trib.failover
+      yield
+    ensure
+      trib.rebuild
+      trib.close
+    end
+
+    # @param slot [Integer]
+    # @param src [String] <ip>:<port>
+    # @param dest [String] <ip>:<port>
+    def redis_cluster_resharding(slot, src:, dest:)
+      trib = ClusterOrchestrator.new(_default_nodes)
+      trib.start_resharding(slot, src, dest)
+      yield
+      trib.finish_resharding(slot, dest)
+    ensure
+      trib.rebuild
+      trib.close
+    end
+
+    private
+
+    def _default_nodes(host: DEFAULT_HOST, ports: DEFAULT_PORTS)
+      ports.map { |port| "redis://#{host}:#{port}" }
+    end
+
+    def _format_options(options)
+      {
+        timeout: OPTIONS[:timeout],
+        logger: ::Logger.new(@log),
+        cluster: _default_nodes
+      }.merge(options)
+    end
+
+    def _new_client(options = {})
+      Redis.new(_format_options(options).merge(driver: ENV['DRIVER']))
+    end
+  end
 end

data/test/internals_test.rb

@@ -202,6 +202,19 @@ class TestInternals < Test::Unit::TestCase
     end
   end
 
+  def test_retry_with_custom_reconnect_attempts_and_exponential_backoff
+    close_on_ping([0, 1, 2], :reconnect_attempts => 3,
+                             :reconnect_delay_max => 0.5,
+                             :reconnect_delay => 0.01) do |redis|
+
+      Kernel.expects(:sleep).with(0.01).returns(true)
+      Kernel.expects(:sleep).with(0.02).returns(true)
+      Kernel.expects(:sleep).with(0.04).returns(true)
+
+      assert_equal "3", redis.ping
+    end
+  end
+
   def test_don_t_retry_when_second_read_in_pipeline_raises_econnreset
     close_on_ping([1]) do |redis|
       assert_raise Redis::ConnectionError do
@@ -334,7 +347,13 @@ class TestInternals < Test::Unit::TestCase
           begin
             sa = Socket.pack_sockaddr_in(1024 + Random.rand(63076), hosts[af])
             s.bind(sa)
-          rescue Errno::EADDRINUSE
+          rescue Errno::EADDRINUSE => e
+            # On JRuby (9.1.15.0), if IPv6 is globally disabled on the system,
+            # we get an EADDRINUSE with belows message.
+            if e.message =~ /Protocol family unavailable/
+              return
+            end
+
             tries -= 1
             retry if tries > 0
 

data/test/lint/blocking_commands.rb

@@ -1,14 +1,15 @@
 module Lint
-
   module BlockingCommands
-
     def setup
       super
 
-      r.rpush("{zap}foo", "s1")
-      r.rpush("{zap}foo", "s2")
-      r.rpush("{zap}bar", "s1")
-      r.rpush("{zap}bar", "s2")
+      r.rpush('{zap}foo', 's1')
+      r.rpush('{zap}foo', 's2')
+      r.rpush('{zap}bar', 's1')
+      r.rpush('{zap}bar', 's2')
+
+      r.zadd('{szap}foo', %w[0 a 1 b 2 c])
+      r.zadd('{szap}bar', %w[0 c 1 d 2 e])
     end
 
     def to_protocol(obj)
@@ -18,27 +19,38 @@ module Lint
       when Array
         "*#{obj.length}\r\n" + obj.map { |e| to_protocol(e) }.join
       else
-        fail
+        raise
       end
     end
 
     def mock(options = {}, &blk)
-      commands = {
-        :blpop => lambda do |*args|
-          sleep options[:delay] if options.has_key?(:delay)
+      commands = build_mock_commands(options)
+      redis_mock(commands, &blk)
+    end
+
+    def build_mock_commands(options = {})
+      {
+        blpop: lambda do |*args|
+          sleep options[:delay] if options.key?(:delay)
           to_protocol([args.first, args.last])
         end,
-        :brpop => lambda do |*args|
-          sleep options[:delay] if options.has_key?(:delay)
+        brpop: lambda do |*args|
+          sleep options[:delay] if options.key?(:delay)
           to_protocol([args.first, args.last])
         end,
-        :brpoplpush => lambda do |*args|
-          sleep options[:delay] if options.has_key?(:delay)
+        brpoplpush: lambda do |*args|
+          sleep options[:delay] if options.key?(:delay)
           to_protocol(args.last)
+        end,
+        bzpopmax: lambda do |*args|
+          sleep options[:delay] if options.key?(:delay)
+          to_protocol([args.first, args.last])
+        end,
+        bzpopmin: lambda do |*args|
+          sleep options[:delay] if options.key?(:delay)
+          to_protocol([args.first, args.last])
         end
       }
-
-      redis_mock(commands, &blk)
     end
 
     def test_blpop
@@ -121,6 +133,18 @@ module Lint
       end
     end
 
+    def test_bzpopmin
+      target_version('4.9.0') do
+        assert_equal %w[{szap}foo a 0], r.bzpopmin('{szap}foo', '{szap}bar', 0)
+      end
+    end
+
+    def test_bzpopmax
+      target_version('4.9.0') do
+        assert_equal %w[{szap}foo c 2], r.bzpopmax('{szap}foo', '{szap}bar', 0)
+      end
+    end
+
     driver(:ruby, :hiredis) do
       def test_blpop_socket_timeout
         mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r|

data/test/lint/hashes.rb

@@ -30,6 +30,21 @@ module Lint
       assert_equal nil, r.hget("foo", "f1")
     end
 
+    def test_splat_hdel
+      target_version "2.3.9" do
+        r.hset("foo", "f1", "s1")
+        r.hset("foo", "f2", "s2")
+
+        assert_equal "s1", r.hget("foo", "f1")
+        assert_equal "s2", r.hget("foo", "f2")
+
+        assert_equal 2, r.hdel("foo", "f1", "f2")
+
+        assert_equal nil, r.hget("foo", "f1")
+        assert_equal nil, r.hget("foo", "f2")
+      end
+    end
+
     def test_variadic_hdel
       target_version "2.3.9" do
         r.hset("foo", "f1", "s1")
@@ -129,6 +144,17 @@ module Lint
       assert({"f1" => "s1", "f2" => "s2"} == r.mapped_hmget("foo", "f1", "f2"))
     end
 
+    def test_mapped_hmget_in_a_pipeline_returns_hash
+      r.hset("foo", "f1", "s1")
+      r.hset("foo", "f2", "s2")
+
+      result = r.pipelined do
+        r.mapped_hmget("foo", "f1", "f2")
+      end
+
+      assert_equal result[0], { "f1" => "s1", "f2" => "s2" }
+    end
+
     def test_hincrby
       r.hincrby("foo", "f1", 1)
 
@@ -158,5 +184,20 @@ module Lint
         assert_equal "1.9", r.hget("foo", "f1")
       end
     end
+
+    def test_hstrlen
+      target_version('3.2.0') do
+        redis.hmset('foo', 'f1', 'HelloWorld', 'f2', 99, 'f3', -256)
+        assert_equal 10, r.hstrlen('foo', 'f1')
+        assert_equal 2, r.hstrlen('foo', 'f2')
+        assert_equal 4, r.hstrlen('foo', 'f3')
+      end
+    end
+
+    def test_hscan
+      redis.hmset('foo', 'f1', 'Jack', 'f2', 33)
+      expected = ['0', [%w[f1 Jack], %w[f2 33]]]
+      assert_equal expected, redis.hscan('foo', 0)
+    end
   end
 end