hurley-http-cache 0.1.0.beta

data/test/http_cache/request_test.rb

@@ -0,0 +1,74 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class RequestTest < MiniTest::Test
+  def test_GET_requests_are_cacheable
+    request = new_request
+
+    assert_predicate request, :cacheable?
+  end
+
+  def test_HEAD_requests_are_cacheable
+    request = new_request(verb: :head)
+
+    assert_predicate request, :cacheable?
+  end
+
+  def test_POST_requests_are_not_cacheable
+    request = new_request(verb: :post)
+
+    refute_predicate request, :cacheable?
+  end
+
+  def test_PUT_requests_are_not_cacheable
+    request = new_request(verb: :put)
+
+    refute_predicate request, :cacheable?
+  end
+
+  def test_OPTIONS_requests_are_not_cacheable
+    request = new_request(verb: :options)
+
+    refute_predicate request, :cacheable?
+  end
+
+  def test_DELETE_requests_are_not_cacheable
+    request = new_request(verb: :delete)
+
+    refute_predicate request, :cacheable?
+  end
+
+  def test_TRACE_requests_are_not_cacheable
+    request = new_request(verb: :trace)
+
+    refute_predicate request, :cacheable?
+  end
+
+  def test_no_store_requests_are_not_cacheable
+    request = new_request(header: { 'Cache-Control' => 'no-store' })
+
+    refute_predicate request, :cacheable?
+  end
+
+  def test_no_cache
+    request = new_request(header: { 'Cache-Control' => 'no-cache' })
+
+    assert_predicate request, :no_cache?
+  end
+
+  def test_serializable_hash
+    request = new_request(header: { 'User-Agent' => 'FooBar' })
+    hash = request.serializable_hash
+
+    assert_equal 'get', hash['verb']
+    assert_equal 'http://test.com', hash['url']
+    assert_instance_of Hash, hash['header']
+    assert_equal({ 'User-Agent' => 'FooBar' }, hash['header'])
+  end
+
+  private
+
+  def new_request(verb: :get, url: 'http://test.com', header: {})
+    req = Hurley::Request.new(verb, url, Hurley::Header.new(header))
+    Hurley::HttpCache::Request.new(req)
+  end
+end

data/test/http_cache/response_test.rb

@@ -0,0 +1,116 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class ResponseTest < MiniTest::Test
+  def test_not_cacheable_in_shared_cache_if_the_response_is_private
+    response = new_response(header: { 'Cache-Control' => 'private, max-age=400' })
+
+    refute_predicate response, :cacheable_in_shared_cache?
+  end
+
+  def test_not_cacheable_in_shared_cache_if_the_response_is_no_store
+    response = new_response(header: { 'Cache-Control' => 'no-store, max-age=400' })
+
+    refute_predicate response, :cacheable_in_shared_cache?
+  end
+
+  def test_not_cacheable_in_shared_cache_if_the_status_code_is_not_acceptable
+    response = new_response(status_code: 503, header: { 'Cache-Control' => 'max-age=400' })
+
+    refute_predicate response, :cacheable_in_shared_cache?
+  end
+
+  [200, 203, 300, 301, 302, 404, 410].each do |status|
+    define_method("test_response_is_cacheable_in_shared_cache_if_status_code_is_#{status}") do
+      response = new_response(status_code: status, header: { 'Cache-Control' => 'max-age=400' })
+
+      assert_predicate response, :cacheable_in_shared_cache?
+    end
+  end
+
+  def test_the_response_is_cacheable_if_the_response_is_marked_as_private
+    response = new_response(header: { 'Cache-Control' => 'private, max-age=400' })
+
+    assert_predicate response, :cacheable_in_private_cache?
+  end
+
+  def test_the_response_is_not_cacheable_if_it_should_not_be_stored
+    response = new_response(header: { 'Cache-Control' => 'no-store, max-age=400' })
+
+    refute_predicate response, :cacheable_in_private_cache?
+  end
+
+  def test_the_response_is_not_cacheable_when_the_status_code_is_not_acceptable
+    response = new_response(status_code: 503, header: { 'Cache-Control' => 'max-age=400' })
+
+    refute_predicate response, :cacheable_in_private_cache?
+  end
+
+  [200, 203, 300, 301, 302, 404, 410].each do |status|
+    define_method("test_response_is_cacheable_in_private_cache_if_status_code_is_#{status}") do
+      headers  = { 'Cache-Control' => 'max-age=400' }
+      response = new_response(status_code: status, header: headers)
+
+      assert_predicate response, :cacheable_in_private_cache?
+    end
+  end
+
+  def test_response_is_fresh
+    date = (Time.now - 200).httpdate
+    response = new_response(header: { 'Cache-Control' => 'max-age=400', 'Date' => date })
+
+    assert_predicate response, :fresh?
+  end
+
+  def test_ttl_expired
+    date = (Time.now - 500).httpdate
+    response = new_response(header: { 'Cache-Control' => 'max-age=400', 'Date' => date })
+
+    refute_predicate response, :fresh?
+  end
+
+  def test_response_not_modified
+    response = new_response(status_code: 304)
+
+    assert_predicate response, :not_modified?
+  end
+
+  def test_response_last_modified
+    response = new_response(header: { 'Last-Modified' => '123' })
+
+    assert_equal '123', response.last_modified
+  end
+
+  def test_etag
+    response = new_response(header: { 'ETag' => 'tag' })
+
+    assert_equal 'tag', response.etag
+  end
+
+  def test_restore
+    payload = { 'status_code' => 200, 'header' => { 'X-Foo' => '123' }, 'body' => 'ohai' }
+    response = Hurley::HttpCache::Response.restore(Hurley::Request.new, payload)
+
+    assert_kind_of Hurley::HttpCache::Response, response
+    assert_equal 200, response.status_code
+    assert_instance_of Hurley::Header, response.header
+    assert_equal 'ohai', response.body
+  end
+
+  def test_serializable_hash
+    response = new_response(body: 'ohai')
+    hash = response.serializable_hash
+
+    assert_kind_of Hash, hash['header']
+    assert_equal 200, hash['status_code']
+    assert_equal 'ohai', hash['body']
+  end
+
+  private
+
+  def new_response(status_code: 200, header: {}, body: '')
+    request = Hurley::Request.new
+    response = Hurley::Response.new(request, status_code, Hurley::Header.new(header))
+    response.body = body
+    Hurley::HttpCache::Response.new(response)
+  end
+end

data/test/http_cache/storage_test.rb

@@ -0,0 +1,80 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class StorageSetupTest < MiniTest::Test
+  def test_raises_an_error_when_the_given_store_is_not_valid
+    assert_raises(ArgumentError) {
+      Hurley::HttpCache::Storage.new(store: Object.new)
+    }
+  end
+end
+
+module StorageTests
+  def setup
+    @logger = TestLogger.new
+    @request = Hurley::HttpCache::Request.new(Hurley::Request.new(:get, 'http://test.com', Hurley::Header.new))
+    @response = Hurley::HttpCache::Response.new(Hurley::Response.new(@request))
+    @storage = Hurley::HttpCache::Storage.new(serializer: serializer, logger: @logger)
+  end
+
+  def serializer
+    raise NotImplementedError
+  end
+
+  def cache_key
+    raise NotImplementedError
+  end
+
+  def test_writes_the_response_object_to_the_underlying_cache
+    @storage.write(@request, @response)
+    assert_kind_of Array, @storage.cache.read(cache_key)
+  end
+
+  def test_retrieves_the_response_from_the_cache
+    @storage.write(@request, @response)
+    refute_nil @storage.read(@request)
+  end
+
+  def test_returns_nil_if_the_response_is_not_cached
+    assert_nil @storage.read(@request)
+  end
+
+  def test_removes_the_entries_from_the_cache_of_the_given_URL
+    @storage.write(@request, @response)
+    @storage.delete(@request.url)
+    assert_nil @storage.read(@request)
+  end
+end
+
+class JSONStorageTest < MiniTest::Test
+  include StorageTests
+
+  def test_raises_when_ascii_cant_be_converted
+    @response.body = "\u2665".force_encoding('ASCII-8BIT')
+
+    assert_raises(Encoding::UndefinedConversionError) {
+      @storage.write(@request, @response)
+    }
+
+    assert_includes @logger.warns, "Response could not be serialized: \"\\xE2\" from ASCII-8BIT to UTF-8. Try using Marshal to serialize."
+  end
+
+  def cache_key
+    'e572976e5e9c037a9a436d280faa5aa102ca1683'
+  end
+
+  def serializer
+    JSON
+  end
+end
+
+class MarshalStorageTest < MiniTest::Test
+  include StorageTests
+
+  def cache_key
+    'cbc594f12e773090622daa7976585aa8e15ff7dc'
+  end
+
+  def serializer
+    Marshal
+  end
+end

data/test/live_http_cache_test.rb

@@ -0,0 +1,238 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'hurley/test/integration'
+
+class HttpCacheTest < MiniTest::Test
+  Hurley::Test::Integration.apply(self)
+
+  def setup
+    client.delete('/')
+  end
+
+  def test_caches_GET_requests
+    client.get('counter')
+
+    assert_equal '1', client.get('counter').body
+  end
+
+  def test_logs_that_a_GET_response_is_stored
+    client.get('counter')
+
+    assert_includes logger.debugs, 'HTTP Cache: [GET /counter] miss, store'
+  end
+
+  def test_does_not_cache_POST_requests
+    client.post('counter')
+
+    assert_equal '2', client.post('counter').body
+  end
+
+  def test_does_not_cache_responses_with_invalid_status_code
+    client.get('broken')
+
+    assert_equal '2', client.get('broken').body
+  end
+
+  %w(post put patch delete).each do |verb|
+    define_method("test_expires_#{verb.upcase}_requests") do
+      client.get('counter')
+      client.send(verb, 'counter')
+
+      assert_equal '3', client.get('counter').body
+    end
+
+    define_method("test_logs_that_a_#{verb.upcase}_request_was_deleted_from_cache") do
+      client.send(verb, 'counter')
+
+      assert_includes logger.debugs, "HTTP Cache: [#{verb.upcase} /counter] unacceptable, delete"
+    end
+  end
+
+  def test_expires_entries_for_the_Location_header
+    client.get('counter')
+    client.post('delete-with-location')
+
+    assert_equal '2', client.get('counter').body
+  end
+
+  def test_expires_entries_for_the_Content_Location_header
+    client.get('counter')
+    client.post('delete-with-content-location')
+
+    assert_equal '2', client.get('counter').body
+  end
+
+  def test_does_not_cache_responses_with_a_explicit_not_store_directive
+    client.get('dontstore')
+
+    assert_equal '2', client.get('dontstore').body
+  end
+
+  def test_logs_that_a_response_with_a_no_store_directive_is_invalid
+    client.get('dontstore')
+
+    assert_includes logger.debugs, 'HTTP Cache: [GET /dontstore] miss, invalid'
+  end
+
+  def test_does_not_caches_multiple_responses_when_the_headers_differ
+    client.get('counter') { |req| req.header[:accept] = 'text/html' }
+
+    assert_equal '1', (client.get('counter') { |req| req.header[:accept] = 'text/html' }).body
+    assert_equal '1', (client.get('counter') { |req| req.header[:accept] = 'application/json' }).body
+  end
+
+  def test_caches_multiples_responses_based_on_the_Vary_header
+    client.get('vary') { |req| req.header['User-Agent'] = 'Agent/1.0' }
+
+    assert_equal '1', (client.get('vary') { |req| req.header['User-Agent'] = 'Agent/1.0' }).body
+    assert_equal '2', (client.get('vary') { |req| req.header['User-Agent'] = 'Agent/2.0' }).body
+    assert_equal '3', (client.get('vary') { |req| req.header['User-Agent'] = 'Agent/3.0' }).body
+  end
+
+  def test_never_caches_responses_with_the_wildcard_Vary_header
+    client.get('vary-wildcard')
+
+    assert_equal '2', client.get('vary-wildcard').body
+  end
+
+  def test_caches_requests_with_the_Expires_header
+    client.get('expires')
+
+    assert_equal '1', client.get('expires').body
+  end
+
+  def test_logs_that_a_request_with_the_Expires_is_fresh_and_stored
+    client.get('expires')
+
+    assert_includes logger.debugs, 'HTTP Cache: [GET /expires] miss, store'
+  end
+
+  def test_differs_requests_with_different_query_strings_in_the_log
+    client.get('counter')
+    client.get('counter', q: 'what')
+
+    assert_includes logger.debugs, 'HTTP Cache: [GET /counter] miss, store'
+    assert_includes logger.debugs, 'HTTP Cache: [GET /counter?q=what] miss, store'
+  end
+
+  def test_logs_that_a_stored_GET_response_is_fresh
+    client.get('counter')
+    client.get('counter')
+
+    assert_includes logger.debugs, 'HTTP Cache: [GET /counter] fresh'
+  end
+
+  def test_maintains_the_Date_header_for_cached_responses
+    first_date = client.get('counter').header['Date']
+    second_date = client.get('counter').header['Date']
+
+    assert_equal second_date, first_date
+  end
+
+  def test_preserves_an_old_Date_header_if_present
+    date = client.get('old').header['Date']
+
+    assert_match(/^\w{3}, \d{2} \w{3} \d{4} \d{2}:\d{2}:\d{2} GMT\z/, date)
+  end
+
+  def test_sends_the_Last_Modified_header_on_response_validation
+    client.get('timestamped')
+
+    assert_equal '1', client.get('timestamped').body
+  end
+  #
+  def test_logs_that_the_request_with_Last_Modified_was_revalidated
+    client.get('timestamped')
+
+    assert_equal '1', client.get('timestamped').body
+    assert_includes logger.debugs, 'HTTP Cache: [GET /timestamped] valid, store'
+  end
+
+  def test_sends_the_If_None_Match_header_on_response_validation
+    client.get('etag')
+
+    assert_equal '1', client.get('etag').body
+  end
+
+  def test_logs_that_the_request_with_ETag_was_revalidated
+    client.get('etag')
+
+    assert_equal '1', client.get('etag').body
+    assert_includes logger.debugs, 'HTTP Cache: [GET /etag] valid, store'
+  end
+
+  def test_updates_the_Cache_Control_header_when_a_response_is_validated
+    first_cache_control  = client.get('etag').header['Cache-Control']
+    second_cache_control = client.get('etag').header['Cache-Control']
+
+    refute_equal first_cache_control, second_cache_control
+  end
+
+  def test_updates_the_Date_header_when_a_response_is_validated
+    first_date  = client.get('etag').header['Date']
+    second_date = client.get('etag').header['Date']
+
+    refute_equal first_date, second_date
+  end
+
+  def test_updates_the_Expires_header_when_a_response_is_validated
+    first_expires  = client.get('etag').header['Expires']
+    second_expires = client.get('etag').header['Expires']
+
+    refute_equal first_expires, second_expires
+  end
+  #
+  def test_updates_the_Vary_header_when_a_response_is_validated
+    first_vary  = client.get('etag').header['Vary']
+    second_vary = client.get('etag').header['Vary']
+
+    refute_equal first_vary, second_vary
+  end
+
+  def test_shared_cache_does_not_cache_private_requests
+    client.get('private')
+
+    assert_equal '2', client.get('private').body
+  end
+
+  def test_shared_cache_logs_invalid_request
+    client.get('private')
+
+    assert_includes logger.debugs, 'HTTP Cache: [GET /private] miss, invalid'
+  end
+
+  def test_private_cache_caches_private_requests
+    client.connection = Hurley::HttpCache.new(logger: logger, shared_cache: false)
+    client.get('private')
+
+    assert_equal '1', client.get('private').body
+  end
+
+  def test_private_cache_logs_valid_requests
+    client.connection = Hurley::HttpCache.new(logger: logger, shared_cache: false)
+    client.get('private')
+
+    assert_includes logger.debugs, 'HTTP Cache: [GET /private] miss, store'
+  end
+
+  def test_no_cache_bypasses_cache
+    client.get('counter')
+
+    assert_equal '2', (client.get('counter') { |req| req.header['Cache-Control'] = 'no-cache' }).body
+  end
+
+  def test_no_cache_caches_the_response
+    client.get('counter') { |req| req.header['Cache-Control'] = 'no-cache' }
+
+    assert_equal '1', client.get('counter').body
+  end
+
+  private
+
+  def logger
+    @logger ||= TestLogger.new
+  end
+
+  def connection
+    @connection ||= Hurley::HttpCache.new(logger: logger)
+  end
+end