redis-store 1.0.0.1 → 1.1.0.rc

data/spec/action_controller/session/redis_session_store_spec.rb

@@ -1,126 +0,0 @@
-require 'spec_helper'
-RAILS_SESSION_STORE_CLASS = ::Redis::Store.rails3? ? ActionDispatch::Session::RedisSessionStore : ActionController::Session::RedisSessionStore
-
-describe RAILS_SESSION_STORE_CLASS do
-  attr_reader :app
-
-  before :each do
-    @app = Object.new
-    @store  = RAILS_SESSION_STORE_CLASS.new(app)
-    @dstore = RAILS_SESSION_STORE_CLASS.new app, :servers => ["redis://127.0.0.1:6380/1", "redis://127.0.0.1:6381/1"]
-    @rabbit = OpenStruct.new :name => "bunny"
-    @white_rabbit = OpenStruct.new :color => "white"
-    @sid = "rabbit"
-    @env = {'rack.session.options' => {:id => @sid}}
-    with_store_management do |store|
-      class << store
-        attr_reader :pool
-        public :get_session, :set_session, :destroy
-      end
-      store.set_session(@env, @sid, @rabbit)
-      store.pool.del "counter"
-      store.pool.del "rub-a-dub"
-    end
-  end
-
-  it "should accept string connection params" do
-    redis = instantiate_store
-    redis.to_s.should == "Redis Client connected to localhost:6379 against DB 0"
-
-    redis = instantiate_store :servers => "redis://localhost"
-    redis.to_s.should == "Redis Client connected to localhost:6379 against DB 0"
-
-    redis = instantiate_store :servers => "redis://localhost:6380"
-    redis.to_s.should == "Redis Client connected to localhost:6380 against DB 0"
-
-    redis = instantiate_store :servers => "redis://localhost:6380/13"
-    redis.to_s.should == "Redis Client connected to localhost:6380 against DB 13"
-
-    redis = instantiate_store :servers => "redis://localhost:6380/13/theplaylist"
-    redis.to_s.should == "Redis Client connected to localhost:6380 against DB 13 with namespace theplaylist"
-  end
-
-  it "should accept hash connection params" do
-    redis = instantiate_store :servers => [{ :host => "192.168.0.1" }]
-    redis.to_s.should == "Redis Client connected to 192.168.0.1:6379 against DB 0"
-
-    redis = instantiate_store :servers => [{ :port => "6380" }]
-    redis.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 0"
-
-    redis = instantiate_store :servers => [{ :db => 13 }]
-    redis.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 13"
-
-    redis = instantiate_store :servers => [{ :key_prefix => "theplaylist" }]
-    redis.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist"
-  end
-
-  it "should accept options when :servers key isn't passed" do
-    redis = RAILS_SESSION_STORE_CLASS.new(app, :key_prefix => "theplaylist").instance_variable_get(:@pool)
-    redis.to_s.should == "Redis Client connected to localhost:6379 against DB 0 with namespace theplaylist"
-  end
-
-  it "should instantiate a ring" do
-    store = instantiate_store
-    store.should be_kind_of(Redis::Store)
-    store = instantiate_store :servers => ["redis://127.0.0.1:6379/0", "redis://127.0.0.1:6379/1"]
-    store.should be_kind_of(Redis::DistributedStore)
-  end
-
-  it "should read the data" do
-    with_store_management do |store|
-      store.get_session(@env, @sid).should === [@sid, @rabbit]
-    end
-  end
-
-  it "should write the data" do
-    with_store_management do |store|
-      store.set_session(@env, @sid, @white_rabbit)
-      store.get_session(@env, @sid).should === [@sid, @white_rabbit]
-    end
-  end
-
-  it "should delete the data" do
-    with_store_management do |store|
-      store.destroy(@env)
-      store.get_session(@env, @sid).should === [@sid, {}]
-    end
-  end
-
-  it "should write the data with expiration time" do
-    with_store_management do |store|
-      @env['rack.session.options'].merge!(:expires_in => 1.second)
-      store.set_session(@env, @sid, @white_rabbit)
-      store.get_session(@env, @sid).should === [@sid, @white_rabbit]; sleep 2
-      store.get_session(@env, @sid).should === [@sid, {}]
-    end
-  end
-
-  describe "namespace" do
-    before :each do
-      @namespace = "theplaylist"
-      @store  = RAILS_SESSION_STORE_CLASS.new(lambda {|| }, :servers => [{ :namespace => @namespace }])
-      @pool   = @store.instance_variable_get(:@pool)
-      @client = @pool.instance_variable_get(:@client)
-    end
-
-    it "should read the data" do
-      @client.should_receive(:call).with([:get, "#{@namespace}:#{@sid}"])
-      @store.send :get_session, @env, @sid
-    end
-
-    it "should write the data" do
-      @client.should_receive(:call).with([:set, "#{@namespace}:#{@sid}", Marshal.dump(@white_rabbit)])
-      @store.send :set_session, @env, @sid, @white_rabbit
-    end
-  end
-
-  private
-    def instantiate_store(params = { })
-      RAILS_SESSION_STORE_CLASS.new(app, params).instance_variable_get(:@pool)
-    end
-
-    def with_store_management
-      yield @store
-      yield @dstore
-    end
-end

data/spec/active_support/cache/redis_store_spec.rb

@@ -1,426 +0,0 @@
-require 'spec_helper'
-
-module ActiveSupport
-  module Cache
-    describe RedisStore do
-      before :each do
-        @store  = ActiveSupport::Cache::RedisStore.new
-        @dstore = ActiveSupport::Cache::RedisStore.new "redis://127.0.0.1:6380/1", "redis://127.0.0.1:6381/1"
-        @rabbit = OpenStruct.new :name => "bunny"
-        @white_rabbit = OpenStruct.new :color => "white"
-        with_store_management do |store|
-          store.write "rabbit", @rabbit
-          store.delete "counter"
-          store.delete "rub-a-dub"
-        end
-      end
-
-      it "should accept connection params" do
-        redis = instantiate_store
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
-
-        redis = instantiate_store "redis://127.0.0.1"
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
-
-        redis = instantiate_store "redis://127.0.0.1:6380"
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 0"
-
-        redis = instantiate_store "redis://127.0.0.1:6380/13"
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 13"
-
-        redis = instantiate_store "redis://127.0.0.1:6380/13/theplaylist"
-        redis.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 13 with namespace theplaylist"
-      end
-
-      it "should instantiate a ring" do
-        store = instantiate_store
-        store.should be_kind_of(Redis::Store)
-        store = instantiate_store ["redis://127.0.0.1:6379/0", "redis://127.0.0.1:6379/1"]
-        store.should be_kind_of(Redis::DistributedStore)
-      end
-
-      it "should force reconnection" do
-        data = @store.instance_variable_get(:@data)
-        data.should_receive(:reconnect)
-        @store.reconnect
-      end
-
-      it "should read the data" do
-        with_store_management do |store|
-          store.read("rabbit").should === @rabbit
-        end
-      end
-
-      it "should write the data" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit
-          store.read("rabbit").should === @white_rabbit
-        end
-      end
-
-      it "should write the data with expiration time" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit, :expires_in => 1.second
-          store.read("rabbit").should == @white_rabbit ; sleep 2
-          store.read("rabbit").should be_nil
-        end
-      end
-
-      it "should not write data if :unless_exist option is true" do
-        with_store_management do |store|
-          store.write "rabbit", @white_rabbit, :unless_exist => true
-          store.read("rabbit").should == @rabbit
-        end
-      end
-
-      if ::Redis::Store.rails3?
-        if RUBY_VERSION.match /1\.9/
-          it "should read raw data" do
-            with_store_management do |store|
-              result = store.read("rabbit", :raw => true)
-              result.should include("ActiveSupport::Cache::Entry")
-              result.should include("\x0FOpenStruct{\x06:\tnameI\"\nbunny\x06:\x06EF")
-            end
-          end
-        else
-          it "should read raw data" do
-            with_store_management do |store|
-              result = store.read("rabbit", :raw => true)
-              result.should include("ActiveSupport::Cache::Entry")
-              result.should include("\017OpenStruct{\006:\tname\"\nbunny")
-            end
-          end
-        end
-
-        it "should write raw data" do
-          with_store_management do |store|
-            store.write "rabbit", @white_rabbit, :raw => true
-            store.read("rabbit", :raw => true).should include("ActiveSupport::Cache::Entry")
-          end
-        end
-      else
-        it "should read raw data" do
-          with_store_management do |store|
-            store.read("rabbit", :raw => true).should == Marshal.dump(@rabbit)
-          end
-        end
-
-        it "should write raw data" do
-          with_store_management do |store|
-            store.write "rabbit", @white_rabbit, :raw => true
-            store.read("rabbit", :raw => true).should == %(#<OpenStruct color="white">)
-          end
-        end
-      end
-
-      it "should delete data" do
-        with_store_management do |store|
-          store.delete "rabbit"
-          store.read("rabbit").should be_nil
-        end
-      end
-
-      it "should delete matched data" do
-        with_store_management do |store|
-          store.delete_matched "rabb*"
-          store.read("rabbit").should be_nil
-        end
-      end
-
-      it "should verify existence of an object in the store" do
-        with_store_management do |store|
-          store.exist?("rabbit").should be_true
-          store.exist?("rab-a-dub").should be_false
-        end
-      end
-
-      it "should increment a key" do
-        with_store_management do |store|
-          3.times { store.increment "counter" }
-          store.read("counter", :raw => true).to_i.should == 3
-        end
-      end
-
-      it "should decrement a key" do
-        with_store_management do |store|
-          3.times { store.increment "counter" }
-          2.times { store.decrement "counter" }
-          store.read("counter", :raw => true).to_i.should == 1
-        end
-      end
-
-      it "should increment a raw key" do
-        with_store_management do |store|
-          store.write("raw-counter", 1, :raw => true).should be_true
-          store.increment("raw-counter", 2)
-          store.read("raw-counter", :raw => true).to_i.should == 3
-        end
-      end
-
-      it "should decrement a raw key" do
-        with_store_management do |store|
-          store.write("raw-counter", 3, :raw => true).should be_true
-          store.decrement("raw-counter", 2)
-          store.read("raw-counter", :raw => true).to_i.should == 1
-        end
-      end
-
-      it "should increment a key by given value" do
-        with_store_management do |store|
-          store.increment "counter", 3
-          store.read("counter", :raw => true).to_i.should == 3
-        end
-      end
-
-      it "should decrement a key by given value" do
-        with_store_management do |store|
-          3.times { store.increment "counter" }
-          store.decrement "counter", 2
-          store.read("counter", :raw => true).to_i.should == 1
-        end
-      end
-
-      it "should clear the store" do
-        with_store_management do |store|
-          store.clear
-          store.instance_variable_get(:@data).keys("*").flatten.should be_empty
-        end
-      end
-
-      it "should return store stats" do
-        with_store_management do |store|
-          store.stats.should_not be_empty
-        end
-      end
-
-      it "should fetch data" do
-        with_store_management do |store|
-          store.fetch("rabbit").should == @rabbit
-          store.fetch("rub-a-dub").should be_nil
-          store.fetch("rub-a-dub") { "Flora de Cana" }
-          store.fetch("rub-a-dub").should === "Flora de Cana"
-          store.fetch("rabbit", :force => true) # force cache miss
-          store.fetch("rabbit", :force => true, :expires_in => 1.second) { @white_rabbit }
-          store.fetch("rabbit").should == @white_rabbit
-          sleep 2
-          store.fetch("rabbit").should be_nil
-        end
-      end
-
-      if ::Redis::Store.rails3?
-        it "should read multiple keys" do
-          @store.write "irish whisky", "Jameson"
-          result = @store.read_multi "rabbit", "irish whisky"
-          result['rabbit'].raw_value.should === @rabbit
-          result['irish whisky'].raw_value.should == "Jameson"
-        end
-      else
-        it "should read multiple keys" do
-          @store.write "irish whisky", "Jameson"
-          result = @store.read_multi "rabbit", "irish whisky"
-          result.should == { 'rabbit' => @rabbit, 'irish whisky' => 'Jameson' }
-        end
-      end
-      
-      it 'should read multiple keys and return only matches' do
-        @store.delete 'irish whisky'
-        result = @store.read_multi "rabbit", "irish whisky"
-        result.should_not include('irish whisky')
-        result.should include('rabbit')
-      end
-
-      describe "namespace" do
-        before :each do
-          @namespace = "theplaylist"
-          @store = ActiveSupport::Cache::RedisStore.new :namespace => @namespace
-          @data = @store.instance_variable_get(:@data)
-          @client = @data.instance_variable_get(:@client)
-        end
-
-        it "should read the data" do
-          @client.should_receive(:call).with([:get, "#{@namespace}:rabbit"])
-          @store.read("rabbit")
-        end
-
-        if ::Redis::Store.rails3?
-          # it "should write the data"
-          # it "should write the data" do
-          #   @data.should_receive(:set).with("#{@namespace}:rabbit"), Marshal.dump(ActiveSupport::Cache::Entry.new(@white_rabbit)))
-          #   @store.write "rabbit", @white_rabbit
-          # end
-        else
-          it "should write the data" do
-            @client.should_receive(:call).with([:set, "#{@namespace}:rabbit", Marshal.dump(@white_rabbit)])
-            @store.write "rabbit", @white_rabbit
-          end
-        end
-
-        it "should delete the data" do
-          @client.should_receive(:call).with([:del, "#{@namespace}:rabbit"])
-          @store.delete "rabbit"
-        end
-
-        it "should delete matched data" do
-          @client.should_receive(:call).with([:del, "#{@namespace}:rabbit"])
-          @client.should_receive(:call).with([:keys, "theplaylist:rabb*"]).and_return [ "#{@namespace}:rabbit" ]
-          @store.delete_matched "rabb*"
-        end
-
-        if ::Redis::Store.rails3?
-          it "should verify existence of an object in the store" do
-            @client.should_receive(:call).with(:get, "#{@namespace}:rabbit")
-            @store.exist?("rabbit")
-          end
-        else
-          it "should verify existence of an object in the store" do
-            @client.should_receive(:call).with([:exists, "#{@namespace}:rabbit"])
-            @store.exist?("rabbit")
-          end
-        end
-
-        it "should increment a key" do
-          @client.should_receive(:call).with([:incrby, "#{@namespace}:counter", 1])
-          @store.increment "counter"
-        end
-
-        it "should decrement a key" do
-          @client.should_receive(:call).with([:decrby, "#{@namespace}:counter", 1])
-          @store.decrement "counter"
-        end
-
-        it "should fetch data" do
-          @client.should_receive(:call).with([:get, "#{@namespace}:rabbit"])
-          @store.fetch "rabbit"
-        end
-
-        it "should read multiple keys" do
-          rabbits = [ Marshal.dump(@rabbit), Marshal.dump(@white_rabbit) ]
-          @client.should_receive(:call).with([:mget, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit"]).and_return rabbits
-          @store.read_multi "rabbit", "white_rabbit"
-        end
-      end
-
-      if ::Redis::Store.rails3?
-        describe "notifications" do
-          it "should notify on #fetch" do
-            with_notifications do
-              @store.fetch("radiohead") { "House Of Cards" }
-            end
-
-            read, generate, write = @events
-            read.name.should        == "cache_read.active_support"
-            read.payload.should     == { :key => "radiohead", :super_operation => :fetch }
-            generate.name.should    == "cache_generate.active_support"
-            generate.payload.should == { :key => "radiohead" }
-            write.name.should       == "cache_write.active_support"
-            write.payload.should    == { :key => "radiohead" }
-          end
-
-          it "should notify on #read" do
-            with_notifications do
-              @store.read "metallica"
-            end
-
-            read = @events.first
-            read.name.should    == "cache_read.active_support"
-            read.payload.should == { :key => "metallica", :hit => false }
-          end
-
-          # it "should notify on #read_multi" # Not supported in Rails 3
-
-          it "should notify on #write" do
-            with_notifications do
-              @store.write "depeche mode", "Enjoy The Silence"
-            end
-
-            write = @events.first
-            write.name.should    == "cache_write.active_support"
-            write.payload.should == { :key => "depeche mode" }
-          end
-
-          it "should notify on #delete" do
-            with_notifications do
-              @store.delete "the new cardigans"
-            end
-
-            delete = @events.first
-            delete.name.should    == "cache_delete.active_support"
-            delete.payload.should == { :key => "the new cardigans" }
-          end
-
-          it "should notify on #exist?" do
-            with_notifications do
-              @store.exist? "the smiths"
-            end
-
-            exist = @events.first
-            exist.name.should    == "cache_exist?.active_support"
-            exist.payload.should == { :key => "the smiths" }
-          end
-
-          it "should notify on #delete_matched" do
-            with_notifications do
-              @store.delete_matched "afterhours*"
-            end
-
-            delete_matched = @events.first
-            delete_matched.name.should    == "cache_delete_matched.active_support"
-            delete_matched.payload.should == { :key => %("afterhours*") }
-          end
-
-          it "should notify on #increment" do
-            with_notifications do
-              @store.increment "pearl jam"
-            end
-
-            increment = @events.first
-            increment.name.should    == "cache_increment.active_support"
-            increment.payload.should == { :key => "pearl jam", :amount => 1 }
-          end
-
-          it "should notify on #decrement" do
-            with_notifications do
-              @store.decrement "placebo"
-            end
-
-            decrement = @events.first
-            decrement.name.should    == "cache_decrement.active_support"
-            decrement.payload.should == { :key => "placebo", :amount => 1 }
-          end
-
-          # it "should notify on cleanup" # TODO implement in ActiveSupport::Cache::RedisStore
-
-          it "should notify on clear" do
-            with_notifications do
-              @store.clear
-            end
-
-            clear = @events.first
-            clear.name.should    == "cache_clear.active_support"
-            clear.payload.should == { :key => nil }
-          end
-        end
-      end
-
-      private
-        def instantiate_store(addresses = nil)
-          ActiveSupport::Cache::RedisStore.new(addresses).instance_variable_get(:@data)
-        end
-
-        def with_store_management
-          yield @store
-          yield @dstore
-        end
-
-        def with_notifications
-          @events = [ ]
-          ActiveSupport::Cache::RedisStore.instrument = true
-          ActiveSupport::Notifications.subscribe(/^cache_(.*)\.active_support$/) do |*args|
-            @events << ActiveSupport::Notifications::Event.new(*args)
-          end
-          yield
-          ActiveSupport::Cache::RedisStore.instrument = false
-        end
-    end
-  end
-end