redis-store 1.9.1 → 1.10.0

data/test/redis/store/factory_test.rb

@@ -6,55 +6,60 @@ describe "Redis::Store::Factory" do
     describe "when not given any arguments" do
       it "instantiates Redis::Store" do
         store = Redis::Store::Factory.create
-        store.must_be_kind_of(Redis::Store)
-        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0")
+        _(store).must_be_kind_of(Redis::Store)
+        # `redis.rb` use different default host values in v4 & v5
+        _(store.to_s).must_match(%r{^Redis Client connected to (127.0.0.1|localhost):6379 against DB 0$})
       end
     end
 
     describe "when given a Hash" do
       it "uses specified host" do
         store = Redis::Store::Factory.create :host => "localhost"
-        store.to_s.must_equal("Redis Client connected to localhost:6379 against DB 0")
+        _(store.to_s).must_equal("Redis Client connected to localhost:6379 against DB 0")
       end
 
       it "uses specified port" do
         store = Redis::Store::Factory.create :host => "localhost", :port => 6380
-        store.to_s.must_equal("Redis Client connected to localhost:6380 against DB 0")
+        _(store.to_s).must_equal("Redis Client connected to localhost:6380 against DB 0")
       end
 
       it "uses specified scheme" do
         store = Redis::Store::Factory.create :scheme => "rediss"
-        store.instance_variable_get(:@client).scheme.must_equal('rediss')
+        client = store.instance_variable_get(:@client)
+        # `redis-client` does NOT have `scheme`
+        client.respond_to?(:scheme) && _(client.scheme).must_equal('rediss')
       end
 
       it "uses specified path" do
         store = Redis::Store::Factory.create :path => "/var/run/redis.sock"
-        store.to_s.must_equal("Redis Client connected to /var/run/redis.sock against DB 0")
+        _(store.to_s).must_equal("Redis Client connected to /var/run/redis.sock against DB 0")
       end
 
       it "uses specified db" do
         store = Redis::Store::Factory.create :host => "localhost", :port => 6380, :db => 13
-        store.to_s.must_equal("Redis Client connected to localhost:6380 against DB 13")
+        _(store.to_s).must_equal("Redis Client connected to localhost:6380 against DB 13")
       end
 
       it "uses specified namespace" do
         store = Redis::Store::Factory.create :namespace => "theplaylist"
-        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
+        # `redis.rb` use different default host values in v4 & v5
+        _(store.to_s).must_match(%r{^Redis Client connected to (127.0.0.1|localhost):6379 against DB 0 with namespace theplaylist$})
       end
 
       it "uses specified key_prefix as namespace" do
         store = Redis::Store::Factory.create :key_prefix => "theplaylist"
-        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
+        # `redis.rb` use different default host values in v4 & v5
+        _(store.to_s).must_match(%r{^Redis Client connected to (127.0.0.1|localhost):6379 against DB 0 with namespace theplaylist$})
       end
 
       it "uses specified password" do
         store = Redis::Store::Factory.create :password => "secret"
-        store.instance_variable_get(:@client).password.must_equal("secret")
+        _(store.instance_variable_get(:@client).password).must_equal("secret")
       end
 
       it 'uses empty password' do
         store = Redis::Store::Factory.create :password => ''
-        store.instance_variable_get(:@client).password.must_equal('')
+        _(store.instance_variable_get(:@client).password).must_equal('')
       end
 
       it 'uses nil password' do
@@ -64,30 +69,35 @@ describe "Redis::Store::Factory" do
 
       it "disables serialization" do
         store = Redis::Store::Factory.create :serializer => nil
-        store.instance_variable_get(:@serializer).must_be_nil
-        store.instance_variable_get(:@options)[:raw].must_equal(true)
+        _(store.instance_variable_get(:@serializer)).must_be_nil
+        # `raw` would be removed when `redis-client` is used
+        defined?(::RedisClient) || _(store.instance_variable_get(:@options)[:raw]).must_equal(true)
       end
 
       it "configures pluggable serialization backend" do
         store = Redis::Store::Factory.create :serializer => JSON
-        store.instance_variable_get(:@serializer).must_equal(JSON)
-        store.instance_variable_get(:@options)[:raw].must_equal(false)
+        _(store.instance_variable_get(:@serializer)).must_equal(JSON)
+        # `raw` would be removed when `redis-client` is used
+        defined?(::RedisClient) || _(store.instance_variable_get(:@options)[:raw]).must_equal(false)
       end
 
       describe "defaults" do
         it "defaults to localhost if no host specified" do
           store = Redis::Store::Factory.create
-          store.instance_variable_get(:@client).host.must_equal('127.0.0.1')
+          # `redis.rb` use different default host values in v4 & v5
+          _(store.instance_variable_get(:@client).host).must_match(%r{^127.0.0.1|localhost$})
         end
 
         it "defaults to 6379 if no port specified" do
           store = Redis::Store::Factory.create
-          store.instance_variable_get(:@client).port.must_equal(6379)
+          _(store.instance_variable_get(:@client).port).must_equal(6379)
         end
 
         it "defaults to redis:// if no scheme specified" do
           store = Redis::Store::Factory.create
-          store.instance_variable_get(:@client).scheme.must_equal('redis')
+          client = store.instance_variable_get(:@client)
+          # `redis-client` does NOT have `scheme`
+          client.respond_to?(:scheme) && _(client.scheme).must_equal('redis')
         end
       end
 
@@ -102,14 +112,16 @@ describe "Redis::Store::Factory" do
 
         it "disables marshalling and provides deprecation warning" do
           store = Redis::Store::Factory.create :marshalling => false
-          store.instance_variable_get(:@serializer).must_be_nil
-          store.instance_variable_get(:@options)[:raw].must_equal(true)
+          _(store.instance_variable_get(:@serializer)).must_be_nil
+          # `raw` would be removed when `redis-client` is used
+          defined?(::RedisClient) || _(store.instance_variable_get(:@options)[:raw]).must_equal(true)
         end
 
         it "enables marshalling but provides warning to use :serializer instead" do
           store = Redis::Store::Factory.create :marshalling => true
-          store.instance_variable_get(:@serializer).must_equal(Marshal)
-          store.instance_variable_get(:@options)[:raw].must_equal(false)
+          _(store.instance_variable_get(:@serializer)).must_equal(Marshal)
+          # `raw` would be removed when `redis-client` is used
+          defined?(::RedisClient) || _(store.instance_variable_get(:@options)[:raw]).must_equal(false)
         end
 
         after do
@@ -123,8 +135,8 @@ describe "Redis::Store::Factory" do
           { :host => "localhost", :port => 6379 },
           { :host => "localhost", :port => 6380 }
         )
-        store.must_be_kind_of(Redis::DistributedStore)
-        store.nodes.map { |node| node.to_s }.must_equal([
+        _(store).must_be_kind_of(Redis::DistributedStore)
+        _(store.nodes.map { |node| node.to_s }).must_equal([
           "Redis Client connected to localhost:6379 against DB 0",
           "Redis Client connected to localhost:6380 against DB 0",
         ])
@@ -134,62 +146,66 @@ describe "Redis::Store::Factory" do
     describe "when given a String" do
       it "uses specified host" do
         store = Redis::Store::Factory.create "redis://127.0.0.1"
-        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0")
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0")
       end
 
       it "uses specified port" do
         store = Redis::Store::Factory.create "redis://127.0.0.1:6380"
-        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6380 against DB 0")
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6380 against DB 0")
       end
 
       it "uses specified scheme" do
         store = Redis::Store::Factory.create "rediss://127.0.0.1:6380"
-        store.instance_variable_get(:@client).scheme.must_equal('rediss')
+        client = store.instance_variable_get(:@client)
+        # `redis-client` does NOT have `scheme`
+        client.respond_to?(:scheme) && _(client.scheme).must_equal('rediss')
       end
 
       it "correctly defaults to redis:// when relative scheme specified" do
         store = Redis::Store::Factory.create "//127.0.0.1:6379"
-        store.instance_variable_get(:@client).scheme.must_equal('redis')
+        client = store.instance_variable_get(:@client)
+        # `redis-client` does NOT have `scheme`
+        client.respond_to?(:scheme) && _(client.scheme).must_equal('redis')
       end
 
       it "uses specified path" do
         store = Redis::Store::Factory.create "unix:///var/run/redis.sock"
-        store.to_s.must_equal("Redis Client connected to /var/run/redis.sock against DB 0")
+        _(store.to_s).must_equal("Redis Client connected to /var/run/redis.sock against DB 0")
       end
 
       it "uses specified db" do
         store = Redis::Store::Factory.create "redis://127.0.0.1:6380/13"
-        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6380 against DB 13")
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6380 against DB 13")
       end
 
       it "uses specified namespace" do
         store = Redis::Store::Factory.create "redis://127.0.0.1:6379/0/theplaylist"
-        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
       end
 
       it "uses specified via query namespace" do
         store = Redis::Store::Factory.create "redis://127.0.0.1:6379/0?namespace=theplaylist"
-        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
       end
 
       it "uses specified namespace with path" do
         store = Redis::Store::Factory.create "unix:///var/run/redis.sock?db=2&namespace=theplaylist"
-        store.to_s.must_equal("Redis Client connected to /var/run/redis.sock against DB 2 with namespace theplaylist")
+        _(store.to_s).must_equal("Redis Client connected to /var/run/redis.sock against DB 2 with namespace theplaylist")
       end
 
       it "uses specified password" do
         store = Redis::Store::Factory.create "redis://:secret@127.0.0.1:6379/0/theplaylist"
-        store.instance_variable_get(:@client).password.must_equal("secret")
+        _(store.instance_variable_get(:@client).password).must_equal("secret")
       end
 
       it 'uses specified password with special characters' do
         store = Redis::Store::Factory.create 'redis://:pwd%40123@127.0.0.1:6379/0/theplaylist'
-        store.instance_variable_get(:@client).password.must_equal('pwd@123')
+        _(store.instance_variable_get(:@client).password).must_equal('pwd@123')
       end
 
       it 'uses empty password' do
         store = Redis::Store::Factory.create 'redis://:@127.0.0.1:6379/0/theplaylist'
-        store.instance_variable_get(:@client).password.must_equal('')
+        _(store.instance_variable_get(:@client).password).must_equal('')
       end
 
       it 'uses nil password' do
@@ -199,14 +215,14 @@ describe "Redis::Store::Factory" do
 
       it "correctly uses specified ipv6 host" do
         store = Redis::Store::Factory.create "redis://[::1]:6380"
-        store.to_s.must_equal("Redis Client connected to [::1]:6380 against DB 0")
-        store.instance_variable_get('@options')[:host].must_equal("::1")
+        _(store.to_s).must_equal("Redis Client connected to [::1]:6380 against DB 0")
+        _(store.instance_variable_get('@options')[:host]).must_equal("::1")
       end
 
       it "instantiates Redis::DistributedStore" do
         store = Redis::Store::Factory.create "redis://127.0.0.1:6379", "redis://127.0.0.1:6380"
-        store.must_be_kind_of(Redis::DistributedStore)
-        store.nodes.map { |node| node.to_s }.must_equal([
+        _(store).must_be_kind_of(Redis::DistributedStore)
+        _(store.nodes.map { |node| node.to_s }).must_equal([
           "Redis Client connected to 127.0.0.1:6379 against DB 0",
           "Redis Client connected to 127.0.0.1:6380 against DB 0",
         ])
@@ -215,7 +231,7 @@ describe "Redis::Store::Factory" do
 
     describe 'when given host Hash and options Hash' do
       it 'instantiates Redis::Store and merges options' do
-        store = Redis::Store::Factory.create(
+        Redis::Store::Factory.create(
           { :host => '127.0.0.1', :port => '6379' },
           { :namespace => 'theplaylist' }
         )
@@ -227,7 +243,7 @@ describe "Redis::Store::Factory" do
           { :host => '127.0.0.1', :port => '6380' },
           { :namespace => 'theplaylist' }
         )
-        store.nodes.map { |node| node.to_s }.must_equal([
+        _(store.nodes.map { |node| node.to_s }).must_equal([
           "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist",
           "Redis Client connected to 127.0.0.1:6380 against DB 0 with namespace theplaylist"
         ])
@@ -237,20 +253,20 @@ describe "Redis::Store::Factory" do
     describe 'when given host String and options Hash' do
       it 'instantiates Redis::Store and merges options' do
         store = Redis::Store::Factory.create "redis://127.0.0.1", :namespace => 'theplaylist'
-        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
       end
 
       it 'instantiates Redis::DistributedStore and merges options' do
         store = Redis::Store::Factory.create "redis://127.0.0.1:6379", "redis://127.0.0.1:6380", :namespace => 'theplaylist'
-        store.nodes.map { |node| node.to_s }.must_equal([
+        _(store.nodes.map { |node| node.to_s }).must_equal([
           "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist",
           "Redis Client connected to 127.0.0.1:6380 against DB 0 with namespace theplaylist",
         ])
       end
 
       it 'instantiates Redis::Store and sets namespace from String' do
-        store = Redis::Store::Factory.create "redis://127.0.0.1:6379/0/theplaylist", :expire_after => 5
-        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
+        store = Redis::Store::Factory.create "redis://127.0.0.1:6379/0/theplaylist"
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
       end
     end
   end

data/test/redis/store/namespace_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 describe "Redis::Store::Namespace" do
   def setup
     @namespace = "theplaylist"
-    @store  = Redis::Store.new :namespace => @namespace, :serializer => nil
+    @store = Redis::Store.new :namespace => @namespace, :serializer => nil
     @client = @store.instance_variable_get(:@client)
     @rabbit = "bunny"
     @default_store = Redis::Store.new
@@ -25,12 +25,14 @@ describe "Redis::Store::Namespace" do
   it "only decorates instances that need to be namespaced" do
     store  = Redis::Store.new
     client = store.instance_variable_get(:@client)
-    client.expects(:call).with([:get, "rabbit"])
+    # `call_v` used since redis-rb 5.0
+    client_call_method_name = client.respond_to?(:call_v) ? :call_v : :call
+    client.expects(client_call_method_name).with([:get, "rabbit"])
     store.get("rabbit")
   end
 
   it "doesn't namespace a key which is already namespaced" do
-    @store.send(:interpolate, "#{@namespace}:rabbit").must_equal("#{@namespace}:rabbit")
+    _(@store.send(:interpolate, "#{@namespace}:rabbit")).must_equal("#{@namespace}:rabbit")
   end
 
   it "should only delete namespaced keys" do
@@ -38,26 +40,27 @@ describe "Redis::Store::Namespace" do
     @store.set 'def', 'fed'
 
     @store.flushdb
-    @store.get('def').must_be_nil
-    @default_store.get('abc').must_equal('cba')
+    _(@store.get('def')).must_be_nil
+    _(@default_store.get('abc')).must_equal('cba')
   end
 
   it 'should allow to change namespace on the fly' do
     @default_store.set 'abc', 'cba'
     @other_store.set 'foo', 'bar'
 
-    @default_store.keys.sort.must_equal ['abc', 'other:foo']
+    _(@default_store.keys).must_include('abc')
+    _(@default_store.keys).must_include('other:foo')
 
     @default_store.with_namespace(@other_namespace) do
-      @default_store.keys.must_equal ['foo']
-      @default_store.get('foo').must_equal('bar')
+      _(@default_store.keys).must_equal ['foo']
+      _(@default_store.get('foo')).must_equal('bar')
     end
   end
 
   it "should not try to delete missing namespaced keys" do
     empty_store = Redis::Store.new :namespace => 'empty'
     empty_store.flushdb
-    empty_store.keys.must_be_empty
+    _(empty_store.keys).must_be_empty
   end
 
   it "should work with dynamic namespace" do
@@ -74,7 +77,7 @@ describe "Redis::Store::Namespace" do
     r2 = dyn_store.get 'key'
     $ns = "ns1"
     r1 = dyn_store.get 'key'
-    r1.must_equal('x') && r2.must_equal('y') && r3.must_be_nil
+    _(r1).must_equal('x') && _(r2).must_equal('y') && _(r3).must_be_nil
   end
 
   it "namespaces setex and ttl" do
@@ -82,45 +85,49 @@ describe "Redis::Store::Namespace" do
     @other_store.flushdb
 
     @store.setex('foo', 30, 'bar')
-    @store.ttl('foo').must_be_close_to(30)
-    @store.get('foo').must_equal('bar')
+    _(@store.ttl('foo')).must_be_close_to(30)
+    _(@store.get('foo')).must_equal('bar')
 
-    @other_store.ttl('foo').must_equal(-2)
-    @other_store.get('foo').must_be_nil
+    _(@other_store.ttl('foo')).must_equal(-2)
+    _(@other_store.get('foo')).must_be_nil
   end
 
   describe 'method calls' do
     let(:store) { Redis::Store.new :namespace => @namespace, :serializer => nil }
     let(:client) { store.instance_variable_get(:@client) }
+    let(:client_call_method_name) do
+      # `call_v` used since redis-rb 5.0
+      client.respond_to?(:call_v) ? :call_v : :call
+    end
 
     it "should namespace get" do
-      client.expects(:call).with([:get, "#{@namespace}:rabbit"]).once
+      client.expects(client_call_method_name).with([:get, "#{@namespace}:rabbit"]).once
       store.get("rabbit")
     end
 
     it "should namespace set" do
-      client.expects(:call).with([:set, "#{@namespace}:rabbit", @rabbit])
+      client.expects(client_call_method_name).with([:set, "#{@namespace}:rabbit", @rabbit])
       store.set "rabbit", @rabbit
     end
 
     it "should namespace setnx" do
-      client.expects(:call).with([:setnx, "#{@namespace}:rabbit", @rabbit])
+      client.expects(client_call_method_name).with([:setnx, "#{@namespace}:rabbit", @rabbit])
       store.setnx "rabbit", @rabbit
     end
 
     it "should namespace del with single key" do
-      client.expects(:call).with([:del, "#{@namespace}:rabbit"])
+      client.expects(client_call_method_name).with([:del, "#{@namespace}:rabbit"])
       store.del "rabbit"
     end
 
     it "should namespace del with multiple keys" do
-      client.expects(:call).with([:del, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit"])
+      client.expects(client_call_method_name).with([:del, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit"])
       store.del "rabbit", "white_rabbit"
     end
 
     it "should namespace keys" do
       store.set "rabbit", @rabbit
-      store.keys("rabb*").must_equal [ "rabbit" ]
+      _(store.keys("rabb*")).must_equal [ "rabbit" ]
     end
 
     it "should namespace scan when a pattern is given" do
@@ -131,173 +138,179 @@ describe "Redis::Store::Namespace" do
         cursor, matched_keys = store.scan(cursor, match: "rabb*")
         keys = keys.concat(matched_keys) unless matched_keys.empty?
       end until cursor == "0"
-      keys.must_equal [ "rabbit" ]
+      _(keys).must_equal [ "rabbit" ]
     end
 
     it "should namespace exists" do
-      client.expects(:call).with([:exists, "#{@namespace}:rabbit"])
+      client.expects(client_call_method_name).with([:exists, "#{@namespace}:rabbit"])
       store.exists "rabbit"
     end
 
     it "should namespace incrby" do
-      client.expects(:call).with([:incrby, "#{@namespace}:counter", 1])
+      client.expects(client_call_method_name).with([:incrby, "#{@namespace}:counter", 1])
       store.incrby "counter", 1
     end
 
     it "should namespace decrby" do
-      client.expects(:call).with([:decrby, "#{@namespace}:counter", 1])
+      client.expects(client_call_method_name).with([:decrby, "#{@namespace}:counter", 1])
       store.decrby "counter", 1
     end
 
     it "should namespace mget" do
-      client.expects(:call).with([:mget, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit"]).returns(%w[ foo bar ])
+      client.expects(client_call_method_name).with([:mget, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit"]).returns(%w[ foo bar ])
       store.mget "rabbit", "white_rabbit" do |result|
-        result.must_equal(%w[ foo bar ])
+        _(result).must_equal(%w[ foo bar ])
       end
     end
 
     it "should namespace mapped_mget" do
-      client.expects(:process).with([[:mget, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit"]]).returns(%w[ foo bar ])
+      if client.respond_to?(:process, true)
+        # Redis < 5.0 uses `#process`
+        client.expects(:process).with([[:mget, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit"]]).returns(%w[ foo bar ])
+      else
+        # Redis 5.x calls `#ensure_connected` (private)
+        client.send(:ensure_connected).expects(:call).returns(%w[ foo bar ])
+      end
       result = store.mapped_mget "rabbit", "white_rabbit"
-      result.keys.must_equal %w[ rabbit white_rabbit ]
-      result["rabbit"].must_equal "foo"
-      result["white_rabbit"].must_equal "bar"
+      _(result.keys).must_equal %w[ rabbit white_rabbit ]
+      _(result["rabbit"]).must_equal "foo"
+      _(result["white_rabbit"]).must_equal "bar"
     end
 
     it "should namespace expire" do
-      client.expects(:call).with([:expire, "#{@namespace}:rabbit", 60]).once
+      client.expects(client_call_method_name).with([:expire, "#{@namespace}:rabbit", 60]).once
       store.expire("rabbit", 60)
     end
 
     it "should namespace ttl" do
-      client.expects(:call).with([:ttl, "#{@namespace}:rabbit"]).once
+      client.expects(client_call_method_name).with([:ttl, "#{@namespace}:rabbit"]).once
       store.ttl("rabbit")
     end
 
     it "should namespace watch" do
-      client.expects(:call).with([:watch, "#{@namespace}:rabbit"]).once
+      client.expects(client_call_method_name).with([:watch, "#{@namespace}:rabbit"]).once
       store.watch("rabbit")
     end
 
     it "wraps flushdb with appropriate KEYS * calls" do
-      client.expects(:call).with([:flushdb]).never
-      client.expects(:call).with([:keys, "#{@namespace}:*"]).once.returns(["rabbit"])
-      client.expects(:call).with([:del, "#{@namespace}:rabbit"]).once
+      client.expects(client_call_method_name).with([:flushdb]).never
+      client.expects(client_call_method_name).with([:keys, "#{@namespace}:*"]).once.returns(["rabbit"])
+      client.expects(client_call_method_name).with([:del, "#{@namespace}:rabbit"]).once
       store.flushdb
     end
 
     it "skips flushdb wrapping if the namespace is nil" do
-      client.expects(:call).with([:flushdb])
-      client.expects(:call).with([:keys]).never
+      client.expects(client_call_method_name).with([:flushdb])
+      client.expects(client_call_method_name).with([:keys]).never
       store.with_namespace(nil) do
         store.flushdb
       end
     end
 
     it "should namespace hdel" do
-      client.expects(:call).with([:hdel, "#{@namespace}:rabbit", "key1", "key2"]).once
+      client.expects(client_call_method_name).with([:hdel, "#{@namespace}:rabbit", "key1", "key2"]).once
       store.hdel("rabbit", "key1", "key2")
     end
 
     it "should namespace hget" do
-      client.expects(:call).with([:hget, "#{@namespace}:rabbit", "key"]).once
+      client.expects(client_call_method_name).with([:hget, "#{@namespace}:rabbit", "key"]).once
       store.hget("rabbit", "key")
     end
 
     it "should namespace hgetall" do
-      client.expects(:call).with([:hgetall, "#{@namespace}:rabbit"]).once
+      client.expects(client_call_method_name).with([:hgetall, "#{@namespace}:rabbit"]).once
       store.hgetall("rabbit")
     end
 
     it "should namespace hexists" do
-      client.expects(:call).with([:hexists, "#{@namespace}:rabbit", "key"]).once
-      results = store.hexists("rabbit", "key")
+      client.expects(client_call_method_name).with([:hexists, "#{@namespace}:rabbit", "key"]).once
+      store.hexists("rabbit", "key")
     end
 
     it "should namespace hincrby" do
-      client.expects(:call).with([:hincrby, "#{@namespace}:rabbit", "key", 1]).once
+      client.expects(client_call_method_name).with([:hincrby, "#{@namespace}:rabbit", "key", 1]).once
       store.hincrby("rabbit", "key", 1)
     end
 
     it "should namespace hincrbyfloat" do
-      client.expects(:call).with([:hincrby, "#{@namespace}:rabbit", "key", 1.5]).once
-      store.hincrby("rabbit", "key", 1.5)
+      client.expects(client_call_method_name).with([:hincrbyfloat, "#{@namespace}:rabbit", "key", 1.5]).once
+      store.hincrbyfloat("rabbit", "key", 1.5)
     end
 
     it "should namespace hkeys" do
-      client.expects(:call).with([:hkeys, "#{@namespace}:rabbit"])
+      client.expects(client_call_method_name).with([:hkeys, "#{@namespace}:rabbit"])
       store.hkeys("rabbit")
     end
 
     it "should namespace hlen" do
-      client.expects(:call).with([:hlen, "#{@namespace}:rabbit"])
+      client.expects(client_call_method_name).with([:hlen, "#{@namespace}:rabbit"])
       store.hlen("rabbit")
     end
 
     it "should namespace hmget" do
-      client.expects(:call).with([:hmget, "#{@namespace}:rabbit", "key1", "key2"])
+      client.expects(client_call_method_name).with([:hmget, "#{@namespace}:rabbit", "key1", "key2"])
       store.hmget("rabbit", "key1", "key2")
     end
 
     it "should namespace hmset" do
-      client.expects(:call).with([:hmset, "#{@namespace}:rabbit", "key", @rabbit])
+      client.expects(client_call_method_name).with([:hmset, "#{@namespace}:rabbit", "key", @rabbit])
       store.hmset("rabbit", "key", @rabbit)
     end
 
     it "should namespace hset" do
-      client.expects(:call).with([:hset, "#{@namespace}:rabbit", "key", @rabbit])
+      client.expects(client_call_method_name).with([:hset, "#{@namespace}:rabbit", "key", @rabbit])
       store.hset("rabbit", "key", @rabbit)
     end
 
     it "should namespace hsetnx" do
-      client.expects(:call).with([:hsetnx, "#{@namespace}:rabbit", "key", @rabbit])
+      client.expects(client_call_method_name).with([:hsetnx, "#{@namespace}:rabbit", "key", @rabbit])
       store.hsetnx("rabbit", "key", @rabbit)
     end
 
     it "should namespace hvals" do
-      client.expects(:call).with([:hvals, "#{@namespace}:rabbit"])
+      client.expects(client_call_method_name).with([:hvals, "#{@namespace}:rabbit"])
       store.hvals("rabbit")
     end
 
     it "should namespace hscan" do
-      client.expects(:call).with([:hscan, "#{@namespace}:rabbit", 0])
+      client.expects(client_call_method_name).with([:hscan, "#{@namespace}:rabbit", 0])
       store.hscan("rabbit", 0)
     end
 
     it "should namespace hscan_each with block" do
-      client.call([:hset, "#{@namespace}:rabbit", "key1", @rabbit])
-      client.expects(:call).with([:hscan, "#{@namespace}:rabbit", 0]).returns(["0", ["key1"]])
+      client.public_send(client_call_method_name, [:hset, "#{@namespace}:rabbit", "key1", @rabbit])
+      client.expects(client_call_method_name).with([:hscan, "#{@namespace}:rabbit", 0]).returns(["0", ["key1"]])
       results = []
       store.hscan_each("rabbit") do |key|
         results << key
       end
-      results.must_equal(["key1"])
+      _(results).must_equal(["key1"])
     end
 
     it "should namespace hscan_each without block" do
-      client.call([:hset, "#{@namespace}:rabbit", "key1", @rabbit])
-      client.expects(:call).with([:hscan, "#{@namespace}:rabbit", 0]).returns(["0", ["key1"]])
+      client.public_send(client_call_method_name, [:hset, "#{@namespace}:rabbit", "key1", @rabbit])
+      client.expects(client_call_method_name).with([:hscan, "#{@namespace}:rabbit", 0]).returns(["0", ["key1"]])
       results = store.hscan_each("rabbit").to_a
-      results.must_equal(["key1"])
+      _(results).must_equal(["key1"])
     end
 
     it "should namespace zincrby" do
-      client.expects(:call).with([:zincrby, "#{@namespace}:rabbit", 1.0, "member"])
+      client.expects(client_call_method_name).with([:zincrby, "#{@namespace}:rabbit", 1.0, "member"])
       store.zincrby("rabbit", 1.0, "member")
     end
 
     it "should namespace zscore" do
-      client.expects(:call).with([:zscore, "#{@namespace}:rabbit", "member"])
+      client.expects(client_call_method_name).with([:zscore, "#{@namespace}:rabbit", "member"])
       store.zscore("rabbit", "member")
     end
 
     it "should namespace zadd" do
-      client.expects(:call).with([:zadd, "#{@namespace}:rabbit", 1.0, "member"])
+      client.expects(client_call_method_name).with([:zadd, "#{@namespace}:rabbit", 1.0, "member"])
       store.zadd("rabbit", 1.0, "member")
     end
 
     it "should namespace zrem" do
-      client.expects(:call).with([:zrem, "#{@namespace}:rabbit", "member"])
+      client.expects(client_call_method_name).with([:zrem, "#{@namespace}:rabbit", "member"])
       store.zrem("rabbit", "member")
     end
   end