actionpack-action_caching 1.0.0 → 1.2.2

data/Rakefile

@@ -1,11 +1,11 @@
 #!/usr/bin/env rake
-require 'bundler/gem_tasks'
-require 'rake/testtask'
+require "bundler/gem_tasks"
+require "rake/testtask"
 
 Rake::TestTask.new do |t|
-  t.libs = ['test']
-  t.pattern = 'test/**/*_test.rb'
-  t.ruby_opts = ['-w']
+  t.libs = ["test"]
+  t.pattern = "test/**/*_test.rb"
+  t.ruby_opts = ["-w"]
 end
 
 task default: :test

data/actionpack-action_caching.gemspec

@@ -1,21 +1,28 @@
-# -*- encoding: utf-8 -*-
-
 Gem::Specification.new do |gem|
-  gem.name          = 'actionpack-action_caching'
-  gem.version       = '1.0.0'
-  gem.author        = 'David Heinemeier Hansson'
-  gem.email         = 'david@loudthinking.com'
-  gem.description   = 'Action caching for Action Pack (removed from core in Rails 4.0)'
-  gem.summary       = 'Action caching for Action Pack (removed from core in Rails 4.0)'
-  gem.homepage      = 'https://github.com/rails/actionpack-action_caching'
+  gem.name          = "actionpack-action_caching"
+  gem.version       = "1.2.2"
+  gem.author        = "David Heinemeier Hansson"
+  gem.email         = "david@loudthinking.com"
+  gem.description   = "Action caching for Action Pack (removed from core in Rails 4.0)"
+  gem.summary       = "Action caching for Action Pack (removed from core in Rails 4.0)"
+  gem.homepage      = "https://github.com/rails/actionpack-action_caching"
+
+  gem.metadata = {
+    "bug_tracker_uri"   => "https://github.com/rails/actionpack-action_caching/issues",
+    "changelog_uri"     => "https://github.com/rails/actionpack-action_caching/blob/v#{gem.version}/CHANGELOG.md",
+    "documentation_uri" => "https://www.rubydoc.info/gems/actionpack-action_caching/#{gem.version}",
+    "source_code_uri"   => "https://github.com/rails/actionpack-action_caching/tree/v#{gem.version}",
+  }
 
+  gem.required_ruby_version = ">= 1.9.3"
   gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ['lib']
+  gem.require_paths = ["lib"]
+  gem.license       = "MIT"
 
-  gem.add_dependency 'actionpack', '>= 4.0.0.beta', '< 5.0'
+  gem.add_dependency "actionpack", ">= 4.0.0"
 
-  gem.add_development_dependency 'mocha'
-  gem.add_development_dependency 'activerecord', '>= 4.0.0.beta', '< 5.0'
+  gem.add_development_dependency "mocha"
+  gem.add_development_dependency "activerecord", ">= 4.0.0"
 end

data/gemfiles/Gemfile-4-2-stable

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "rails", github: "rails/rails", branch: "4-2-stable"
+gem "mime-types", "< 3"
+
+if RUBY_VERSION < "2.1"
+  gem "nokogiri", "< 1.7"
+end

data/gemfiles/Gemfile-5-0-stable

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "rails", github: "rails/rails", branch: "5-0-stable"

data/gemfiles/Gemfile-5-1-stable

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "rails", github: "rails/rails", branch: "5-1-stable"

data/gemfiles/Gemfile-5-2-stable

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "rails", github: "rails/rails", branch: "5-2-stable"

data/gemfiles/Gemfile-6-0-stable

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "rails", github: "rails/rails", branch: "6-0-stable"

data/gemfiles/Gemfile-6-1-stable

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "rails", github: "rails/rails", branch: "6-1-stable"

data/gemfiles/Gemfile-edge

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "rails", github: "rails/rails", branch: "main"
+gem "activerecord", github: "rails/rails", branch: "main"

data/lib/action_controller/action_caching.rb

@@ -1,5 +1,9 @@
+require "action_controller/caching/actions"
+
 module ActionController
   module Caching
+    extend ActiveSupport::Autoload
+
     eager_autoload do
       autoload :Actions
     end
@@ -7,3 +11,5 @@ module ActionController
     include Actions
   end
 end
+
+ActionController::Base.send(:include, ActionController::Caching::Actions)

data/lib/action_controller/caching/actions.rb

@@ -1,4 +1,4 @@
-require 'set'
+require "set"
 
 module ActionController
   module Caching
@@ -10,7 +10,7 @@ module ActionController
     # to execute such action.
     #
     #   class ListsController < ApplicationController
-    #     before_filter :authenticate, except: :public
+    #     before_action :authenticate, except: :public
     #
     #     caches_page   :public
     #     caches_action :index, :show
@@ -35,14 +35,16 @@ module ActionController
     # <tt>http://david.example.com/lists.xml</tt>
     # are treated like separate requests and so are cached separately.
     # Keep in mind when expiring an action cache that
-    # <tt>action: 'lists'</tt> is not the same as
-    # <tt>action: 'list', format: :xml</tt>.
+    # <tt>action: "lists"</tt> is not the same as
+    # <tt>action: "lists", format: :xml</tt>.
     #
     # You can modify the default action cache path by passing a
     # <tt>:cache_path</tt> option. This will be passed directly to
     # <tt>ActionCachePath.new</tt>. This is handy for actions with
     # multiple possible routes that should be cached differently. If a
     # block is given, it is called with the current controller instance.
+    # If an object that responds to <tt>call</tt> is given, it'll be called
+    # with the current controller instance.
     #
     # And you can also use <tt>:if</tt> (or <tt>:unless</tt>) to pass a
     # proc that specifies when the action should be cached.
@@ -52,8 +54,19 @@ module ActionController
     #
     # The following example depicts some of the points made above:
     #
+    #   class CachePathCreator
+    #     def initialize(name)
+    #       @name = name
+    #     end
+    #
+    #     def call(controller)
+    #       "cache-path-#{@name}"
+    #     end
+    #   end
+    #
+    #
     #   class ListsController < ApplicationController
-    #     before_filter :authenticate, except: :public
+    #     before_action :authenticate, except: :public
     #
     #     caches_page :public
     #
@@ -71,6 +84,8 @@ module ActionController
     #         list_url(params[:id])
     #       end
     #     end
+    #
+    #     caches_action :posts, cache_path: CachePathCreator.new("posts")
     #   end
     #
     # If you pass <tt>layout: false</tt>, it will only cache your action
@@ -98,12 +113,12 @@ module ActionController
           filter_options = options.extract!(:if, :unless).merge(only: actions)
           cache_options  = options.extract!(:layout, :cache_path).merge(store_options: options)
 
-          around_filter ActionCacheFilter.new(cache_options), filter_options
+          around_action ActionCacheFilter.new(cache_options), filter_options
         end
       end
 
       def _save_fragment(name, options)
-        content = ''
+        content = ""
         response_body.each do |parts|
           content << parts
         end
@@ -137,14 +152,8 @@ module ActionController
         end
 
         def around(controller)
-          cache_layout = @cache_layout.respond_to?(:call) ? @cache_layout.call(controller) : @cache_layout
-
-          path_options = if @cache_path.respond_to?(:call)
-            controller.instance_exec(controller, &@cache_path)
-          else
-            @cache_path
-          end
-
+          cache_layout = expand_option(controller, @cache_layout)
+          path_options = expand_option(controller, @cache_path)
           cache_path = ActionCachePath.new(controller, path_options || {})
 
           body = controller.read_fragment(cache_path.path, @store_options)
@@ -156,11 +165,41 @@ module ActionController
             body = controller._save_fragment(cache_path.path, @store_options)
           end
 
-          body = controller.render_to_string(text: body, layout: true) unless cache_layout
+          body = render_to_string(controller, body) unless cache_layout
 
           controller.response_body = body
           controller.content_type = Mime[cache_path.extension || :html]
         end
+
+        if ActionPack::VERSION::STRING < "4.1"
+          def render_to_string(controller, body)
+            controller.render_to_string(text: body, layout: true)
+          end
+        else
+          def render_to_string(controller, body)
+            controller.render_to_string(html: body.html_safe, layout: true)
+          end
+        end
+
+        private
+          def expand_option(controller, option)
+            option = option.to_proc if option.respond_to?(:to_proc)
+
+            if option.is_a?(Proc)
+              case option.arity
+              when -2, -1, 1
+                controller.instance_exec(controller, &option)
+              when 0
+                controller.instance_exec(&option)
+              else
+                raise ArgumentError, "Invalid proc arity of #{option.arity} - proc options should have an arity of 0 or 1"
+              end
+            elsif option.respond_to?(:call)
+              option.call(controller)
+            else
+              option
+            end
+          end
       end
 
       class ActionCachePath
@@ -172,20 +211,27 @@ module ActionController
         # request format.
         def initialize(controller, options = {}, infer_extension = true)
           if infer_extension
-            @extension = controller.params[:format]
+            if controller.params.key?(:format)
+              @extension = controller.params[:format]
+            elsif !controller.request.format.html?
+              @extension = controller.request.format.to_sym
+            else
+              @extension = nil
+            end
+
             options.reverse_merge!(format: @extension) if options.is_a?(Hash)
           end
 
-          path = controller.url_for(options).split('://', 2).last
+          path = controller.url_for(options).split("://", 2).last
           @path = normalize!(path)
         end
 
       private
         def normalize!(path)
-          ext = URI.parser.escape(extension) if extension
-          path << 'index' if path[-1] == ?/
-          path << ".#{ext}" if extension and !path.split('?', 2).first.ends_with?(".#{ext}")
-          URI.parser.unescape(path)
+          ext = URI::DEFAULT_PARSER.escape(extension.to_s) if extension
+          path << "index" if path[-1] == ?/
+          path << ".#{ext}" if extension && !path.split("?", 2).first.end_with?(".#{ext}")
+          URI::DEFAULT_PARSER.unescape(path)
         end
       end
     end

data/lib/actionpack/action_caching.rb

@@ -1 +1 @@
-require 'action_controller/action_caching'
+require "actionpack/action_caching/railtie"

data/lib/actionpack/action_caching/railtie.rb

@@ -0,0 +1,13 @@
+require "rails/railtie"
+
+module ActionPack
+  module ActionCaching
+    class Railtie < Rails::Railtie
+      initializer "action_pack.action_caching" do
+        ActiveSupport.on_load(:action_controller) do
+          require "action_controller/action_caching"
+        end
+      end
+    end
+  end
+end

data/test/abstract_unit.rb

@@ -1,40 +1,11 @@
-require 'bundler/setup'
-require 'minitest/autorun'
-require 'action_controller'
-require 'active_record'
-require 'action_controller/action_caching'
+require "bundler/setup"
+require "minitest/autorun"
+require "action_controller"
+require "active_record"
+require "action_controller/action_caching"
 
-FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), 'fixtures')
+FIXTURE_LOAD_PATH = File.expand_path("../fixtures", __FILE__)
 
-SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
-
-module ActionController
-  class Base
-    include SharedTestRoutes.url_helpers
-
-    self.view_paths = FIXTURE_LOAD_PATH
-  end
-
-  class TestCase
-    def setup
-      @routes = SharedTestRoutes
-
-      @routes.draw do
-        get ':controller(/:action)'
-      end
-    end
-  end
-end
-
-module RackTestUtils
-  def body_to_string(body)
-    if body.respond_to?(:each)
-      str = ''
-      body.each {|s| str << s }
-      str
-    else
-      body
-    end
-  end
-  extend self
+if ActiveSupport.respond_to?(:test_order)
+  ActiveSupport.test_order = :random
 end

data/test/caching_test.rb

@@ -1,8 +1,10 @@
-require 'abstract_unit'
+require "abstract_unit"
+require "mocha/setup"
 
-CACHE_DIR = 'test_cache'
-# Don't change '/../temp/' cavalierly or you might hose something you don't want hosed
-FILE_STORE_PATH = File.join(File.dirname(__FILE__), '/../temp/', CACHE_DIR)
+CACHE_DIR = "test_cache"
+# Don't change "../tmp" cavalierly or you might hose something you don't want hosed
+TEST_TMP_DIR = File.expand_path("../tmp", __FILE__)
+FILE_STORE_PATH = File.join(TEST_TMP_DIR, CACHE_DIR)
 
 class CachingController < ActionController::Base
   abstract!
@@ -10,6 +12,12 @@ class CachingController < ActionController::Base
   self.cache_store = :file_store, FILE_STORE_PATH
 end
 
+class CachePath
+  def call(controller)
+    ["controller", controller.params[:id]].compact.join("-")
+  end
+end
+
 class ActionCachingTestController < CachingController
   rescue_from(Exception) { head 500 }
   rescue_from(ActionController::UnknownFormat) { head :not_acceptable }
@@ -17,97 +25,160 @@ class ActionCachingTestController < CachingController
     rescue_from(ActiveRecord::RecordNotFound) { head :not_found }
   end
 
-  # Eliminate uninitialized ivar warning
-  before_filter { @title = nil }
+  self.view_paths = FIXTURE_LOAD_PATH
 
-  caches_action :index, :redirected, :forbidden, if: Proc.new { |c| c.request.format && !c.request.format.json? }, expires_in: 1.hour
-  caches_action :show, cache_path: 'http://test.host/custom/show'
-  caches_action :edit, cache_path: Proc.new { |c| c.params[:id] ? "http://test.host/#{c.params[:id]};edit" : 'http://test.host/edit' }
+  before_action only: :with_symbol_format do
+    request.params[:format] = :json
+  end
+
+  caches_action :index, :redirected, :forbidden, if: ->(c) { c.request.format && !c.request.format.json? }, expires_in: 1.hour
+  caches_action :show, cache_path: "http://test.host/custom/show"
+  caches_action :edit, cache_path: ->(c) { c.params[:id] ? "http://test.host/#{c.params[:id]};edit" : "http://test.host/edit" }
+  caches_action :custom_cache_path, cache_path: CachePath.new
+  caches_action :symbol_cache_path, cache_path: :cache_path_protected_method
   caches_action :with_layout
-  caches_action :with_format_and_http_param, cache_path: Proc.new { |c| { key: 'value' } }
+  caches_action :with_format_and_http_param, cache_path: ->(c) { { key: "value" } }
+  caches_action :with_symbol_format, cache_path: "http://test.host/action_caching_test/with_symbol_format"
+  caches_action :not_url_cache_path, cache_path: ->(c) { "#{c.params[:action]}_key" }
+  caches_action :not_url_cache_path_no_args, cache_path: -> { "#{params[:action]}_key" }
   caches_action :layout_false, layout: false
-  caches_action :with_layout_proc_param, layout: Proc.new { |c| c.params[:layout] }
+  caches_action :with_layout_proc_param, layout: ->(c) { c.params[:layout] != "false" }
+  caches_action :with_layout_proc_param_no_args, layout: -> { params[:layout] != "false" }
   caches_action :record_not_found, :four_oh_four, :simple_runtime_error
   caches_action :streaming
   caches_action :invalid
+  caches_action :accept
 
-  layout 'talk_from_action'
+  layout "talk_from_action"
 
   def index
-    @cache_this = MockTime.now.to_f.to_s
-    render text: @cache_this
+    @cache_this = CacheContent.to_s
+    render plain: @cache_this
   end
 
   def redirected
-    redirect_to action: 'index'
+    redirect_to action: "index"
   end
 
   def forbidden
-    render text: 'Forbidden'
-    response.status = '403 Forbidden'
+    render plain: "Forbidden"
+    response.status = "403 Forbidden"
   end
 
   def with_layout
-    @cache_this = MockTime.now.to_f.to_s
-    @title = nil
-    render text: @cache_this, layout: true
+    @cache_this = CacheContent.to_s
+    render html: @cache_this, layout: true
   end
 
   def with_format_and_http_param
-    @cache_this = MockTime.now.to_f.to_s
-    render text: @cache_this
+    @cache_this = CacheContent.to_s
+    render plain: @cache_this
+  end
+
+  def with_symbol_format
+    @cache_this = CacheContent.to_s
+    render json: { timestamp: @cache_this }
+  end
+
+  def not_url_cache_path
+    render plain: "cache_this"
   end
+  alias_method :not_url_cache_path_no_args, :not_url_cache_path
 
   def record_not_found
-    raise ActiveRecord::RecordNotFound, 'oops!'
+    raise ActiveRecord::RecordNotFound, "oops!"
   end
 
   def four_oh_four
-    render text: "404'd!", status: 404
+    render plain: "404'd!", status: 404
   end
 
   def simple_runtime_error
-    raise 'oops!'
+    raise "oops!"
   end
 
   alias_method :show, :index
   alias_method :edit, :index
   alias_method :destroy, :index
+  alias_method :custom_cache_path, :index
+  alias_method :symbol_cache_path, :index
   alias_method :layout_false, :with_layout
   alias_method :with_layout_proc_param, :with_layout
+  alias_method :with_layout_proc_param_no_args, :with_layout
 
   def expire
-    expire_action controller: 'action_caching_test', action: 'index'
-    render nothing: true
+    expire_action controller: "action_caching_test", action: "index"
+    head :ok
   end
 
   def expire_xml
-    expire_action controller: 'action_caching_test', action: 'index', format: 'xml'
-    render nothing: true
+    expire_action controller: "action_caching_test", action: "index", format: "xml"
+    head :ok
   end
 
   def expire_with_url_string
-    expire_action url_for(controller: 'action_caching_test', action: 'index')
-    render nothing: true
+    expire_action url_for(controller: "action_caching_test", action: "index")
+    head :ok
   end
 
   def streaming
-    render text: 'streaming', stream: true
+    render plain: "streaming", stream: true
   end
 
   def invalid
-    @cache_this = MockTime.now.to_f.to_s
+    @cache_this = CacheContent.to_s
+
+    respond_to do |format|
+      format.json { render json: @cache_this }
+    end
+  end
+
+  def accept
+    @cache_this = CacheContent.to_s
 
     respond_to do |format|
-      format.json{ render json: @cache_this }
+      format.html { render html: @cache_this }
+      format.json { render json: @cache_this }
+    end
+  end
+
+  def expire_accept
+    if params.key?(:format)
+      expire_action action: "accept", format: params[:format]
+    elsif !request.format.html?
+      expire_action action: "accept", format: request.format.to_sym
+    else
+      expire_action action: "accept"
     end
+
+    head :ok
   end
+
+  protected
+    def cache_path_protected_method
+      ["controller", params[:id]].compact.join("-")
+    end
+
+    if ActionPack::VERSION::STRING < "4.1"
+      def render(options)
+        if options.key?(:plain)
+          super({ text: options.delete(:plain) }.merge(options))
+          response.content_type = "text/plain"
+        elsif options.key?(:html)
+          super({ text: options.delete(:html) }.merge(options))
+          response.content_type = "text/html"
+        else
+          super
+        end
+      end
+    end
 end
 
-class MockTime < Time
-  # Let Time spicy to assure that Time.now != Time.now
-  def to_f
-    super+rand
+class CacheContent
+  def self.to_s
+    # Let Time spicy to assure that Time.now != Time.now
+    time = Time.now.to_f + rand
+    (time.to_s + "<div />").html_safe
   end
 end
 
@@ -128,9 +199,9 @@ class ActionCachingMockController
   end
 
   def request
-    Object.new.instance_eval(<<-EVAL)
-      def path; '#{@mock_path}' end
-      def format; 'all' end
+    Object.new.instance_eval <<-EVAL
+      def path; "#{@mock_path}" end
+      def format; "all" end
       def parameters; { format: nil }; end
       self
     EVAL
@@ -142,7 +213,10 @@ class ActionCacheTest < ActionController::TestCase
 
   def setup
     super
-    @request.host = 'hostname.com'
+
+    @routes = ActionDispatch::Routing::RouteSet.new
+
+    @request.host = "hostname.com"
     FileUtils.mkdir_p(FILE_STORE_PATH)
     @path_class = ActionController::Caching::Actions::ActionCachePath
     @mock_controller = ActionCachingMockController.new
@@ -154,11 +228,15 @@ class ActionCacheTest < ActionController::TestCase
   end
 
   def test_simple_action_cache_with_http_head
+    draw do
+      get "/action_caching_test", to: "action_caching_test#index"
+    end
+
     head :index
     assert_response :success
     cached_time = content_to_cache
     assert_equal cached_time, @response.body
-    assert fragment_exist?('hostname.com/action_caching_test')
+    assert fragment_exist?("hostname.com/action_caching_test")
 
     head :index
     assert_response :success
@@ -166,11 +244,15 @@ class ActionCacheTest < ActionController::TestCase
   end
 
   def test_simple_action_cache
+    draw do
+      get "/action_caching_test", to: "action_caching_test#index"
+    end
+
     get :index
     assert_response :success
     cached_time = content_to_cache
     assert_equal cached_time, @response.body
-    assert fragment_exist?('hostname.com/action_caching_test')
+    assert fragment_exist?("hostname.com/action_caching_test")
 
     get :index
     assert_response :success
@@ -178,103 +260,155 @@ class ActionCacheTest < ActionController::TestCase
   end
 
   def test_simple_action_not_cached
+    draw do
+      get "/action_caching_test/destroy", to: "action_caching_test#destroy"
+    end
+
     get :destroy
     assert_response :success
     cached_time = content_to_cache
     assert_equal cached_time, @response.body
-    assert !fragment_exist?('hostname.com/action_caching_test/destroy')
+    assert !fragment_exist?("hostname.com/action_caching_test/destroy")
 
     get :destroy
     assert_response :success
     assert_not_equal cached_time, @response.body
   end
 
-  include RackTestUtils
-
   def test_action_cache_with_layout
+    draw do
+      get "/action_caching_test/with_layout", to: "action_caching_test#with_layout"
+    end
+
     get :with_layout
     assert_response :success
     cached_time = content_to_cache
     assert_not_equal cached_time, @response.body
-    assert fragment_exist?('hostname.com/action_caching_test/with_layout')
+    assert fragment_exist?("hostname.com/action_caching_test/with_layout")
 
     get :with_layout
     assert_response :success
     assert_not_equal cached_time, @response.body
-    body = body_to_string(read_fragment('hostname.com/action_caching_test/with_layout'))
-    assert_equal @response.body, body
+    assert_equal @response.body, read_fragment("hostname.com/action_caching_test/with_layout")
   end
 
   def test_action_cache_with_layout_and_layout_cache_false
-    get :layout_false
+    draw do
+      get "/action_caching_test/layout_false", to: "action_caching_test#layout_false"
+    end
+
+    get :layout_false, params: { title: "Request 1" }
     assert_response :success
     cached_time = content_to_cache
-    assert_not_equal cached_time, @response.body
-    assert fragment_exist?('hostname.com/action_caching_test/layout_false')
+    assert_equal "<title>Request 1</title>\n#{cached_time}", @response.body
+    assert_equal cached_time, read_fragment("hostname.com/action_caching_test/layout_false")
 
-    get :layout_false
+    get :layout_false, params: { title: "Request 2" }
     assert_response :success
-    assert_not_equal cached_time, @response.body
-    body = body_to_string(read_fragment('hostname.com/action_caching_test/layout_false'))
-    assert_equal cached_time, body
+    assert_equal "<title>Request 2</title>\n#{cached_time}", @response.body
+    assert_equal cached_time, read_fragment("hostname.com/action_caching_test/layout_false")
   end
 
   def test_action_cache_with_layout_and_layout_cache_false_via_proc
-    get :with_layout_proc_param, layout: false
+    draw do
+      get "/action_caching_test/with_layout_proc_param", to: "action_caching_test#with_layout_proc_param"
+    end
+
+    get :with_layout_proc_param, params: { title: "Request 1", layout: "false" }
     assert_response :success
     cached_time = content_to_cache
-    assert_not_equal cached_time, @response.body
-    assert fragment_exist?('hostname.com/action_caching_test/with_layout_proc_param')
+    assert_equal "<title>Request 1</title>\n#{cached_time}", @response.body
+    assert_equal cached_time, read_fragment("hostname.com/action_caching_test/with_layout_proc_param")
 
-    get :with_layout_proc_param, layout: false
+    get :with_layout_proc_param, params: { title: "Request 2", layout: "false" }
     assert_response :success
-    assert_not_equal cached_time, @response.body
-    body = body_to_string(read_fragment('hostname.com/action_caching_test/with_layout_proc_param'))
-    assert_equal cached_time, body
+    assert_equal "<title>Request 2</title>\n#{cached_time}", @response.body
+    assert_equal cached_time, read_fragment("hostname.com/action_caching_test/with_layout_proc_param")
   end
 
   def test_action_cache_with_layout_and_layout_cache_true_via_proc
-    get :with_layout_proc_param, layout: true
+    draw do
+      get "/action_caching_test/with_layout_proc_param", to: "action_caching_test#with_layout_proc_param"
+    end
+
+    get :with_layout_proc_param, params: { title: "Request 1", layout: "true" }
     assert_response :success
     cached_time = content_to_cache
-    assert_not_equal cached_time, @response.body
-    assert fragment_exist?('hostname.com/action_caching_test/with_layout_proc_param')
+    assert_equal "<title>Request 1</title>\n#{cached_time}", @response.body
+    assert_equal "<title>Request 1</title>\n#{cached_time}", read_fragment("hostname.com/action_caching_test/with_layout_proc_param")
 
-    get :with_layout_proc_param, layout: true
+    get :with_layout_proc_param, params: { title: "Request 2", layout: "true" }
     assert_response :success
-    assert_not_equal cached_time, @response.body
-    body = body_to_string(read_fragment('hostname.com/action_caching_test/with_layout_proc_param'))
-    assert_equal @response.body, body
+    assert_equal "<title>Request 1</title>\n#{cached_time}", @response.body
+    assert_equal "<title>Request 1</title>\n#{cached_time}", read_fragment("hostname.com/action_caching_test/with_layout_proc_param")
   end
 
   def test_action_cache_conditional_options
-    @request.env['HTTP_ACCEPT'] = 'application/json'
+    draw do
+      get "/action_caching_test", to: "action_caching_test#index"
+    end
+
+    @request.accept = "application/json"
     get :index
     assert_response :success
-    assert !fragment_exist?('hostname.com/action_caching_test')
+    assert !fragment_exist?("hostname.com/action_caching_test")
   end
 
   def test_action_cache_with_format_and_http_param
-    get :with_format_and_http_param, format: 'json'
+    draw do
+      get "/action_caching_test/with_format_and_http_param", to: "action_caching_test#with_format_and_http_param"
+    end
+
+    get :with_format_and_http_param, format: "json"
+    assert_response :success
+    assert !fragment_exist?("hostname.com/action_caching_test/with_format_and_http_param.json?key=value.json")
+    assert fragment_exist?("hostname.com/action_caching_test/with_format_and_http_param.json?key=value")
+  end
+
+  def test_action_cache_with_symbol_format
+    draw do
+      get "/action_caching_test/with_symbol_format", to: "action_caching_test#with_symbol_format"
+    end
+
+    get :with_symbol_format
+    assert_response :success
+    assert !fragment_exist?("test.host/action_caching_test/with_symbol_format")
+    assert fragment_exist?("test.host/action_caching_test/with_symbol_format.json")
+  end
+
+  def test_action_cache_not_url_cache_path
+    draw do
+      get "/action_caching_test/not_url_cache_path", to: "action_caching_test#not_url_cache_path"
+    end
+
+    get :not_url_cache_path
     assert_response :success
-    assert !fragment_exist?('hostname.com/action_caching_test/with_format_and_http_param.json?key=value.json')
-    assert fragment_exist?('hostname.com/action_caching_test/with_format_and_http_param.json?key=value')
+    assert !fragment_exist?("test.host/action_caching_test/not_url_cache_path")
+    assert fragment_exist?("not_url_cache_path_key")
   end
 
   def test_action_cache_with_store_options
-    MockTime.expects(:now).returns(12345).once
-    @controller.expects(:read_fragment).with('hostname.com/action_caching_test', expires_in: 1.hour).once
-    @controller.expects(:write_fragment).with('hostname.com/action_caching_test', '12345.0', expires_in: 1.hour).once
+    draw do
+      get "/action_caching_test", to: "action_caching_test#index"
+    end
+
+    CacheContent.expects(:to_s).returns('12345.0').once
+    @controller.expects(:read_fragment).with("hostname.com/action_caching_test", expires_in: 1.hour).once
+    @controller.expects(:write_fragment).with("hostname.com/action_caching_test", "12345.0", expires_in: 1.hour).once
     get :index
     assert_response :success
   end
 
   def test_action_cache_with_custom_cache_path
+    draw do
+      get "/action_caching_test/show", to: "action_caching_test#show"
+    end
+
     get :show
     assert_response :success
     cached_time = content_to_cache
     assert_equal cached_time, @response.body
-    assert fragment_exist?('test.host/custom/show')
+    assert fragment_exist?("test.host/custom/show")
 
     get :show
     assert_response :success
@@ -282,16 +416,53 @@ class ActionCacheTest < ActionController::TestCase
   end
 
   def test_action_cache_with_custom_cache_path_in_block
+    draw do
+      get "/action_caching_test/edit(/:id)", to: "action_caching_test#edit"
+    end
+
     get :edit
     assert_response :success
-    assert fragment_exist?('test.host/edit')
+    assert fragment_exist?("test.host/edit")
+
+    get :edit, params: { id: 1 }
+    assert_response :success
+    assert fragment_exist?("test.host/1;edit")
+  end
+
+  def test_action_cache_with_custom_cache_path_with_custom_object
+    draw do
+      get "/action_caching_test/custom_cache_path(/:id)", to: "action_caching_test#custom_cache_path"
+    end
+
+    get :custom_cache_path
+    assert_response :success
+    assert fragment_exist?("controller")
+
+    get :custom_cache_path, params: { id: 1 }
+    assert_response :success
+    assert fragment_exist?("controller-1")
+  end
+
+  def test_action_cache_with_symbol_cache_path
+    draw do
+      get "/action_caching_test/symbol_cache_path(/:id)", to: "action_caching_test#symbol_cache_path"
+    end
+
+    get :symbol_cache_path
+    assert_response :success
+    assert fragment_exist?("controller")
 
-    get :edit, id: 1
+    get :symbol_cache_path, params: { id: 1 }
     assert_response :success
-    assert fragment_exist?('test.host/1;edit')
+    assert fragment_exist?("controller-1")
   end
 
   def test_cache_expiration
+    draw do
+      get "/action_caching_test", to: "action_caching_test#index"
+      get "/action_caching_test/expire", to: "action_caching_test#expire"
+    end
+
     get :index
     assert_response :success
     cached_time = content_to_cache
@@ -314,6 +485,11 @@ class ActionCacheTest < ActionController::TestCase
   end
 
   def test_cache_expiration_isnt_affected_by_request_format
+    draw do
+      get "/action_caching_test", to: "action_caching_test#index"
+      get "/action_caching_test/expire", to: "action_caching_test#expire"
+    end
+
     get :index
     cached_time = content_to_cache
 
@@ -327,6 +503,11 @@ class ActionCacheTest < ActionController::TestCase
   end
 
   def test_cache_expiration_with_url_string
+    draw do
+      get "/action_caching_test", to: "action_caching_test#index"
+      get "/action_caching_test/expire_with_url_string", to: "action_caching_test#expire_with_url_string"
+    end
+
     get :index
     cached_time = content_to_cache
 
@@ -340,29 +521,38 @@ class ActionCacheTest < ActionController::TestCase
   end
 
   def test_cache_is_scoped_by_subdomain
-    @request.host = 'jamis.hostname.com'
+    draw do
+      get "/action_caching_test", to: "action_caching_test#index"
+    end
+
+    @request.host = "jamis.hostname.com"
     get :index
     assert_response :success
     jamis_cache = content_to_cache
 
-    @request.host = 'david.hostname.com'
+    @request.host = "david.hostname.com"
     get :index
     assert_response :success
     david_cache = content_to_cache
     assert_not_equal jamis_cache, @response.body
 
-    @request.host = 'jamis.hostname.com'
+    @request.host = "jamis.hostname.com"
     get :index
     assert_response :success
     assert_equal jamis_cache, @response.body
 
-    @request.host = 'david.hostname.com'
+    @request.host = "david.hostname.com"
     get :index
     assert_response :success
     assert_equal david_cache, @response.body
   end
 
   def test_redirect_is_not_cached
+    draw do
+      get "/action_caching_test", to: "action_caching_test#index"
+      get "/action_caching_test/redirected", to: "action_caching_test#redirected"
+    end
+
     get :redirected
     assert_response :redirect
     get :redirected
@@ -370,6 +560,10 @@ class ActionCacheTest < ActionController::TestCase
   end
 
   def test_forbidden_is_not_cached
+    draw do
+      get "/action_caching_test/forbidden", to: "action_caching_test#forbidden"
+    end
+
     get :forbidden
     assert_response :forbidden
     get :forbidden
@@ -377,71 +571,103 @@ class ActionCacheTest < ActionController::TestCase
   end
 
   def test_xml_version_of_resource_is_treated_as_different_cache
-    with_routing do |set|
-      set.draw do
-        get ':controller(/:action(.:format))'
-      end
+    draw do
+      get "/action_caching_test/index", to: "action_caching_test#index"
+      get "/action_caching_test/expire_xml", to: "action_caching_test#expire_xml"
+    end
 
-      get :index, format: 'xml'
-      assert_response :success
-      cached_time = content_to_cache
-      assert_equal cached_time, @response.body
-      assert fragment_exist?('hostname.com/action_caching_test/index.xml')
+    get :index, format: "xml"
+    assert_response :success
+    cached_time = content_to_cache
+    assert_equal cached_time, @response.body
+    assert fragment_exist?("hostname.com/action_caching_test/index.xml")
 
-      get :index, format: 'xml'
-      assert_response :success
-      assert_equal cached_time, @response.body
-      assert_equal 'application/xml', @response.content_type
+    get :index, format: "xml"
+    assert_cached(cached_time, "application/xml")
 
-      get :expire_xml
-      assert_response :success
+    get :expire_xml
+    assert_response :success
 
-      get :index, format: 'xml'
-      assert_response :success
-      assert_not_equal cached_time, @response.body
-    end
+    get :index, format: "xml"
+    assert_response :success
+    assert_not_equal cached_time, @response.body
   end
 
   def test_correct_content_type_is_returned_for_cache_hit
+    draw do
+      get "/action_caching_test/index/:id", to: "action_caching_test#index"
+    end
+
     # run it twice to cache it the first time
-    get :index, id: 'content-type', format: 'xml'
-    get :index, id: 'content-type', format: 'xml'
+    get :index, params: { id: "content-type" }, format: "xml"
+    get :index, params: { id: "content-type" }, format: "xml"
     assert_response :success
-    assert_equal 'application/xml', @response.content_type
+
+    if @response.respond_to?(:media_type)
+      assert_equal "application/xml", @response.media_type
+    else
+      assert_equal "application/xml", @response.content_type
+    end
   end
 
   def test_correct_content_type_is_returned_for_cache_hit_on_action_with_string_key
+    draw do
+      get "/action_caching_test/show", to: "action_caching_test#show"
+    end
+
     # run it twice to cache it the first time
-    get :show, format: 'xml'
-    get :show, format: 'xml'
+    get :show, format: "xml"
+    get :show, format: "xml"
     assert_response :success
-    assert_equal 'application/xml', @response.content_type
+
+    if @response.respond_to?(:media_type)
+      assert_equal "application/xml", @response.media_type
+    else
+      assert_equal "application/xml", @response.content_type
+    end
   end
 
   def test_correct_content_type_is_returned_for_cache_hit_on_action_with_string_key_from_proc
+    draw do
+      get "/action_caching_test/edit/:id", to: "action_caching_test#edit"
+    end
+
     # run it twice to cache it the first time
-    get :edit, id: 1, format: 'xml'
-    get :edit, id: 1, format: 'xml'
+    get :edit, params: { id: 1 }, format: "xml"
+    get :edit, params: { id: 1 }, format: "xml"
     assert_response :success
-    assert_equal 'application/xml', @response.content_type
+
+    if @response.respond_to?(:media_type)
+      assert_equal "application/xml", @response.media_type
+    else
+      assert_equal "application/xml", @response.content_type
+    end
   end
 
   def test_empty_path_is_normalized
-    @mock_controller.mock_url_for = 'http://example.org/'
-    @mock_controller.mock_path    = '/'
+    @mock_controller.mock_url_for = "http://example.org/"
+    @mock_controller.mock_path    = "/"
 
-    assert_equal 'example.org/index', @path_class.new(@mock_controller, {}).path
+    assert_equal "example.org/index", @path_class.new(@mock_controller, {}).path
   end
 
   def test_file_extensions
-    get :index, id: 'kitten.jpg'
-    get :index, id: 'kitten.jpg'
+    draw do
+      get "/action_caching_test/index/*id", to: "action_caching_test#index", format: false
+    end
+
+    get :index, params: { id: "kitten.jpg" }
+    get :index, params: { id: "kitten.jpg" }
 
     assert_response :success
   end
 
   if defined? ActiveRecord
     def test_record_not_found_returns_404_for_multiple_requests
+      draw do
+        get "/action_caching_test/record_not_found", to: "action_caching_test#record_not_found"
+      end
+
       get :record_not_found
       assert_response 404
       get :record_not_found
@@ -450,6 +676,10 @@ class ActionCacheTest < ActionController::TestCase
   end
 
   def test_four_oh_four_returns_404_for_multiple_requests
+    draw do
+      get "/action_caching_test/four_oh_four", to: "action_caching_test#four_oh_four"
+    end
+
     get :four_oh_four
     assert_response 404
     get :four_oh_four
@@ -457,11 +687,19 @@ class ActionCacheTest < ActionController::TestCase
   end
 
   def test_four_oh_four_renders_content
+    draw do
+      get "/action_caching_test/four_oh_four", to: "action_caching_test#four_oh_four"
+    end
+
     get :four_oh_four
     assert_equal "404'd!", @response.body
   end
 
   def test_simple_runtime_error_returns_500_for_multiple_requests
+    draw do
+      get "/action_caching_test/simple_runtime_error", to: "action_caching_test#simple_runtime_error"
+    end
+
     get :simple_runtime_error
     assert_response 500
     get :simple_runtime_error
@@ -469,35 +707,187 @@ class ActionCacheTest < ActionController::TestCase
   end
 
   def test_action_caching_plus_streaming
+    draw do
+      get "/action_caching_test/streaming", to: "action_caching_test#streaming"
+    end
+
     get :streaming
     assert_response :success
     assert_match(/streaming/, @response.body)
-    assert fragment_exist?('hostname.com/action_caching_test/streaming')
+    assert fragment_exist?("hostname.com/action_caching_test/streaming")
   end
 
   def test_invalid_format_returns_not_acceptable
-    get :invalid, format: 'json'
+    draw do
+      get "/action_caching_test/invalid", to: "action_caching_test#invalid"
+    end
+
+    get :invalid, format: "json"
     assert_response :success
     cached_time = content_to_cache
     assert_equal cached_time, @response.body
 
     assert fragment_exist?("hostname.com/action_caching_test/invalid.json")
 
-    get :invalid, format: 'json'
+    get :invalid, format: "json"
     assert_response :success
     assert_equal cached_time, @response.body
 
-    get :invalid, format: 'xml'
+    get :invalid, format: "xml"
     assert_response :not_acceptable
 
-    get :invalid, format: '\xC3\x83'
+    get :invalid, format: "\xC3\x83"
     assert_response :not_acceptable
   end
 
+  def test_format_from_accept_header
+    draw do
+      get "/action_caching_test/accept", to: "action_caching_test#accept"
+      get "/action_caching_test/accept/expire", to: "action_caching_test#expire_accept"
+    end
+
+    # Cache the JSON format
+    get_json :accept
+    json_cached_time = content_to_cache
+    assert_cached json_cached_time, "application/json"
+
+    # Check that the JSON format is cached
+    get_json :accept
+    assert_cached json_cached_time, "application/json"
+
+    # Cache the HTML format
+    get_html :accept
+    html_cached_time = content_to_cache
+    assert_cached html_cached_time
+
+    # Check that it's not the JSON format
+    assert_not_equal json_cached_time, @response.body
+
+    # Check that the HTML format is cached
+    get_html :accept
+    assert_cached html_cached_time
+
+    # Check that the JSON format is still cached
+    get_json :accept
+    assert_cached json_cached_time, "application/json"
+
+    # Expire the JSON format
+    get_json :expire_accept
+    assert_response :success
+
+    # Check that the HTML format is still cached
+    get_html :accept
+    assert_cached html_cached_time
+
+    # Check the JSON format was expired
+    get_json :accept
+    new_json_cached_time = content_to_cache
+    assert_cached new_json_cached_time, "application/json"
+    assert_not_equal json_cached_time, @response.body
+
+    # Expire the HTML format
+    get_html :expire_accept
+    assert_response :success
+
+    # Check that the JSON format is still cached
+    get_json :accept
+    assert_cached new_json_cached_time, "application/json"
+
+    # Check the HTML format was expired
+    get_html :accept
+    new_html_cached_time = content_to_cache
+    assert_cached new_html_cached_time
+    assert_not_equal html_cached_time, @response.body
+  end
+
+  def test_explicit_html_format_is_used_for_fragment_path
+    draw do
+      get "/action_caching_test/accept", to: "action_caching_test#accept"
+      get "/action_caching_test/accept/expire", to: "action_caching_test#expire_accept"
+    end
+
+    get :accept, format: "html"
+    cached_time = content_to_cache
+    assert_cached cached_time
+
+    assert fragment_exist?("hostname.com/action_caching_test/accept.html")
+
+    get :accept, format: "html"
+    cached_time = content_to_cache
+    assert_cached cached_time
+
+    get :expire_accept, format: "html"
+    assert_response :success
+
+    assert !fragment_exist?("hostname.com/action_caching_test/accept.html")
+
+    get :accept, format: "html"
+    assert_not_cached cached_time
+  end
+
+  def test_lambda_arity_with_cache_path
+    draw do
+      get "/action_caching_test/not_url_cache_path_no_args", to: "action_caching_test#not_url_cache_path_no_args"
+    end
+
+    get :not_url_cache_path_no_args
+    assert_response :success
+    assert !fragment_exist?("test.host/action_caching_test/not_url_cache_path_no_args")
+    assert fragment_exist?("not_url_cache_path_no_args_key")
+  end
+
+  def test_lambda_arity_with_layout
+    draw do
+      get "/action_caching_test/with_layout_proc_param_no_args", to: "action_caching_test#with_layout_proc_param_no_args"
+    end
+
+    get :with_layout_proc_param_no_args, params: { title: "Request 1", layout: "false" }
+    assert_response :success
+    cached_time = content_to_cache
+    assert_equal "<title>Request 1</title>\n#{cached_time}", @response.body
+    assert_equal cached_time, read_fragment("hostname.com/action_caching_test/with_layout_proc_param_no_args")
+
+    get :with_layout_proc_param_no_args, params: { title: "Request 2", layout: "false" }
+    assert_response :success
+    assert_equal "<title>Request 2</title>\n#{cached_time}", @response.body
+    assert_equal cached_time, read_fragment("hostname.com/action_caching_test/with_layout_proc_param_no_args")
+  end
+
   private
+    def get_html(*args)
+      @request.accept = "text/html"
+      get(*args)
+    end
+
+    def get_json(*args)
+      @request.accept = "application/json"
+      get(*args)
+    end
+
+    def assert_cached(cache_time, media_type = "text/html")
+      assert_response :success
+      assert_equal cache_time, @response.body
+
+      if @response.respond_to?(:media_type)
+        assert_equal media_type, @response.media_type
+      else
+        assert_equal media_type, @response.content_type
+      end
+    end
+
+    def assert_not_cached(cache_time, media_type = "text/html")
+      assert_response :success
+      assert_not_equal cache_time, @response.body
+
+      if @response.respond_to?(:media_type)
+        assert_equal media_type, @response.media_type
+      else
+        assert_equal media_type, @response.content_type
+      end
+    end
 
     def content_to_cache
-      assigns(:cache_this)
+      @controller.instance_variable_get(:@cache_this)
     end
 
     def fragment_exist?(path)
@@ -507,4 +897,21 @@ class ActionCacheTest < ActionController::TestCase
     def read_fragment(path)
       @controller.read_fragment(path)
     end
+
+    def draw(&block)
+      @routes = ActionDispatch::Routing::RouteSet.new
+      @routes.draw(&block)
+      @controller.extend(@routes.url_helpers)
+    end
+
+    if ActionPack::VERSION::STRING < "5.0"
+      def get(action, options = {})
+        format = options.slice(:format)
+        params = options[:params] || {}
+        session = options[:session] || {}
+        flash = options[:flash] || {}
+
+        super(action, params.merge(format), session, flash)
+      end
+    end
 end