redis-store 1.9.2 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a70e9a1e720591e28f5abee4cbfff877503f808a9318143234579ea942dc073
-  data.tar.gz: 037aa5824d933374d37e0f922c8992034ed48d05bf00069be6040d52a6706b2e
+  metadata.gz: b56845874e768c8ec1357c19affb5e7cdb3914d4839cd18d0e443f03b0e843e8
+  data.tar.gz: ab3b3872974e7e6fef5992701227397dbc00e8a905d532ab031da57eb2a7ed83
 SHA512:
-  metadata.gz: fe1f61f58277a706a19100e85433bd7177b23b8245c6f1354cbe49abdcb2aa9abed9a3956686b074d5c9edb7006f5dbb8f8715d579f316832eecf711a656dab1
-  data.tar.gz: 22d18ed2621e2075d2e02a7f830d4ad2de45f834405f62650e9f41f19bff6b6d3a5017d1247fe0de893e5d3c21f71c3aed63f742c8823d05bef5cf6148c74c4d
+  metadata.gz: 96808f1f4a574c79e2e322825e1d7c0f89265ca06db21de1d277e6d519a5c4698b495b9f9c81c3d72811280d400de8b043f15c57bb7f1a02fdf08023b3dcd673
+  data.tar.gz: 5f6a9ca80e5c7166c003421a6942bed21996b8daa09f134e1646f47942ae086246655068b7f0108e8a710622ec96f4bf4649812d44c2c8538b484bb401a38d60

data/.github/workflows/ci.yml

@@ -1,5 +1,6 @@
 name: CI
 on:
+  pull_request:
   push:
     branches-ignore: [master]
     tags-ignore: [v*]
@@ -18,6 +19,8 @@ jobs:
           - "2.7"
           - "3.0"
           - "3.1"
+          - "3.2"
+          - "3.3"
           # - 'head'
           - "jruby"
           # - 'jruby-head'
@@ -27,6 +30,7 @@ jobs:
           - 4_0_x
           - 4_1_x
           - 4_x
+          - 5_x
     env:
       BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/redis_${{ matrix.redis }}.gemfile
     services:
@@ -43,7 +47,7 @@ jobs:
         ports:
           - 6381:6381
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
@@ -52,11 +56,11 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 3.1
+          ruby-version: 3.3
           bundler-cache: true
       - run: bundle exec rake lint

data/.github/workflows/publish.yml

@@ -11,10 +11,10 @@ jobs:
   release:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ruby/setup-ruby@v1
         with:
-          ruby-version: "3.1"
+          ruby-version: "3.3"
           bundler-cache: true
       - run: |
           mkdir -p ~/.gem

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
@@ -77,12 +78,19 @@ class Redis
             :scheme   => uri.scheme,
             :host     => uri.hostname,
             :port     => uri.port || DEFAULT_PORT,
-            :password => uri.password.nil? ? nil : CGI.unescape(uri.password.to_s)
+            :ssl      => uri.scheme == 'rediss'
           }
 
           options[:db]        = db.to_i   if db
           options[:namespace] = namespace if namespace
         end
+
+        if uri.user && !uri.user.empty?
+          options[:username] = uri.user
+        end
+
+        options[:password] = CGI.unescape(uri.password.to_s) if uri.password
+
         if uri.query
           query = Hash[URI.decode_www_form(uri.query)]
           query.each do |(key, value)|

data/lib/redis/store/version.rb

@@ -1,5 +1,12 @@
 class Redis
   class Store < self
-    VERSION = '1.9.2'
+    VERSION = '1.11.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,21 @@ 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)
+        # Redis ACL support added in https://github.com/redis/redis-rb/pull/967
+        options.delete(:username) unless Gem::Version.new(Redis::VERSION) >= Gem::Version.new("4.3.0")
+      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
@@ -135,6 +147,13 @@ describe "Redis::Store::Factory" 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")
+        client = store.instance_variable_get(:@client)
+
+        if Gem::Version.new(Redis::VERSION) >= Gem::Version.new('5.0.0')
+          assert_equal(false, client.instance_variable_get(:@config).instance_variable_get(:@ssl))
+        else
+          assert_equal(false, client.options[:ssl])
+        end
       end
 
       it "uses specified port" do
@@ -144,12 +163,23 @@ 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')
+
+        if Gem::Version.new(Redis::VERSION) >= Gem::Version.new('5.0.0')
+          # binding.irb
+          assert_equal(true, client.instance_variable_get(:@config).instance_variable_get(:@ssl))
+        else
+          assert_equal(true, client.options[:ssl])
+        end
       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
@@ -182,6 +212,28 @@ describe "Redis::Store::Factory" do
         _(store.instance_variable_get(:@client).password).must_equal("secret")
       end
 
+      if Gem::Version.new(Redis::VERSION) >= Gem::Version.new("4.3.0")
+        it "uses specified path with username and password" do
+          store = Redis::Store::Factory.create "unix://test-user:secret@/var/run/redis.sock"
+          _(store.instance_variable_get(:@client).username).must_equal("test-user")
+          _(store.instance_variable_get(:@client).password).must_equal("secret")
+        end
+
+        it "uses specified username and password" do
+          store = Redis::Store::Factory.create "redis://test-user:secret@127.0.0.1:6379/0/theplaylist"
+          _(store.instance_variable_get(:@client).username).must_equal("test-user")
+          _(store.instance_variable_get(:@client).password).must_equal("secret")
+        end
+
+        it "uses a default username" do
+          store = Redis::Store::Factory.create "redis://:secret@127.0.0.1:6379/0/theplaylist"
+          username = Gem::Version.new(Redis::VERSION) >= Gem::Version.new("5.0") ? "default" : nil
+
+          _(store.instance_variable_get(:@client).username).must_equal(username)
+          _(store.instance_variable_get(:@client).password).must_equal("secret")
+        end
+      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')
@@ -215,7 +267,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 +301,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.11.0
 platform: ruby
 authors:
 - Luca Guidi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-24 00:00:00.000000000 Z
+date: 2024-08-09 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
@@ -237,7 +237,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.5.11
 signing_key: 
 specification_version: 4
 summary: Redis stores for Ruby frameworks