redis-store 1.9.1 → 1.10.0

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

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/
+  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/
+  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

@@ -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,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
       end
 
@@ -142,14 +132,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
       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

data/test/test_helper.rb

@@ -1,9 +1,8 @@
 require 'bundler/setup'
 require 'minitest/autorun'
-require 'mocha/setup'
+require 'mocha/minitest'
 require 'redis'
 require 'redis-store'
-require 'pry'
 
 $DEBUG = ENV["DEBUG"] === "true"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-store
 version: !ruby/object:Gem::Version
-  version: 1.9.1
+  version: 1.10.0
 platform: ruby
 authors:
 - Luca Guidi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-24 00:00:00.000000000 Z
+date: 2023-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -19,7 +19,7 @@ dependencies:
         version: '4'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: '4'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -64,14 +64,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 2.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -180,9 +180,11 @@ 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
@@ -192,7 +194,9 @@ files:
 - Rakefile
 - 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
@@ -233,7 +237,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.16
 signing_key:
 specification_version: 4
 summary: Redis stores for Ruby frameworks

data/.travis.yml

@@ -1,39 +0,0 @@
-language: ruby
-sudo: false
-cache: bundler
-notifications:
-  webhooks: https://www.travisbuddy.com
-  on_success: never
-before_install:
-- curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64
-  > ./cc-test-reporter
-- chmod +x ./cc-test-reporter
-rvm:
-  - 2.3
-  - 2.4
-  - 2.5
-  - 2.6
-  - 2.7
-  - ruby-head
-  - jruby-head
-gemfile:
-- gemfiles/redis_4_0_x.gemfile
-- gemfiles/redis_4_1_x.gemfile
-- gemfiles/redis_4_x.gemfile
-before_script: "./cc-test-reporter before-build"
-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
-matrix:
-  allow_failures:
-  - rvm: jruby-head
-  - rvm: ruby-head
-deploy:
-  provider: rubygems
-  api_key:
-    secure: vhwP2VNfVYgppPNis7asqMnWuIcURr2e99uhYeHS4Sc+hIozu2QzAAekDrVpEDpeaEubtmTi19UcV4dZbDrQ0M+buE8LJEpItz73yK++J75Rzyh/bsGnWTy2FIvedLrH+jBNf28I9p8XNWkQxVaTc/r/v6BX3mmyV/jVoTBz9es=
-  gem: redis-store
-  on:
-    tags: true
-    repo: redis-store/redis-store