redis 3.3.5 → 4.0.3

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

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")
@@ -8,18 +11,6 @@ module Lint
       assert_equal "s1", r.get("foo")
     end
 
-    def test_set_and_get_with_brackets
-      r["foo"] = "s1"
-
-      assert_equal "s1", r["foo"]
-    end
-
-    def test_set_and_get_with_brackets_and_symbol
-      r[:foo] = "s1"
-
-      assert_equal "s1", r[:foo]
-    end
-
     def test_set_and_get_with_newline_characters
       r.set("foo", "1\n")
 
@@ -35,14 +26,12 @@ module Lint
     end
 
     def test_set_and_get_with_ascii_characters
-      if defined?(Encoding)
-        with_external_encoding("ASCII-8BIT") do
-          (0..255).each do |i|
-            str = "#{i.chr}---#{i.chr}"
-            r.set("foo", str)
-
-            assert_equal str, r.get("foo")
-          end
+      with_external_encoding("ASCII-8BIT") do
+        (0..255).each do |i|
+          str = "#{i.chr}---#{i.chr}"
+          r.set("foo", str)
+
+          assert_equal str, r.get("foo")
         end
       end
     end
@@ -256,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

data/test/lint/value_types.rb

@@ -93,6 +93,14 @@ module Lint
         assert r.restore("bar", 1000, w)
         assert_equal ["b", "c", "d"], r.lrange("bar", 0, -1)
         assert [0, 1].include? r.ttl("bar")
+
+        r.set("bar", "somethingelse")
+        assert_raises(Redis::CommandError) { r.restore("bar", 1000, w) } # ensure by default replace is false
+        assert_raises(Redis::CommandError) { r.restore("bar", 1000, w, :replace => false) }
+        assert_equal "somethingelse", r.get("bar")
+        assert r.restore("bar", 1000, w, :replace => true)
+        assert_equal ["b", "c", "d"], r.lrange("bar", 0, -1)
+        assert [0, 1].include? r.ttl("bar")
       end
     end
 

data/test/persistence_control_commands_test.rb

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

data/test/pipelining_commands_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestPipeliningCommands < Test::Unit::TestCase
 
@@ -130,15 +128,21 @@ class TestPipeliningCommands < Test::Unit::TestCase
     end
   end
 
+  def test_futures_raise_when_command_errors_and_needs_transformation
+    assert_raise(Redis::CommandError) do
+      r.pipelined do
+        @result = r.zrange("a", "b", 5, :with_scores => true)
+      end
+    end
+  end
+
   def test_futures_can_be_identified
     r.pipelined do
       @result = r.sadd("foo", 1)
     end
 
     assert_equal true, @result.is_a?(Redis::Future)
-    if defined?(::BasicObject)
-      assert_equal true, @result.is_a?(::BasicObject)
-    end
+    assert_equal true, @result.is_a?(::BasicObject)
     assert_equal Redis::Future, @result.class
   end
 
@@ -225,7 +229,7 @@ class TestPipeliningCommands < Test::Unit::TestCase
       p2.select 2
     end
 
-    assert_equal 2, r.client.db
+    assert_equal 2, r._client.db
   end
 
   def test_nested_pipeline_select_client_db
@@ -237,6 +241,6 @@ class TestPipeliningCommands < Test::Unit::TestCase
       end
     end
 
-    assert_equal 3, r.client.db
+    assert_equal 3, r._client.db
   end
 end