instructure-redis-store 1.0.0.1.instructure1

data/lib/redis/distributed_store.rb

@@ -0,0 +1,39 @@
+class Redis
+  class DistributedStore < Distributed
+    attr_reader :ring
+
+    def initialize(addresses, options = { })
+      nodes = addresses.map do |address|
+        ::Redis::Store.new address
+      end
+      _extend_namespace options
+      @ring = Redis::HashRing.new nodes
+    end
+
+    def nodes
+      ring.nodes
+    end
+
+    def reconnect
+      nodes.each {|node| node.reconnect }
+    end
+
+    def set(key, value, options = nil)
+      node_for(key).set(key, value, options)
+    end
+
+    def get(key, options = nil)
+      node_for(key).get(key, options)
+    end
+
+    def setnx(key, value, options = nil)
+      node_for(key).setnx(key, value, options)
+    end
+
+    private
+      def _extend_namespace(options)
+        @namespace = options[:namespace]
+        extend ::Redis::Store::Namespace if @namespace
+      end
+  end
+end

data/lib/redis/factory.rb

@@ -0,0 +1,46 @@
+class Redis
+  class Factory
+    def self.create(*redis_client_options)
+      redis_client_options = redis_client_options.flatten.compact.inject([]) do |result, address|
+        result << convert_to_redis_client_options(address)
+        result
+      end
+      if redis_client_options.size > 1
+        ::Redis::DistributedStore.new redis_client_options
+      else
+        ::Redis::Store.new redis_client_options.first || {}
+      end
+    end
+
+    def self.convert_to_redis_client_options(address_or_options)
+      if address_or_options.is_a?(Hash)
+        options = address_or_options.dup
+        options[:namespace] ||= options.delete(:key_prefix) # RailsSessionStore
+        options
+      else
+        if address_or_options =~ /redis\:\/\//
+          require 'uri'
+          uri = URI.parse address_or_options
+          _, db, namespace = if uri.path
+            uri.path.split /\//
+          end
+        else
+          warn "[DEPRECATION] `#{address_or_options}` is deprecated. Please use `redis://#{address_or_options}` instead."
+          address_or_options, password = address_or_options.split(/\@/).reverse
+          password = password.gsub(/\:/, "") if password
+          host, port = address_or_options.split /\:/
+          port, db, namespace = port.split /\// if port
+        end
+
+        options = {}
+        options[:host] = host || uri && uri.host
+        options[:port] = port || uri && uri.port
+        options[:db]  = db.to_i if db
+        options[:namespace] = namespace if namespace
+        options[:password]  = password || uri && uri.password
+        [:host, :port, :password].each { |o| options.delete(o) if options[o].nil? }
+        options
+      end
+    end
+  end
+end

data/lib/redis/store.rb

@@ -0,0 +1,39 @@
+class Redis
+  class Store < self
+    include Ttl, Interface
+
+    def initialize(options = { })
+      super
+      _extend_marshalling options
+      _extend_namespace   options
+    end
+
+    def self.rails3? #:nodoc:
+      defined?(::Rails) && ::Rails::VERSION::MAJOR == 3
+    end
+
+    def self.rails31? #:nodoc:
+      defined?(::Rails) && ::Rails::VERSION::MAJOR == 3 && ::Rails::VERSION::MINOR == 1
+    end
+
+    def reconnect
+      @client.reconnect
+    end
+
+    def to_s
+      "Redis Client connected to #{@client.host}:#{@client.port} against DB #{@client.db}"
+    end
+
+    private
+      def _extend_marshalling(options)
+        @marshalling = !(options[:marshalling] === false) # HACK - TODO delegate to Factory
+        extend Marshalling if @marshalling
+      end
+
+      def _extend_namespace(options)
+        @namespace = options[:namespace]
+        extend Namespace if @namespace
+      end
+  end
+end
+

data/lib/redis/store/interface.rb

@@ -0,0 +1,17 @@
+class Redis
+  class Store < self
+    module Interface
+      def get(key, options = nil)
+        super(key)
+      end
+
+      def set(key, value, options = nil)
+        super(key, value)
+      end
+
+      def setnx(key, value, options = nil)
+        super(key, value)
+      end
+    end
+  end
+end

data/lib/redis/store/marshalling.rb

@@ -0,0 +1,51 @@
+class Redis
+  class Store < self
+    module Marshalling
+      def set(key, value, options = nil)
+        _marshal(value, options) { |value| super encode(key), encode(value), options }
+      end
+
+      def setnx(key, value, options = nil)
+        _marshal(value, options) { |value| super encode(key), encode(value), options }
+      end
+
+      def get(key, options = nil)
+        _unmarshal super(key), options
+      end
+
+      def mget(*keys)
+        options = keys.flatten.pop if keys.flatten.last.is_a?(Hash)
+        super(*keys).map do |result|
+          _unmarshal result, options
+        end
+      end
+
+      private
+        def _marshal(val, options)
+          yield marshal?(options) ? Marshal.dump(val) : val
+        end
+
+        def _unmarshal(val, options)
+          unmarshal?(val, options) ? Marshal.load(val) : val
+        end
+
+        def marshal?(options)
+          !(options && options[:raw])
+        end
+
+        def unmarshal?(result, options)
+          result && result.size > 0 && marshal?(options)
+        end
+
+        if defined?(Encoding)
+          def encode(string)
+            string.to_s.force_encoding(Encoding::BINARY)
+          end
+        else
+          def encode(string)
+            string
+          end
+        end
+    end
+  end
+end

data/lib/redis/store/namespace.rb

@@ -0,0 +1,62 @@
+class Redis
+  class Store < self
+    module Namespace
+      def set(key, val, options = nil)
+        namespace(key) { |key| super(key, val, options) }
+      end
+
+      def setnx(key, val, options = nil)
+        namespace(key) { |key| super(key, val, options) }
+      end
+
+      def get(key, options = nil)
+        namespace(key) { |key| super(key, options) }
+      end
+
+      def exists(key)
+        namespace(key) { |key| super(key) }
+      end
+
+      def incrby(key, increment)
+        namespace(key) { |key| super(key, increment) }
+      end
+
+      def decrby(key, increment)
+        namespace(key) { |key| super(key, increment) }
+      end
+
+      def keys(pattern = "*")
+        namespace(pattern) { |pattern| super(pattern).map{|key| strip_namespace(key) } }
+      end
+
+      def del(*keys)
+        super *keys.map {|key| interpolate(key) }
+      end
+
+      def mget(*keys)
+        super *keys.map {|key| interpolate(key) }
+      end
+
+      def to_s
+        "#{super} with namespace #{@namespace}"
+      end
+
+      private
+        def namespace(key)
+          yield interpolate(key)
+        end
+
+        def interpolate(key)
+          key.match(namespace_regexp) ? key : "#{@namespace}:#{key}"
+        end
+
+        def strip_namespace(key)
+          key.gsub namespace_regexp, ""
+        end
+
+        def namespace_regexp
+          @namespace_regexp ||= %r{^#{@namespace}\:}
+        end
+    end
+  end
+end

data/lib/redis/store/ttl.rb

@@ -0,0 +1,37 @@
+class Redis
+  class Store < self
+    module Ttl
+      def set(key, value, options = nil)
+        if ttl = expires_in(options)
+          setex(key, ttl, value)
+        else
+          super(key, value)
+        end
+      end
+
+      def setnx(key, value, options = nil)
+        if ttl = expires_in(options)
+          setnx_with_expire(key, value, ttl)
+        else
+          super(key, value)
+        end
+      end
+
+      protected
+        def setnx_with_expire(key, value, ttl)
+          multi do
+            setnx(key, value)
+            expire(key, expires_in)
+          end
+        end
+
+      private
+        def expires_in(options)
+          if options
+            # Rack::Session           Merb                    Rails/Sinatra
+            options[:expire_after] || options[:expires_in] || options[:expire_in]
+          end
+        end
+    end
+  end
+end

data/lib/redis/store/version.rb

@@ -0,0 +1,12 @@
+class Redis
+  class Store < self
+    module VERSION #:nodoc:
+      MAJOR = 1
+      MINOR = 0
+      TINY  = 0
+      BUILD = 1
+
+      STRING = [MAJOR, MINOR, TINY, BUILD].join('.')
+    end
+  end
+end

data/spec/action_controller/session/redis_session_store_spec.rb

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

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