redis-store 1.6.0 → 1.9.2

data/test/redis/store/factory_test.rb

@@ -6,55 +6,55 @@ 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)
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1: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')
+        _(store.instance_variable_get(:@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")
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1: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")
+        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1: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 +64,30 @@ 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
+        _(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)
+        _(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')
+          _(store.instance_variable_get(:@client).host).must_equal('127.0.0.1')
         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')
+          _(store.instance_variable_get(:@client).scheme).must_equal('redis')
         end
       end
 
@@ -102,14 +102,14 @@ 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
+          _(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)
+          _(store.instance_variable_get(:@options)[:raw]).must_equal(false)
         end
 
         after do
@@ -123,8 +123,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 +134,62 @@ 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')
+        _(store.instance_variable_get(:@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')
+        _(store.instance_variable_get(:@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 +199,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",
         ])
@@ -227,7 +227,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,12 +237,12 @@ 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",
         ])
@@ -250,7 +250,7 @@ describe "Redis::Store::Factory" do
 
       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.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
@@ -30,7 +30,7 @@ describe "Redis::Store::Namespace" do
   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 +38,26 @@ 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.sort).must_equal ['abc', '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 +74,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,11 +82,11 @@ 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
@@ -120,7 +120,18 @@ describe "Redis::Store::Namespace" do
 
     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
+      store.set "rabbit", @rabbit
+      cursor = "0"
+      keys = []
+      begin
+        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" ]
     end
 
     it "should namespace exists" do
@@ -141,16 +152,16 @@ describe "Redis::Store::Namespace" do
     it "should namespace mget" do
       client.expects(:call).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 ])
       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
@@ -182,5 +193,112 @@ describe "Redis::Store::Namespace" do
         store.flushdb
       end
     end
+
+    it "should namespace hdel" do
+      client.expects(:call).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
+      store.hget("rabbit", "key")
+    end
+
+    it "should namespace hgetall" do
+      client.expects(:call).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")
+    end
+
+    it "should namespace hincrby" do
+      client.expects(:call).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)
+    end
+
+    it "should namespace hkeys" do
+      client.expects(:call).with([:hkeys, "#{@namespace}:rabbit"])
+      store.hkeys("rabbit")
+    end
+
+    it "should namespace hlen" do
+      client.expects(:call).with([:hlen, "#{@namespace}:rabbit"])
+      store.hlen("rabbit")
+    end
+
+    it "should namespace hmget" do
+      client.expects(:call).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])
+      store.hmset("rabbit", "key", @rabbit)
+    end
+
+    it "should namespace hset" do
+      client.expects(:call).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])
+      store.hsetnx("rabbit", "key", @rabbit)
+    end
+
+    it "should namespace hvals" do
+      client.expects(:call).with([:hvals, "#{@namespace}:rabbit"])
+      store.hvals("rabbit")
+    end
+
+    it "should namespace hscan" do
+      client.expects(:call).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"]])
+      results = []
+      store.hscan_each("rabbit") do |key|
+        results << key
+      end
+      _(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"]])
+      results = store.hscan_each("rabbit").to_a
+      _(results).must_equal(["key1"])
+    end
+
+    it "should namespace zincrby" do
+      client.expects(:call).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"])
+      store.zscore("rabbit", "member")
+    end
+
+    it "should namespace zadd" do
+      client.expects(:call).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"])
+      store.zrem("rabbit", "member")
+    end
   end
 end

data/test/redis/store/redis_version_test.rb

@@ -11,18 +11,18 @@ describe "Redis::RedisVersion" do
 
   describe '#redis_version' do
     it 'returns redis version' do
-      @store.redis_version.to_s.must_match(/^\d{1}\.\d{1,}\.\d{1,}$/)
+      _(@store.redis_version.to_s).must_match(/^\d{1}\.\d{1,}\.\d{1,}$/)
     end
   end
 
   describe '#supports_redis_version?' do
     it 'returns true if redis version is greater or equal to required version' do
       @store.stubs(:redis_version).returns('2.8.19')
-      @store.supports_redis_version?('2.6.0').must_equal(true)
-      @store.supports_redis_version?('2.8.19').must_equal(true)
-      @store.supports_redis_version?('2.8.20').must_equal(false)
-      @store.supports_redis_version?('2.9.0').must_equal(false)
-      @store.supports_redis_version?('3.0.0').must_equal(false)
+      _(@store.supports_redis_version?('2.6.0')).must_equal(true)
+      _(@store.supports_redis_version?('2.8.19')).must_equal(true)
+      _(@store.supports_redis_version?('2.8.20')).must_equal(false)
+      _(@store.supports_redis_version?('2.9.0')).must_equal(false)
+      _(@store.supports_redis_version?('3.0.0')).must_equal(false)
     end
   end
 end