redis-store-pika 1.9.2.1

data/test/redis/store/namespace_test.rb

@@ -0,0 +1,316 @@
+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.sort).must_equal ['abc', '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

@@ -0,0 +1,28 @@
+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

data/test/redis/store/serialization_test.rb

@@ -0,0 +1,173 @@
+require 'test_helper'
+
+describe "Redis::Serialization" do
+  def setup
+    @store = Redis::Store.new serializer: Marshal
+    @rabbit = OpenStruct.new :name => "bunny"
+    @white_rabbit = OpenStruct.new :color => "white"
+    @store.set "rabbit", @rabbit
+    @store.del "rabbit2"
+  end
+
+  def teardown
+    @store.flushdb
+    @store.quit
+  end
+
+  it "unmarshals on get" do
+    _(@store.get("rabbit")).must_equal(@rabbit)
+  end
+
+  it "marshals on set" do
+    @store.set "rabbit", @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)
+  end
+
+  if RUBY_VERSION.match(/1\.9/)
+    it "doesn't unmarshal on get if raw option is true" do
+      _(@store.get("rabbit", :raw => true)).must_equal("\x04\bU:\x0FOpenStruct{\x06:\tnameI\"\nbunny\x06:\x06EF")
+    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")
+    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">))
+  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">))
+  end
+
+  it "doesn't unmarshal if get returns an empty string" do
+    @store.set "empty_string", ""
+    _(@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)
+  end
+
+  it "marshals on set unless exists" do
+    @store.setnx "rabbit2", @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">))
+  end
+
+  it "marshals on set expire" do
+    @store.setex "rabbit2", 1, @white_rabbit
+    _(@store.get("rabbit2")).must_equal(@white_rabbit)
+    sleep 2
+    _(@store.get("rabbit2")).must_be_nil
+  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">))
+    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)
+    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
+  end
+
+  if RUBY_VERSION.match(/1\.9/)
+    it "doesn't unmarshal on multi get if raw option is true" do
+      @store.set "rabbit2", @white_rabbit
+      @store.mget "rabbit", "rabbit2", :raw => true do |rabbit, rabbit2|
+        _(rabbit).must_equal("\x04\bU:\x0FOpenStruct{\x06:\tnameI\"\nbunny\x06:\x06EF")
+        _(rabbit2).must_equal("\x04\bU:\x0FOpenStruct{\x06:\ncolorI\"\nwhite\x06:\x06EF")
+      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")
+      end
+    end
+  end
+
+  describe "binary safety" do
+    it "marshals objects" do
+      utf8_key = [51339].pack("U*")
+      ascii_rabbit = OpenStruct.new(:name => [128].pack("C*"))
+
+      @store.set(utf8_key, ascii_rabbit)
+      _(@store.get(utf8_key)).must_equal(ascii_rabbit)
+    end
+
+    it "gets and sets raw values" do
+      utf8_key = [51339].pack("U*")
+      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)
+    end
+
+    it "marshals objects on setnx" do
+      utf8_key = [51339].pack("U*")
+      ascii_rabbit = OpenStruct.new(:name => [128].pack("C*"))
+
+      @store.del(utf8_key)
+      @store.setnx(utf8_key, ascii_rabbit)
+      _(@store.get(utf8_key)).must_equal(ascii_rabbit)
+    end
+
+    it "gets and sets raw values on setnx" do
+      utf8_key = [51339].pack("U*")
+      ascii_string = [128].pack("C*")
+
+      @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)
+    end
+  end if defined?(Encoding)
+end

data/test/redis/store/ttl_test.rb

@@ -0,0 +1,142 @@
+require 'test_helper'
+
+class MockRedis
+  def initialize
+    @sets = []
+    @setexes = []
+    @setnxes = []
+    @expires = []
+  end
+
+  def set(*a)
+    @sets << a
+  end
+
+  def has_set?(*a)
+    @sets.include?(a)
+  end
+
+  def setex(*a)
+    @setexes << a
+  end
+
+  def has_setex?(*a)
+    @setexes.include?(a)
+  end
+
+  def setnx(*a)
+    @setnxes << a
+  end
+
+  def has_setnx?(*a)
+    @setnxes.include?(a)
+  end
+
+  def multi(&block)
+    instance_eval do
+      def setnx(*a)
+        @setnxes << a
+      end
+
+      block.call(self)
+    end
+  end
+  alias_method :pipelined, :multi
+
+  def expire(*a)
+    @expires << a
+  end
+
+  def has_expire?(*a)
+    @expires.include?(a)
+  end
+end
+
+class MockTtlStore < MockRedis
+  include Redis::Store::Ttl
+end
+
+describe MockTtlStore do
+  let(:key) { 'hello' }
+  let(:mock_value) { 'value' }
+  let(:options) { { :expire_after => 3600 } }
+  let(:redis) { MockTtlStore.new }
+
+  describe '#set' 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
+      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
+      end
+    end
+
+    describe 'with nx and ex option' 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
+      end
+    end
+  end
+
+  describe '#setnx' do
+    describe 'without expiry' do
+      it 'must call super with key and value' do
+        redis.setnx(key, mock_value)
+        redis.has_setnx?(key, mock_value)
+      end
+
+      it 'must not call expire' do
+        redis.expects(:expire).never
+        redis.setnx(key, mock_value)
+      end
+    end
+
+    describe 'with expiry' do
+      it 'uses the mutli command to chain commands' do
+        redis.expects(:multi)
+        redis.setnx(key, mock_value, options)
+      end
+
+      it 'must call expire' do
+        redis.setnx(key, mock_value, options)
+        _(redis.has_expire?(key, options[:expire_after])).must_equal true
+      end
+
+      describe 'avoiding multi commands' do
+        let(:options) { { :expire_after => 3600, :avoid_multi_commands => true } }
+
+        it 'uses the redis pipelined feature to chain commands' do
+          redis.expects(:pipelined)
+          redis.setnx(key, mock_value, options)
+        end
+
+        it 'must call expire' do
+          redis.setnx(key, mock_value, options)
+          _(redis.has_expire?(key, options[:expire_after])).must_equal true
+        end
+      end
+
+      describe 'using a redis cluster' do
+        let(:options) { { :expire_after => 3600, :cluster => %w[redis://127.0.0.1:6379/0] } }
+
+        it 'uses the redis pipelined feature to chain commands' do
+          redis.expects(:pipelined)
+          redis.setnx(key, mock_value, options)
+        end
+
+        it 'must call expire' do
+          redis.setnx(key, mock_value, options)
+          _(redis.has_expire?(key, options[:expire_after])).must_equal true
+        end
+      end
+    end
+  end
+end

data/test/redis/store/version_test.rb

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