redis-store 1.10.0 → 1.12.0

data/test/redis/store/serialization_test.rb

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

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

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

data/test/redis/store_test.rb

@@ -1,68 +0,0 @@
-require 'test_helper'
-
-describe Redis::Store do
-  def setup
-    @store  = Redis::Store.new
-    @client = @store.instance_variable_get(:@client)
-  end
-
-  def teardown
-    @store.flushdb
-    @store.quit
-  end
-
-  it "returns useful informations about the server" do
-    _(@store.to_s).must_equal("Redis Client connected to #{@client.host}:#{@client.port} against DB #{@client.db}")
-  end
-
-  it "must force reconnection" do
-    @client.expects(:reconnect)
-    @store.reconnect
-  end
-
-  describe '#set' do
-    describe 'with expiry' do
-      let(:options) { { :expire_after => 3600 } }
-
-      it 'must not double marshall' do
-        Marshal.expects(:dump).once
-
-        @store.set('key', 'value', options)
-      end
-    end
-
-    describe 'with ex and nx' do
-      let(:key) { 'key' }
-      let(:mock_value) { 'value' }
-      let(:options) { { nx: true, ex: 3600 } }
-
-      it 'must pass on options' do
-        Marshal.expects(:dump).times(4)
-
-        # without options no ex or nx will be set
-        @store.del(key)
-        _(@store.set(key, mock_value, {})).must_equal 'OK'
-        _(@store.set(key, mock_value, {})).must_equal 'OK'
-        _(@store.ttl(key)).must_equal(-1)
-
-        # with ex and nx options, the key can only be set once and a ttl will be set
-        @store.del(key)
-        _(@store.set(key, mock_value, options)).must_equal true
-        _(@store.set(key, mock_value, options)).must_equal false
-        _(@store.ttl(key)).must_equal 3600
-      end
-    end
-  end
-
-  describe '#setnx' do
-    describe 'with expiry' do
-      let(:options) { { :expire_after => 3600 } }
-
-      it 'must not double marshall' do
-        Marshal.expects(:dump).once
-
-        @store.setnx('key', 'value', options)
-      end
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,20 +0,0 @@
-require 'bundler/setup'
-require 'minitest/autorun'
-require 'mocha/minitest'
-require 'redis'
-require 'redis-store'
-
-$DEBUG = ENV["DEBUG"] === "true"
-
-Redis::DistributedStore.send(:class_variable_set, :@@timeout, 30)
-
-# http://mentalized.net/journal/2010/04/02/suppress_warnings_from_ruby/
-module Kernel
-  def suppress_warnings
-    original_verbosity = $VERBOSE
-    $VERBOSE = nil
-    result = yield
-    $VERBOSE = original_verbosity
-    result
-  end
-end