redis 4.0.2 → 4.0.3

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

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

@@ -144,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)
 
@@ -173,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

data/test/lint/hyper_log_log.rb

@@ -55,6 +55,20 @@ module Lint
       end
     end
 
-  end
+    def test_pfmerge
+      target_version '2.8.9' do
+        r.pfadd 'foo', 's1'
+        r.pfadd 'bar', 's2'
+
+        assert_equal true, r.pfmerge('res', 'foo', 'bar')
+        assert_equal 2, r.pfcount('res')
+      end
+    end
 
+    def test_variadic_pfmerge_expanded
+      redis.pfadd('{1}foo', %w[foo bar zap a])
+      redis.pfadd('{1}bar', %w[a b c foo])
+      assert_equal true, redis.pfmerge('{1}baz', '{1}foo', '{1}bar')
+    end
+  end
 end

data/test/lint/lists.rb

@@ -139,5 +139,21 @@ module Lint
         r.linsert "foo", :anywhere, "s3", "s2"
       end
     end
+
+    def test_rpoplpush
+      r.rpush 'foo', 's1'
+      r.rpush 'foo', 's2'
+
+      assert_equal 's2', r.rpoplpush('foo', 'bar')
+      assert_equal ['s2'], r.lrange('bar', 0, -1)
+      assert_equal 's1', r.rpoplpush('foo', 'bar')
+      assert_equal %w[s1 s2], r.lrange('bar', 0, -1)
+    end
+
+    def test_variadic_rpoplpush_expand
+      redis.rpush('{1}foo', %w[a b c])
+      redis.rpush('{1}bar', %w[d e f])
+      assert_equal 'c', redis.rpoplpush('{1}foo', '{1}bar')
+    end
   end
 end

data/test/lint/sets.rb

@@ -136,5 +136,147 @@ module Lint
 
       assert_equal 4, r.scard("foo")
     end
+
+    def test_smove
+      r.sadd 'foo', 's1'
+      r.sadd 'bar', 's2'
+
+      assert r.smove('foo', 'bar', 's1')
+      assert r.sismember('bar', 's1')
+    end
+
+    def test_sinter
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+
+      assert_equal ['s2'], r.sinter('foo', 'bar')
+    end
+
+    def test_variadic_smove_expand
+      r.sadd('{1}foo', 's1')
+      r.sadd('{1}foo', 's2')
+      r.sadd('{1}foo', 's3')
+      r.sadd('{1}bar', 's3')
+      r.sadd('{1}bar', 's4')
+      r.sadd('{1}bar', 's5')
+      assert_equal true, r.smove('{1}foo', '{1}bar', 's2')
+    end
+
+    def test_variadic_sinter_expand
+      r.sadd('{1}foo', 's1')
+      r.sadd('{1}foo', 's2')
+      r.sadd('{1}foo', 's3')
+      r.sadd('{1}bar', 's3')
+      r.sadd('{1}bar', 's4')
+      r.sadd('{1}bar', 's5')
+      assert_equal %w[s3], r.sinter('{1}foo', '{1}bar')
+    end
+
+    def test_sinterstore
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+
+      r.sinterstore('baz', 'foo', 'bar')
+
+      assert_equal ['s2'], r.smembers('baz')
+    end
+
+    def test_variadic_sinterstore_expand
+      r.sadd('{1}foo', 's1')
+      r.sadd('{1}foo', 's2')
+      r.sadd('{1}foo', 's3')
+      r.sadd('{1}bar', 's3')
+      r.sadd('{1}bar', 's4')
+      r.sadd('{1}bar', 's5')
+      assert_equal 1, r.sinterstore('{1}baz', '{1}foo', '{1}bar')
+    end
+
+    def test_sunion
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
+
+      assert_equal %w[s1 s2 s3], r.sunion('foo', 'bar').sort
+    end
+
+    def test_variadic_sunion_expand
+      r.sadd('{1}foo', 's1')
+      r.sadd('{1}foo', 's2')
+      r.sadd('{1}foo', 's3')
+      r.sadd('{1}bar', 's3')
+      r.sadd('{1}bar', 's4')
+      r.sadd('{1}bar', 's5')
+      assert_equal %w[s1 s2 s3 s4 s5], r.sunion('{1}foo', '{1}bar').sort
+    end
+
+    def test_sunionstore
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
+
+      r.sunionstore('baz', 'foo', 'bar')
+
+      assert_equal %w[s1 s2 s3], r.smembers('baz').sort
+    end
+
+    def test_variadic_sunionstore_expand
+      r.sadd('{1}foo', 's1')
+      r.sadd('{1}foo', 's2')
+      r.sadd('{1}foo', 's3')
+      r.sadd('{1}bar', 's3')
+      r.sadd('{1}bar', 's4')
+      r.sadd('{1}bar', 's5')
+      assert_equal 5, r.sunionstore('{1}baz', '{1}foo', '{1}bar')
+    end
+
+    def test_sdiff
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
+
+      assert_equal ['s1'], r.sdiff('foo', 'bar')
+      assert_equal ['s3'], r.sdiff('bar', 'foo')
+    end
+
+    def test_variadic_sdiff_expand
+      r.sadd('{1}foo', 's1')
+      r.sadd('{1}foo', 's2')
+      r.sadd('{1}foo', 's3')
+      r.sadd('{1}bar', 's3')
+      r.sadd('{1}bar', 's4')
+      r.sadd('{1}bar', 's5')
+      assert_equal %w[s1 s2], r.sdiff('{1}foo', '{1}bar').sort
+    end
+
+    def test_sdiffstore
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
+
+      r.sdiffstore('baz', 'foo', 'bar')
+
+      assert_equal ['s1'], r.smembers('baz')
+    end
+
+    def test_variadic_sdiffstore_expand
+      r.sadd('{1}foo', 's1')
+      r.sadd('{1}foo', 's2')
+      r.sadd('{1}foo', 's3')
+      r.sadd('{1}bar', 's3')
+      r.sadd('{1}bar', 's4')
+      r.sadd('{1}bar', 's5')
+      assert_equal 2, r.sdiffstore('{1}baz', '{1}foo', '{1}bar')
+    end
+
+    def test_sscan
+      r.sadd('foo', %w[1 2 3 foo foobar feelsgood])
+      assert_equal %w[0 feelsgood foo foobar], r.sscan('foo', 0, match: 'f*').flatten.sort
+    end
   end
 end

data/test/lint/sorted_sets.rb

@@ -41,7 +41,8 @@ module Lint
         assert_equal 11.0, r.zadd("foo", 10, "s1", :incr => true)
         assert_equal(-Infinity, r.zadd("bar", "-inf", "s1", :incr => true))
         assert_equal(+Infinity, r.zadd("bar", "+inf", "s2", :incr => true))
-        r.del "foo", "bar"
+        r.del 'foo'
+        r.del 'bar'
 
         # Incompatible options combination
         assert_raise(Redis::CommandError) { r.zadd("foo", 1, "s1", :xx => true, :nx => true) }
@@ -104,7 +105,8 @@ module Lint
         assert_equal(-Infinity, r.zadd("bar", ["-inf", "s1"], :incr => true))
         assert_equal(+Infinity, r.zadd("bar", ["+inf", "s2"], :incr => true))
         assert_raise(Redis::CommandError) { r.zadd("foo", [1, "s1", 2, "s2"], :incr => true) }
-        r.del "foo", "bar"
+        r.del 'foo'
+        r.del 'bar'
 
         # Incompatible options combination
         assert_raise(Redis::CommandError) { r.zadd("foo", [1, "s1"], :xx => true, :nx => true) }
@@ -312,5 +314,184 @@ module Lint
       assert_equal 3, r.zremrangebyscore("foo", 2, 4)
       assert_equal ["s1"], r.zrange("foo", 0, -1)
     end
+
+    def test_zpopmax
+      target_version('4.9.0') do
+        r.zadd('foo', %w[0 a 1 b 2 c])
+        assert_equal %w[c 2], r.zpopmax('foo')
+      end
+    end
+
+    def test_zpopmin
+      target_version('4.9.0') do
+        r.zadd('foo', %w[0 a 1 b 2 c])
+        assert_equal %w[a 0], r.zpopmin('foo')
+      end
+    end
+
+    def test_zremrangebylex
+      r.zadd('foo', %w[0 a 0 b 0 c 0 d 0 e 0 f 0 g])
+      assert_equal 5, r.zremrangebylex('foo', '(b', '[g')
+    end
+
+    def test_zlexcount
+      target_version '2.8.9' do
+        r.zadd 'foo', 0, 'aaren'
+        r.zadd 'foo', 0, 'abagael'
+        r.zadd 'foo', 0, 'abby'
+        r.zadd 'foo', 0, 'abbygail'
+
+        assert_equal 4, r.zlexcount('foo', '[a', "[a\xff")
+        assert_equal 4, r.zlexcount('foo', '[aa', "[ab\xff")
+        assert_equal 3, r.zlexcount('foo', '(aaren', "[ab\xff")
+        assert_equal 2, r.zlexcount('foo', '[aba', '(abbygail')
+        assert_equal 1, r.zlexcount('foo', '(aaren', '(abby')
+      end
+    end
+
+    def test_zrangebylex
+      target_version '2.8.9' do
+        r.zadd 'foo', 0, 'aaren'
+        r.zadd 'foo', 0, 'abagael'
+        r.zadd 'foo', 0, 'abby'
+        r.zadd 'foo', 0, 'abbygail'
+
+        assert_equal %w[aaren abagael abby abbygail], r.zrangebylex('foo', '[a', "[a\xff")
+        assert_equal %w[aaren abagael], r.zrangebylex('foo', '[a', "[a\xff", limit: [0, 2])
+        assert_equal %w[abby abbygail], r.zrangebylex('foo', '(abb', "(abb\xff")
+        assert_equal %w[abbygail], r.zrangebylex('foo', '(abby', "(abby\xff")
+      end
+    end
+
+    def test_zrevrangebylex
+      target_version '2.9.9' do
+        r.zadd 'foo', 0, 'aaren'
+        r.zadd 'foo', 0, 'abagael'
+        r.zadd 'foo', 0, 'abby'
+        r.zadd 'foo', 0, 'abbygail'
+
+        assert_equal %w[abbygail abby abagael aaren], r.zrevrangebylex('foo', "[a\xff", '[a')
+        assert_equal %w[abbygail abby], r.zrevrangebylex('foo', "[a\xff", '[a', limit: [0, 2])
+        assert_equal %w[abbygail abby], r.zrevrangebylex('foo', "(abb\xff", '(abb')
+        assert_equal %w[abbygail], r.zrevrangebylex('foo', "(abby\xff", '(abby')
+      end
+    end
+
+    def test_zcount
+      r.zadd 'foo', 1, 's1'
+      r.zadd 'foo', 2, 's2'
+      r.zadd 'foo', 3, 's3'
+
+      assert_equal 2, r.zcount('foo', 2, 3)
+    end
+
+    def test_zunionstore
+      r.zadd 'foo', 1, 's1'
+      r.zadd 'bar', 2, 's2'
+      r.zadd 'foo', 3, 's3'
+      r.zadd 'bar', 4, 's4'
+
+      assert_equal 4, r.zunionstore('foobar', %w[foo bar])
+      assert_equal %w[s1 s2 s3 s4], r.zrange('foobar', 0, -1)
+    end
+
+    def test_zunionstore_with_weights
+      r.zadd 'foo', 1, 's1'
+      r.zadd 'foo', 3, 's3'
+      r.zadd 'bar', 20, 's2'
+      r.zadd 'bar', 40, 's4'
+
+      assert_equal 4, r.zunionstore('foobar', %w[foo bar])
+      assert_equal %w[s1 s3 s2 s4], r.zrange('foobar', 0, -1)
+
+      assert_equal 4, r.zunionstore('foobar', %w[foo bar], weights: [10, 1])
+      assert_equal %w[s1 s2 s3 s4], r.zrange('foobar', 0, -1)
+    end
+
+    def test_zunionstore_with_aggregate
+      r.zadd 'foo', 1, 's1'
+      r.zadd 'foo', 2, 's2'
+      r.zadd 'bar', 4, 's2'
+      r.zadd 'bar', 3, 's3'
+
+      assert_equal 3, r.zunionstore('foobar', %w[foo bar])
+      assert_equal %w[s1 s3 s2], r.zrange('foobar', 0, -1)
+
+      assert_equal 3, r.zunionstore('foobar', %w[foo bar], aggregate: :min)
+      assert_equal %w[s1 s2 s3], r.zrange('foobar', 0, -1)
+
+      assert_equal 3, r.zunionstore('foobar', %w[foo bar], aggregate: :max)
+      assert_equal %w[s1 s3 s2], r.zrange('foobar', 0, -1)
+    end
+
+    def test_zunionstore_expand
+      r.zadd('{1}foo', %w[0 a 1 b 2 c])
+      r.zadd('{1}bar', %w[0 c 1 d 2 e])
+      assert_equal 5, r.zunionstore('{1}baz', %w[{1}foo {1}bar])
+    end
+
+    def test_zinterstore
+      r.zadd 'foo', 1, 's1'
+      r.zadd 'bar', 2, 's1'
+      r.zadd 'foo', 3, 's3'
+      r.zadd 'bar', 4, 's4'
+
+      assert_equal 1, r.zinterstore('foobar', %w[foo bar])
+      assert_equal ['s1'], r.zrange('foobar', 0, -1)
+    end
+
+    def test_zinterstore_with_weights
+      r.zadd 'foo', 1, 's1'
+      r.zadd 'foo', 2, 's2'
+      r.zadd 'foo', 3, 's3'
+      r.zadd 'bar', 20, 's2'
+      r.zadd 'bar', 30, 's3'
+      r.zadd 'bar', 40, 's4'
+
+      assert_equal 2, r.zinterstore('foobar', %w[foo bar])
+      assert_equal %w[s2 s3], r.zrange('foobar', 0, -1)
+
+      assert_equal 2, r.zinterstore('foobar', %w[foo bar], weights: [10, 1])
+      assert_equal %w[s2 s3], r.zrange('foobar', 0, -1)
+
+      assert_equal 40.0, r.zscore('foobar', 's2')
+      assert_equal 60.0, r.zscore('foobar', 's3')
+    end
+
+    def test_zinterstore_with_aggregate
+      r.zadd 'foo', 1, 's1'
+      r.zadd 'foo', 2, 's2'
+      r.zadd 'foo', 3, 's3'
+      r.zadd 'bar', 20, 's2'
+      r.zadd 'bar', 30, 's3'
+      r.zadd 'bar', 40, 's4'
+
+      assert_equal 2, r.zinterstore('foobar', %w[foo bar])
+      assert_equal %w[s2 s3], r.zrange('foobar', 0, -1)
+      assert_equal 22.0, r.zscore('foobar', 's2')
+      assert_equal 33.0, r.zscore('foobar', 's3')
+
+      assert_equal 2, r.zinterstore('foobar', %w[foo bar], aggregate: :min)
+      assert_equal %w[s2 s3], r.zrange('foobar', 0, -1)
+      assert_equal 2.0, r.zscore('foobar', 's2')
+      assert_equal 3.0, r.zscore('foobar', 's3')
+
+      assert_equal 2, r.zinterstore('foobar', %w[foo bar], aggregate: :max)
+      assert_equal %w[s2 s3], r.zrange('foobar', 0, -1)
+      assert_equal 20.0, r.zscore('foobar', 's2')
+      assert_equal 30.0, r.zscore('foobar', 's3')
+    end
+
+    def test_zinterstore_expand
+      r.zadd '{1}foo', %w[0 s1 1 s2 2 s3]
+      r.zadd '{1}bar', %w[0 s3 1 s4 2 s5]
+      assert_equal 1, r.zinterstore('{1}baz', %w[{1}foo {1}bar], weights: [2.0, 3.0])
+    end
+
+    def test_zscan
+      r.zadd('foo', %w[0 a 1 b 2 c])
+      expected = ['0', [['a', 0.0], ['b', 1.0], ['c', 2.0]]]
+      assert_equal expected, r.zscan('foo', 0)
+    end
   end
 end