redis-store 1.6.0 → 1.9.2

data/test/redis/store/serialization_test.rb

@@ -15,120 +15,122 @@ describe "Redis::Serialization" do
   end
 
   it "unmarshals on get" do
-    @store.get("rabbit").must_equal(@rabbit)
+    _(@store.get("rabbit")).must_equal(@rabbit)
   end
 
   it "marshals on set" do
     @store.set "rabbit", @white_rabbit
-    @store.get("rabbit").must_equal(@white_rabbit)
+    _(@store.get("rabbit")).must_equal(@white_rabbit)
   end
 
   it "marshals on multi set" do
     @store.mset("rabbit", @white_rabbit, "rabbit2", @rabbit)
-    @store.get("rabbit").must_equal(@white_rabbit)
-    @store.get("rabbit2").must_equal(@rabbit)
+    _(@store.get("rabbit")).must_equal(@white_rabbit)
+    _(@store.get("rabbit2")).must_equal(@rabbit)
   end
 
   if RUBY_VERSION.match /1\.9/
     it "doesn't unmarshal on get if raw option is true" do
-      @store.get("rabbit", :raw => true).must_equal("\x04\bU:\x0FOpenStruct{\x06:\tnameI\"\nbunny\x06:\x06EF")
+      _(@store.get("rabbit", :raw => true)).must_equal("\x04\bU:\x0FOpenStruct{\x06:\tnameI\"\nbunny\x06:\x06EF")
     end
   else
     it "doesn't unmarshal on get if raw option is true" do
-      @store.get("rabbit", :raw => true).must_include("\x04\bU:\x0FOpenStruct{\x06:\tname")
+      _(@store.get("rabbit", :raw => true)).must_include("\x04\bU:\x0FOpenStruct{\x06:\tname")
     end
   end
 
   it "doesn't marshal set if raw option is true" do
     @store.set "rabbit", @white_rabbit, :raw => true
-    @store.get("rabbit", :raw => true).must_equal(%(#<OpenStruct color="white">))
+    _(@store.get("rabbit", :raw => true)).must_equal(%(#<OpenStruct color="white">))
   end
 
   it "doesn't marshal multi set if raw option is true" do
     @store.mset("rabbit", @white_rabbit, "rabbit2", @rabbit, :raw => true)
-    @store.get("rabbit", :raw => true).must_equal(%(#<OpenStruct color="white">))
-    @store.get("rabbit2", :raw => true).must_equal(%(#<OpenStruct name="bunny">))
+    _(@store.get("rabbit", :raw => true)).must_equal(%(#<OpenStruct color="white">))
+    _(@store.get("rabbit2", :raw => true)).must_equal(%(#<OpenStruct name="bunny">))
   end
 
   it "doesn't unmarshal if get returns an empty string" do
     @store.set "empty_string", ""
-    @store.get("empty_string").must_equal("")
+    _(@store.get("empty_string")).must_equal("")
     # TODO use a meaningful Exception
     # lambda { @store.get("empty_string").must_equal("") }.wont_raise Exception
   end
 
   it "doesn't set an object if already exist" do
     @store.setnx "rabbit", @white_rabbit
-    @store.get("rabbit").must_equal(@rabbit)
+    _(@store.get("rabbit")).must_equal(@rabbit)
   end
 
   it "marshals on set unless exists" do
     @store.setnx "rabbit2", @white_rabbit
-    @store.get("rabbit2").must_equal(@white_rabbit)
+    _(@store.get("rabbit2")).must_equal(@white_rabbit)
   end
 
   it "doesn't marshal on set unless exists if raw option is true" do
     @store.setnx "rabbit2", @white_rabbit, :raw => true
-    @store.get("rabbit2", :raw => true).must_equal(%(#<OpenStruct color="white">))
+    _(@store.get("rabbit2", :raw => true)).must_equal(%(#<OpenStruct color="white">))
   end
 
   it "marshals on set expire" do
     @store.setex "rabbit2", 1, @white_rabbit
-    @store.get("rabbit2").must_equal(@white_rabbit)
+    _(@store.get("rabbit2")).must_equal(@white_rabbit)
     sleep 2
-    @store.get("rabbit2").must_be_nil
+    _(@store.get("rabbit2")).must_be_nil
   end
 
-  it "marshals setex (over a distributed store)" do
-    @store = Redis::DistributedStore.new [
-      { :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)
-  end
+  unless ENV['CI']
+    it "marshals setex (over a distributed store)" do
+      @store = Redis::DistributedStore.new [
+        { :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)
+    end
 
-  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 }
-    ]
-    @store.setex "rabbit", 50, @white_rabbit, :raw => true
-    @store.get("rabbit", :raw => true).must_equal(%(#<OpenStruct color="white">))
+    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 }
+      ]
+      @store.setex "rabbit", 50, @white_rabbit, :raw => true
+      _(@store.get("rabbit", :raw => true)).must_equal(%(#<OpenStruct color="white">))
+    end
   end
 
   it "unmarshals on multi get" do
     @store.set "rabbit2", @white_rabbit
     @store.mget "rabbit", "rabbit2" do |rabbits|
       rabbit, rabbit2 = rabbits
-      rabbits.length.must_equal(2)
-      rabbit.must_equal(@rabbit)
-      rabbit2.must_equal(@white_rabbit)
+      _(rabbits.length).must_equal(2)
+      _(rabbit).must_equal(@rabbit)
+      _(rabbit2).must_equal(@white_rabbit)
     end
   end
 
   it "unmarshals on mapped_mget" do
     @store.set "rabbit2", @white_rabbit
     result = @store.mapped_mget("rabbit", "rabbit2")
-    result.keys.must_equal %w[ rabbit rabbit2 ]
-    result["rabbit"].must_equal @rabbit
-    result["rabbit2"].must_equal @white_rabbit
+    _(result.keys).must_equal %w[ rabbit rabbit2 ]
+    _(result["rabbit"]).must_equal @rabbit
+    _(result["rabbit2"]).must_equal @white_rabbit
   end
 
   if RUBY_VERSION.match /1\.9/
     it "doesn't unmarshal on multi get if raw option is true" do
       @store.set "rabbit2", @white_rabbit
       @store.mget "rabbit", "rabbit2", :raw => true do |rabbit, rabbit2|
-        rabbit.must_equal("\x04\bU:\x0FOpenStruct{\x06:\tnameI\"\nbunny\x06:\x06EF")
-        rabbit2.must_equal("\x04\bU:\x0FOpenStruct{\x06:\ncolorI\"\nwhite\x06:\x06EF")
+        _(rabbit).must_equal("\x04\bU:\x0FOpenStruct{\x06:\tnameI\"\nbunny\x06:\x06EF")
+        _(rabbit2).must_equal("\x04\bU:\x0FOpenStruct{\x06:\ncolorI\"\nwhite\x06:\x06EF")
       end
     end
   else
     it "doesn't unmarshal on multi get if raw option is true" do
       @store.set "rabbit2", @white_rabbit
       @store.mget "rabbit", "rabbit2", :raw => true do |rabbit, rabbit2|
-        rabbit.must_include("\x04\bU:\x0FOpenStruct{\x06:\tname")
-        rabbit2.must_include("\x04\bU:\x0FOpenStruct{\x06:\ncolor")
+        _(rabbit).must_include("\x04\bU:\x0FOpenStruct{\x06:\tname")
+        _(rabbit2).must_include("\x04\bU:\x0FOpenStruct{\x06:\ncolor")
       end
     end
   end
@@ -139,7 +141,7 @@ describe "Redis::Serialization" do
       ascii_rabbit = OpenStruct.new(:name => [128].pack("C*"))
 
       @store.set(utf8_key, ascii_rabbit)
-      @store.get(utf8_key).must_equal(ascii_rabbit)
+      _(@store.get(utf8_key)).must_equal(ascii_rabbit)
     end
 
     it "gets and sets raw values" do
@@ -147,7 +149,7 @@ describe "Redis::Serialization" do
       ascii_string = [128].pack("C*")
 
       @store.set(utf8_key, ascii_string, :raw => true)
-      @store.get(utf8_key, :raw => true).bytes.to_a.must_equal(ascii_string.bytes.to_a)
+      _(@store.get(utf8_key, :raw => true).bytes.to_a).must_equal(ascii_string.bytes.to_a)
     end
 
     it "marshals objects on setnx" do
@@ -156,7 +158,7 @@ describe "Redis::Serialization" do
 
       @store.del(utf8_key)
       @store.setnx(utf8_key, ascii_rabbit)
-      @store.get(utf8_key).must_equal(ascii_rabbit)
+      _(@store.get(utf8_key)).must_equal(ascii_rabbit)
     end
 
     it "gets and sets raw values on setnx" do
@@ -165,7 +167,7 @@ describe "Redis::Serialization" do
 
       @store.del(utf8_key)
       @store.setnx(utf8_key, ascii_string, :raw => true)
-      @store.get(utf8_key, :raw => true).bytes.to_a.must_equal(ascii_string.bytes.to_a)
+      _(@store.get(utf8_key, :raw => true).bytes.to_a).must_equal(ascii_string.bytes.to_a)
     end
   end if defined?(Encoding)
 end

data/test/redis/store/ttl_test.rb

@@ -38,7 +38,7 @@ class MockRedis
         @setnxes << a
       end
 
-      block.call
+      block.call(self)
     end
   end
   alias_method :pipelined, :multi
@@ -66,14 +66,14 @@ describe MockTtlStore do
     describe 'without options' do
       it 'must call super with key and value' do
         redis.set(key, mock_value)
-        redis.has_set?(key, mock_value, nil).must_equal true
+        _(redis.has_set?(key, mock_value, nil)).must_equal true
       end
     end
 
     describe 'with options' do
       it 'must call setex with proper expiry and set raw to true' do
         redis.set(key, mock_value, options)
-        redis.has_setex?(key, options[:expire_after], mock_value, :raw => true).must_equal true
+        _(redis.has_setex?(key, options[:expire_after], mock_value, :raw => true)).must_equal true
       end
     end
 
@@ -81,7 +81,7 @@ describe MockTtlStore do
       it 'must call super with key and value and options' do
         set_options = { nx: true, ex: 3600 }
         redis.set(key, mock_value, set_options)
-        redis.has_set?(key, mock_value, set_options).must_equal true
+        _(redis.has_set?(key, mock_value, set_options)).must_equal true
       end
     end
   end
@@ -105,14 +105,9 @@ describe MockTtlStore do
         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
+        _(redis.has_expire?(key, options[:expire_after])).must_equal true
       end
 
       describe 'avoiding multi commands' do
@@ -123,14 +118,23 @@ describe MockTtlStore do
           redis.setnx(key, mock_value, options)
         end
 
-        it 'must call setnx with key and value and set raw to true' do
+        it 'must call expire' do
+          redis.setnx(key, mock_value, options)
+          _(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)
-          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
+          _(redis.has_expire?(key, options[:expire_after])).must_equal true
         end
       end
     end

data/test/redis/store/version_test.rb

@@ -2,6 +2,6 @@ require 'test_helper'
 
 describe Redis::Store::VERSION do
   it 'returns current version' do
-    Redis::Store::VERSION.wont_equal nil
+    _(Redis::Store::VERSION).wont_equal nil
   end
 end

data/test/redis/store_test.rb

@@ -12,7 +12,7 @@ describe Redis::Store do
   end
 
   it "returns useful informations about the server" do
-    @store.to_s.must_equal("Redis Client connected to #{@client.host}:#{@client.port} against DB #{@client.db}")
+    _(@store.to_s).must_equal("Redis Client connected to #{@client.host}:#{@client.port} against DB #{@client.db}")
   end
 
   it "must force reconnection" do
@@ -41,15 +41,15 @@ describe Redis::Store do
 
         # without options no ex or nx will be set
         @store.del(key)
-        @store.set(key, mock_value, {}).must_equal 'OK'
-        @store.set(key, mock_value, {}).must_equal 'OK'
-        @store.ttl(key).must_equal -1
+        _(@store.set(key, mock_value, {})).must_equal 'OK'
+        _(@store.set(key, mock_value, {})).must_equal 'OK'
+        _(@store.ttl(key)).must_equal -1
 
         # with ex and nx options, the key can only be set once and a ttl will be set
         @store.del(key)
-        @store.set(key, mock_value, options).must_equal true
-        @store.set(key, mock_value, options).must_equal false
-        @store.ttl(key).must_equal 3600
+        _(@store.set(key, mock_value, options)).must_equal true
+        _(@store.set(key, mock_value, options)).must_equal false
+        _(@store.ttl(key)).must_equal 3600
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-store
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.9.2
 platform: ruby
 authors:
 - Luca Guidi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-05 00:00:00.000000000 Z
+date: 2023-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -16,48 +16,48 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '4'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '4'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '6'
 - !ruby/object:Gem::Dependency
   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
@@ -179,17 +179,24 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".codeclimate.yml"
+- ".github/auto-assign-issues.yml"
+- ".github/release.yml"
+- ".github/workflows/ci.yml"
+- ".github/workflows/publish.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_6_x.gemfile
 - gemfiles/redis_4_x.gemfile
+- gemfiles/redis_5_x.gemfile
 - lib/redis-store.rb
 - lib/redis/distributed_store.rb
 - lib/redis/store.rb
@@ -230,19 +237,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: redis-store
-rubygems_version: 2.6.14
+rubygems_version: 3.3.26
 signing_key: 
 specification_version: 4
 summary: Redis stores for Ruby frameworks
-test_files:
-- test/redis/distributed_store_test.rb
-- test/redis/store/factory_test.rb
-- test/redis/store/interface_test.rb
-- test/redis/store/namespace_test.rb
-- test/redis/store/redis_version_test.rb
-- test/redis/store/serialization_test.rb
-- test/redis/store/ttl_test.rb
-- test/redis/store/version_test.rb
-- test/redis/store_test.rb
-- test/test_helper.rb
+test_files: []

data/.travis.yml

@@ -1,41 +0,0 @@
-language: ruby
-sudo: false
-cache: bundler
-notifications:
-  webhooks: https://www.travisbuddy.com
-  on_success: never
-
-before_install:
-  # Install Code Climate test reporter
-  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
-  - chmod +x ./cc-test-reporter
-  # 1.9.3 has Bundler 1.7.6 with the "undefined method `spec' for nil" bug
-  - gem install bundler
-
-rvm:
-  - 2.1
-  - 2.2
-  - 2.3
-  - 2.4
-  - ruby-head
-  - jruby-head
-
-gemfile:
-  - gemfiles/redis_3_x.gemfile
-  - gemfiles/redis_4_x.gemfile
-
-before_script: ./cc-test-reporter before-build
-
-# Pipe the coverage data to Code Climate if tests pass
-after_script:
-  - ./cc-test-reporter after-build --exit-code $EXIT_CODE
-  - ./cc-test-reporter format-coverage -t simplecov -o coverage/codeclimate.json
-  - if [[ "$TRAVIS_TEST_RESULT" == 0 ]]; then ./cc-test-reporter upload-coverage; fi  # Upload coverage/codeclimate.json
-
-matrix:
-  allow_failures:
-    - rvm: jruby-head
-    - rvm: ruby-head
-  exclude:
-    - rvm: 2.1
-      gemfile: gemfiles/redis_4_x.gemfile