redis-store 1.10.0 → 1.12.0

data/test/redis/store/factory_test.rb

@@ -1,273 +0,0 @@
-require 'test_helper'
-require 'json'
-
-describe "Redis::Store::Factory" do
-  describe ".create" do
-    describe "when not given any arguments" do
-      it "instantiates Redis::Store" do
-        store = Redis::Store::Factory.create
-        _(store).must_be_kind_of(Redis::Store)
-        # `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
-
-    describe "when given a Hash" do
-      it "uses specified host" do
-        store = Redis::Store::Factory.create :host => "localhost"
-        _(store.to_s).must_equal("Redis Client connected to localhost:6379 against DB 0")
-      end
-
-      it "uses specified port" do
-        store = Redis::Store::Factory.create :host => "localhost", :port => 6380
-        _(store.to_s).must_equal("Redis Client connected to localhost:6380 against DB 0")
-      end
-
-      it "uses specified scheme" do
-        store = Redis::Store::Factory.create :scheme => "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
-        store = Redis::Store::Factory.create :path => "/var/run/redis.sock"
-        _(store.to_s).must_equal("Redis Client connected to /var/run/redis.sock against DB 0")
-      end
-
-      it "uses specified db" do
-        store = Redis::Store::Factory.create :host => "localhost", :port => 6380, :db => 13
-        _(store.to_s).must_equal("Redis Client connected to localhost:6380 against DB 13")
-      end
-
-      it "uses specified namespace" do
-        store = Redis::Store::Factory.create :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"
-        # `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
-        store = Redis::Store::Factory.create :password => "secret"
-        _(store.instance_variable_get(:@client).password).must_equal("secret")
-      end
-
-      it 'uses empty password' do
-        store = Redis::Store::Factory.create :password => ''
-        _(store.instance_variable_get(:@client).password).must_equal('')
-      end
-
-      it 'uses nil password' do
-        store = Redis::Store::Factory.create :password => nil
-        assert_nil(store.instance_variable_get(:@client).password)
-      end
-
-      it "disables serialization" do
-        store = Redis::Store::Factory.create :serializer => nil
-        _(store.instance_variable_get(:@serializer)).must_be_nil
-        # `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)
-        # `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
-          # `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
-          store = Redis::Store::Factory.create
-          _(store.instance_variable_get(:@client).port).must_equal(6379)
-        end
-
-        it "defaults to redis:// if no scheme specified" do
-          store = Redis::Store::Factory.create
-          client = store.instance_variable_get(:@client)
-          # `redis-client` does NOT have `scheme`
-          client.respond_to?(:scheme) && _(client.scheme).must_equal('redis')
-        end
-      end
-
-      describe 'with stdout disabled' do
-        before do
-          @original_stderr = $stderr
-          @original_stdout = $stdout
-
-          $stderr = Tempfile.new('stderr')
-          $stdout = Tempfile.new('stdout')
-        end
-
-        it "disables marshalling and provides deprecation warning" do
-          store = Redis::Store::Factory.create :marshalling => false
-          _(store.instance_variable_get(:@serializer)).must_be_nil
-          # `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)
-          # `raw` would be removed when `redis-client` is used
-          defined?(::RedisClient) || _(store.instance_variable_get(:@options)[:raw]).must_equal(false)
-        end
-
-        after do
-          $stderr = @original_stderr
-          $stdout = @original_stdout
-        end
-      end
-
-      it "should instantiate a Redis::DistributedStore store" do
-        store = Redis::Store::Factory.create(
-          { :host => "localhost", :port => 6379 },
-          { :host => "localhost", :port => 6380 }
-        )
-        _(store).must_be_kind_of(Redis::DistributedStore)
-        _(store.nodes.map { |node| node.to_s }).must_equal([
-          "Redis Client connected to localhost:6379 against DB 0",
-          "Redis Client connected to localhost:6380 against DB 0",
-        ])
-      end
-    end
-
-    describe "when given a String" 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")
-      end
-
-      it "uses specified port" do
-        store = Redis::Store::Factory.create "redis://127.0.0.1:6380"
-        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6380 against DB 0")
-      end
-
-      it "uses specified scheme" do
-        store = Redis::Store::Factory.create "rediss://127.0.0.1:6380"
-        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"
-        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
-        store = Redis::Store::Factory.create "unix:///var/run/redis.sock"
-        _(store.to_s).must_equal("Redis Client connected to /var/run/redis.sock against DB 0")
-      end
-
-      it "uses specified db" do
-        store = Redis::Store::Factory.create "redis://127.0.0.1:6380/13"
-        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6380 against DB 13")
-      end
-
-      it "uses specified namespace" do
-        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
-
-      it "uses specified via query namespace" do
-        store = Redis::Store::Factory.create "redis://127.0.0.1:6379/0?namespace=theplaylist"
-        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
-      end
-
-      it "uses specified namespace with path" do
-        store = Redis::Store::Factory.create "unix:///var/run/redis.sock?db=2&namespace=theplaylist"
-        _(store.to_s).must_equal("Redis Client connected to /var/run/redis.sock against DB 2 with namespace theplaylist")
-      end
-
-      it "uses specified password" do
-        store = Redis::Store::Factory.create "redis://:secret@127.0.0.1:6379/0/theplaylist"
-        _(store.instance_variable_get(:@client).password).must_equal("secret")
-      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')
-      end
-
-      it 'uses empty password' do
-        store = Redis::Store::Factory.create 'redis://:@127.0.0.1:6379/0/theplaylist'
-        _(store.instance_variable_get(:@client).password).must_equal('')
-      end
-
-      it 'uses nil password' do
-        store = Redis::Store::Factory.create 'redis://127.0.0.1:6379/0/theplaylist'
-        assert_nil(store.instance_variable_get(:@client).password)
-      end
-
-      it "correctly uses specified ipv6 host" do
-        store = Redis::Store::Factory.create "redis://[::1]:6380"
-        _(store.to_s).must_equal("Redis Client connected to [::1]:6380 against DB 0")
-        _(store.instance_variable_get('@options')[:host]).must_equal("::1")
-      end
-
-      it "instantiates Redis::DistributedStore" do
-        store = Redis::Store::Factory.create "redis://127.0.0.1:6379", "redis://127.0.0.1:6380"
-        _(store).must_be_kind_of(Redis::DistributedStore)
-        _(store.nodes.map { |node| node.to_s }).must_equal([
-          "Redis Client connected to 127.0.0.1:6379 against DB 0",
-          "Redis Client connected to 127.0.0.1:6380 against DB 0",
-        ])
-      end
-    end
-
-    describe 'when given host Hash and options Hash' do
-      it 'instantiates Redis::Store and merges options' do
-        Redis::Store::Factory.create(
-          { :host => '127.0.0.1', :port => '6379' },
-          { :namespace => 'theplaylist' }
-        )
-      end
-
-      it 'instantiates Redis::DistributedStore and merges options' do
-        store = Redis::Store::Factory.create(
-          { :host => '127.0.0.1', :port => '6379' },
-          { :host => '127.0.0.1', :port => '6380' },
-          { :namespace => 'theplaylist' }
-        )
-        _(store.nodes.map { |node| node.to_s }).must_equal([
-          "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist",
-          "Redis Client connected to 127.0.0.1:6380 against DB 0 with namespace theplaylist"
-        ])
-      end
-    end
-
-    describe 'when given host String and options Hash' do
-      it 'instantiates Redis::Store and merges options' do
-        store = Redis::Store::Factory.create "redis://127.0.0.1", :namespace => 'theplaylist'
-        _(store.to_s).must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
-      end
-
-      it 'instantiates Redis::DistributedStore and merges options' do
-        store = Redis::Store::Factory.create "redis://127.0.0.1:6379", "redis://127.0.0.1:6380", :namespace => 'theplaylist'
-        _(store.nodes.map { |node| node.to_s }).must_equal([
-          "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist",
-          "Redis Client connected to 127.0.0.1:6380 against DB 0 with namespace theplaylist",
-        ])
-      end
-
-      it 'instantiates Redis::Store and sets namespace from String' do
-        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
-  end
-end

data/test/redis/store/interface_test.rb

@@ -1,27 +0,0 @@
-require 'test_helper'
-
-class InterfacedRedis < Redis
-  include Redis::Store::Interface
-end
-
-describe Redis::Store::Interface do
-  before do
-    @r = InterfacedRedis.new
-  end
-
-  it "should get an element" do
-    lambda { @r.get("key", :option => true) } # .wont_raise ArgumentError
-  end
-
-  it "should set an element" do
-    lambda { @r.set("key", "value", :option => true) } # .wont_raise ArgumentError
-  end
-
-  it "should setnx an element" do
-    lambda { @r.setnx("key", "value", :option => true) } # .wont_raise ArgumentError
-  end
-
-  it "should setex an element" do
-    lambda { @r.setex("key", 1, "value", :option => true) } # .wont_raise ArgumentError
-  end
-end

data/test/redis/store/namespace_test.rb

@@ -1,317 +0,0 @@
-require 'test_helper'
-
-describe "Redis::Store::Namespace" do
-  def setup
-    @namespace = "theplaylist"
-    @store = Redis::Store.new :namespace => @namespace, :serializer => nil
-    @client = @store.instance_variable_get(:@client)
-    @rabbit = "bunny"
-    @default_store = Redis::Store.new
-    @other_namespace = 'other'
-    @other_store = Redis::Store.new :namespace => @other_namespace
-  end
-
-  def teardown
-    @store.flushdb
-    @store.quit
-
-    @default_store.flushdb
-    @default_store.quit
-
-    @other_store.flushdb
-    @other_store.quit
-  end
-
-  it "only decorates instances that need to be namespaced" do
-    store  = Redis::Store.new
-    client = store.instance_variable_get(:@client)
-    # `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
-
-  it "doesn't namespace a key which is already namespaced" do
-    _(@store.send(:interpolate, "#{@namespace}:rabbit")).must_equal("#{@namespace}:rabbit")
-  end
-
-  it "should only delete namespaced keys" do
-    @default_store.set 'abc', 'cba'
-    @store.set 'def', 'fed'
-
-    @store.flushdb
-    _(@store.get('def')).must_be_nil
-    _(@default_store.get('abc')).must_equal('cba')
-  end
-
-  it 'should allow to change namespace on the fly' do
-    @default_store.set 'abc', 'cba'
-    @other_store.set 'foo', 'bar'
-
-    _(@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']
-      _(@default_store.get('foo')).must_equal('bar')
-    end
-  end
-
-  it "should not try to delete missing namespaced keys" do
-    empty_store = Redis::Store.new :namespace => 'empty'
-    empty_store.flushdb
-    _(empty_store.keys).must_be_empty
-  end
-
-  it "should work with dynamic namespace" do
-    $ns = "ns1"
-    dyn_store = Redis::Store.new :namespace => -> { $ns }
-    dyn_store.set 'key', 'x'
-    $ns = "ns2"
-    dyn_store.set 'key', 'y'
-    $ns = "ns3"
-    dyn_store.set 'key', 'z'
-    dyn_store.flushdb
-    r3 = dyn_store.get 'key'
-    $ns = "ns2"
-    r2 = dyn_store.get 'key'
-    $ns = "ns1"
-    r1 = dyn_store.get 'key'
-    _(r1).must_equal('x') && _(r2).must_equal('y') && _(r3).must_be_nil
-  end
-
-  it "namespaces setex and ttl" do
-    @store.flushdb
-    @other_store.flushdb
-
-    @store.setex('foo', 30, 'bar')
-    _(@store.ttl('foo')).must_be_close_to(30)
-    _(@store.get('foo')).must_equal('bar')
-
-    _(@other_store.ttl('foo')).must_equal(-2)
-    _(@other_store.get('foo')).must_be_nil
-  end
-
-  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(client_call_method_name).with([:get, "#{@namespace}:rabbit"]).once
-      store.get("rabbit")
-    end
-
-    it "should namespace set" do
-      client.expects(client_call_method_name).with([:set, "#{@namespace}:rabbit", @rabbit])
-      store.set "rabbit", @rabbit
-    end
-
-    it "should namespace setnx" do
-      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(client_call_method_name).with([:del, "#{@namespace}:rabbit"])
-      store.del "rabbit"
-    end
-
-    it "should namespace del with multiple keys" do
-      client.expects(client_call_method_name).with([:del, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit"])
-      store.del "rabbit", "white_rabbit"
-    end
-
-    it "should namespace keys" do
-      store.set "rabbit", @rabbit
-      _(store.keys("rabb*")).must_equal [ "rabbit" ]
-    end
-
-    it "should namespace scan when a pattern is given" do
-      store.set "rabbit", @rabbit
-      cursor = "0"
-      keys = []
-      begin
-        cursor, matched_keys = store.scan(cursor, match: "rabb*")
-        keys = keys.concat(matched_keys) unless matched_keys.empty?
-      end until cursor == "0"
-      _(keys).must_equal [ "rabbit" ]
-    end
-
-    it "should namespace exists" do
-      client.expects(client_call_method_name).with([:exists, "#{@namespace}:rabbit"])
-      store.exists "rabbit"
-    end
-
-    it "should namespace incrby" do
-      client.expects(client_call_method_name).with([:incrby, "#{@namespace}:counter", 1])
-      store.incrby "counter", 1
-    end
-
-    it "should namespace decrby" do
-      client.expects(client_call_method_name).with([:decrby, "#{@namespace}:counter", 1])
-      store.decrby "counter", 1
-    end
-
-    it "should namespace mget" do
-      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
-      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"
-      _(result["white_rabbit"]).must_equal "bar"
-    end
-
-    it "should namespace expire" do
-      client.expects(client_call_method_name).with([:expire, "#{@namespace}:rabbit", 60]).once
-      store.expire("rabbit", 60)
-    end
-
-    it "should namespace ttl" do
-      client.expects(client_call_method_name).with([:ttl, "#{@namespace}:rabbit"]).once
-      store.ttl("rabbit")
-    end
-
-    it "should namespace watch" do
-      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(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(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(client_call_method_name).with([:hdel, "#{@namespace}:rabbit", "key1", "key2"]).once
-      store.hdel("rabbit", "key1", "key2")
-    end
-
-    it "should namespace hget" do
-      client.expects(client_call_method_name).with([:hget, "#{@namespace}:rabbit", "key"]).once
-      store.hget("rabbit", "key")
-    end
-
-    it "should namespace hgetall" do
-      client.expects(client_call_method_name).with([:hgetall, "#{@namespace}:rabbit"]).once
-      store.hgetall("rabbit")
-    end
-
-    it "should namespace hexists" do
-      client.expects(client_call_method_name).with([:hexists, "#{@namespace}:rabbit", "key"]).once
-      store.hexists("rabbit", "key")
-    end
-
-    it "should namespace hincrby" do
-      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(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(client_call_method_name).with([:hkeys, "#{@namespace}:rabbit"])
-      store.hkeys("rabbit")
-    end
-
-    it "should namespace hlen" do
-      client.expects(client_call_method_name).with([:hlen, "#{@namespace}:rabbit"])
-      store.hlen("rabbit")
-    end
-
-    it "should namespace hmget" do
-      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(client_call_method_name).with([:hmset, "#{@namespace}:rabbit", "key", @rabbit])
-      store.hmset("rabbit", "key", @rabbit)
-    end
-
-    it "should namespace hset" do
-      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(client_call_method_name).with([:hsetnx, "#{@namespace}:rabbit", "key", @rabbit])
-      store.hsetnx("rabbit", "key", @rabbit)
-    end
-
-    it "should namespace hvals" do
-      client.expects(client_call_method_name).with([:hvals, "#{@namespace}:rabbit"])
-      store.hvals("rabbit")
-    end
-
-    it "should namespace hscan" do
-      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.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
-      end
-      _(results).must_equal(["key1"])
-    end
-
-    it "should namespace hscan_each without block" do
-      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(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(client_call_method_name).with([:zscore, "#{@namespace}:rabbit", "member"])
-      store.zscore("rabbit", "member")
-    end
-
-    it "should namespace zadd" do
-      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(client_call_method_name).with([:zrem, "#{@namespace}:rabbit", "member"])
-      store.zrem("rabbit", "member")
-    end
-  end
-end

data/test/redis/store/redis_version_test.rb

@@ -1,28 +0,0 @@
-require 'test_helper'
-
-describe "Redis::RedisVersion" do
-  def setup
-    @store = Redis::Store.new
-  end
-
-  def teardown
-    @store.quit
-  end
-
-  describe '#redis_version' do
-    it 'returns redis version' do
-      _(@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)
-    end
-  end
-end