redis 4.0.1 → 4.0.3

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

data/test/lint/strings.rb

@@ -1,6 +1,9 @@
 module Lint
 
   module Strings
+    def mock(*args, &block)
+      redis_mock(*args, &block)
+    end
 
     def test_set_and_get
       r.set("foo", "s1")
@@ -242,5 +245,104 @@ module Lint
 
       assert_equal 5, r.strlen("foo")
     end
+
+    def test_bitfield
+      target_version('3.2.0') do
+        mock(bitfield: ->(*_) { "*2\r\n:1\r\n:0\r\n" }) do |redis|
+          assert_equal [1, 0], redis.bitfield('foo', 'INCRBY', 'i5', 100, 1, 'GET', 'u4', 0)
+        end
+      end
+    end
+
+    def test_mget
+      r.set('{1}foo', 's1')
+      r.set('{1}bar', 's2')
+
+      assert_equal %w[s1 s2],         r.mget('{1}foo', '{1}bar')
+      assert_equal ['s1', 's2', nil], r.mget('{1}foo', '{1}bar', '{1}baz')
+    end
+
+    def test_mget_mapped
+      r.set('{1}foo', 's1')
+      r.set('{1}bar', 's2')
+
+      response = r.mapped_mget('{1}foo', '{1}bar')
+
+      assert_equal 's1', response['{1}foo']
+      assert_equal 's2', response['{1}bar']
+
+      response = r.mapped_mget('{1}foo', '{1}bar', '{1}baz')
+
+      assert_equal 's1', response['{1}foo']
+      assert_equal 's2', response['{1}bar']
+      assert_equal nil,  response['{1}baz']
+    end
+
+    def test_mapped_mget_in_a_pipeline_returns_hash
+      r.set('{1}foo', 's1')
+      r.set('{1}bar', 's2')
+
+      result = r.pipelined do
+        r.mapped_mget('{1}foo', '{1}bar')
+      end
+
+      assert_equal({ '{1}foo' => 's1', '{1}bar' => 's2' }, result[0])
+    end
+
+    def test_mset
+      r.mset('{1}foo', 's1', '{1}bar', 's2')
+
+      assert_equal 's1', r.get('{1}foo')
+      assert_equal 's2', r.get('{1}bar')
+    end
+
+    def test_mset_mapped
+      r.mapped_mset('{1}foo' => 's1', '{1}bar' => 's2')
+
+      assert_equal 's1', r.get('{1}foo')
+      assert_equal 's2', r.get('{1}bar')
+    end
+
+    def test_msetnx
+      r.set('{1}foo', 's1')
+      assert_equal false, r.msetnx('{1}foo', 's2', '{1}bar', 's3')
+      assert_equal 's1', r.get('{1}foo')
+      assert_equal nil, r.get('{1}bar')
+
+      r.del('{1}foo')
+      assert_equal true, r.msetnx('{1}foo', 's2', '{1}bar', 's3')
+      assert_equal 's2', r.get('{1}foo')
+      assert_equal 's3', r.get('{1}bar')
+    end
+
+    def test_msetnx_mapped
+      r.set('{1}foo', 's1')
+      assert_equal false, r.mapped_msetnx('{1}foo' => 's2', '{1}bar' => 's3')
+      assert_equal 's1', r.get('{1}foo')
+      assert_equal nil, r.get('{1}bar')
+
+      r.del('{1}foo')
+      assert_equal true, r.mapped_msetnx('{1}foo' => 's2', '{1}bar' => 's3')
+      assert_equal 's2', r.get('{1}foo')
+      assert_equal 's3', r.get('{1}bar')
+    end
+
+    def test_bitop
+      with_external_encoding('UTF-8') do
+        target_version '2.5.10' do
+          r.set('foo{1}', 'a')
+          r.set('bar{1}', 'b')
+
+          r.bitop(:and, 'foo&bar{1}', 'foo{1}', 'bar{1}')
+          assert_equal "\x60", r.get('foo&bar{1}')
+          r.bitop(:or, 'foo|bar{1}', 'foo{1}', 'bar{1}')
+          assert_equal "\x63", r.get('foo|bar{1}')
+          r.bitop(:xor, 'foo^bar{1}', 'foo{1}', 'bar{1}')
+          assert_equal "\x03", r.get('foo^bar{1}')
+          r.bitop(:not, '~foo{1}', 'foo{1}')
+          assert_equal "\x9E", r.get('~foo{1}')
+        end
+      end
+    end
   end
 end