actionpack-page_caching 1.0.2 → 1.1.0

data/gemfiles/Gemfile-4-1-stable

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "rails", github: "rails/rails", branch: "4-1-stable"
+gem "mime-types", "< 3"

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-edge

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

data/lib/action_controller/caching/pages.rb

@@ -1,5 +1,7 @@
-require 'fileutils'
-require 'active_support/core_ext/class/attribute_accessors'
+require "fileutils"
+require "uri"
+require "active_support/core_ext/class/attribute_accessors"
+require "active_support/core_ext/string/strip"
 
 module ActionController
   module Caching
@@ -32,8 +34,8 @@ module ActionController
     #   class WeblogController < ActionController::Base
     #     def update
     #       List.update(params[:list][:id], params[:list])
-    #       expire_page action: 'show', id: params[:list][:id]
-    #       redirect_to action: 'show', id: params[:list][:id]
+    #       expire_page action: "show", id: params[:list][:id]
+    #       redirect_to action: "show", id: params[:list][:id]
     #     end
     #   end
     #
@@ -51,7 +53,7 @@ module ActionController
         # likely require configuring your web server to look in the new location for
         # cached files.
         class_attribute :page_cache_directory
-        self.page_cache_directory ||= ''
+        self.page_cache_directory ||= ""
 
         # The compression used for gzip. If +false+ (default), the page is not compressed.
         # If can be a symbol showing the ZLib compression method, for example, <tt>:best_compression</tt>
@@ -60,33 +62,137 @@ module ActionController
         self.page_cache_compression ||= false
       end
 
+      class PageCache #:nodoc:
+        def initialize(cache_directory, default_extension, controller = nil)
+          @cache_directory = cache_directory
+          @default_extension = default_extension
+          @controller = controller
+        end
+
+        def expire(path)
+          instrument :expire_page, path do
+            delete(cache_path(path))
+          end
+        end
+
+        def cache(content, path, extension = nil, gzip = Zlib::BEST_COMPRESSION)
+          instrument :write_page, path do
+            write(content, cache_path(path, extension), gzip)
+          end
+        end
+
+        private
+          def cache_directory
+            case @cache_directory
+            when Proc
+              handle_proc_cache_directory
+            when Symbol
+              handle_symbol_cache_directory
+            else
+              handle_default_cache_directory
+            end
+          end
+
+          def handle_proc_cache_directory
+            if @controller
+              @controller.instance_exec(&@cache_directory)
+            else
+              raise_runtime_error
+            end
+          end
+
+          def handle_symbol_cache_directory
+            if @controller
+              @controller.send(@cache_directory)
+            else
+              raise_runtime_error
+            end
+          end
+
+          def handle_callable_cache_directory
+            if @controller
+              @cache_directory.call(@controller.request)
+            else
+              raise_runtime_error
+            end
+          end
+
+          def handle_default_cache_directory
+            if @cache_directory.respond_to?(:call)
+              handle_callable_cache_directory
+            else
+              @cache_directory.to_s
+            end
+          end
+
+          def raise_runtime_error
+            raise RuntimeError, <<-MSG.strip_heredoc
+              Dynamic page_cache_directory used with class-level cache_page method
+
+              You have specified either a Proc, Symbol or callable object for page_cache_directory
+              which needs to be executed within the context of a request. If you need to call the
+              cache_page method from a class-level context then set the page_cache_directory to a
+              static value and override the setting at the instance-level using before_action.
+            MSG
+          end
+
+          def default_extension
+            @default_extension
+          end
+
+          def cache_file(path, extension)
+            if path.empty? || path == "/"
+              name = "/index"
+            else
+              name = URI.parser.unescape(path.chomp("/"))
+            end
+
+            if File.extname(name).empty?
+              name + (extension || default_extension)
+            else
+              name
+            end
+          end
+
+          def cache_path(path, extension = nil)
+            File.join(cache_directory, cache_file(path, extension))
+          end
+
+          def delete(path)
+            File.delete(path) if File.exist?(path)
+            File.delete(path + ".gz") if File.exist?(path + ".gz")
+          end
+
+          def write(content, path, gzip)
+            FileUtils.makedirs(File.dirname(path))
+            File.open(path, "wb+") { |f| f.write(content) }
+
+            if gzip
+              Zlib::GzipWriter.open(path + ".gz", gzip) { |f| f.write(content) }
+            end
+          end
+
+          def instrument(name, path)
+            ActiveSupport::Notifications.instrument("#{name}.action_controller", path: path) { yield }
+          end
+      end
+
       module ClassMethods
         # Expires the page that was cached with the +path+ as a key.
         #
-        #   expire_page '/lists/show'
+        #   expire_page "/lists/show"
         def expire_page(path)
-          return unless perform_caching
-          path = page_cache_path(path)
-
-          instrument_page_cache :expire_page, path do
-            File.delete(path) if File.exist?(path)
-            File.delete(path + '.gz') if File.exist?(path + '.gz')
+          if perform_caching
+            page_cache.expire(path)
           end
         end
 
         # Manually cache the +content+ in the key determined by +path+.
         #
-        #   cache_page "I'm the cached content", '/lists/show'
+        #   cache_page "I'm the cached content", "/lists/show"
         def cache_page(content, path, extension = nil, gzip = Zlib::BEST_COMPRESSION)
-          return unless perform_caching
-          path = page_cache_path(path, extension)
-
-          instrument_page_cache :write_page, path do
-            FileUtils.makedirs(File.dirname(path))
-            File.open(path, 'wb+') { |f| f.write(content) }
-            if gzip
-              Zlib::GzipWriter.open(path + '.gz', gzip) { |f| f.write(content) }
-            end
+          if perform_caching
+            page_cache.cache(content, path, extension, gzip)
           end
         end
 
@@ -105,60 +211,50 @@ module ActionController
         #   # don't gzip images
         #   caches_page :image, gzip: false
         def caches_page(*actions)
-          return unless perform_caching
-          options = actions.extract_options!
-
-          gzip_level = options.fetch(:gzip, page_cache_compression)
-          gzip_level = case gzip_level
-          when Symbol
-            Zlib.const_get(gzip_level.upcase)
-          when Fixnum
-            gzip_level
-          when false
-            nil
-          else
-            Zlib::BEST_COMPRESSION
-          end
+          if perform_caching
+            options = actions.extract_options!
 
-          after_filter({only: actions}.merge(options)) do |c|
-            c.cache_page(nil, nil, gzip_level)
-          end
-        end
+            gzip_level = options.fetch(:gzip, page_cache_compression)
+            gzip_level = \
+              case gzip_level
+              when Symbol
+                Zlib.const_get(gzip_level.upcase)
+              when Integer
+                gzip_level
+              when false
+                nil
+              else
+                Zlib::BEST_COMPRESSION
+              end
 
-        private
-          def page_cache_file(path, extension)
-            name = (path.empty? || path == '/') ? '/index' : URI.parser.unescape(path.chomp('/'))
-            unless (name.split('/').last || name).include? '.'
-              name << (extension || self.default_static_extension)
+            after_action({ only: actions }.merge(options)) do |c|
+              c.cache_page(nil, nil, gzip_level)
             end
-            return name
-          end
-
-          def page_cache_path(path, extension = nil)
-            page_cache_directory.to_s + page_cache_file(path, extension)
           end
+        end
 
-          def instrument_page_cache(name, path)
-            ActiveSupport::Notifications.instrument("#{name}.action_controller", path: path){ yield }
+        private
+          def page_cache
+            PageCache.new(page_cache_directory, default_static_extension)
           end
       end
 
       # Expires the page that was cached with the +options+ as a key.
       #
-      #   expire_page controller: 'lists', action: 'show'
+      #   expire_page controller: "lists", action: "show"
       def expire_page(options = {})
-        return unless self.class.perform_caching
-
-        if options.is_a?(Hash)
-          if options[:action].is_a?(Array)
-            options[:action].each do |action|
-              self.class.expire_page(url_for(options.merge(only_path: true, action: action)))
+        if perform_caching?
+          case options
+          when Hash
+            case options[:action]
+            when Array
+              options[:action].each { |action| expire_page(options.merge(action: action)) }
+            else
+              page_cache.expire(url_for(options.merge(only_path: true)))
             end
           else
-            self.class.expire_page(url_for(options.merge(only_path: true)))
+            page_cache.expire(options)
           end
-        else
-          self.class.expire_page(options)
         end
       end
 
@@ -166,29 +262,39 @@ module ActionController
       # the contents of response.body is used. If no options are provided, the url of the current
       # request being handled is used.
       #
-      #   cache_page "I'm the cached content", controller: 'lists', action: 'show'
+      #   cache_page "I'm the cached content", controller: "lists", action: "show"
       def cache_page(content = nil, options = nil, gzip = Zlib::BEST_COMPRESSION)
-        return unless self.class.perform_caching && caching_allowed?
+        if perform_caching? && caching_allowed?
+          path = \
+            case options
+            when Hash
+              url_for(options.merge(only_path: true, format: params[:format]))
+            when String
+              options
+            else
+              request.path
+            end
 
-        path = case options
-          when Hash
-            url_for(options.merge(only_path: true, format: params[:format]))
-          when String
-            options
-          else
-            request.path
-        end
+          if (type = Mime::LOOKUP[self.content_type]) && (type_symbol = type.symbol).present?
+            extension = ".#{type_symbol}"
+          end
 
-        if (type = Mime::LOOKUP[self.content_type]) && (type_symbol = type.symbol).present?
-          extension = ".#{type_symbol}"
+          page_cache.cache(content || response.body, path, extension, gzip)
         end
-
-        self.class.cache_page(content || response.body, path, extension, gzip)
       end
 
       def caching_allowed?
         (request.get? || request.head?) && response.status == 200
       end
+
+      def perform_caching?
+        self.class.perform_caching
+      end
+
+      private
+        def page_cache
+          PageCache.new(page_cache_directory, default_static_extension, self)
+        end
     end
   end
 end

data/lib/action_controller/page_caching.rb

@@ -1,4 +1,4 @@
-require 'action_controller/caching/pages'
+require "action_controller/caching/pages"
 
 module ActionController
   module Caching

data/lib/actionpack/page_caching.rb

@@ -1 +1 @@
-require 'actionpack/page_caching/railtie'
+require "actionpack/page_caching/railtie"

data/lib/actionpack/page_caching/railtie.rb

@@ -1,16 +1,16 @@
-require 'rails/railtie'
+require "rails/railtie"
 
 module ActionPack
   module PageCaching
     class Railtie < Rails::Railtie
-      initializer 'action_pack.page_caching' do
+      initializer "action_pack.page_caching" do
         ActiveSupport.on_load(:action_controller) do
-          require 'action_controller/page_caching'
+          require "action_controller/page_caching"
         end
       end
 
-      initializer 'action_pack.page_caching.set_config', before: 'action_controller.set_configs' do |app|
-        app.config.action_controller.page_cache_directory ||= app.config.paths['public'].first
+      initializer "action_pack.page_caching.set_config", before: "action_controller.set_configs" do |app|
+        app.config.action_controller.page_cache_directory ||= app.config.paths["public"].first
       end
     end
   end

data/test/abstract_unit.rb

@@ -1,22 +1,12 @@
-require 'bundler/setup'
-require 'minitest/autorun'
-require 'action_controller'
-require 'action_controller/page_caching'
+require "bundler/setup"
+require "minitest/autorun"
+require "action_controller"
+require "action_controller/page_caching"
 
-SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
-
-module ActionController
-  class Base
-    include SharedTestRoutes.url_helpers
-  end
-
-  class TestCase
-    def setup
-      @routes = SharedTestRoutes
+if ActiveSupport.respond_to?(:test_order)
+  ActiveSupport.test_order = :random
+end
 
-      @routes.draw do
-        get ':controller(/:action)'
-      end
-    end
-  end
+if ActionController::Base.respond_to?(:enable_fragment_cache_logging=)
+  ActionController::Base.enable_fragment_cache_logging = true
 end

data/test/caching_test.rb

@@ -1,12 +1,69 @@
-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)
+
+module PageCachingTestHelpers
+  def setup
+    super
+
+    @routes = ActionDispatch::Routing::RouteSet.new
+
+    FileUtils.rm_rf(File.dirname(FILE_STORE_PATH))
+    FileUtils.mkdir_p(FILE_STORE_PATH)
+  end
+
+  def teardown
+    super
+
+    FileUtils.rm_rf(File.dirname(FILE_STORE_PATH))
+    @controller.perform_caching = false
+  end
+
+  private
+
+    def assert_page_cached(action, options = {})
+      expected = options[:content] || action.to_s
+      path = cache_file(action, options)
+
+      assert File.exist?(path), "The cache file #{path} doesn't exist"
+
+      if File.extname(path) == ".gz"
+        actual = Zlib::GzipReader.open(path) { |f| f.read }
+      else
+        actual = File.read(path)
+      end
+
+      assert_equal expected, actual, "The cached content doesn't match the expected value"
+    end
+
+    def assert_page_not_cached(action, options = {})
+      path = cache_file(action, options)
+      assert !File.exist?(path), "The cache file #{path} still exists"
+    end
+
+    def cache_file(action, options = {})
+      path = options[:path] || FILE_STORE_PATH
+      controller = options[:controller] || self.class.name.underscore
+      format = options[:format] || "html"
+
+      "#{path}/#{controller}/#{action}.#{format}"
+    end
+
+    def draw(&block)
+      @routes = ActionDispatch::Routing::RouteSet.new
+      @routes.draw(&block)
+      @controller.extend(@routes.url_helpers)
+    end
+end
 
 class CachingMetalController < ActionController::Metal
   abstract!
 
+  include AbstractController::Callbacks
   include ActionController::Caching
 
   self.page_cache_directory = FILE_STORE_PATH
@@ -17,28 +74,22 @@ class PageCachingMetalTestController < CachingMetalController
   caches_page :ok
 
   def ok
-    self.response_body = 'ok'
+    self.response_body = "ok"
   end
 end
 
 class PageCachingMetalTest < ActionController::TestCase
+  include PageCachingTestHelpers
   tests PageCachingMetalTestController
 
-  def setup
-    super
-
-    FileUtils.rm_rf(File.dirname(FILE_STORE_PATH))
-    FileUtils.mkdir_p(FILE_STORE_PATH)
-  end
-
-  def teardown
-    FileUtils.rm_rf(File.dirname(FILE_STORE_PATH))
-  end
-
   def test_should_cache_get_with_ok_status
+    draw do
+      get "/page_caching_metal_test/ok", to: "page_caching_metal_test#ok"
+    end
+
     get :ok
     assert_response :ok
-    assert File.exist?("#{FILE_STORE_PATH}/page_caching_metal_test/ok.html"), 'get with ok status should have been cached'
+    assert_page_cached :ok
   end
 end
 
@@ -48,6 +99,17 @@ class CachingController < ActionController::Base
   abstract!
 
   self.cache_store = :file_store, FILE_STORE_PATH
+
+  protected
+    if ActionPack::VERSION::STRING < "4.1"
+      def render(options)
+        if options.key?(:html)
+          super({ text: options.delete(:html) }.merge(options))
+        else
+          super
+        end
+      end
+    end
 end
 
 class PageCachingTestController < CachingController
@@ -61,7 +123,7 @@ class PageCachingTestController < CachingController
   caches_page :gzip_level, gzip: :best_speed
 
   def ok
-    head :ok
+    render html: "ok"
   end
 
   def no_content
@@ -69,7 +131,7 @@ class PageCachingTestController < CachingController
   end
 
   def found
-    redirect_to action: 'ok'
+    redirect_to action: "ok"
   end
 
   def not_found
@@ -77,170 +139,204 @@ class PageCachingTestController < CachingController
   end
 
   def custom_path
-    render text: 'Super soaker'
-    cache_page('Super soaker', '/index.html')
+    render html: "custom_path"
+    cache_page(nil, "/index.html")
   end
 
   def default_gzip
-    render text: 'Text'
+    render html: "default_gzip"
   end
 
   def no_gzip
-    render text: 'PNG'
+    render html: "no_gzip"
   end
 
   def gzip_level
-    render text: 'Big text'
+    render html: "gzip_level"
   end
 
   def expire_custom_path
-    expire_page('/index.html')
+    expire_page("/index.html")
     head :ok
   end
 
   def trailing_slash
-    render text: 'Sneak attack'
+    render html: "trailing_slash"
   end
 
   def about_me
     respond_to do |format|
-      format.html { render text: 'I am html' }
-      format.xml  { render text: 'I am xml'  }
+      format.html { render html: "I am html" }
+      format.xml  { render xml: "I am xml" }
     end
   end
 end
 
 class PageCachingTest < ActionController::TestCase
-  def setup
-    super
-
-    @request = ActionController::TestRequest.new
-    @request.host = 'hostname.com'
-    @request.env.delete('PATH_INFO')
+  include PageCachingTestHelpers
+  tests PageCachingTestController
 
-    @controller = PageCachingTestController.new
-    @controller.perform_caching = true
-    @controller.cache_store = :file_store, FILE_STORE_PATH
-
-    @response   = ActionController::TestResponse.new
+  def test_page_caching_resources_saves_to_correct_path_with_extension_even_if_default_route
+    draw do
+      get "posts.:format", to: "posts#index", as: :formatted_posts
+      get "/", to: "posts#index", as: :main
+    end
 
-    @params = { controller: 'posts', action: 'index', only_path: true }
+    defaults = { controller: "posts", action: "index", only_path: true }
 
-    FileUtils.rm_rf(File.dirname(FILE_STORE_PATH))
-    FileUtils.mkdir_p(FILE_STORE_PATH)
+    assert_equal "/posts.rss", @routes.url_for(defaults.merge(format: "rss"))
+    assert_equal "/", @routes.url_for(defaults.merge(format: nil))
   end
 
-  def teardown
-    FileUtils.rm_rf(File.dirname(FILE_STORE_PATH))
-    @controller.perform_caching = false
-  end
-
-  def test_page_caching_resources_saves_to_correct_path_with_extension_even_if_default_route
-    with_routing do |set|
-      set.draw do
-        get 'posts.:format', to: 'posts#index', as: :formatted_posts
-        get '/', to: 'posts#index', as: :main
-      end
-      @params[:format] = 'rss'
-      assert_equal '/posts.rss', @routes.url_for(@params)
-      @params[:format] = nil
-      assert_equal '/', @routes.url_for(@params)
+  def test_should_cache_head_with_ok_status
+    draw do
+      get "/page_caching_test/ok", to: "page_caching_test#ok"
     end
-  end
 
-  def test_should_cache_head_with_ok_status
     head :ok
     assert_response :ok
-    assert_page_cached :ok, 'head with ok status should have been cached'
+    assert_page_cached :ok
   end
 
   def test_should_cache_get_with_ok_status
+    draw do
+      get "/page_caching_test/ok", to: "page_caching_test#ok"
+    end
+
     get :ok
     assert_response :ok
-    assert_page_cached :ok, 'get with ok status should have been cached'
+    assert_page_cached :ok
   end
 
   def test_should_cache_with_custom_path
+    draw do
+      get "/page_caching_test/custom_path", to: "page_caching_test#custom_path"
+    end
+
     get :custom_path
-    assert File.exist?("#{FILE_STORE_PATH}/index.html")
+    assert_page_cached :index, controller: ".", content: "custom_path"
   end
 
   def test_should_expire_cache_with_custom_path
+    draw do
+      get "/page_caching_test/custom_path", to: "page_caching_test#custom_path"
+      get "/page_caching_test/expire_custom_path", to: "page_caching_test#expire_custom_path"
+    end
+
     get :custom_path
-    assert File.exist?("#{FILE_STORE_PATH}/index.html")
+    assert_page_cached :index, controller: ".", content: "custom_path"
 
     get :expire_custom_path
-    assert !File.exist?("#{FILE_STORE_PATH}/index.html")
+    assert_page_not_cached :index, controller: ".", content: "custom_path"
   end
 
   def test_should_gzip_cache
+    draw do
+      get "/page_caching_test/custom_path", to: "page_caching_test#custom_path"
+      get "/page_caching_test/expire_custom_path", to: "page_caching_test#expire_custom_path"
+    end
+
     get :custom_path
-    assert File.exist?("#{FILE_STORE_PATH}/index.html.gz")
+    assert_page_cached :index, controller: ".", format: "html.gz", content: "custom_path"
 
     get :expire_custom_path
-    assert !File.exist?("#{FILE_STORE_PATH}/index.html.gz")
+    assert_page_not_cached :index, controller: ".", format: "html.gz"
   end
 
   def test_should_allow_to_disable_gzip
+    draw do
+      get "/page_caching_test/no_gzip", to: "page_caching_test#no_gzip"
+    end
+
     get :no_gzip
-    assert File.exist?("#{FILE_STORE_PATH}/page_caching_test/no_gzip.html")
-    assert !File.exist?("#{FILE_STORE_PATH}/page_caching_test/no_gzip.html.gz")
+    assert_page_cached :no_gzip, format: "html"
+    assert_page_not_cached :no_gzip, format: "html.gz"
   end
 
   def test_should_use_config_gzip_by_default
+    draw do
+      get "/page_caching_test/default_gzip", to: "page_caching_test#default_gzip"
+    end
+
     @controller.expects(:cache_page).with(nil, nil, Zlib::BEST_COMPRESSION)
     get :default_gzip
   end
 
   def test_should_set_gzip_level
+    draw do
+      get "/page_caching_test/gzip_level", to: "page_caching_test#gzip_level"
+    end
+
     @controller.expects(:cache_page).with(nil, nil, Zlib::BEST_SPEED)
     get :gzip_level
   end
 
   def test_should_cache_without_trailing_slash_on_url
-    @controller.class.cache_page 'cached content', '/page_caching_test/trailing_slash'
-    assert File.exist?("#{FILE_STORE_PATH}/page_caching_test/trailing_slash.html")
+    @controller.class.cache_page "cached content", "/page_caching_test/trailing_slash"
+    assert_page_cached :trailing_slash, content: "cached content"
   end
 
   def test_should_obey_http_accept_attribute
-    @request.env['HTTP_ACCEPT'] = 'text/xml'
+    draw do
+      get "/page_caching_test/about_me", to: "page_caching_test#about_me"
+    end
+
+    @request.env["HTTP_ACCEPT"] = "text/xml"
     get :about_me
-    assert File.exist?("#{FILE_STORE_PATH}/page_caching_test/about_me.xml")
-    assert_equal 'I am xml', @response.body
+    assert_equal "I am xml", @response.body
+    assert_page_cached :about_me, format: "xml", content: "I am xml"
   end
 
   def test_cached_page_should_not_have_trailing_slash_even_if_url_has_trailing_slash
-    @controller.class.cache_page 'cached content', '/page_caching_test/trailing_slash/'
-    assert File.exist?("#{FILE_STORE_PATH}/page_caching_test/trailing_slash.html")
+    @controller.class.cache_page "cached content", "/page_caching_test/trailing_slash/"
+    assert_page_cached :trailing_slash, content: "cached content"
   end
 
   def test_should_cache_ok_at_custom_path
-    @request.env['PATH_INFO'] = '/index.html'
+    draw do
+      get "/page_caching_test/ok", to: "page_caching_test#ok"
+    end
+
+    @request.env["PATH_INFO"] = "/index.html"
     get :ok
     assert_response :ok
-    assert File.exist?("#{FILE_STORE_PATH}/index.html")
+    assert_page_cached :index, controller: ".", content: "ok"
   end
 
   [:ok, :no_content, :found, :not_found].each do |status|
     [:get, :post, :patch, :put, :delete].each do |method|
       unless method == :get && status == :ok
         define_method "test_shouldnt_cache_#{method}_with_#{status}_status" do
+          draw do
+            get "/page_caching_test/ok", to: "page_caching_test#ok"
+            match "/page_caching_test/#{status}", to: "page_caching_test##{status}", via: method
+          end
+
           send(method, status)
           assert_response status
-          assert_page_not_cached status, "#{method} with #{status} status shouldn't have been cached"
+          assert_page_not_cached status
         end
       end
     end
   end
 
   def test_page_caching_conditional_options
-    get :ok, format: 'json'
+    draw do
+      get "/page_caching_test/ok", to: "page_caching_test#ok"
+    end
+
+    get :ok, format: "json"
     assert_page_not_cached :ok
   end
 
   def test_page_caching_directory_set_as_pathname
     begin
       ActionController::Base.page_cache_directory = Pathname.new(FILE_STORE_PATH)
+
+      draw do
+        get "/page_caching_test/ok", to: "page_caching_test#ok"
+      end
+
       get :ok
       assert_response :ok
       assert_page_cached :ok
@@ -249,17 +345,180 @@ class PageCachingTest < ActionController::TestCase
     end
   end
 
-  private
+  def test_page_caching_directory_set_on_controller_instance
+    draw do
+      get "/page_caching_test/ok", to: "page_caching_test#ok"
+    end
+
+    file_store_path = File.join(TEST_TMP_DIR, "instance_cache")
+    @controller.page_cache_directory = file_store_path
+
+    get :ok
+    assert_response :ok
+    assert_page_cached :ok, path: file_store_path
+  end
+end
+
+class ProcPageCachingTestController < CachingController
+  self.page_cache_directory = -> { File.join(TEST_TMP_DIR, request.domain) }
+
+  caches_page :ok
+
+  def ok
+    render html: "ok"
+  end
+
+  def expire_ok
+    expire_page action: :ok
+    head :ok
+  end
+end
+
+class ProcPageCachingTest < ActionController::TestCase
+  include PageCachingTestHelpers
+  tests ProcPageCachingTestController
+
+  def test_page_is_cached_by_domain
+    draw do
+      get "/proc_page_caching_test/ok", to: "proc_page_caching_test#ok"
+      get "/proc_page_caching_test/ok/expire", to: "proc_page_caching_test#expire_ok"
+    end
+
+    @request.env["HTTP_HOST"] = "www.foo.com"
+    get :ok
+    assert_response :ok
+    assert_page_cached :ok, path: TEST_TMP_DIR + "/foo.com"
+
+    get :expire_ok
+    assert_response :ok
+    assert_page_not_cached :ok, path: TEST_TMP_DIR + "/foo.com"
+
+    @request.env["HTTP_HOST"] = "www.bar.com"
+    get :ok
+    assert_response :ok
+    assert_page_cached :ok, path: TEST_TMP_DIR + "/bar.com"
+
+    get :expire_ok
+    assert_response :ok
+    assert_page_not_cached :ok, path: TEST_TMP_DIR + "/bar.com"
+  end
+
+  def test_class_level_cache_page_raise_error
+    assert_raises(RuntimeError, /class-level cache_page method/) do
+      @controller.class.cache_page "cached content", "/proc_page_caching_test/ok"
+    end
+  end
+end
+
+class SymbolPageCachingTestController < CachingController
+  self.page_cache_directory = :domain_cache_directory
+
+  caches_page :ok
+
+  def ok
+    render html: "ok"
+  end
+
+  def expire_ok
+    expire_page action: :ok
+    head :ok
+  end
 
-    def assert_page_cached(action, message = "#{action} should have been cached")
-      assert page_cached?(action), message
+  protected
+    def domain_cache_directory
+      File.join(TEST_TMP_DIR, request.domain)
     end
+end
+
+class SymbolPageCachingTest < ActionController::TestCase
+  include PageCachingTestHelpers
+  tests SymbolPageCachingTestController
 
-    def assert_page_not_cached(action, message = "#{action} shouldn't have been cached")
-      assert !page_cached?(action), message
+  def test_page_is_cached_by_domain
+    draw do
+      get "/symbol_page_caching_test/ok", to: "symbol_page_caching_test#ok"
+      get "/symbol_page_caching_test/ok/expire", to: "symbol_page_caching_test#expire_ok"
     end
 
-    def page_cached?(action)
-      File.exist? "#{FILE_STORE_PATH}/page_caching_test/#{action}.html"
+    @request.env["HTTP_HOST"] = "www.foo.com"
+    get :ok
+    assert_response :ok
+    assert_page_cached :ok, path: TEST_TMP_DIR + "/foo.com"
+
+    get :expire_ok
+    assert_response :ok
+    assert_page_not_cached :ok, path: TEST_TMP_DIR + "/foo.com"
+
+    @request.env["HTTP_HOST"] = "www.bar.com"
+    get :ok
+    assert_response :ok
+    assert_page_cached :ok, path: TEST_TMP_DIR + "/bar.com"
+
+    get :expire_ok
+    assert_response :ok
+    assert_page_not_cached :ok, path: TEST_TMP_DIR + "/bar.com"
+  end
+
+  def test_class_level_cache_page_raise_error
+    assert_raises(RuntimeError, /class-level cache_page method/) do
+      @controller.class.cache_page "cached content", "/symbol_page_caching_test/ok"
+    end
+  end
+end
+
+class CallablePageCachingTestController < CachingController
+  class DomainCacheDirectory
+    def self.call(request)
+      File.join(TEST_TMP_DIR, request.domain)
     end
+  end
+
+  self.page_cache_directory = DomainCacheDirectory
+
+  caches_page :ok
+
+  def ok
+    render html: "ok"
+  end
+
+  def expire_ok
+    expire_page action: :ok
+    head :ok
+  end
+end
+
+class CallablePageCachingTest < ActionController::TestCase
+  include PageCachingTestHelpers
+  tests CallablePageCachingTestController
+
+  def test_page_is_cached_by_domain
+    draw do
+      get "/callable_page_caching_test/ok", to: "callable_page_caching_test#ok"
+      get "/callable_page_caching_test/ok/expire", to: "callable_page_caching_test#expire_ok"
+    end
+
+    @request.env["HTTP_HOST"] = "www.foo.com"
+    get :ok
+    assert_response :ok
+    assert_page_cached :ok, path: TEST_TMP_DIR + "/foo.com"
+
+    get :expire_ok
+    assert_response :ok
+    assert_page_not_cached :ok, path: TEST_TMP_DIR + "/foo.com"
+
+    @request.env["HTTP_HOST"] = "www.bar.com"
+    get :ok
+    assert_response :ok
+    assert_page_cached :ok, path: TEST_TMP_DIR + "/bar.com"
+
+    get :expire_ok
+    assert_response :ok
+    assert_page_not_cached :ok, path: TEST_TMP_DIR + "/bar.com"
+  end
+
+  def test_class_level_cache_page_raise_error
+    assert_raises(RuntimeError, /class-level cache_page method/) do
+      @controller.class.cache_page "cached content", "/callable_page_caching_test/ok"
+    end
+  end
 end