rack-page_caching 0.0.1

data/test/rack/page_caching/action_controller_spec.rb

@@ -0,0 +1,272 @@
+require 'action_controller'
+require "rack/page_caching/action_controller"
+require 'test_helper'
+require './test/support/file_helper'
+
+class TestController < ActionController::Base
+  caches_page :cache, if: Proc.new { |c| !c.request.format.json? }
+  caches_page :just_head
+  caches_page :redirect_somewhere
+  caches_page :no_gzip, gzip: false
+  caches_page :gzip_level, gzip: :best_speed
+  caches_page :accept_xml
+
+  def cache
+    render text: 'foo bar'
+  end
+
+  def no_gzip
+    render text: 'no gzip'
+  end
+
+  def just_head
+    head :ok
+  end
+
+  def redirect_somewhere
+    redirect_to '/just_head'
+  end
+
+  def custom_caching
+    render text: 'custom'
+    cache_page('Cache rules everything around me', 'wootang.html')
+  end
+
+  def expire_custom_caching
+    expire_page 'wootang.html'
+    head :ok
+  end
+
+  def custom_caching_with_starting_slash
+    render text: 'custom'
+    cache_page('Starting slash', '/slash.html')
+  end
+
+  def expire_starting_slash
+    expire_page '/slash.html'
+    head :ok
+  end
+
+  def without_extension
+    render text: 'without extension'
+    cache_page('Path without extension', 'without_extension')
+  end
+
+  def with_trailing_slash
+    render text: 'trailing slash'
+    cache_page('trailing slash', 'hello/world/')
+  end
+
+  def expire_trailing_slash
+    expire_page 'hello/world.html'
+    head :ok
+  end
+
+  def gzip_level
+    render text: 'level up'
+  end
+
+  def accept_xml
+    respond_to do |format|
+      format.html { render text: 'I am html' }
+      format.xml  { render text: 'I am xml'  }
+    end
+  end
+end
+
+describe Rack::PageCaching::ActionController do
+  include Rack::Test::Methods
+  include FileHelper
+
+  def app
+    options = {
+      page_cache_directory: cache_path,
+      include_hostname: false
+    }
+    Rack::Builder.new {
+      map '/with-domain' do
+        use Rack::PageCaching, options.merge(include_hostname: true)
+        run TestController.action(:cache)
+      end
+      map '/' do
+        use Rack::PageCaching, options
+        run TestController.action(:cache)
+      end
+      [:cache, :just_head, :redirect_somewhere, :custom_caching,
+       :no_gzip, :gzip_level, :without_extension, :accept_xml,
+       :custom_caching_with_starting_slash, :expire_custom_caching,
+       :expire_starting_slash, :with_trailing_slash, :expire_trailing_slash
+      ].each do |action|
+        map "/#{action}" do
+          use Rack::PageCaching, options
+          run TestController.action(action)
+        end
+      end
+    }.to_app
+  end
+
+  def set_path(*path)
+    @cache_path = [cache_path].concat path
+  end
+
+  let(:cache_file) { File.join(*@cache_path) }
+
+  it 'caches the requested page and creates gzipped file by default' do
+    get '/cache'
+    set_path 'cache.html'
+    assert File.exist?(cache_file), 'cache.html should exist'
+    File.read(cache_file).must_equal 'foo bar'
+    assert File.exist?(File.join(cache_path, 'cache.html.gz')),
+      'gzipped cache.html file should exist'
+    assert last_request.env['rack.page_caching.compression'] == Zlib::BEST_COMPRESSION,
+      'compression level must use config gzip by default'
+  end
+
+  it 'saves to a file with the domain as a folder' do
+    get 'http://www.test.org/with-domain'
+    set_path 'www.test.org', 'with-domain.html'
+    assert File.exist?(cache_file), 'with-domain.html should exist'
+    File.read(cache_file).must_equal 'foo bar'
+  end
+
+  it 'respects conditionals' do
+    get '/cache', format: :json
+    assert_cache_folder_is_empty
+  end
+
+  it 'caches to index.html when caching on /' do
+    get '/'
+    set_path 'index.html'
+    assert File.exist?(cache_file),
+      'index.html file should exist'
+  end
+
+  it 'caches head request' do
+    head '/just_head'
+    set_path 'just_head.html'
+    assert File.exist?(cache_file), 'head response should have been cached'
+  end
+
+  it 'will not cache when http status is not 200' do
+    get '/redirect_somewhere'
+    assert_cache_folder_is_empty
+  end
+
+  it 'caches custom text to a custom path' do
+    get '/custom_caching'
+    set_path 'wootang.html'
+    assert File.exist?(cache_file), 'wootang.html should exist'
+    File.read(cache_file).must_equal 'Cache rules everything around me'
+  end
+
+  def assert_file_deleted_after_expiry(path, expire_path, file)
+    get path
+    set_path file
+    assert File.exist?(cache_file), "#{file} should exist"
+    assert File.exist?(cache_file + '.gz'), "#{file}.gz should exist"
+
+    get expire_path
+    refute File.exist?(cache_file), "#{file} should be deleted"
+    refute File.exist?(cache_file + '.gz'), "#{file}.gz should be deleted"
+  end
+
+  it 'expires page at custom path' do
+    assert_file_deleted_after_expiry '/custom_caching', '/expire_custom_caching',
+      'wootang.html'
+  end
+
+  it 'caches custom text whose path starts with a slash' do
+    get '/custom_caching_with_starting_slash'
+    set_path 'slash.html'
+    assert File.exist?(cache_file), '/slash.html should exist'
+    File.read(cache_file).must_equal 'Starting slash'
+  end
+
+  it 'expires page with path that starts with slash' do
+    assert_file_deleted_after_expiry '/custom_caching_with_starting_slash',
+      '/expire_starting_slash', 'slash.html'
+  end
+
+  it 'caches path that does not have extensions' do
+    get '/without_extension'
+    set_path 'without_extension.html'
+    assert File.exist?(cache_file), 'without_extension.html should exist'
+  end
+
+  it 'caches path with trailing slash' do
+    get '/with_trailing_slash'
+    set_path 'hello/world.html'
+    assert File.exist?(cache_file), 'hello/world.html should exist'
+  end
+
+  it 'expires path with trailing slash' do
+    assert_file_deleted_after_expiry '/with_trailing_slash',
+      '/expire_trailing_slash', 'hello/world.html'
+  end
+
+  it 'does not create a gzip file when gzip argument is false' do
+    get '/no_gzip'
+    set_path 'no_gzip.html'
+    assert File.exist?(cache_file), 'no_gzip.html should exist'
+    refute File.exist?(File.join(cache_path, 'no_gzip.html.gz')),
+      'gzipped no_gzip.html file should not exist'
+  end
+
+  it 'allows overriding of gzip level' do
+    get '/gzip_level'
+    assert last_request.env['rack.page_caching.compression'] == Zlib::BEST_SPEED,
+      'compression level must be set to the requested level'
+  end
+
+  it 'caches according to requested format' do
+    get '/accept_xml', { format: :xml }
+    set_path 'accept_xml.xml'
+    assert File.exist?(cache_file), 'accept_xml.xml should exist'
+  end
+
+  describe 'notifications' do
+    class Counter
+      def self.incr
+        @counter += 1
+      end
+
+      def self.reset
+        @counter = 0
+      end
+
+      def self.check
+        @counter
+      end
+    end
+
+    let(:subscribe) do
+      Counter.reset
+      Counter.check.must_equal 0
+      @subscriber = ActiveSupport::Notifications.subscribe(@event) do |name, start, finish, id, payload|
+        payload[:path].must_equal cache_file
+        Counter.incr
+      end
+    end
+
+    after do
+      ActiveSupport::Notifications.unsubscribe @subscriber
+    end
+
+    it 'notifies subscribers after writing' do
+      @event = 'write_page.action_controller'
+      set_path 'cache.html'
+      subscribe
+      get '/cache'
+      Counter.check.must_equal 1
+    end
+
+    it 'notifies subscribers after deleting' do
+      @event = 'expire_page.action_controller'
+      set_path 'wootang.html'
+      subscribe
+      get '/custom_caching'
+      get '/expire_custom_caching'
+      Counter.check.must_equal 1
+    end
+  end
+end

data/test/rack/page_caching/cache_spec.rb

@@ -0,0 +1,187 @@
+require 'test_helper'
+require './test/support/file_helper'
+
+describe Rack::PageCaching::Cache do
+  let(:options) { {} }
+
+  let(:config) { Rack::PageCaching::Environment.new(options) }
+
+  let(:content_type) { 'text/html' }
+
+  let(:path) { '/hotels/singapore' }
+
+  let(:env) do
+    {
+      'PATH_INFO' => path,
+      'REQUEST_METHOD' => 'GET',
+      'HTTP_HOST' => 'www.example.org',
+      'rack.page_caching.perform_caching' => true
+    }
+  end
+
+  let(:response) do
+    Rack::PageCaching::Response.new(
+      [
+        200,
+        { 'Content-Type' => content_type },
+        ['Foo Bar']
+      ],
+      env
+    )
+  end
+
+  let(:cache) { Rack::PageCaching::Cache.new(response) }
+
+  before { Rack::PageCaching.environment = config }
+
+  describe '#gzip_level' do
+    subject { cache.gzip_level }
+
+    describe 'from config' do
+      let(:options) { { page_cache_compression: :best_compression } }
+
+      it 'returns the gzip_level from config if gzip level is not specified in response' do
+        subject.must_equal Zlib::BEST_COMPRESSION
+      end
+    end
+
+    describe 'from response' do
+      before do
+        env.merge! 'rack.page_caching.compression' => Rack::PageCaching::Utils.gzip_level(:best_speed)
+        options.merge! page_cache_compression: :best_compression
+      end
+
+      it 'returns the gzip_level from response' do
+        subject.must_equal Zlib::BEST_SPEED
+      end
+    end
+  end
+
+  describe '#page_cache_path' do
+    subject { cache.page_cache_path }
+
+    it 'returns the correct page_cache_path' do
+      subject.must_equal '/hotels/singapore.html'
+    end
+
+    describe 'uses correct extension' do
+      let(:content_type) { 'application/xml' }
+      it 'returns the correct extension for the cache path' do
+        subject.must_equal '/hotels/singapore.xml'
+      end
+    end
+
+    describe 'uses index.html' do
+      let(:path) { '/' }
+
+      it 'appends index.html when path is only a slash' do
+        subject.must_equal '/index.html'
+      end
+    end
+
+    describe 'uses hostname' do
+      before { options.merge!(include_hostname: true) }
+
+      it 'includes hostname in cache path' do
+        subject.must_equal '/www.example.org/hotels/singapore.html'
+      end
+    end
+
+    describe 'skips extension' do
+      let(:path) { '/index.json' }
+      let(:content_type) { 'application/json' }
+
+      it 'does not add extension again if path already has extension' do
+        subject.must_equal '/index.json'
+      end
+    end
+
+    describe 'escapes path' do
+      let(:path) { '/path%20with%20spaces' }
+
+      it 'escapes the path' do
+        subject.must_equal '/path with spaces.html'
+      end
+    end
+  end
+
+  describe 'saving to disk' do
+    include FileHelper
+
+    let(:options) { { page_cache_directory: cache_path } }
+    let(:cache_file) { File.join(cache_path, 'hotels', 'singapore.html') }
+    let(:cache_content) { File.read(cache_file) }
+
+    describe '#store' do
+      it 'stores the response to disk' do
+        cache.store
+        cache_content.must_equal 'Foo Bar'
+      end
+
+      it 'overwrites the file for the same call' do
+        cache.store
+        cache.store
+        cache_content.must_equal 'Foo Bar'
+      end
+
+      describe 'compression' do
+        let(:options) do
+          {
+            page_cache_compression: :best_speed,
+            page_cache_directory:  cache_path,
+          }
+        end
+
+        let(:zipped_path) { File.join(cache_path, 'hotels', 'singapore.html.gz') }
+
+        it 'creates a compressed file' do
+          cache.store
+          File.exist?(zipped_path).must_equal true
+        end
+
+        it 'zips the content' do
+          cache.store
+          Zlib::GzipReader.open(zipped_path) do |gz|
+            gz.read.must_equal 'Foo Bar'
+          end
+        end
+      end
+    end
+
+    describe '.store' do
+      it 'stores the response to disk' do
+        Rack::PageCaching::Cache.store(response)
+        cache_content.must_equal 'Foo Bar'
+      end
+    end
+
+    describe '.delete' do
+      it 'stores the file to disk' do
+        Rack::PageCaching::Cache.store(response)
+        File.exist?(cache_file).must_equal true
+        Rack::PageCaching::Cache.delete(File.join('hotels', 'singapore.html'))
+        refute File.exist?(cache_file)
+      end
+
+      describe 'globs' do
+        let(:options) do
+          {
+            page_cache_directory:  cache_path,
+            include_hostname: true
+          }
+        end
+
+        let(:cache_file) do
+          File.join(cache_path, 'www.example.org', 'hotels', 'singapore.html')
+        end
+
+        it 'accepts globs in path' do
+          Rack::PageCaching::Cache.store(response)
+          File.exist?(cache_file).must_equal true
+          Rack::PageCaching::Cache.delete(File.join('**', 'hotels', 'singapore.html'))
+          refute File.exist?(cache_file)
+        end
+      end
+    end
+  end
+end

data/test/rack/page_caching/environment_spec.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+require 'pathname'
+
+describe Rack::PageCaching::Environment do
+  let(:env) { Rack::PageCaching::Environment.new(options) }
+
+  describe 'defaults' do
+    let(:options) { {} }
+
+    it 'is not enabled when a page_cache_directory is not set' do
+      refute env.enabled?
+    end
+
+    it 'defaults page_cache_compression to false' do
+      refute env.page_cache_compression
+    end
+
+    it 'defaults include_hostname to false' do
+      refute env.include_hostname?
+    end
+  end
+
+  describe 'set options' do
+    let(:options) {
+      {
+        include_hostname: true,
+        page_cache_compression: :best_compression,
+        page_cache_directory: '/var/tmp'
+      }
+    }
+
+    it 'includes hostname' do
+      env.include_hostname?.must_equal true
+    end
+
+    it 'is enabled' do
+      env.enabled?.must_equal true
+    end
+
+    it 'returns the correct zlib compression constant' do
+      env.page_cache_compression.must_equal Zlib::BEST_COMPRESSION
+    end
+
+    it 'sets the correct page cache directory' do
+      env.page_cache_directory.must_equal '/var/tmp'
+    end
+
+    describe 'page_cache_directory' do
+      before { options.merge! page_cache_directory: Pathname.new('/var/tmp') }
+
+      it 'accepts a Pathname as page cache directory' do
+        env.page_cache_directory.must_equal '/var/tmp'
+      end
+    end
+  end
+
+  describe 'in Rails' do
+    before do
+      controller = Object.new
+      controller.define_singleton_method(:perform_caching) { true }
+      config = Object.new
+      config.define_singleton_method(:action_controller) { controller }
+      application = Object.new
+      application.define_singleton_method(:config) { config }
+      root = Object.new
+      root.define_singleton_method(:join) do |folder|
+        Pathname.new('/var/www/app').join(folder)
+      end
+      Rails = Class.new
+      Rails.define_singleton_method(:application) { application }
+      Rails.define_singleton_method(:root) { root }
+    end
+
+    let(:options) { {} }
+
+    it 'sets the page cache path to public folder relative to rails root' do
+      env.page_cache_directory.must_equal '/var/www/app/public'
+    end
+
+    after { Object.send(:remove_const, :Rails) }
+  end
+end

data/test/rack/page_caching/mime_types_spec.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+describe Rack::PageCaching::MimeTypes do
+  let(:mime_types) { Rack::PageCaching::MimeTypes }
+
+  describe '.extension_for' do
+    {
+      'text/html' => '.html',
+      'application/json' => '.json',
+      'text/css' => '.css'
+    }.each do |content_type, extension|
+      it "returns #{extension} for content type #{content_type}" do
+        mime_types.extension_for(content_type).must_equal extension
+      end
+    end
+  end
+
+  describe '.register' do
+    it 'allows registration of custom content_type' do
+      mime_types.register 'text/ing', '.ing'
+      mime_types.extension_for('text/ing').must_equal '.ing'
+    end
+  end
+end

data/test/rack/page_caching/response_spec.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+
+describe Rack::PageCaching::Response do
+  let(:rack_response) do
+    [
+      200,
+      { 'Content-Type' => 'text/html; charset=utf-8' },
+      ['Foo Bar']
+    ]
+  end
+
+  let(:env) do
+    {
+      'PATH_INFO' => '/hotels/singapore',
+      'REQUEST_METHOD' => 'GET',
+      'HTTP_HOST' => 'www.example.org',
+      'rack.page_caching.perform_caching' => true
+    }
+  end
+
+  let(:response) { Rack::PageCaching::Response.new(rack_response, env) }
+
+  it 'is cacheable for successful html responses' do
+    response.cacheable?.must_equal true
+  end
+
+  it 'returns the path' do
+    response.path.must_equal '/hotels/singapore'
+  end
+
+  it 'returns the body' do
+    response.body.must_equal ['Foo Bar']
+  end
+
+  it 'returns the content type' do
+    response.content_type.must_equal 'text/html'
+  end
+
+  it 'returns the host' do
+    response.host.must_equal 'www.example.org'
+  end
+
+  describe 'no caching' do
+    describe 'no directive provided' do
+      before { env.delete 'rack.page_caching.perform_caching' }
+      it 'is not cacheable by default' do
+        response.cacheable?.must_equal false
+      end
+    end
+
+    describe 'directive is false' do
+      before { env.merge! 'rack.page_caching.perform_caching' => false }
+      it 'is not cacheable if perform_caching env is set to false' do
+        response.cacheable?.must_equal false
+      end
+    end
+
+    describe 'response not cacheable' do
+      before { env.merge! 'REQUEST_METHOD' => 'POST' }
+      it 'does not cache post requests' do
+        response.cacheable?.must_equal false
+      end
+    end
+
+    describe 'non-200 response' do
+      before { rack_response[0] = 404 }
+      it 'does not cache resposes where status is not 200' do
+        response.cacheable?.must_equal false
+      end
+    end
+  end
+end

data/test/rack/page_caching/utils_spec.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+describe Rack::PageCaching::Utils do
+  let(:utils) { Rack::PageCaching::Utils }
+  describe '.gzip_level' do
+    it 'accepts a number and returns it' do
+      utils.gzip_level(1).must_equal 1
+    end
+
+    it 'accepts a symbol and returns the corresponding zlib constant' do
+      utils.gzip_level(:best_speed).must_equal Zlib::BEST_SPEED
+    end
+
+    it 'returns false for unrecognized input' do
+      utils.gzip_level('best_speed').must_equal false
+    end
+  end
+end