faraday-http-cache 0.0.1.dev

data/spec/cache_control_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Faraday::HttpCache::CacheControl do
+  it 'takes a String with multiple name=value pairs' do
+    instance = Faraday::HttpCache::CacheControl.new('max-age=600, max-stale=300, min-fresh=570')
+    instance.max_age.should == 600
+  end
+
+  it 'takes a String with a single flag value' do
+    instance = Faraday::HttpCache::CacheControl.new('no-cache')
+    instance.should be_no_cache
+  end
+
+  it 'takes a String with a bunch of all kinds of stuff' do
+    instance =
+      Faraday::HttpCache::CacheControl.new('max-age=600,must-revalidate,min-fresh=3000,foo=bar,baz')
+    instance.max_age.should == 600
+    instance.should be_must_revalidate
+  end
+
+  it 'strips leading and trailing spaces' do
+    instance = Faraday::HttpCache::CacheControl.new('   public,   max-age =   600  ')
+    instance.should be_public
+    instance.max_age.should == 600
+  end
+
+  it 'ignores blank segments' do
+    instance = Faraday::HttpCache::CacheControl.new('max-age=600,,s-maxage=300')
+    instance.max_age.should == 600
+    instance.shared_max_age.should == 300
+  end
+
+  it 'sorts alphabetically with boolean directives before value directives' do
+    instance = Faraday::HttpCache::CacheControl.new('foo=bar, z, x, y, bling=baz, zoom=zib, b, a')
+    instance.to_s.should == 'a, b, x, y, z, bling=baz, foo=bar, zoom=zib'
+  end
+
+  it 'responds to #max_age with an integer when max-age directive present' do
+    instance = Faraday::HttpCache::CacheControl.new('public, max-age=600')
+    instance.max_age.should == 600
+  end
+
+  it 'responds to #max_age with nil when no max-age directive present' do
+    instance = Faraday::HttpCache::CacheControl.new('public')
+    instance.max_age.should be_nil
+  end
+
+  it 'responds to #shared_max_age with an integer when s-maxage directive present' do
+    instance = Faraday::HttpCache::CacheControl.new('public, s-maxage=600')
+    instance.shared_max_age.should == 600
+  end
+
+  it 'responds to #shared_max_age with nil when no s-maxage directive present' do
+    instance = Faraday::HttpCache::CacheControl.new('public')
+    instance.shared_max_age.should be_nil
+  end
+
+  it 'responds to #public? truthfully when public directive present' do
+    instance = Faraday::HttpCache::CacheControl.new('public')
+    instance.should be_public
+  end
+
+  it 'responds to #public? non-truthfully when no public directive present' do
+    instance = Faraday::HttpCache::CacheControl.new('private')
+    instance.should_not be_public
+  end
+
+  it 'responds to #private? truthfully when private directive present' do
+    instance = Faraday::HttpCache::CacheControl.new('private')
+    instance.should be_private
+  end
+
+  it 'responds to #private? non-truthfully when no private directive present' do
+    instance = Faraday::HttpCache::CacheControl.new('public')
+    instance.should_not be_private
+  end
+
+  it 'responds to #no_cache? truthfully when no-cache directive present' do
+    instance = Faraday::HttpCache::CacheControl.new('no-cache')
+    instance.should be_no_cache
+  end
+
+  it 'responds to #no_cache? non-truthfully when no no-cache directive present' do
+    instance = Faraday::HttpCache::CacheControl.new('max-age=600')
+    instance.should_not be_no_cache
+  end
+
+  it 'responds to #must_revalidate? truthfully when must-revalidate directive present' do
+    instance = Faraday::HttpCache::CacheControl.new('must-revalidate')
+    instance.should be_must_revalidate
+  end
+
+  it 'responds to #must_revalidate? non-truthfully when no must-revalidate directive present' do
+    instance = Faraday::HttpCache::CacheControl.new('max-age=600')
+    instance.should_not be_no_cache
+  end
+
+  it 'responds to #proxy_revalidate? truthfully when proxy-revalidate directive present' do
+    instance = Faraday::HttpCache::CacheControl.new('proxy-revalidate')
+    instance.should be_proxy_revalidate
+  end
+
+  it 'responds to #proxy_revalidate? non-truthfully when no proxy-revalidate directive present' do
+    instance = Faraday::HttpCache::CacheControl.new('max-age=600')
+    instance.should_not be_no_cache
+  end
+end

data/spec/middleware_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe Faraday::HttpCache do
+  let(:logger) { double('a Logger object', :debug => nil) }
+
+  let(:client) do
+    Faraday.new(:url => ENV['FARADAY_SERVER']) do |stack|
+      stack.use Faraday::HttpCache, :logger => logger
+      adapter = ENV['FARADAY_ADAPTER']
+      stack.headers['X-Faraday-Adapter'] = adapter
+      stack.adapter adapter.to_sym
+    end
+  end
+
+  before do
+    client.get('clear')
+  end
+
+  it "doesn't cache POST requests" do
+    client.post('post').body
+    client.post('post').body.should == "2"
+  end
+
+  it "logs that a POST request is unacceptable" do
+    logger.should_receive(:debug).with('HTTP Cache: [POST /post] unacceptable')
+    client.post('post').body
+  end
+
+  it "doesn't cache responses with invalid status code" do
+    client.get('broken')
+    client.get('broken').body.should == "2"
+  end
+
+  it "logs that a response with a bad status code is invalid" do
+    logger.should_receive(:debug).with('HTTP Cache: [GET /broken] miss, invalid')
+    client.get('broken')
+  end
+
+  it "doesn't cache requests with a private cache control" do
+    client.get('private')
+    client.get('private').body.should == "2"
+  end
+
+  it "logs that a private response is invalid" do
+    logger.should_receive(:debug).with('HTTP Cache: [GET /private] miss, invalid')
+    client.get('private')
+  end
+
+  it "doesn't cache requests with a explicit no-store directive" do
+    client.get('dontstore')
+    client.get('dontstore').body.should == "2"
+  end
+
+  it "logs that a response with a no-store directive is invalid" do
+    logger.should_receive(:debug).with('HTTP Cache: [GET /dontstore] miss, invalid')
+    client.get('dontstore')
+  end
+
+  it "caches multiple responses when the headers differ" do
+    client.get('get', nil, 'HTTP_ACCEPT' => 'text/html')
+    client.get('get', nil, 'HTTP_ACCEPT' => 'text/html').body.should == "1"
+
+    client.get('get', nil, 'HTTP_ACCEPT' => 'application/json').body.should == "2"
+  end
+
+  it "caches requests with the 'Expires' header" do
+    client.get('expires')
+    client.get('expires').body.should == "1"
+  end
+
+  it "logs that a request with the 'Expires' is fresh and stored" do
+    logger.should_receive(:debug).with('HTTP Cache: [GET /expires] miss, store')
+    client.get('expires')
+  end
+
+  it "caches GET responses" do
+    client.get('get')
+    client.get('get').body.should == "1"
+  end
+
+  it "logs that a GET response is stored" do
+    logger.should_receive(:debug).with('HTTP Cache: [GET /get] miss, store')
+    client.get('get')
+  end
+
+  it "logs that a stored GET response is fresh" do
+    client.get('get')
+    logger.should_receive(:debug).with('HTTP Cache: [GET /get] fresh')
+    client.get('get')
+  end
+
+  it "sends the 'Last-Modified' header on response validation" do
+    client.get('timestamped')
+    client.get('timestamped').body.should == "1"
+  end
+
+  it "logs that the request with 'Last-Modified' was revalidated" do
+    client.get('timestamped')
+    logger.should_receive(:debug).with('HTTP Cache: [GET /timestamped] valid, store')
+    client.get('timestamped').body.should == "1"
+  end
+
+  it "sends the 'If-None-Match' header on response validation" do
+    client.get('etag')
+    client.get('etag').body.should == "1"
+  end
+
+  it "logs that the request with 'ETag' was revalidated" do
+    client.get('etag')
+    logger.should_receive(:debug).with('HTTP Cache: [GET /etag] valid, store')
+    client.get('etag').body.should == "1"
+  end
+
+  it "maintains the 'Date' header for cached responses" do
+    date = client.get('get').headers['Date']
+    client.get('get').headers['Date'].should == date
+  end
+
+  it "preserves an old 'Date' header if present" do
+    date = client.get('yesterday').headers['Date']
+    date.should =~ /^\w{3}, \d{2} \w{3} \d{4} \d{2}:\d{2}:\d{2} GMT$/
+  end
+
+  describe 'Configuration options' do
+    let(:app) { double("it's an app!") }
+
+    it 'uses the options to create a Cache Store' do
+      ActiveSupport::Cache.should_receive(:lookup_store).with(:file_store, ['tmp'])
+      Faraday::HttpCache.new(app, :file_store, 'tmp')
+    end
+
+    it 'accepts a Hash option' do
+      ActiveSupport::Cache.should_receive(:lookup_store).with(:memory_store, { :size => 1024 })
+      Faraday::HttpCache.new(app, :memory_store, :size => 1024)
+    end
+
+    it "consumes the 'logger' key" do
+      logger = double('a logger object')
+      ActiveSupport::Cache.should_receive(:lookup_store).with(:memory_store, {})
+      Faraday::HttpCache.new(app, :memory_store, :logger => logger)
+    end
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe Faraday::HttpCache::Response do
+  describe 'cacheable?' do
+    it "the response isn't' cacheable if the response is marked as private" do
+      headers  = { 'Cache-Control' => 'private' }
+      response = Faraday::HttpCache::Response.new(:response_headers => headers)
+
+      response.should_not be_cacheable
+    end
+
+    it "the response isn't' cacheable if it shouldn't be stored" do
+      headers  = { 'Cache-Control' => 'no-store' }
+      response = Faraday::HttpCache::Response.new(:response_headers => headers)
+
+      response.should_not be_cacheable
+    end
+
+    it "the response isn't cacheable when the status code isn't acceptable" do
+      headers  = { 'Cache-Control' => 'max-age=400' }
+      response = Faraday::HttpCache::Response.new(:status => 503, :response_headers => headers)
+      response.should_not be_cacheable
+    end
+
+    [200, 203, 300, 301, 302, 404, 410].each do |status|
+      it "the response is cacheable if the status code is #{status} and the response is fresh" do
+        headers  = { 'Cache-Control' => 'max-age=400' }
+        response = Faraday::HttpCache::Response.new(:status => status, :response_headers => headers)
+
+        response.should be_cacheable
+      end
+    end
+  end
+
+  describe 'freshness' do
+    it "is fresh if the response still has some time to live" do
+      date = 200.seconds.ago.httpdate
+      headers = { 'Cache-Control' => 'max-age=400', 'Date' => date }
+      response = Faraday::HttpCache::Response.new(:response_headers => headers)
+
+      response.should be_fresh
+    end
+
+    it "isn't fresh when the ttl has expired" do
+      date = 500.seconds.ago.httpdate
+      headers = { 'Cache-Control' => 'max-age=400', 'Date' => date }
+      response = Faraday::HttpCache::Response.new(:response_headers => headers)
+
+      response.should_not be_fresh
+    end
+  end
+
+  it "sets the 'Date' header if isn't present" do
+    headers = { 'Date' => nil }
+    response = Faraday::HttpCache::Response.new(:response_headers => headers)
+
+    response.date.should be_present
+  end
+
+  it "the response is not modified if the status code is 304" do
+    response = Faraday::HttpCache::Response.new(:status => 304)
+    response.should be_not_modified
+  end
+
+  it "returns the 'Last-Modified' header on the #last_modified method" do
+    headers = { 'Last-Modified' => '123'}
+    response = Faraday::HttpCache::Response.new(:response_headers => headers)
+    response.last_modified.should == '123'
+  end
+
+  it "returns the 'ETag' header on the #etag method" do
+    headers = { 'ETag' => 'tag'}
+    response = Faraday::HttpCache::Response.new(:response_headers => headers)
+    response.etag.should == 'tag'
+  end
+
+  describe 'max age calculation' do
+
+    it 'uses the shared max age directive when present' do
+      headers = { 'Cache-Control' => 's-maxage=200, max-age=0'}
+      response = Faraday::HttpCache::Response.new(:response_headers => headers)
+      response.max_age.should == 200
+    end
+
+    it 'uses the max age directive when present' do
+      headers = { 'Cache-Control' => 'max-age=200'}
+      response = Faraday::HttpCache::Response.new(:response_headers => headers)
+      response.max_age.should == 200
+    end
+
+    it "fallsback to the expiration date leftovers" do
+      headers = { 'Expires' => (Time.now + 100).httpdate, 'Date' => Time.now.httpdate }
+      response = Faraday::HttpCache::Response.new(:response_headers => headers)
+      response.max_age.should == 100
+    end
+
+    it "returns nil when there's no information to calculate the max age" do
+      response = Faraday::HttpCache::Response.new
+      response.max_age.should be_nil
+    end
+  end
+
+  describe 'age calculation' do
+    it "uses the 'Age' header if it's present" do
+      response = Faraday::HttpCache::Response.new(:response_headers => { 'Age' => '3' })
+      response.age.should == 3
+    end
+
+    it "calculates the time from the 'Date' header" do
+      date = 3.seconds.ago.httpdate
+      response = Faraday::HttpCache::Response.new(:response_headers => { 'Date' => date })
+      response.age.should == 3
+    end
+
+    it "returns 0 if there's no 'Age' or 'Date' header present" do
+      response = Faraday::HttpCache::Response.new(:response_headers => {})
+      response.age.should == 0
+    end
+  end
+
+  describe 'time to live calculation' do
+    it "returns the time to live based on the max age limit" do
+      date = 200.seconds.ago.httpdate
+      headers = { 'Cache-Control' => 'max-age=400', 'Date' => date }
+      response = Faraday::HttpCache::Response.new(:response_headers => headers)
+      response.ttl.should == 200
+    end
+  end
+
+  describe "response unboxing" do
+    subject { described_class.new(:status => 200, :response_headers => {}, :body => 'Hi!') }
+    let(:response) { subject.to_response }
+
+    it 'returns a Faraday::Response' do
+      response.should be_a Faraday::Response
+    end
+
+    it 'merges the status code' do
+      response.status.should == 200
+    end
+
+    it 'merges the headers' do
+      response.headers.should be_a Faraday::Utils::Headers
+    end
+
+    it 'merges the body' do
+      response.body.should == "Hi!"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'uri'
+require 'socket'
+
+require 'faraday-http-cache'
+require 'active_support/core_ext/date/calculations'
+require 'active_support/core_ext/numeric/time'
+require 'yajl'
+
+require 'support/test_app'
+require 'support/test_server'
+
+server = TestServer.new
+
+ENV['FARADAY_SERVER'] = server.endpoint
+ENV['FARADAY_ADAPTER'] ||= 'net_http'
+
+server.start
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.after(:suite) do
+    server.stop
+  end
+end

data/spec/storage_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Faraday::HttpCache::Storage do
+  let(:request) do
+    { :method => :get, :request_headers => {}, :url => URI.parse("http://foo.bar/") }
+  end
+
+  let(:response) { double(:payload => {}) }
+
+  let(:cache) { ActiveSupport::Cache.lookup_store }
+
+  subject { Faraday::HttpCache::Storage.new(cache) }
+
+  describe 'Cache configuration' do
+    it 'lookups a ActiveSupport cache store' do
+      ActiveSupport::Cache.should_receive(:lookup_store).with(:file_store, '/tmp')
+      Faraday::HttpCache::Storage.new(:file_store, '/tmp')
+    end
+  end
+
+  describe 'storing responses' do
+    it 'writes the response json to the underlying cache using a digest as the key' do
+      json = MultiJson.dump(response.payload)
+
+      cache.should_receive(:write).with('503ac9f7180ca1cdec49e8eb73a9cc0b47c27325', json)
+      subject.write(request, response)
+    end
+  end
+
+  describe 'reading responses' do
+    it "returns nil if the response isn't cached" do
+      subject.read(request).should be_nil
+    end
+
+    it 'decodes a stored response' do
+      subject.write(request, response)
+
+      subject.read(request).should be_a(Faraday::HttpCache::Response)
+    end
+  end
+end

data/spec/support/test_app.rb

@@ -0,0 +1,72 @@
+require 'sinatra/base'
+
+class TestApp < Sinatra::Base
+
+  set :environment, :test
+  set :server, 'webrick'
+  disable :protection
+
+  set :counter, 0
+  set :requests, 0
+  set :yesterday, 1.day.ago.httpdate
+
+  get '/ping' do
+    "PONG"
+  end
+
+  get '/clear' do
+    settings.counter = 0
+    settings.requests = 0
+    status 204
+  end
+
+  post '/post' do
+    [200, { 'Cache-Control' => 'max-age=400' }, "#{settings.requests += 1}"]
+  end
+
+  get '/broken' do
+    [500, { 'Cache-Control' => 'max-age=400' }, "#{settings.requests += 1}"]
+  end
+
+  get '/get' do
+    [200, { 'Cache-Control' => 'max-age=200' }, "#{settings.requests += 1}"]
+  end
+
+  get '/private' do
+    [200, { 'Cache-Control' => 'private' }, "#{settings.requests += 1}"]
+  end
+
+  get '/dontstore' do
+    [200, { 'Cache-Control' => 'no-store' }, "#{settings.requests += 1}"]
+  end
+
+  get '/expires' do
+    [200, { 'Expires' => (Time.now + 10).httpdate }, "#{settings.requests += 1}"]
+  end
+
+  get '/yesterday' do
+    [200, { 'Date' => settings.yesterday, 'Expires' => settings.yesterday }, "#{settings.requests += 1}"]
+  end
+
+  get '/timestamped' do
+    settings.counter += 1
+    header = settings.counter > 2 ? '1' : '2'
+
+    if env['HTTP_IF_MODIFIED_SINCE'] == header
+      [304, {}, ""]
+    else
+      [200, { 'Last-Modified' => header }, "#{settings.requests += 1}"]
+    end
+  end
+
+  get '/etag' do
+    settings.counter += 1
+    tag = settings.counter > 2 ? '1' : '2'
+
+    if env['HTTP_IF_NONE_MATCH'] == tag
+      [304, { 'ETag' => tag }, ""]
+    else
+      [200, { 'ETag' => tag }, "#{settings.requests += 1}"]
+    end
+  end
+end

data/spec/support/test_server.rb

@@ -0,0 +1,64 @@
+require 'net/http'
+
+class TestServer
+  attr_reader :endpoint
+
+  def initialize
+    @host = 'localhost'
+    @port = find_port
+    @endpoint = "http://#{@host}:#{@port}"
+  end
+
+  def start
+    @pid = run!
+    wait
+  end
+
+  def stop
+    `kill -9 #{@pid}`
+  end
+
+  private
+
+  def run!
+    fork do
+      require 'webrick'
+      log = File.open('log/test.log', 'w+')
+      log.sync = true
+      webrick_opts = {
+       :Port => @port,
+       :Logger => WEBrick::Log::new(log),
+       :AccessLog => [[log, "[%{X-Faraday-Adapter}i] %m  %U  ->  %s %b"]]
+      }
+      Rack::Handler::WEBrick.run(TestApp, webrick_opts)
+    end
+  end
+
+  def wait
+    conn = Net::HTTP.new @host, @port
+    conn.open_timeout = conn.read_timeout = 0.1
+
+    responsive = lambda { |path|
+      begin
+        res = conn.start { conn.get(path) }
+        res.is_a?(Net::HTTPSuccess)
+      rescue Errno::ECONNREFUSED, Errno::EBADF, Timeout::Error, Net::HTTPBadResponse
+        false
+      end
+    }
+
+    server_pings = 0
+    begin
+      server_pings += 1
+      sleep 0.05
+      abort "test server didn't manage to start" if server_pings >= 50
+    end until responsive.call('/ping')
+  end
+
+  def find_port
+    server = TCPServer.new(@host, 0)
+    server.addr[1]
+  ensure
+    server.close if server
+  end
+end