redis 3.3.5 → 4.0.3

data/test/encoding_test.rb

@@ -1,18 +1,14 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestEncoding < Test::Unit::TestCase
 
   include Helper::Client
 
   def test_returns_properly_encoded_strings
-    if defined?(Encoding)
-      with_external_encoding("UTF-8") do
-        r.set "foo", "שלום"
+    with_external_encoding("UTF-8") do
+      r.set "foo", "שלום"
 
-        assert_equal "Shalom שלום", "Shalom " + r.get("foo")
-      end
+      assert_equal "Shalom שלום", "Shalom " + r.get("foo")
     end
   end
 end

data/test/error_replies_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestErrorReplies < Test::Unit::TestCase
 
@@ -47,7 +45,7 @@ class TestErrorReplies < Test::Unit::TestCase
   def test_recover_from_raise_in__call_loop
     with_reconnection_check do
       begin
-        r.client.call_loop([:invalid_monitor]) do
+        r._client.call_loop([:invalid_monitor]) do
           assert false # Should never be executed
         end
       rescue => ex

data/test/fork_safety_test.rb

@@ -1,11 +1,8 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestForkSafety < Test::Unit::TestCase
 
   include Helper::Client
-  include Helper::Skipable
 
   driver(:ruby, :hiredis) do
     def test_fork_safety
@@ -32,7 +29,6 @@ class TestForkSafety < Test::Unit::TestCase
 
     rescue NotImplementedError => error
       raise unless error.message =~ /fork is not available/
-      return skip(error.message)
     end
 
     def test_fork_safety_with_enabled_inherited_socket
@@ -59,7 +55,6 @@ class TestForkSafety < Test::Unit::TestCase
 
     rescue NotImplementedError => error
       raise unless error.message =~ /fork is not available/
-      return skip(error.message)
     end
   end
 end

data/test/helper.rb

@@ -1,62 +1,26 @@
-$:.unshift File.expand_path("../lib", File.dirname(__FILE__))
-$:.unshift File.expand_path(File.dirname(__FILE__))
-
 require "test/unit"
+require "mocha/test_unit"
 require "logger"
 require "stringio"
 
-(class Random; def self.rand(*args) super end; end) unless defined?(Random)
-
-begin
-  require "ruby-debug"
-rescue LoadError
-end
-
 $VERBOSE = true
 
-ENV["conn"] ||= "ruby"
+ENV["DRIVER"] ||= "ruby"
 
-require "redis"
-require "redis/distributed"
-require "redis/connection/#{ENV["conn"]}"
+require_relative "../lib/redis"
+require_relative "../lib/redis/distributed"
+require_relative "../lib/redis/connection/#{ENV["DRIVER"]}"
 
-require "support/redis_mock"
-require "support/connection/#{ENV["conn"]}"
+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:
-
-        $ rake clean
-
-      Then run the build again:
-
-        $ rake
-
-    EOS
-    exit 1
-  end
-end
-
 def driver(*drivers, &blk)
-  if drivers.map(&:to_s).include?(ENV["conn"])
+  if drivers.map(&:to_s).include?(ENV["DRIVER"])
     class_eval(&blk)
   end
 end
@@ -92,14 +56,6 @@ module Helper
     end
   end
 
-  def try_encoding(encoding, &block)
-    if defined?(Encoding)
-      with_external_encoding(encoding, &block)
-    else
-      yield
-    end
-  end
-
   class Version
 
     include Comparable
@@ -151,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))
@@ -174,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)
@@ -191,7 +173,7 @@ module Helper
     end
 
     def _new_client(options = {})
-      Redis.new(_format_options(options).merge(:driver => ENV["conn"]))
+      Redis.new(_format_options(options).merge(:driver => ENV["DRIVER"]))
     end
   end
 
@@ -217,16 +199,147 @@ module Helper
     end
   end
 
-  # Basic support for `skip` in 1.8.x
-  # Note: YOU MUST use `return skip(message)` in order to appropriately bail
-  # from a running test.
-  module Skipable
-    Skipped = Class.new(RuntimeError)
+  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 skip(message = nil, bt = caller)
-      return super if defined?(super)
+    def redis_cluster_down
+      trib = ClusterOrchestrator.new(_default_nodes)
+      trib.down
+      yield
+    ensure
+      trib.rebuild
+      trib.close
+    end
 
-      $stderr.puts("SKIPPED: #{self} #{message || 'no reason given'}")
+    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/helper_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestHelper < Test::Unit::TestCase
 

data/test/internals_test.rb

@@ -1,11 +1,8 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestInternals < Test::Unit::TestCase
 
   include Helper::Client
-  include Helper::Skipable
 
   def test_logger
     r.ping
@@ -45,23 +42,23 @@ class TestInternals < Test::Unit::TestCase
   end
 
   def test_redis_current
-    assert_equal "127.0.0.1", Redis.current.client.host
-    assert_equal 6379, Redis.current.client.port
-    assert_equal 0, Redis.current.client.db
+    assert_equal "127.0.0.1", Redis.current._client.host
+    assert_equal 6379, Redis.current._client.port
+    assert_equal 0, Redis.current._client.db
 
     Redis.current = Redis.new(OPTIONS.merge(:port => 6380, :db => 1))
 
     t = Thread.new do
-      assert_equal "127.0.0.1", Redis.current.client.host
-      assert_equal 6380, Redis.current.client.port
-      assert_equal 1, Redis.current.client.db
+      assert_equal "127.0.0.1", Redis.current._client.host
+      assert_equal 6380, Redis.current._client.port
+      assert_equal 1, Redis.current._client.db
     end
 
     t.join
 
-    assert_equal "127.0.0.1", Redis.current.client.host
-    assert_equal 6380, Redis.current.client.port
-    assert_equal 1, Redis.current.client.db
+    assert_equal "127.0.0.1", Redis.current._client.host
+    assert_equal 6380, Redis.current._client.port
+    assert_equal 1, Redis.current._client.db
   end
 
   def test_redis_connected?
@@ -88,7 +85,7 @@ class TestInternals < Test::Unit::TestCase
       redis = Redis.new(OPTIONS.merge(:tcp_keepalive => keepalive))
       redis.ping
 
-      connection = redis.client.connection
+      connection = redis._client.connection
       actual_keepalive = connection.get_tcp_keepalive
 
       [:time, :intvl, :probes].each do |key|
@@ -121,22 +118,10 @@ class TestInternals < Test::Unit::TestCase
     assert (Time.now - start_time) <= opts[:timeout]
   end
 
-  driver(:ruby) do
-    def test_write_timeout
-      return skip("Relies on buffer sizes, might be unreliable")
-
-      server = TCPServer.new("127.0.0.1", 0)
-      port   = server.addr[1]
-
-      # Hacky, but we need the buffer size
-      val = TCPSocket.new("127.0.0.1", port).getsockopt(Socket::SOL_SOCKET, Socket::SO_SNDBUF).unpack("i")[0]
-
-      assert_raise(Redis::TimeoutError) do
-        Timeout.timeout(1) do
-          redis = Redis.new(:port => port, :timeout => 5, :write_timeout => 0.1)
-          redis.set("foo", "1" * val*2)
-        end
-      end
+  def test_missing_socket
+    opts = { :path => '/missing.sock' }
+    assert_raise Redis::CannotConnectError do
+      Redis.new(opts).ping
     end
   end
 
@@ -197,7 +182,7 @@ class TestInternals < Test::Unit::TestCase
         redis.ping
       end
 
-      assert !redis.client.connected?
+      assert !redis._client.connected?
     end
   end
 
@@ -213,7 +198,20 @@ class TestInternals < Test::Unit::TestCase
         redis.ping
       end
 
-      assert !redis.client.connected?
+      assert !redis._client.connected?
+    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
 
@@ -226,7 +224,7 @@ class TestInternals < Test::Unit::TestCase
         end
       end
 
-      assert !redis.client.connected?
+      assert !redis._client.connected?
     end
   end
 
@@ -267,14 +265,14 @@ class TestInternals < Test::Unit::TestCase
 
   def test_retry_on_write_error_by_default
     close_on_connection([0]) do |redis|
-      assert_equal "1", redis.client.call(["x" * 128 * 1024])
+      assert_equal "1", redis._client.call(["x" * 128 * 1024])
     end
   end
 
   def test_retry_on_write_error_when_wrapped_in_with_reconnect_true
     close_on_connection([0]) do |redis|
       redis.with_reconnect(true) do
-        assert_equal "1", redis.client.call(["x" * 128 * 1024])
+        assert_equal "1", redis._client.call(["x" * 128 * 1024])
       end
     end
   end
@@ -283,7 +281,7 @@ class TestInternals < Test::Unit::TestCase
     close_on_connection([0]) do |redis|
       assert_raise Redis::ConnectionError do
         redis.with_reconnect(false) do
-          redis.client.call(["x" * 128 * 1024])
+          redis._client.call(["x" * 128 * 1024])
         end
       end
     end
@@ -293,7 +291,7 @@ class TestInternals < Test::Unit::TestCase
     close_on_connection([0]) do |redis|
       assert_raise Redis::ConnectionError do
         redis.without_reconnect do
-          redis.client.call(["x" * 128 * 1024])
+          redis._client.call(["x" * 128 * 1024])
         end
       end
     end
@@ -301,7 +299,7 @@ class TestInternals < Test::Unit::TestCase
 
   def test_connecting_to_unix_domain_socket
     assert_nothing_raised do
-      Redis.new(OPTIONS.merge(:path => "./test/db/redis.sock")).ping
+      Redis.new(OPTIONS.merge(:path => ENV.fetch("SOCKET_PATH"))).ping
     end
   end
 
@@ -323,23 +321,10 @@ class TestInternals < Test::Unit::TestCase
   def test_client_options
     redis = Redis.new(OPTIONS.merge(:host => "host", :port => 1234, :db => 1, :scheme => "foo"))
 
-    assert_equal "host", redis.client.options[:host]
-    assert_equal 1234, redis.client.options[:port]
-    assert_equal 1, redis.client.options[:db]
-    assert_equal "foo", redis.client.options[:scheme]
-  end
-
-  def test_does_not_change_self_client_options
-    redis = Redis.new(OPTIONS.merge(:host => "host", :port => 1234, :db => 1, :scheme => "foo"))
-    options = redis.client.options
-
-    options[:host] << "new_host"
-    options[:scheme] << "bar"
-    options.merge!(:db => 0)
-
-    assert_equal "host", redis.client.options[:host]
-    assert_equal 1, redis.client.options[:db]
-    assert_equal "foo", redis.client.options[:scheme]
+    assert_equal "host", redis._client.options[:host]
+    assert_equal 1234, redis._client.options[:port]
+    assert_equal 1, redis._client.options[:db]
+    assert_equal "foo", redis._client.options[:scheme]
   end
 
   def test_resolves_localhost
@@ -362,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|