rails-cache-tags 1.0.0

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rails-cache-tags.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 amikhailov
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+# Synopsys
+
+Tagged caching support within your Rails application.
+
+# Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rails-cache-tags'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rails-cache-tags
+
+# Usage
+
+Anywhere:
+
+```ruby
+cache = Rails.cache
+
+cache.write "foo", "bar", :tags => %w(baz foo)
+cache.read "foo" # => "bar"
+
+cache.delete_tag "baz"
+cache.read "foo" => nil
+```
+
+In your controller:
+```ruby
+class PostController < ActionController::Base
+  def update
+    @post = Post.find_by_id(params[:id])
+
+    if @post.update_attributes(params)
+      expire_fragments_by_tags :post => @post.id
+    else
+      render :edit
+    end
+  end
+end
+```
+
+# Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+desc 'Run tests'
+task :test do
+  test_dir = File.expand_path(File.join("..", "test"), __FILE__)
+
+  Dir[File.join(test_dir, '**', '*_test.rb')].each { |f| require f }
+  require 'minitest/autorun'
+end

data/lib/rails-cache-tags.rb

@@ -0,0 +1,27 @@
+require "active_support/cache"
+
+require "rails/cache/tag"
+require "rails/cache/tags/store"
+
+module ActiveSupport
+  module Cache
+    class Store
+      extend Rails::Cache::Tags::Store
+    end
+
+    class Entry
+      attr_accessor :tags
+    end
+  end
+end
+
+if defined?(ActionController::Base)
+  class ActionController::Base < ActionController::Metal
+    def expire_fragments_by_tags *args
+      return unless cache_configured?
+
+      cache_store.delete_tag *args
+    end
+    alias expire_fragments_by_tag expire_fragments_by_tags
+  end
+end

data/lib/rails/cache/tag.rb

@@ -0,0 +1,60 @@
+module Rails
+  module Cache
+    class Tag #:nodoc:all:
+      KEY_PREFIX = '_tags'
+
+      class << self
+        # {:post => ['1', '2', '3']} => [Tag(post:1), Tag(post:2), Tag(post:3)]
+        # {:post => 1, :user => 2} => [Tag(post:1), Tag(user:2)]
+        # ['post:1', 'post:2', 'post:3'] => [Tag(post:1), Tag(post:2), Tag(post:3)]
+        def build_tags(names)
+          case names
+            when NilClass then nil
+            when Hash then names.map do |key, value|
+              Array.wrap(value).map { |v| new([key, v]) }
+            end.flatten
+            when Enumerable then names.map { |v| build_tags(v) }.flatten
+            when self then names
+            else [new(names)]
+          end
+        end
+      end
+
+      attr_reader :name
+
+      # Tag constructor, accepts String, Symbol and Array
+      def initialize(name)
+        @name = case name
+          when String, Symbol then name
+          when Array then name.join(':')
+          else raise ArgumentError
+        end
+      end
+
+      # real cache key
+      def to_key
+        [KEY_PREFIX, name].join('/')
+      end
+
+      # read tag's version from +store+
+      def fetch(store)
+        store.read(to_key)
+      end
+
+      # increment tag's version inside +store+
+      def increment(store)
+        current = fetch(store)
+
+        version = if current.is_a?(Fixnum)
+          current + 1
+        else
+          1
+        end
+
+        store.write(to_key, version, :expires_in => nil)
+
+        version
+      end
+    end # class Tag
+  end # module Cache
+end # module Rails

data/lib/rails/cache/tags/store.rb

@@ -0,0 +1,78 @@
+module Rails
+  module Cache
+    module Tags
+      module Store
+        # patched +new+ method
+        def new(*args, &block) #:nodoc:
+          unless acts_like?(:cached_tags)
+            extend ClassMethods
+            include InstanceMethods
+
+            alias_method_chain :read_entry, :tags
+            alias_method_chain :write_entry, :tags
+          end
+
+          super
+        end
+
+        module ClassMethods #:nodoc:all:
+          def acts_like_cached_tags?
+          end
+        end
+
+        module InstanceMethods
+          # Increment the version of tags, so all entries referring to the tags become invalid
+          def delete_tag *names
+            tags = Rails::Cache::Tag.build_tags(names)
+
+            tags.each { |tag| tag.increment(self) } unless tags.empty?
+          end
+          alias delete_by_tag  delete_tag
+          alias delete_by_tags delete_tag
+          alias expire_tag     delete_tag
+
+          protected
+          def read_entry_with_tags(key, options) #:nodoc
+            entry = read_entry_without_tags(key, options)
+
+            if entry && entry.tags.present?
+              current_versions = fetch_tags(entry.tags.keys)
+              saved_versions   = entry.tags.values
+
+              if current_versions != saved_versions
+                delete_entry(key, options)
+
+                return nil
+              end
+            end
+
+            entry
+          end # def read_entry_with_tags
+
+          def write_entry_with_tags(key, entry, options) #:nodoc:
+            tags = Rails::Cache::Tag.build_tags Array.wrap(options[:tags]).flatten.compact
+
+            unless tags.empty?
+              current_versions = fetch_tags(tags) # => [1, 2, 3]
+              entry.tags = Hash[tags.zip(current_versions).map { |tag, v| [tag.name, v || tag.increment(self)] }]
+            end
+
+            write_entry_without_tags(key, entry, options)
+          end # def write_entry_without_tags
+
+          private
+          # fetch tags versions from store
+          # fetch ['user:1', 'post:2', 'country:2'] => [3, 4, nil]
+          def fetch_tags(names) #:nodoc:
+            tags = Rails::Cache::Tag.build_tags names
+            keys = tags.map(&:to_key)
+            stored = read_multi(*keys)
+
+            # we should save order
+            keys.collect { |k| stored[k] }
+          end
+        end
+      end # module Store
+    end # module Tags
+  end # module Cache
+end # module Rails

data/lib/rails/cache/tags/version.rb

@@ -0,0 +1,7 @@
+module Rails
+  module Cache
+    module Tags
+      VERSION = "1.0.0"
+    end
+  end
+end

data/rails-cache-tags.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rails/cache/tags/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Alexei Mikhailov"]
+  gem.email         = %W(amikhailov83@gmail.com)
+  gem.description   = %q{Tagged caching support for Rails}
+  gem.summary       = %q{Tagged caching support for Rails}
+  gem.homepage      = "https://github.com/take-five/rails-cache-tags"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "rails-cache-tags"
+  gem.require_paths = %W(lib)
+  gem.version       = Rails::Cache::Tags::VERSION
+
+  gem.add_dependency "activesupport", ">= 3.0"
+  gem.add_dependency "actionpack", ">= 3.0"
+
+  gem.add_development_dependency 'minitest', '~> 3.2'
+  gem.add_development_dependency 'memcache-client'
+  gem.add_development_dependency 'rack'
+  gem.add_development_dependency 'mocha'
+  gem.add_development_dependency 'simplecov'
+end

data/test/cache_tags_test.rb

@@ -0,0 +1,80 @@
+$:.unshift(File.dirname(__FILE__))
+
+require "test_helper"
+require "caching_test"
+
+module CacheTagsBehavior
+  def test_read_and_write_with_tags
+    @cache.write("foo", "bar", :tags => "baz")
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_read_after_tag_deleted
+    @cache.write("foo", "bar", :tags => "baz")
+    @cache.delete_tag("baz")
+
+    assert_nil @cache.read("foo")
+  end
+
+  def test_read_after_another_tag_deleted
+    @cache.write("foo", "bar", :tags => "baz")
+    @cache.delete_tag("fu")
+
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_read_and_write_with_multiple_tags
+    @cache.write("foo", "bar", :tags => [:baz, :kung])
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_read_after_one_of_tags_deleted
+    @cache.write("foo", "bar", :tags => [:baz, :kung])
+    @cache.delete_tag :kung
+
+    assert_nil @cache.read("foo")
+  end
+
+  def test_read_after_another_of_multiple_tags_deleted
+    @cache.write("foo", "bar", :tags => [:baz, :kung])
+    @cache.delete_tag("fu")
+
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_read_with_small_default_expiration_time
+    cache = if is_a?(FileStoreTest)
+      @cache.class.new @cache.cache_path, :expires_in => 0.001
+    else
+      @cache.class.new :expires_in => 0.001
+    end
+
+    cache.write("foo", "bar", :tags => "baz", :expires_in => 2)
+    sleep 0.02
+
+    assert_equal 'bar', cache.read('foo')
+  end
+
+  def test_exists_with_tags
+    @cache.write("foo", "bar", :tags => "baz")
+    @cache.delete_tag("baz")
+
+    assert_equal @cache.exist?("foo"), false
+  end
+
+  def test_read_and_write_with_tags_hash
+    @cache.write("foo", "bar", :tags => {:baz => 1})
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_read_and_write_with_tags_hash_after_expiration
+    @cache.write("foo", "bar", :tags => {:baz => 1})
+    @cache.delete_tag :baz => 1
+
+    assert_nil @cache.read('foo')
+  end
+end
+
+[FileStoreTest, MemoryStoreTest, MemCacheStoreTest].each do |klass|
+  klass.send :include, CacheTagsBehavior
+end

data/test/caching_test.rb

@@ -0,0 +1,846 @@
+$:.unshift(File.dirname(__FILE__))
+
+require 'test_helper'
+require 'logger'
+
+class CacheKeyTest < ActiveSupport::TestCase
+  def test_expand_cache_key
+    assert_equal '1/2/true', ActiveSupport::Cache.expand_cache_key([1, '2', true])
+    assert_equal 'name/1/2/true', ActiveSupport::Cache.expand_cache_key([1, '2', true], :name)
+  end
+
+  def test_expand_cache_key_with_rails_cache_id
+    begin
+      ENV['RAILS_CACHE_ID'] = 'c99'
+      assert_equal 'c99/foo', ActiveSupport::Cache.expand_cache_key(:foo)
+      assert_equal 'c99/foo', ActiveSupport::Cache.expand_cache_key([:foo])
+      assert_equal 'c99/foo/bar', ActiveSupport::Cache.expand_cache_key([:foo, :bar])
+      assert_equal 'nm/c99/foo', ActiveSupport::Cache.expand_cache_key(:foo, :nm)
+      assert_equal 'nm/c99/foo', ActiveSupport::Cache.expand_cache_key([:foo], :nm)
+      assert_equal 'nm/c99/foo/bar', ActiveSupport::Cache.expand_cache_key([:foo, :bar], :nm)
+    ensure
+      ENV['RAILS_CACHE_ID'] = nil
+    end
+  end
+
+  def test_expand_cache_key_with_rails_app_version
+    begin
+      ENV['RAILS_APP_VERSION'] = 'rails3'
+      assert_equal 'rails3/foo', ActiveSupport::Cache.expand_cache_key(:foo)
+    ensure
+      ENV['RAILS_APP_VERSION'] = nil
+    end
+  end
+
+  def test_expand_cache_key_rails_cache_id_should_win_over_rails_app_version
+    begin
+      ENV['RAILS_CACHE_ID'] = 'c99'
+      ENV['RAILS_APP_VERSION'] = 'rails3'
+      assert_equal 'c99/foo', ActiveSupport::Cache.expand_cache_key(:foo)
+    ensure
+      ENV['RAILS_CACHE_ID'] = nil
+      ENV['RAILS_APP_VERSION'] = nil
+    end
+  end
+
+  def test_expand_cache_key_respond_to_cache_key
+    key = 'foo'
+    def key.cache_key
+      :foo_key
+    end
+    assert_equal 'foo_key', ActiveSupport::Cache.expand_cache_key(key)
+  end
+
+  def test_expand_cache_key_array_with_something_that_responds_to_cache_key
+    key = 'foo'
+    def key.cache_key
+      :foo_key
+    end
+    assert_equal 'foo_key', ActiveSupport::Cache.expand_cache_key([key])
+  end
+
+  def test_expand_cache_key_of_nil
+    assert_equal '', ActiveSupport::Cache.expand_cache_key(nil)
+  end
+
+  def test_expand_cache_key_of_false
+    assert_equal 'false', ActiveSupport::Cache.expand_cache_key(false)
+  end
+
+  def test_expand_cache_key_of_true
+    assert_equal 'true', ActiveSupport::Cache.expand_cache_key(true)
+  end
+end
+
+class CacheStoreSettingTest < ActiveSupport::TestCase
+  def test_file_fragment_cache_store
+    store = ActiveSupport::Cache.lookup_store :file_store, "/path/to/cache/directory"
+    assert_kind_of(ActiveSupport::Cache::FileStore, store)
+    assert_equal "/path/to/cache/directory", store.cache_path
+  end
+
+  def test_mem_cache_fragment_cache_store
+    MemCache.expects(:new).with(%w[localhost], {})
+    store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost"
+    assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+  end
+
+  def test_mem_cache_fragment_cache_store_with_given_mem_cache
+    mem_cache = MemCache.new
+    MemCache.expects(:new).never
+    store = ActiveSupport::Cache.lookup_store :mem_cache_store, mem_cache
+    assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+  end
+
+  def test_mem_cache_fragment_cache_store_with_given_mem_cache_like_object
+    MemCache.expects(:new).never
+    memcache = Object.new
+    def memcache.get() true end
+    store = ActiveSupport::Cache.lookup_store :mem_cache_store, memcache
+    assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+  end
+
+  def test_mem_cache_fragment_cache_store_with_multiple_servers
+    MemCache.expects(:new).with(%w[localhost 192.168.1.1], {})
+    store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost", '192.168.1.1'
+    assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+  end
+
+  def test_mem_cache_fragment_cache_store_with_options
+    MemCache.expects(:new).with(%w[localhost 192.168.1.1], { :timeout => 10 })
+    store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost", '192.168.1.1', :namespace => 'foo', :timeout => 10
+    assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+    assert_equal 'foo', store.options[:namespace]
+  end
+
+  def test_object_assigned_fragment_cache_store
+    store = ActiveSupport::Cache.lookup_store ActiveSupport::Cache::FileStore.new("/path/to/cache/directory")
+    assert_kind_of(ActiveSupport::Cache::FileStore, store)
+    assert_equal "/path/to/cache/directory", store.cache_path
+  end
+end
+
+class CacheStoreNamespaceTest < ActiveSupport::TestCase
+  def test_static_namespace
+    cache = ActiveSupport::Cache.lookup_store(:memory_store, :namespace => "tester")
+    cache.write("foo", "bar")
+    assert_equal "bar", cache.read("foo")
+    assert_equal "bar", cache.instance_variable_get(:@data)["tester:foo"].value
+  end
+
+  def test_proc_namespace
+    test_val = "tester"
+    proc = lambda{test_val}
+    cache = ActiveSupport::Cache.lookup_store(:memory_store, :namespace => proc)
+    cache.write("foo", "bar")
+    assert_equal "bar", cache.read("foo")
+    assert_equal "bar", cache.instance_variable_get(:@data)["tester:foo"].value
+  end
+
+  def test_delete_matched_key_start
+    cache = ActiveSupport::Cache.lookup_store(:memory_store, :namespace => "tester")
+    cache.write("foo", "bar")
+    cache.write("fu", "baz")
+    cache.delete_matched(/^fo/)
+    assert !cache.exist?("foo")
+    assert cache.exist?("fu")
+  end
+
+  def test_delete_matched_key
+    cache = ActiveSupport::Cache.lookup_store(:memory_store, :namespace => "foo")
+    cache.write("foo", "bar")
+    cache.write("fu", "baz")
+    cache.delete_matched(/OO/i)
+    assert !cache.exist?("foo")
+    assert cache.exist?("fu")
+  end
+end
+
+# Tests the base functionality that should be identical across all cache stores.
+module CacheStoreBehavior
+  def test_should_read_and_write_strings
+    assert @cache.write('foo', 'bar')
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_should_overwrite
+    @cache.write('foo', 'bar')
+    @cache.write('foo', 'baz')
+    assert_equal 'baz', @cache.read('foo')
+  end
+
+  def test_fetch_without_cache_miss
+    @cache.write('foo', 'bar')
+    @cache.expects(:write).never
+    assert_equal 'bar', @cache.fetch('foo') { 'baz' }
+  end
+
+  def test_fetch_with_cache_miss
+    @cache.expects(:write).with('foo', 'baz', @cache.options)
+    assert_equal 'baz', @cache.fetch('foo') { 'baz' }
+  end
+
+  def test_fetch_with_forced_cache_miss
+    @cache.write('foo', 'bar')
+    @cache.expects(:read).never
+    @cache.expects(:write).with('foo', 'bar', @cache.options.merge(:force => true))
+    @cache.fetch('foo', :force => true) { 'bar' }
+  end
+
+  def test_fetch_with_cached_nil
+    @cache.write('foo', nil)
+    @cache.expects(:write).never
+    assert_nil @cache.fetch('foo') { 'baz' }
+  end
+
+  def test_should_read_and_write_hash
+    assert @cache.write('foo', {:a => "b"})
+    assert_equal({:a => "b"}, @cache.read('foo'))
+  end
+
+  def test_should_read_and_write_integer
+    assert @cache.write('foo', 1)
+    assert_equal 1, @cache.read('foo')
+  end
+
+  def test_should_read_and_write_nil
+    assert @cache.write('foo', nil)
+    assert_equal nil, @cache.read('foo')
+  end
+
+  def test_should_read_and_write_false
+    assert @cache.write('foo', false)
+    assert_equal false, @cache.read('foo')
+  end
+
+  def test_should_read_cached_numeric_from_previous_rails_versions
+    @old_cache = ActiveSupport::Cache::Entry.create( 1, Time.now )
+    assert_equal( 1, @old_cache.value )
+  end
+
+  def test_should_read_cached_hash_from_previous_rails_versions
+    @old_cache = ActiveSupport::Cache::Entry.create( {}, Time.now )
+    assert_equal( {}, @old_cache.value )
+  end
+
+  def test_should_read_cached_string_from_previous_rails_versions
+    @old_cache = ActiveSupport::Cache::Entry.create( 'string', Time.now )
+    assert_equal( 'string', @old_cache.value )
+  end
+
+  def test_read_multi
+    @cache.write('foo', 'bar')
+    @cache.write('fu', 'baz')
+    @cache.write('fud', 'biz')
+    assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi('foo', 'fu'))
+  end
+
+  def test_read_multi_with_expires
+    @cache.write('foo', 'bar', :expires_in => 0.001)
+    @cache.write('fu', 'baz')
+    @cache.write('fud', 'biz')
+    sleep(0.002)
+    assert_equal({"fu" => "baz"}, @cache.read_multi('foo', 'fu'))
+  end
+
+  def test_read_and_write_compressed_small_data
+    @cache.write('foo', 'bar', :compress => true)
+    raw_value = @cache.send(:read_entry, 'foo', {}).raw_value
+    assert_equal 'bar', @cache.read('foo')
+    assert_equal 'bar', Marshal.load(raw_value)
+  end
+
+  def test_read_and_write_compressed_large_data
+    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 2)
+    raw_value = @cache.send(:read_entry, 'foo', {}).raw_value
+    assert_equal 'bar', @cache.read('foo')
+    assert_equal 'bar', Marshal.load(Zlib::Inflate.inflate(raw_value))
+  end
+
+  def test_read_and_write_compressed_nil
+    @cache.write('foo', nil, :compress => true)
+    assert_nil @cache.read('foo')
+  end
+
+  def test_cache_key
+    obj = Object.new
+    def obj.cache_key
+      :foo
+    end
+    @cache.write(obj, "bar")
+    assert_equal "bar", @cache.read("foo")
+  end
+
+  def test_param_as_cache_key
+    obj = Object.new
+    def obj.to_param
+      "foo"
+    end
+    @cache.write(obj, "bar")
+    assert_equal "bar", @cache.read("foo")
+  end
+
+  def test_array_as_cache_key
+    @cache.write([:fu, "foo"], "bar")
+    assert_equal "bar", @cache.read("fu/foo")
+  end
+
+  def test_hash_as_cache_key
+    @cache.write({:foo => 1, :fu => 2}, "bar")
+    assert_equal "bar", @cache.read("foo=1/fu=2")
+  end
+
+  def test_keys_are_case_sensitive
+    @cache.write("foo", "bar")
+    assert_nil @cache.read("FOO")
+  end
+
+  def test_exist
+    @cache.write('foo', 'bar')
+    assert @cache.exist?('foo')
+    assert !@cache.exist?('bar')
+  end
+
+  def test_nil_exist
+    @cache.write('foo', nil)
+    assert @cache.exist?('foo')
+  end
+
+  def test_delete
+    @cache.write('foo', 'bar')
+    assert @cache.exist?('foo')
+    assert @cache.delete('foo')
+    assert !@cache.exist?('foo')
+  end
+
+  def test_read_should_return_a_different_object_id_each_time_it_is_called
+    @cache.write('foo', 'bar')
+    assert_not_equal @cache.read('foo').object_id, @cache.read('foo').object_id
+    value = @cache.read('foo')
+    value << 'bingo'
+    assert_not_equal value, @cache.read('foo')
+  end
+
+  def test_original_store_objects_should_not_be_immutable
+    bar = 'bar'
+    @cache.write('foo', bar)
+    assert_nothing_raised { bar.gsub!(/.*/, 'baz') }
+  end
+
+  def test_expires_in
+    time = Time.local(2008, 4, 24)
+    Time.stubs(:now).returns(time)
+
+    @cache.write('foo', 'bar')
+    assert_equal 'bar', @cache.read('foo')
+
+    Time.stubs(:now).returns(time + 30)
+    assert_equal 'bar', @cache.read('foo')
+
+    Time.stubs(:now).returns(time + 61)
+    assert_nil @cache.read('foo')
+  end
+
+  def test_race_condition_protection
+    time = Time.now
+    @cache.write('foo', 'bar', :expires_in => 60)
+    Time.stubs(:now).returns(time + 61)
+    result = @cache.fetch('foo', :race_condition_ttl => 10) do
+      assert_equal 'bar', @cache.read('foo')
+      "baz"
+    end
+    assert_equal "baz", result
+  end
+
+  def test_race_condition_protection_is_limited
+    time = Time.now
+    @cache.write('foo', 'bar', :expires_in => 60)
+    Time.stubs(:now).returns(time + 71)
+    result = @cache.fetch('foo', :race_condition_ttl => 10) do
+      assert_equal nil, @cache.read('foo')
+      "baz"
+    end
+    assert_equal "baz", result
+  end
+
+  def test_race_condition_protection_is_safe
+    time = Time.now
+    @cache.write('foo', 'bar', :expires_in => 60)
+    Time.stubs(:now).returns(time + 61)
+    begin
+      @cache.fetch('foo', :race_condition_ttl => 10) do
+        assert_equal 'bar', @cache.read('foo')
+        raise ArgumentError.new
+      end
+    rescue ArgumentError
+    end
+    assert_equal "bar", @cache.read('foo')
+    Time.stubs(:now).returns(time + 71)
+    assert_nil @cache.read('foo')
+  end
+
+  def test_crazy_key_characters
+    crazy_key = "#/:*(<+=> )&$%@?;'\"\'`~-"
+    assert @cache.write(crazy_key, "1", :raw => true)
+    assert_equal "1", @cache.read(crazy_key)
+    assert_equal "1", @cache.fetch(crazy_key)
+    assert @cache.delete(crazy_key)
+    assert_equal "2", @cache.fetch(crazy_key, :raw => true) { "2" }
+    assert_equal 3, @cache.increment(crazy_key)
+    assert_equal 2, @cache.decrement(crazy_key)
+  end
+
+  def test_really_long_keys
+    key = ""
+    900.times{key << "x"}
+    assert @cache.write(key, "bar")
+    assert_equal "bar", @cache.read(key)
+    assert_equal "bar", @cache.fetch(key)
+    assert_nil @cache.read("#{key}x")
+    assert_equal({key => "bar"}, @cache.read_multi(key))
+    assert @cache.delete(key)
+  end
+end
+
+# https://rails.lighthouseapp.com/projects/8994/tickets/6225-memcachestore-cant-deal-with-umlauts-and-special-characters
+# The error is caused by charcter encodings that can't be compared with ASCII-8BIT regular expressions and by special
+# characters like the umlaut in UTF-8.
+module EncodedKeyCacheBehavior
+  if defined?(Encoding)
+    Encoding.list.each do |encoding|
+      define_method "test_#{encoding.name.underscore}_encoded_values" do
+        key = "foo".force_encoding(encoding)
+        assert @cache.write(key, "1", :raw => true)
+        assert_equal "1", @cache.read(key)
+        assert_equal "1", @cache.fetch(key)
+        assert @cache.delete(key)
+        assert_equal "2", @cache.fetch(key, :raw => true) { "2" }
+        assert_equal 3, @cache.increment(key)
+        assert_equal 2, @cache.decrement(key)
+      end
+    end
+
+    def test_common_utf8_values
+      key = "\xC3\xBCmlaut".force_encoding(Encoding::UTF_8)
+      assert @cache.write(key, "1", :raw => true)
+      assert_equal "1", @cache.read(key)
+      assert_equal "1", @cache.fetch(key)
+      assert @cache.delete(key)
+      assert_equal "2", @cache.fetch(key, :raw => true) { "2" }
+      assert_equal 3, @cache.increment(key)
+      assert_equal 2, @cache.decrement(key)
+    end
+
+    def test_retains_encoding
+      key = "\xC3\xBCmlaut".force_encoding(Encoding::UTF_8)
+      assert @cache.write(key, "1", :raw => true)
+      assert_equal Encoding::UTF_8, key.encoding
+    end
+  end
+end
+
+module CacheDeleteMatchedBehavior
+  def test_delete_matched
+    @cache.write("foo", "bar")
+    @cache.write("fu", "baz")
+    @cache.write("foo/bar", "baz")
+    @cache.write("fu/baz", "bar")
+    @cache.delete_matched(/oo/)
+    assert !@cache.exist?("foo")
+    assert @cache.exist?("fu")
+    assert !@cache.exist?("foo/bar")
+    assert @cache.exist?("fu/baz")
+  end
+end
+
+module CacheIncrementDecrementBehavior
+  def test_increment
+    @cache.write('foo', 1, :raw => true)
+    assert_equal 1, @cache.read('foo').to_i
+    assert_equal 2, @cache.increment('foo')
+    assert_equal 2, @cache.read('foo').to_i
+    assert_equal 3, @cache.increment('foo')
+    assert_equal 3, @cache.read('foo').to_i
+  end
+
+  def test_decrement
+    @cache.write('foo', 3, :raw => true)
+    assert_equal 3, @cache.read('foo').to_i
+    assert_equal 2, @cache.decrement('foo')
+    assert_equal 2, @cache.read('foo').to_i
+    assert_equal 1, @cache.decrement('foo')
+    assert_equal 1, @cache.read('foo').to_i
+  end
+end
+
+module LocalCacheBehavior
+  def test_local_writes_are_persistent_on_the_remote_cache
+    retval = @cache.with_local_cache do
+      @cache.write('foo', 'bar')
+    end
+    assert retval
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_clear_also_clears_local_cache
+    @cache.with_local_cache do
+      @cache.write('foo', 'bar')
+      @cache.clear
+      assert_nil @cache.read('foo')
+    end
+
+    assert_nil @cache.read('foo')
+  end
+
+  def test_local_cache_of_write
+    @cache.with_local_cache do
+      @cache.write('foo', 'bar')
+      @peek.delete('foo')
+      assert_equal 'bar', @cache.read('foo')
+    end
+  end
+
+  def test_local_cache_of_read
+    @cache.write('foo', 'bar')
+    @cache.with_local_cache do
+      assert_equal 'bar', @cache.read('foo')
+    end
+  end
+
+  def test_local_cache_of_write_nil
+    @cache.with_local_cache do
+      assert @cache.write('foo', nil)
+      assert_nil @cache.read('foo')
+      @peek.write('foo', 'bar')
+      assert_nil @cache.read('foo')
+    end
+  end
+
+  def test_local_cache_of_delete
+    @cache.with_local_cache do
+      @cache.write('foo', 'bar')
+      @cache.delete('foo')
+      assert_nil @cache.read('foo')
+    end
+  end
+
+  def test_local_cache_of_exist
+    @cache.with_local_cache do
+      @cache.write('foo', 'bar')
+      @peek.delete('foo')
+      assert @cache.exist?('foo')
+    end
+  end
+
+  def test_local_cache_of_increment
+    @cache.with_local_cache do
+      @cache.write('foo', 1, :raw => true)
+      @peek.write('foo', 2, :raw => true)
+      @cache.increment('foo')
+      assert_equal 3, @cache.read('foo')
+    end
+  end
+
+  def test_local_cache_of_decrement
+    @cache.with_local_cache do
+      @cache.write('foo', 1, :raw => true)
+      @peek.write('foo', 3, :raw => true)
+      @cache.decrement('foo')
+      assert_equal 2, @cache.read('foo')
+    end
+  end
+
+  def test_middleware
+    app = lambda { |env|
+      result = @cache.write('foo', 'bar')
+      assert_equal 'bar', @cache.read('foo') # make sure 'foo' was written
+      assert result
+    }
+    app = @cache.middleware.new(app)
+    app.call({})
+  end
+end
+
+class FileStoreTest < ActiveSupport::TestCase
+  def setup
+    Dir.mkdir(cache_dir) unless File.exist?(cache_dir)
+    @cache = ActiveSupport::Cache.lookup_store(:file_store, cache_dir, :expires_in => 60)
+    @peek = ActiveSupport::Cache.lookup_store(:file_store, cache_dir, :expires_in => 60)
+    @cache_with_pathname = ActiveSupport::Cache.lookup_store(:file_store, Pathname.new(cache_dir), :expires_in => 60)
+  end
+
+  def teardown
+    FileUtils.rm_r(cache_dir)
+  end
+
+  def cache_dir
+    File.join(Dir.pwd, 'tmp_cache')
+  end
+
+  include CacheStoreBehavior
+  include LocalCacheBehavior
+  include CacheDeleteMatchedBehavior
+  include CacheIncrementDecrementBehavior
+
+  def test_key_transformation
+    key = @cache.send(:key_file_path, "views/index?id=1")
+    assert_equal "views/index?id=1", @cache.send(:file_path_key, key)
+  end
+
+  def test_key_transformation_with_pathname
+    FileUtils.touch(File.join(cache_dir, "foo"))
+    key = @cache_with_pathname.send(:key_file_path, "views/index?id=1")
+    assert_equal "views/index?id=1", @cache_with_pathname.send(:file_path_key, key)
+  end
+
+  # Because file systems have a maximum filename size, filenames > max size should be split in to directories
+  # If filename is 'AAAAB', where max size is 4, the returned path should be AAAA/B
+  def test_key_transformation_max_filename_size
+    key = "#{'A' * ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE}B"
+    path = @cache.send(:key_file_path, key)
+    assert path.split('/').all? { |dir_name| dir_name.size <= ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE}
+    assert_equal 'B', File.basename(path)
+  end
+
+  # If nothing has been stored in the cache, there is a chance the cache directory does not yet exist
+  # Ensure delete_matched gracefully handles this case
+  def test_delete_matched_when_cache_directory_does_not_exist
+    assert_nothing_raised(Exception) do
+      ActiveSupport::Cache::FileStore.new('/test/cache/directory').delete_matched(/does_not_exist/)
+    end
+  end
+end
+
+class MemoryStoreTest < ActiveSupport::TestCase
+  def setup
+    @record_size = Marshal.dump("aaaaaaaaaa").bytesize
+    @cache = ActiveSupport::Cache.lookup_store(:memory_store, :expires_in => 60, :size => @record_size * 10)
+  end
+
+  include CacheStoreBehavior
+  include CacheDeleteMatchedBehavior
+  include CacheIncrementDecrementBehavior
+
+  def test_prune_size
+    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
+    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
+    @cache.write(3, "cccccccccc") && sleep(0.001)
+    @cache.write(4, "dddddddddd") && sleep(0.001)
+    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
+    @cache.read(2) && sleep(0.001)
+    @cache.read(4)
+    @cache.prune(@record_size * 3)
+    assert @cache.exist?(5)
+    assert @cache.exist?(4)
+    assert !@cache.exist?(3)
+    assert @cache.exist?(2)
+    assert !@cache.exist?(1)
+  end
+
+  def test_prune_size_on_write
+    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
+    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
+    @cache.write(3, "cccccccccc") && sleep(0.001)
+    @cache.write(4, "dddddddddd") && sleep(0.001)
+    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
+    @cache.write(6, "ffffffffff") && sleep(0.001)
+    @cache.write(7, "gggggggggg") && sleep(0.001)
+    @cache.write(8, "hhhhhhhhhh") && sleep(0.001)
+    @cache.write(9, "iiiiiiiiii") && sleep(0.001)
+    @cache.write(10, "kkkkkkkkkk") && sleep(0.001)
+    @cache.read(2) && sleep(0.001)
+    @cache.read(4) && sleep(0.001)
+    @cache.write(11, "llllllllll")
+    assert @cache.exist?(11)
+    assert @cache.exist?(10)
+    assert @cache.exist?(9)
+    assert @cache.exist?(8)
+    assert @cache.exist?(7)
+    assert !@cache.exist?(6)
+    assert !@cache.exist?(5)
+    assert @cache.exist?(4)
+    assert !@cache.exist?(3)
+    assert @cache.exist?(2)
+    assert !@cache.exist?(1)
+  end
+
+  def test_pruning_is_capped_at_a_max_time
+    def @cache.delete_entry (*args)
+      sleep(0.01)
+      super
+    end
+    @cache.write(1, "aaaaaaaaaa") && sleep(0.001)
+    @cache.write(2, "bbbbbbbbbb") && sleep(0.001)
+    @cache.write(3, "cccccccccc") && sleep(0.001)
+    @cache.write(4, "dddddddddd") && sleep(0.001)
+    @cache.write(5, "eeeeeeeeee") && sleep(0.001)
+    @cache.prune(30, 0.001)
+    assert @cache.exist?(5)
+    assert @cache.exist?(4)
+    assert @cache.exist?(3)
+    assert @cache.exist?(2)
+    assert !@cache.exist?(1)
+  end
+end
+
+uses_memcached 'memcached backed store' do
+  class MemCacheStoreTest < ActiveSupport::TestCase
+    def setup
+      @cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, :expires_in => 60)
+      @peek = ActiveSupport::Cache.lookup_store(:mem_cache_store)
+      @data = @cache.instance_variable_get(:@data)
+      @cache.clear
+      @cache.silence!
+      @cache.logger = Logger.new("/dev/null")
+    end
+
+    include CacheStoreBehavior
+    include LocalCacheBehavior
+    include CacheIncrementDecrementBehavior
+    include EncodedKeyCacheBehavior
+
+    def test_raw_values
+      cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, :raw => true)
+      cache.clear
+      cache.write("foo", 2)
+      assert_equal "2", cache.read("foo")
+    end
+
+    def test_raw_values_with_marshal
+      cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, :raw => true)
+      cache.clear
+      cache.write("foo", Marshal.dump([]))
+      assert_equal [], cache.read("foo")
+    end
+
+    def test_local_cache_raw_values
+      cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, :raw => true)
+      cache.clear
+      cache.with_local_cache do
+        cache.write("foo", 2)
+        assert_equal "2", cache.read("foo")
+      end
+    end
+
+    def test_local_cache_raw_values_with_marshal
+      cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, :raw => true)
+      cache.clear
+      cache.with_local_cache do
+        cache.write("foo", Marshal.dump([]))
+        assert_equal [], cache.read("foo")
+      end
+    end
+  end
+end
+
+class NullStoreTest < ActiveSupport::TestCase
+  def setup
+    @cache = ActiveSupport::Cache.lookup_store(:null_store)
+  end
+
+  def test_clear
+    @cache.clear
+  end
+
+  def test_cleanup
+    @cache.cleanup
+  end
+
+  def test_write
+    assert_equal true, @cache.write("name", "value")
+  end
+
+  def test_read
+    @cache.write("name", "value")
+    assert_nil @cache.read("name")
+  end
+
+  def test_delete
+    @cache.write("name", "value")
+    assert_equal false, @cache.delete("name")
+  end
+
+  def test_increment
+    @cache.write("name", 1, :raw => true)
+    assert_nil @cache.increment("name")
+  end
+
+  def test_decrement
+    @cache.write("name", 1, :raw => true)
+    assert_nil @cache.increment("name")
+  end
+
+  def test_delete_matched
+    @cache.write("name", "value")
+    @cache.delete_matched(/name/)
+  end
+
+  def test_local_store_strategy
+    @cache.with_local_cache do
+      @cache.write("name", "value")
+      assert_equal "value", @cache.read("name")
+      @cache.delete("name")
+      assert_nil @cache.read("name")
+      @cache.write("name", "value")
+    end
+    assert_nil @cache.read("name")
+  end
+
+  def test_setting_nil_cache_store
+    assert ActiveSupport::Cache.lookup_store.class.name, ActiveSupport::Cache::NullStore.name
+  end
+end
+
+class CacheStoreLoggerTest < ActiveSupport::TestCase
+  def setup
+    @cache = ActiveSupport::Cache.lookup_store(:memory_store)
+
+    @buffer = StringIO.new
+    @cache.logger = Logger.new(@buffer)
+  end
+
+  def test_logging
+    @cache.fetch('foo') { 'bar' }
+    assert_present @buffer.string
+  end
+
+  def test_mute_logging
+    @cache.mute { @cache.fetch('foo') { 'bar' } }
+    assert_blank @buffer.string
+  end
+end
+
+class CacheEntryTest < ActiveSupport::TestCase
+  def test_create_raw_entry
+    time = Time.now
+    entry = ActiveSupport::Cache::Entry.create("raw", time, :compress => false, :expires_in => 300)
+    assert_equal "raw", entry.raw_value
+    assert_equal time.to_f, entry.created_at
+    assert !entry.compressed?
+    assert_equal 300, entry.expires_in
+  end
+
+  def test_expired
+    entry = ActiveSupport::Cache::Entry.new("value")
+    assert !entry.expired?, 'entry not expired'
+    entry = ActiveSupport::Cache::Entry.new("value", :expires_in => 60)
+    assert !entry.expired?, 'entry not expired'
+    time = Time.now + 61
+    Time.stubs(:now).returns(time)
+    assert entry.expired?, 'entry is expired'
+  end
+
+  def test_compress_values
+    entry = ActiveSupport::Cache::Entry.new("value", :compress => true, :compress_threshold => 1)
+    assert_equal "value", entry.value
+    assert entry.compressed?
+    assert_equal "value", Marshal.load(Zlib::Inflate.inflate(entry.raw_value))
+  end
+
+  def test_non_compress_values
+    entry = ActiveSupport::Cache::Entry.new("value")
+    assert_equal "value", entry.value
+    assert_equal "value", Marshal.load(entry.raw_value)
+    assert !entry.compressed?
+  end
+end