redis-store 1.5.0 → 1.9.0

data/test/redis/store/namespace_test.rb

@@ -90,52 +90,63 @@ describe "Redis::Store::Namespace" do
   end
 
   describe 'method calls' do
-    let(:store){Redis::Store.new :namespace => @namespace, :serializer => nil}
-    let(:client){store.instance_variable_get(:@client)}
+    let(:store) { Redis::Store.new :namespace => @namespace, :serializer => nil }
+    let(:client) { store.instance_variable_get(:@client) }
 
     it "should namespace get" do
-       client.expects(:call).with([:get, "#{@namespace}:rabbit"]).once
-       store.get("rabbit")
+      client.expects(:call).with([:get, "#{@namespace}:rabbit"]).once
+      store.get("rabbit")
     end
 
     it "should namespace set" do
-       client.expects(:call).with([:set, "#{@namespace}:rabbit", @rabbit])
-       store.set "rabbit", @rabbit
+      client.expects(:call).with([:set, "#{@namespace}:rabbit", @rabbit])
+      store.set "rabbit", @rabbit
     end
 
     it "should namespace setnx" do
-       client.expects(:call).with([:setnx, "#{@namespace}:rabbit", @rabbit])
-       store.setnx "rabbit", @rabbit
+      client.expects(:call).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"])
-       store.del "rabbit"
+      client.expects(:call).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"])
-       store.del "rabbit", "white_rabbit"
+      client.expects(:call).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.set "rabbit", @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
-       client.expects(:call).with([:exists, "#{@namespace}:rabbit"])
-       store.exists "rabbit"
+      client.expects(:call).with([:exists, "#{@namespace}:rabbit"])
+      store.exists "rabbit"
     end
 
     it "should namespace incrby" do
-       client.expects(:call).with([:incrby, "#{@namespace}:counter", 1])
-       store.incrby "counter", 1
+      client.expects(:call).with([:incrby, "#{@namespace}:counter", 1])
+      store.incrby "counter", 1
     end
 
     it "should namespace decrby" do
-       client.expects(:call).with([:decrby, "#{@namespace}:counter", 1])
-       store.decrby "counter", 1
+      client.expects(:call).with([:decrby, "#{@namespace}:counter", 1])
+      store.decrby "counter", 1
     end
 
     it "should namespace mget" do
@@ -154,24 +165,24 @@ describe "Redis::Store::Namespace" do
     end
 
     it "should namespace expire" do
-       client.expects(:call).with([:expire, "#{@namespace}:rabbit", 60]).once
-       store.expire("rabbit",60)
+      client.expects(:call).with([:expire, "#{@namespace}:rabbit", 60]).once
+      store.expire("rabbit", 60)
     end
 
     it "should namespace ttl" do
-       client.expects(:call).with([:ttl, "#{@namespace}:rabbit"]).once
-       store.ttl("rabbit")
+      client.expects(:call).with([:ttl, "#{@namespace}:rabbit"]).once
+      store.ttl("rabbit")
     end
 
     it "should namespace watch" do
-      client.expects(:call).with([:watch,"#{@namespace}:rabbit"]).once
+      client.expects(:call).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(:call).with([:keys, "#{@namespace}:*"]).once.returns(["rabbit"])
+      client.expects(:call).with([:del, "#{@namespace}:rabbit"]).once
       store.flushdb
     end
 
@@ -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

@@ -2,7 +2,7 @@ require 'test_helper'
 
 describe "Redis::RedisVersion" do
   def setup
-    @store  = Redis::Store.new
+    @store = Redis::Store.new
   end
 
   def teardown
@@ -26,4 +26,3 @@ describe "Redis::RedisVersion" do
     end
   end
 end
-

data/test/redis/store/serialization_test.rb

@@ -81,8 +81,8 @@ describe "Redis::Serialization" do
 
   it "marshals setex (over a distributed store)" do
     @store = Redis::DistributedStore.new [
-      {:host => "localhost", :port => "6380", :db => 0},
-      {:host => "localhost", :port => "6381", :db => 0}
+      { :host => "localhost", :port => "6380", :db => 0 },
+      { :host => "localhost", :port => "6381", :db => 0 }
     ]
     @store.setex "rabbit", 50, @white_rabbit
     @store.get("rabbit").must_equal(@white_rabbit)
@@ -90,8 +90,8 @@ describe "Redis::Serialization" do
 
   it "doesn't marshal setex if raw option is true (over a distributed store)" do
     @store = Redis::DistributedStore.new [
-      {:host => "localhost", :port => "6380", :db => 0},
-      {:host => "localhost", :port => "6381", :db => 0}
+      { :host => "localhost", :port => "6380", :db => 0 },
+      { :host => "localhost", :port => "6381", :db => 0 }
     ]
     @store.setex "rabbit", 50, @white_rabbit, :raw => true
     @store.get("rabbit", :raw => true).must_equal(%(#<OpenStruct color="white">))

data/test/redis/store/ttl_test.rb

@@ -50,7 +50,6 @@ class MockRedis
   def has_expire?(*a)
     @expires.include?(a)
   end
-
 end
 
 class MockTtlStore < MockRedis
@@ -80,7 +79,7 @@ describe MockTtlStore do
 
     describe 'with nx and ex option' do
       it 'must call super with key and value and options' do
-        set_options = {nx: true, ex: 3600}
+        set_options = { nx: true, ex: 3600 }
         redis.set(key, mock_value, set_options)
         redis.has_set?(key, mock_value, set_options).must_equal true
       end
@@ -134,6 +133,25 @@ describe MockTtlStore do
           redis.has_expire?(key, options[:expire_after]).must_equal true
         end
       end
+
+      describe 'using a redis cluster' do
+        let(:options) { { :expire_after => 3600, :cluster => %w[redis://127.0.0.1:6379/0] } }
+
+        it 'uses the redis pipelined feature to chain commands' do
+          redis.expects(:pipelined)
+          redis.setnx(key, mock_value, options)
+        end
+
+        it 'must call setnx with key and value and set raw to true' do
+          redis.setnx(key, mock_value, options)
+          redis.has_setnx?(key, mock_value, :raw => true).must_equal true
+        end
+
+        it 'must call expire' do
+          redis.setnx(key, mock_value, options)
+          redis.has_expire?(key, options[:expire_after]).must_equal true
+        end
+      end
     end
   end
 end

data/test/test_helper.rb

@@ -16,6 +16,6 @@ module Kernel
     $VERBOSE = nil
     result = yield
     $VERBOSE = original_verbosity
-    return result
+    result
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-store
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.9.0
 platform: ruby
 authors:
 - Luca Guidi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-16 00:00:00.000000000 Z
+date: 2020-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '4'
     - - "<"
       - !ruby/object:Gem::Version
         version: '5'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '4'
     - - "<"
       - !ruby/object:Gem::Version
         version: '5'
@@ -34,30 +34,30 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -156,6 +156,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.54'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.54'
 description: Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for
   Ruby web frameworks.
 email:
@@ -164,15 +178,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
+- ".github/auto-assign-issues.yml"
 - ".gitignore"
+- ".rubocop.yml"
 - ".travis.yml"
 - Appraisals
 - CHANGELOG.md
+- CODEOWNERS
 - Gemfile
 - MIT-LICENSE
 - README.md
 - Rakefile
-- gemfiles/redis_3_x.gemfile
+- gemfiles/redis_4_0_x.gemfile
+- gemfiles/redis_4_1_x.gemfile
 - gemfiles/redis_4_x.gemfile
 - lib/redis-store.rb
 - lib/redis/distributed_store.rb
@@ -214,8 +233,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: redis-store
-rubygems_version: 2.7.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Redis stores for Ruby frameworks