redis 4.0.2 → 4.0.3

data/test/distributed_blocking_commands_test.rb

@@ -41,4 +41,12 @@ class TestDistributedBlockingCommands < Test::Unit::TestCase
       r.brpoplpush("foo", "bar", 0)
     end
   end
+
+  def test_bzpopmin
+    # Not implemented yet
+  end
+
+  def test_bzpopmax
+    # Not implemented yet
+  end
 end

data/test/distributed_commands_on_hashes_test.rb

@@ -1,8 +1,21 @@
-require_relative "helper"
-require_relative "lint/hashes"
+require_relative 'helper'
+require_relative 'lint/hashes'
 
 class TestDistributedCommandsOnHashes < Test::Unit::TestCase
-
   include Helper::Distributed
   include Lint::Hashes
+
+  def test_hscan
+    # Not implemented yet
+  end
+
+  def test_hstrlen
+    # Not implemented yet
+  end
+
+  def test_mapped_hmget_in_a_pipeline_returns_hash
+    assert_raise(Redis::Distributed::CannotDistribute) do
+      super
+    end
+  end
 end

data/test/distributed_commands_on_hyper_log_log_test.rb

@@ -1,31 +1,26 @@
-require_relative "helper"
-require_relative "lint/hyper_log_log"
+require_relative 'helper'
+require_relative 'lint/hyper_log_log'
 
 class TestDistributedCommandsOnHyperLogLog < Test::Unit::TestCase
-
   include Helper::Distributed
   include Lint::HyperLogLog
 
   def test_pfmerge
-    target_version "2.8.9" do
+    target_version '2.8.9' do
       assert_raise Redis::Distributed::CannotDistribute do
-        r.pfadd "foo", "s1"
-        r.pfadd "bar", "s2"
-
-        assert r.pfmerge("res", "foo", "bar")
+        super
       end
     end
   end
 
   def test_pfcount_multiple_keys_diff_nodes
-    target_version "2.8.9" do
+    target_version '2.8.9' do
       assert_raise Redis::Distributed::CannotDistribute do
-        r.pfadd "foo", "s1"
-        r.pfadd "bar", "s2"
+        r.pfadd 'foo', 's1'
+        r.pfadd 'bar', 's2'
 
-        assert r.pfcount("res", "foo", "bar")
+        assert r.pfcount('res', 'foo', 'bar')
       end
     end
   end
-
 end

data/test/distributed_commands_on_lists_test.rb

@@ -1,20 +1,19 @@
-require_relative "helper"
-require_relative "lint/lists"
+require_relative 'helper'
+require_relative 'lint/lists'
 
 class TestDistributedCommandsOnLists < Test::Unit::TestCase
-
   include Helper::Distributed
   include Lint::Lists
 
   def test_rpoplpush
     assert_raise Redis::Distributed::CannotDistribute do
-      r.rpoplpush("foo", "bar")
+      r.rpoplpush('foo', 'bar')
     end
   end
 
   def test_brpoplpush
     assert_raise Redis::Distributed::CannotDistribute do
-      r.brpoplpush("foo", "bar", :timeout => 1)
+      r.brpoplpush('foo', 'bar', timeout: 1)
     end
   end
 end

data/test/distributed_commands_on_sets_test.rb

@@ -1,106 +1,105 @@
-require_relative "helper"
-require_relative "lint/sets"
+require_relative 'helper'
+require_relative 'lint/sets'
 
 class TestDistributedCommandsOnSets < Test::Unit::TestCase
-
   include Helper::Distributed
   include Lint::Sets
 
   def test_smove
     assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "bar", "s2"
+      r.sadd 'foo', 's1'
+      r.sadd 'bar', 's2'
 
-      r.smove("foo", "bar", "s1")
+      r.smove('foo', 'bar', 's1')
     end
   end
 
   def test_sinter
     assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
 
-      r.sinter("foo", "bar")
+      r.sinter('foo', 'bar')
     end
   end
 
   def test_sinterstore
     assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
 
-      r.sinterstore("baz", "foo", "bar")
+      r.sinterstore('baz', 'foo', 'bar')
     end
   end
 
   def test_sunion
     assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-      r.sadd "bar", "s3"
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
 
-      r.sunion("foo", "bar")
+      r.sunion('foo', 'bar')
     end
   end
 
   def test_sunionstore
     assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-      r.sadd "bar", "s3"
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
 
-      r.sunionstore("baz", "foo", "bar")
+      r.sunionstore('baz', 'foo', 'bar')
     end
   end
 
   def test_sdiff
     assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-      r.sadd "bar", "s3"
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
 
-      r.sdiff("foo", "bar")
+      r.sdiff('foo', 'bar')
     end
   end
 
   def test_sdiffstore
     assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-      r.sadd "bar", "s3"
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
 
-      r.sdiffstore("baz", "foo", "bar")
+      r.sdiffstore('baz', 'foo', 'bar')
     end
   end
 
   def test_sscan
     assert_nothing_raised do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-      r.sadd "bar", "s3"
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
 
-      cursor, vals = r.sscan "foo", 0
+      cursor, vals = r.sscan 'foo', 0
       assert_equal '0', cursor
-      assert_equal %w(s1 s2), vals.sort
+      assert_equal %w[s1 s2], vals.sort
     end
   end
 
   def test_sscan_each
     assert_nothing_raised do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-      r.sadd "bar", "s3"
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
 
-      vals = r.sscan_each("foo").to_a
-      assert_equal %w(s1 s2), vals.sort
+      vals = r.sscan_each('foo').to_a
+      assert_equal %w[s1 s2], vals.sort
     end
   end
 end

data/test/distributed_commands_on_sorted_sets_test.rb

@@ -1,16 +1,59 @@
-require_relative "helper"
-require_relative "lint/sorted_sets"
+require_relative 'helper'
+require_relative 'lint/sorted_sets'
 
 class TestDistributedCommandsOnSortedSets < Test::Unit::TestCase
-
   include Helper::Distributed
   include Lint::SortedSets
 
-  def test_zcount
-    r.zadd "foo", 1, "s1"
-    r.zadd "foo", 2, "s2"
-    r.zadd "foo", 3, "s3"
+  def test_zinterstore
+    assert_raise(Redis::Distributed::CannotDistribute) { super }
+  end
+
+  def test_zinterstore_with_aggregate
+    assert_raise(Redis::Distributed::CannotDistribute) { super }
+  end
+
+  def test_zinterstore_with_weights
+    assert_raise(Redis::Distributed::CannotDistribute) { super }
+  end
+
+  def test_zlexcount
+    # Not implemented yet
+  end
+
+  def test_zpopmax
+    # Not implemented yet
+  end
+
+  def test_zpopmin
+    # Not implemented yet
+  end
+
+  def test_zrangebylex
+    # Not implemented yet
+  end
+
+  def test_zremrangebylex
+    # Not implemented yet
+  end
+
+  def test_zrevrangebylex
+    # Not implemented yet
+  end
+
+  def test_zscan
+    # Not implemented yet
+  end
+
+  def test_zunionstore
+    assert_raise(Redis::Distributed::CannotDistribute) { super }
+  end
+
+  def test_zunionstore_with_aggregate
+    assert_raise(Redis::Distributed::CannotDistribute) { super }
+  end
 
-    assert_equal 2, r.zcount("foo", 2, 3)
+  def test_zunionstore_with_weights
+    assert_raise(Redis::Distributed::CannotDistribute) { super }
   end
 end

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/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