redis-store 1.9.2 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a70e9a1e720591e28f5abee4cbfff877503f808a9318143234579ea942dc073
-  data.tar.gz: 037aa5824d933374d37e0f922c8992034ed48d05bf00069be6040d52a6706b2e
+  metadata.gz: 90b9775d198eedd8f7fbfbf48548ea825bf888a80bf430be0b7124d9092b6f7a
+  data.tar.gz: bfa57fa72dafc2bf60885da2501cd377eaceb45892a5e21ca9515d378556f95a
 SHA512:
-  metadata.gz: fe1f61f58277a706a19100e85433bd7177b23b8245c6f1354cbe49abdcb2aa9abed9a3956686b074d5c9edb7006f5dbb8f8715d579f316832eecf711a656dab1
-  data.tar.gz: 22d18ed2621e2075d2e02a7f830d4ad2de45f834405f62650e9f41f19bff6b6d3a5017d1247fe0de893e5d3c21f71c3aed63f742c8823d05bef5cf6148c74c4d
+  metadata.gz: c4c0e067c7e20907158913fa39dbc86abc5c5b3a8120f966e2f311dcb3ae380596c824d0bfcb9385ca77681e8fb98d06ff63f45c289dfb51a1916d5448fe7ab4
+  data.tar.gz: d6e2d2bc963b99870f4a4abe0e20ede46dc3177f214685922aa0313e8baa9f2879d1fadd1d7786b5ce6d7dc9b736ee7a1ee74664041bbf4479347e96c44b0421

data/.github/workflows/ci.yml

@@ -1,5 +1,6 @@
 name: CI
 on:
+  pull_request:
   push:
     branches-ignore: [master]
     tags-ignore: [v*]
@@ -27,6 +28,7 @@ jobs:
           - 4_0_x
           - 4_1_x
           - 4_x
+          - 5_x
     env:
       BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/redis_${{ matrix.redis }}.gemfile
     services:

data/.github/workflows/publish.yml

@@ -15,7 +15,7 @@ jobs:
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: "3.1"
-          bundler-cache: true
+          bundle-cache: true
       - run: |
           mkdir -p ~/.gem
           cat << EOF > ~/.gem/credentials

data/.gitignore

@@ -4,3 +4,6 @@ tmp/
 stdout
 # Gemfile locks generated by Appraisals
 gemfiles/*.gemfile.lock
+gemfiles/.bundle/
+# ASDF
+.tool-versions

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 1.10.0 and future
+
+As at 1.10 and above, changelog information will be on this project's releases page:
+
+https://github.com/redis-store/redis-store/releases
+
+
 ## 1.9.0
 
 Breaking Changes

data/README.md

@@ -46,7 +46,7 @@ s.add_dependency 'redis-store', '>= 1.4', '< 2'
 ## Status
 
 [![Gem Version](https://badge.fury.io/rb/redis-store.svg)](http://badge.fury.io/rb/redis-store)
-[![Build Status](https://secure.travis-ci.org/redis-store/redis-store.svg?branch=master)](http://travis-ci.org/redis-store/redis-store?branch=master)
+[![Build Status](https://github.com/redis-store/redis-store/actions/workflows/ci.yml/badge.svg)](https://github.com/redis-store/redis-store/actions/workflows/ci.yml)
 [![Code Climate](https://codeclimate.com/github/redis-store/redis-store.svg)](https://codeclimate.com/github/redis-store/redis-store)
 
 ## Copyright

data/Rakefile

@@ -1,7 +1,6 @@
 require 'bundler/setup'
 require 'rake'
 require 'bundler/gem_tasks'
-require 'redis-store/testing/tasks'
 require 'appraisal'
 require 'rubocop/rake_task'
 
@@ -11,4 +10,6 @@ if !ENV["APPRAISAL_INITIALIZED"] && !ENV["CI"]
   task :default do
     sh "appraisal install && rake appraisal default"
   end
+else
+  require 'redis-store/testing/tasks'
 end

data/lib/redis/distributed_store.rb

@@ -7,6 +7,8 @@ class Redis
 
     def initialize(addresses, options = {})
       _extend_namespace options
+      # `@tag` introduced in `redis-rb` 5.0
+      @tag = options[:tag] || /^\{(.+?)\}/
       @ring = options[:ring] || Redis::HashRing.new([], options[:replicas] || Redis::HashRing::POINTS_PER_SERVER)
 
       addresses.each do |address|

data/lib/redis/store/factory.rb

@@ -1,3 +1,4 @@
+require 'cgi'
 require 'uri'
 
 class Redis

data/lib/redis/store/version.rb

@@ -1,5 +1,12 @@
 class Redis
   class Store < self
-    VERSION = '1.9.2'
+    VERSION = '1.10.0'
+
+    def self.redis_client_defined?
+      # Doesn't work if declared as constant
+      # due to unpredictable gem loading order
+      # https://github.com/redis-rb/redis-client
+      defined?(::RedisClient::VERSION)
+    end
   end
 end

data/lib/redis/store.rb

@@ -14,9 +14,13 @@ class Redis
     include Ttl, Interface, RedisVersion
 
     def initialize(options = {})
-      super
+      orig_options = options.dup
 
-      unless options[:marshalling].nil?
+      _remove_unsupported_options(options)
+      # The options here is updated
+      super(options)
+
+      unless orig_options[:marshalling].nil?
         puts %(
           DEPRECATED: You are passing the :marshalling option, which has been
           replaced with `serializer: Marshal` to support pluggable serialization
@@ -27,14 +31,15 @@ class Redis
         )
       end
 
-      @serializer = options.key?(:serializer) ? options[:serializer] : Marshal
+      @serializer = orig_options.key?(:serializer) ? orig_options.delete(:serializer) : Marshal
 
-      unless options[:marshalling].nil?
-        @serializer = options[:marshalling] ? Marshal : nil
+      unless orig_options[:marshalling].nil?
+        # `marshalling` only used here, might not be supported in `super`
+        @serializer = orig_options.delete(:marshalling) ? Marshal : nil
       end
 
-      _extend_marshalling options
-      _extend_namespace   options
+      _extend_marshalling
+      _extend_namespace orig_options
     end
 
     def reconnect
@@ -56,7 +61,19 @@ class Redis
     end
 
     private
-      def _extend_marshalling(options)
+      def _remove_unsupported_options(options)
+        return unless self.class.redis_client_defined?
+
+        # Unsupported keywords should be removed to avoid errors
+        # https://github.com/redis-rb/redis-client/blob/v0.13.0/lib/redis_client/config.rb#L21
+        options.delete(:raw)
+        options.delete(:serializer)
+        options.delete(:marshalling)
+        options.delete(:namespace)
+        options.delete(:scheme)
+      end
+
+      def _extend_marshalling
         extend Serialization unless @serializer.nil?
       end
 

data/redis-store.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rake',     '>= 12.3.3'
   s.add_development_dependency 'bundler'
-  s.add_development_dependency 'mocha',    '~> 0.14.0'
+  s.add_development_dependency 'mocha',    '~> 2.1.0'
   s.add_development_dependency 'minitest', '~> 5'
   s.add_development_dependency 'git',      '~> 1.2'
   s.add_development_dependency 'pry-nav',  '~> 0.2.4'

data/test/redis/distributed_store_test.rb

@@ -17,7 +17,7 @@ describe "Redis::DistributedStore" do
 
   it "accepts connection params" do
     dmr = Redis::DistributedStore.new [ :host => "localhost", :port => "6380", :db => "1" ]
-    dmr.ring.nodes.size == 1
+    _(dmr.ring.nodes.size).must_equal(1)
     mr = dmr.ring.nodes.first
     _(mr.to_s).must_equal("Redis Client connected to localhost:6380 against DB 1")
   end

data/test/redis/store/factory_test.rb

@@ -7,7 +7,8 @@ describe "Redis::Store::Factory" 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")
+        # `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
 
@@ -24,7 +25,9 @@ describe "Redis::Store::Factory" do
 
       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
@@ -39,12 +42,14 @@ describe "Redis::Store::Factory" do
 
       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
@@ -65,19 +70,22 @@ 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)
+        # `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)
+        # `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
@@ -87,7 +95,9 @@ describe "Redis::Store::Factory" do
 
         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
 
@@ -103,13 +113,15 @@ 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)
+          # `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)
+          # `raw` would be removed when `redis-client` is used
+          defined?(::RedisClient) || _(store.instance_variable_get(:@options)[:raw]).must_equal(false)
         end
 
         after do
@@ -144,12 +156,16 @@ describe "Redis::Store::Factory" do
 
       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
@@ -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' }
         )
@@ -249,7 +265,7 @@ describe "Redis::Store::Factory" do
       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 = 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

data/test/redis/store/namespace_test.rb

@@ -25,7 +25,9 @@ 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
 
@@ -46,7 +48,8 @@ describe "Redis::Store::Namespace" 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']
@@ -92,29 +95,33 @@ describe "Redis::Store::Namespace" do
   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
 
@@ -135,29 +142,35 @@ describe "Redis::Store::Namespace" do
     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 ])
       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"
@@ -165,108 +178,108 @@ describe "Redis::Store::Namespace" do
     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
@@ -275,29 +288,29 @@ describe "Redis::Store::Namespace" do
     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"])
     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

data/test/redis/store/serialization_test.rb

@@ -29,7 +29,7 @@ describe "Redis::Serialization" do
     _(@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")
     end
@@ -117,7 +117,7 @@ describe "Redis::Serialization" do
     _(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|

data/test/redis/store_test.rb

@@ -43,7 +43,7 @@ describe Redis::Store do
         @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.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)

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.2
+  version: 1.10.0
 platform: ruby
 authors:
 - Luca Guidi
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-24 00:00:00.000000000 Z
+date: 2023-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -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
@@ -222,7 +222,7 @@ homepage: http://redis-store.org/redis-store
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -237,8 +237,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key: 
+rubygems_version: 3.3.16
+signing_key:
 specification_version: 4
 summary: Redis stores for Ruby frameworks
 test_files: []