cache_rules 0.1.1

data/lib/validations.rb

@@ -0,0 +1,111 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+# Copyright (c) 2014-2015 Alexander Williams, Unscramble <license@unscramble.jp>
+
+module CacheRules
+  extend self
+
+  # HTTP Header Validators
+  #
+  # Parameters must always be normalized
+  #
+  # Return must always be 0 or 1
+  #
+  # The If-Match and If-Unmodified-Since conditional header fields are not applicable to a cache.
+  # source: https://tools.ietf.org/html/rfc7234#section-4.3.2
+
+  def validate_cached?(headers)
+    headers[:cached].length > 0 ? 1 : 0
+  end
+
+  # Precedence: If-None-Match (ETag), then If-Modified-Since (Last-Modified)
+  # source: https://tools.ietf.org/html/rfc7232#section-6
+  def validate_precond_match?(headers)
+    request, cached = headers.values_at :request, :cached
+    return 0 if cached.length == 0
+
+    # Return when the If-None-Match header exists, ignore If-Modified-Since
+    # source: https://tools.ietf.org/html/rfc7232#section-3.3
+    etag_match = helper_etag(request, cached)
+    return etag_match ? 1 : 0 unless etag_match.nil?
+
+    helper_last_modified(request, cached) ? 1 : 0
+  end
+
+  # Compare headers to see if the cached request is expired (Freshness)
+  # source: https://tools.ietf.org/html/rfc7234#section-4.2
+  def validate_expired?(headers)
+    return 0 if headers[:cached].length == 0
+
+    freshness_lifetime, current_age = helper_freshness_lifetime.call headers[:cached]
+
+    response_is_fresh = freshness_lifetime.to_i > current_age
+
+    response_is_fresh ? 0 : 1
+  end
+
+  def validate_only_if_cached?(headers)
+    headers[:request]['Cache-Control'] && headers[:request]['Cache-Control']['only-if-cached'] ? 1 : 0
+  end
+
+  # Serving Stale Responses
+  # source: https://tools.ietf.org/html/rfc7234#section-4.2.4
+  def validate_allow_stale?(headers)
+    request, cached = headers.values_at :request, :cached
+    return 0 if cached.length == 0 || helper_validate_allow_stale(request, cached)
+
+    freshness_lifetime, current_age = helper_freshness_lifetime.call cached
+
+    max_stale = helper_max_stale.call request['Cache-Control'], freshness_lifetime, current_age
+    min_fresh = helper_min_fresh.call request['Cache-Control'], freshness_lifetime, current_age
+
+    (max_stale && min_fresh != false) || (max_stale.nil? && min_fresh) ? 1 : 0
+  end
+
+  # Response Cache-Control Directives
+  # source: https://tools.ietf.org/html/rfc7234#section-5.2.2
+  def validate_must_revalidate?(headers)
+    return 1 if headers[:cached].length == 0
+
+    # source: https://tools.ietf.org/html/rfc7234#section-5.2.2.1
+    # source: https://tools.ietf.org/html/rfc7234#section-5.2.2.7
+    (( cached = headers[:cached]['Cache-Control'] )) && ( cached['must-revalidate'] || cached['proxy-revalidate'] ) ? 1 : 0
+  end
+
+  # Verify if we're explicitly told not to cache the response
+  def validate_no_cache?(headers)
+    request_headers, cached_headers = headers.values_at :request, :cached
+    return 1 if cached_headers.length == 0
+
+    # Must revalidate if this request header exists
+    # source: https://tools.ietf.org/html/rfc7234#section-5.2.1.4
+    return 1 if (( request = request_headers['Cache-Control'] )) &&
+      request_headers['Cache-Control']['no-cache']
+
+    # source: https://tools.ietf.org/html/rfc7234#section-5.2.2.2
+    # source: https://tools.ietf.org/html/rfc7234#section-3.2
+    return 1 if (( cached = cached_headers['Cache-Control'] )) &&
+      helper_no_cache.call(cached_headers)                               ||
+        (cached['no-cache'] && cached['no-cache']['quoted_string'].nil?) ||
+        (cached['s-maxage'] && cached['s-maxage']['token'].to_s == "0")  ||
+        (cached['max-age'] && cached['max-age']['token'].to_s   == "0")
+
+    # source: https://tools.ietf.org/html/rfc7234#section-5.4
+    # Legacy support for HTTP/1.0 Pragma header
+    return 1 if request_headers['Pragma'] && request_headers['Pragma']['no-cache']
+
+    return 0
+  end
+
+  def validate_is_error?(headers)
+    headers[:response]['Status'].to_i.between?(500,599) ? 1 : 0
+  end
+
+  def validate_validator_match?(headers)
+    request, response = headers.values_at :request, :response
+    response['ETag'] && request['If-None-Match'] && request['If-None-Match'].include?(response['ETag']) ? 1 : 0
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'coveralls'
+require 'fakeweb'
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter '/test/'
+  add_filter '.bundle'
+  minimum_coverage 100
+end
+
+require './lib/cache_rules'
+require 'minitest/autorun'
+require 'minitest/unit'
+require 'minitest/reporters'
+
+Minitest::Reporters.use! [Minitest::Reporters::SpecReporter.new]
+
+Coveralls.wear!

data/test/test_cache_rules.rb

@@ -0,0 +1,253 @@
+class TestCacheRules < MiniTest::Test
+
+  def setup
+    @request_if_none_match          = CacheRules.normalize.call({ "Host" => "test.com", "If-None-Match" => "*", "Cache-Control" => "max-stale=100000000" })
+    @request_if_modified_since_yes  = CacheRules.normalize.call({ "Host" => "test.com", "If-Modified-Since" => "Thu, 01 Jan 2015 07:03:45 GMT", "Cache-Control" => "max-stale=100000000" })
+    @request_if_modified_since_no   = CacheRules.normalize.call({ "Host" => "test.com" })
+    @cached_headers = {
+      "Date"              => {"httpdate"=>"Thu, 01 Jan 2015 07:03:45 GMT", "timestamp"=>1420095825},
+      "Cache-Control"     => {
+        "public"          => {"token"=>nil, "quoted_string"=>nil}
+      },
+      "X-Cache-Req-Date"  => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625},
+      "X-Cache-Res-Date"  => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}
+    }
+  end
+
+  def test_get_money
+    got_money = CacheRules::Everything::Around::Me.get_the_money
+
+    assert_equal got_money, "Dolla Dolla Bill Y'all"
+  end
+
+  def test_validate_column0
+    request = {"Host"=>"test.url"}
+
+    result = CacheRules.validate('http://test.url/test1', request)
+
+    assert_equal result[:code], 307
+    assert_nil   result[:body]
+    assert_equal result[:headers]['Cache-Lookup'], 'MISS'
+    assert_equal result[:headers]['Location'], "http://test.url/test1"
+  end
+
+  def test_validate_column1
+    request = {"Host"=>"test.url","Cache-Control"=>"only-if-cached"}
+
+    result = CacheRules.validate('http://test.url/test1', request)
+
+    assert_equal result[:code], 504
+    assert_equal result[:body], 'Gateway Timeout'
+    assert_equal result[:headers]['Cache-Lookup'], 'MISS'
+  end
+
+  def test_validate_column2
+    request = {"Host"=>"test.url"}
+    cached  = {"Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Cache-Control"=>{"s-maxage"=>{"token"=>"100000000", "quoted_string"=>nil}}, "X-Cache-Req-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Res-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}} 
+
+    result = CacheRules.validate('http://test.url/test1', request, cached)
+
+    assert_equal result[:code], 200
+    assert_equal result[:body], 'cached'
+    assert_equal result[:headers]['Cache-Lookup'], 'HIT'
+  end
+
+  def test_validate_column3
+    request = {"Host"=>"test.url", "If-None-Match" => "*"}
+    cached  = {"Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Cache-Control"=>{"s-maxage"=>{"token"=>"100000000", "quoted_string"=>nil}}, "X-Cache-Req-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Res-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "ETag" => "\"validEtag\""} 
+
+    result = CacheRules.validate('http://test.url/test1', request, cached)
+
+    assert_equal result[:code], 304
+    assert_nil   result[:body]
+    assert_equal result[:headers]['Cache-Lookup'], 'HIT'
+  end
+
+  def test_validate_column4
+    request = {"Host"=>"test.url", "Cache-Control"=>"max-stale=10000000"}
+    cached  = {"Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Req-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Res-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "ETag" => "\"validEtag\"", "Cache-Control"=>{"max-age"=>{"token"=>"100", "quoted_string" => nil}}} 
+
+    result = CacheRules.validate('http://test.url/test1', request, cached)
+
+    assert_equal result[:code], 200
+    assert_equal result[:body], 'stale'
+    assert_equal result[:headers]['Cache-Lookup'], 'STALE'
+    assert_equal result[:headers]['Warning'], "110 - \"Response is Stale\""
+  end
+
+  def test_validate_column5
+    request = {"Host"=>"test.url", "Cache-Control"=>"max-stale=10000000", "If-None-Match"=>"*"}
+    cached  = {"Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Req-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Res-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "ETag" => "\"validEtag\"", "Cache-Control"=>{"max-age"=>{"token"=>"100", "quoted_string" => nil}}} 
+
+    result = CacheRules.validate('http://test.url/test1', request, cached)
+
+    assert_equal result[:code], 304
+    assert_nil   result[:body]
+    assert_equal result[:headers]['Cache-Lookup'], 'STALE'
+    assert_equal result[:headers]['Warning'], "110 - \"Response is Stale\""
+  end
+
+  def test_validate_column6
+    request = {"Host"=>"test.url", "Cache-Control"=>"max-stale=0", "If-None-Match"=>"*"}
+    cached  = {"Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Req-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Res-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "ETag" => "\"validEtag\"", "Cache-Control"=>{"max-age"=>{"token"=>"100", "quoted_string" => nil}}} 
+
+    result = CacheRules.validate('http://test.url/test1', request, cached)
+
+    assert_equal result[:code], 504
+    assert_equal result[:body], 'Gateway Timeout'
+    assert_equal result[:headers]['Cache-Lookup'], 'EXPIRED'
+  end
+
+  def test_validate_column7
+    request = {"Host"=>"test.url", "Cache-Control"=>"max-stale=0", "If-None-Match"=>"*"}
+    cached  = {"Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Req-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Res-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "ETag" => "\"validEtag\"", "Cache-Control"=>{"max-age"=>{"token"=>"100", "quoted_string" => nil}, "must-revalidate"=>{"token"=>nil, "quoted_string"=>nil}}} 
+
+    FakeWeb.register_uri(:head, "http://test.url/test1", :status => ["304", "Not Modified"], :date => "Sat, 03 Jan 2015 07:15:45 GMT")
+    result = CacheRules.validate('http://test.url/test1', request, cached)
+
+    assert_equal result[:code], 307
+    assert_nil   result[:body]
+    assert_equal result[:headers]['Cache-Lookup'], 'EXPIRED'
+    assert_equal result[:headers]['Location'], "http://test.url/test1"
+  end
+
+  def test_validate_column8
+    request = {"Host"=>"test.url", "Cache-Control"=>"max-stale=0", "If-None-Match"=>"*"}
+    cached  = {"Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Req-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Res-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "ETag" => "\"validEtag\"", "Cache-Control"=>{"max-age"=>{"token"=>"100", "quoted_string" => nil}, "no-cache"=>{"token"=>nil, "quoted_string"=>nil}}}
+
+    FakeWeb.register_uri(:head, "http://test.url/test1", :status => ["304", "Not Modified"], :date => "Sat, 03 Jan 2015 07:15:45 GMT")
+    result = CacheRules.validate('http://test.url/test1', request, cached)
+
+    assert_equal result[:code], 307
+    assert_nil   result[:body]
+    assert_equal result[:headers]['Cache-Lookup'], 'EXPIRED'
+    assert_equal result[:headers]['Location'], "http://test.url/test1"
+  end
+
+  def test_revalidate_response_column0
+    request = {"Host"=>"test.url", "If-None-Match"=>["*"], "Cache-Control"=>{"max-age"=>{"token"=>"100000000", "quoted_string"=>nil}}}
+    cached  = {"Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Cache-Control"=>{"s-maxage"=>{"token"=>"100000000", "quoted_string"=>nil}}, "X-Cache-Req-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Res-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}} 
+
+    FakeWeb.register_uri(:head, "http://test.url/test1", :status => ["304", "Not Modified"], :date => "Sat, 03 Jan 2015 07:15:45 GMT")
+    result = CacheRules.revalidate_response('http://test.url/test1', request, cached)
+
+    assert_equal result[:code], 200
+    assert_equal result[:body], 'cached'
+    assert_equal result[:headers]['Cache-Lookup'], 'REVALIDATED'
+  end
+
+  def test_revalidate_response_column1
+    request = {"Host"=>"test.url", "If-None-Match"=>["\"validEtag\""], "Cache-Control"=>{"max-age"=>{"token"=>"100000000", "quoted_string"=>nil}}}
+    cached  = {"Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Cache-Control"=>{"s-maxage"=>{"token"=>"100000000", "quoted_string"=>nil}}, "X-Cache-Req-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Res-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "ETag" => "\"validEtag\""} 
+
+    FakeWeb.register_uri(:head, "http://test.url/test1", :status => ["304", "Not Modified"], :date => "Sat, 03 Jan 2015 07:15:45 GMT", :ETag => "\"validEtag\"")
+    result = CacheRules.revalidate_response('http://test.url/test1', request, cached)
+
+    assert_equal result[:code], 304
+    assert_nil   result[:body]
+    assert_equal result[:headers]['Cache-Lookup'], 'REVALIDATED'
+    assert_equal result[:headers]['ETag'], "\"validEtag\""
+  end
+
+  def test_revalidate_response_column2_5xx
+    request = {"Host"=>"test.url", "If-None-Match"=>["\"validEtag\""], "Cache-Control"=>{"max-age"=>{"token"=>"100000000", "quoted_string"=>nil}}}
+    cached  = {"Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Cache-Control"=>{"s-maxage"=>{"token"=>"100000000", "quoted_string"=>nil}}, "X-Cache-Req-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Res-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "ETag" => "\"validEtag\""} 
+
+    FakeWeb.register_uri(:head, "http://test.url/test1", :status => ["504", "Gateway Timeout"], :date => "Sat, 03 Jan 2015 07:15:45 GMT", :ETag => "\"validEtag\"")
+    result = CacheRules.revalidate_response('http://test.url/test1', request, cached)
+
+    assert_equal result[:code], 504
+    assert_equal result[:body], 'Gateway Timeout'
+    assert_equal result[:headers]['Cache-Lookup'], 'EXPIRED'
+  end
+
+  def test_revalidate_response_column2_error
+    result = CacheRules.revalidate_response('ftp://test.url/test1', {}, {})
+
+    assert_equal result[:code], 504
+    assert_equal result[:body], 'Gateway Timeout'
+    assert result[:error]
+  end
+
+  def test_revalidate_response_column3
+    request = {"Host"=>"test.url", "If-None-Match"=>["*"], "Cache-Control"=>{"max-stale"=>{"token"=>"100000000", "quoted_string"=>nil}}}
+    cached  = {"Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Req-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Res-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "ETag" => "\"validEtag\""} 
+
+    FakeWeb.register_uri(:head, "http://test.url/test1", :status => ["504", "Gateway Timeout"], :date => "Sat, 03 Jan 2015 07:15:45 GMT")
+    result = CacheRules.revalidate_response('http://test.url/test1', request, cached)
+
+    assert_equal result[:code], 200
+    assert_equal result[:body], 'stale'
+    assert_equal result[:headers]['Warning'], "111 - \"Revalidation Failed\""
+    assert_equal result[:headers]['Cache-Lookup'], 'STALE'
+  end
+
+  def test_revalidate_response_column4
+    request = {"Host"=>"test.url", "If-None-Match"=>["\"validEtag\""], "Cache-Control"=>{"max-stale"=>{"token"=>"100000000", "quoted_string"=>nil}}}
+    cached  = {"Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Req-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Res-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "Last-Modified" => {"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "ETag" => "\"validEtag\""} 
+
+    FakeWeb.register_uri(:head, "http://test.url/test1", :status => ["504", "Gateway Timeout"], :date => "Sat, 03 Jan 2015 07:15:45 GMT", :ETag => "\"validEtag\"")
+    result = CacheRules.revalidate_response('http://test.url/test1', request, cached)
+
+    assert_equal result[:code], 304
+    assert_nil   result[:body]
+    assert_equal result[:headers]['Warning'], "111 - \"Revalidation Failed\""
+    assert_equal result[:headers]['Cache-Lookup'], 'STALE'
+    assert_equal result[:headers]['ETag'], "\"validEtag\""
+  end
+
+  def test_revalidate_response_column5
+    request = {"Host"=>"test.url", "If-None-Match"=>["*"], "Cache-Control"=>{"max-stale"=>{"token"=>"100000000", "quoted_string"=>nil}}}
+    cached  = {"Date"=>{"httpdate"=>"Thu, 01 Jan 2015 07:03:45 GMT", "timestamp"=>1420095825}, "Cache-Control"=>{"public"=>{"token"=>nil, "quoted_string"=>nil}}, "X-Cache-Req-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}, "X-Cache-Res-Date"=>{"httpdate"=>"Sat, 03 Jan 2015 07:03:45 GMT", "timestamp"=>1420268625}} 
+
+    FakeWeb.register_uri(:head, "http://test.url/test1", :status => ["200", "OK"])
+    result = CacheRules.revalidate_response('http://test.url/test1', request, cached)
+
+    assert_equal result[:code], 307
+    assert_nil   result[:body]
+    assert_equal result[:headers]['Cache-Lookup'], 'EXPIRED'
+    assert_equal result[:headers]['Location'], "http://test.url/test1"
+  end
+
+  def test_make_http_request_with_entity_tag
+    result  = CacheRules.make_request.call('http://test.url', @request_if_none_match, @cached_headers)
+    http    = eval "http",    result.binding
+    request = eval "request", result.binding
+
+    assert_kind_of  Proc, result
+    assert_kind_of  FalseClass, http.use_ssl?
+    assert_equal    http.address, 'test.url'
+    assert_equal    http.port, 80
+    assert_equal    request.method, 'HEAD'
+  end
+
+  def test_make_http_request_with_last_modified
+    result  = CacheRules.make_request.call('http://test.url', @request_if_modified_since_yes, @cached_headers)
+    http    = eval "http",    result.binding
+    request = eval "request", result.binding
+
+    assert_kind_of  Proc, result
+    assert_kind_of  FalseClass, http.use_ssl?
+    assert_equal    http.address, 'test.url'
+    assert_equal    http.port, 80
+    assert_equal    request.method, 'HEAD'
+  end
+
+  def test_make_http_request_without_preconditions
+    result  = CacheRules.make_request.call('https://test.url', @request_if_modified_since_no, @cached_headers)
+    http    = eval "http",    result.binding
+    request = eval "request", result.binding
+
+    assert_kind_of  Proc, result
+    assert_kind_of  TrueClass, http.use_ssl?
+    assert_equal    http.address, 'test.url'
+    assert_equal    http.port, 443
+    assert_equal    request.method, 'HEAD'
+  end
+
+  def test_raises_an_error_if_the_url_is_invalid
+    assert_raises(SocketError)   { CacheRules.make_request.call('http://test.urlzzz', {}, {}).call }
+    assert_raises(NoMethodError) { CacheRules.make_request.call('ftp://test.urlzzz', {}, {}).call }
+  end
+
+end

data/test/test_formatting.rb

@@ -0,0 +1,135 @@
+class TestFormatting < MiniTest::Test
+
+  def setup
+    @request_headers = {
+      "Version"       => "HTTP/1.1",
+      "user-agent"    => "test user agent",
+      "Cookie"        => "testcookie=deleteme",
+      "If-Modified-Since" => "Thu, 01 Jan 2015 07:03:42 GMT",
+      "Cache-Control" => "max-stale=1000, no-cache=\"Cookie\", no-store",
+      "Referer"       => "http://some.url"
+    }
+    @cached_headers = {
+      "Retry-After" => 60,
+      "Cache-Control"     => {
+        "public"          => {"token"=>nil, "quoted_string"=>nil},
+        "max-stale"       => {"token"=>"1000", "quoted_string"=>nil},
+        "no-cache"        => {"token"=>nil, "quoted_string"=>"Cookie"}
+      },
+      "Last-Modified"     => {"httpdate"=>"Thu, 01 Jan 2015 07:03:42 GMT", "timestamp"=>1420095822},
+      "ETag"              => "\"validEtag\""
+    }
+    @nocache_headers = {"Version"=>"HTTP/1.1", "Set-Cookie"=>"test", "Cookie"=>"test", "Accept-Ranges"=>"test", "Range"=>"test", "If-Range"=>"test", "Content-Range"=>"test", "Referer"=>"http://test.url", "From"=>"test", "Authorization"=>"test", "Proxy-Authorization"=>"test", "User-Agent"=>"test", "If-Modified-Since"=>"invalid date"}
+    @duplicate_headers = [
+      ['Accept', 'text/html'],
+      ['Accept', 'application/json']
+    ]
+    @non_duplicate_headers = [
+      ['Age', '12345'],
+      ['Age', '67890']
+    ]
+    @normalized          = {"Version"=>"HTTP/1.1", "User-Agent"=>"test user agent", "If-Modified-Since"=>{"httpdate"=>"Thu, 01 Jan 2015 07:03:42 GMT", "timestamp"=>1420095822}, "Cache-Control"=>{"max-stale"=>{"token"=>"1000", "quoted_string"=>nil}, "no-cache"=>{"token"=>nil, "quoted_string"=>"Cookie"}, "no-store"=>{"token"=>nil, "quoted_string"=>nil}}}
+    @normalized_fields   = [["Version", "HTTP/1.1"], ["user-agent", "test user agent"], ["Cookie", "testcookie=deleteme"], ["If-Modified-Since", {"httpdate"=>"Thu, 01 Jan 2015 07:03:42 GMT", "timestamp"=>1420095822}], ["Cache-Control", {"max-stale"=>{"token"=>"1000", "quoted_string"=>nil}, "no-cache"=>{"token"=>nil, "quoted_string"=>"Cookie"}, "no-store"=>{"token"=>nil, "quoted_string"=>nil}}], ["Referer", "http://some.url"]]
+    @unnormalized_fields = {"Retry-After"=>"60", "Cache-Control"=>"public, max-stale=1000, no-cache=\"Cookie\"", "Last-Modified"=>"Thu, 01 Jan 2015 07:03:42 GMT", "ETag"=>"\"validEtag\""}
+  end
+
+  def test_normalize
+    normalized = CacheRules.normalize.call @request_headers
+
+    assert_kind_of Hash, normalized
+
+    assert_includes normalized, 'Version'
+    assert_includes normalized, 'User-Agent'
+    assert_includes normalized, 'If-Modified-Since'
+    assert_includes normalized, 'Cache-Control'
+
+    assert_equal normalized, @normalized
+  end
+
+  def test_format_key
+    etag = CacheRules.format_key.call 'etag', 'test value'
+    user = CacheRules.format_key.call 'user-agent', 'test user agent'
+    vary = CacheRules.format_key.call 'Vary', '*'
+
+    assert_equal etag, ['ETag', 'test value']
+    assert_equal user, ['User-Agent', 'test user agent']
+    assert_equal vary, ['Vary', '*']
+  end
+
+  def test_clean
+    cleaned     = CacheRules.clean.call @nocache_headers
+    # if_modified = CacheRules.clean.call @nocache_headers
+    assert_equal cleaned, [['Version', 'HTTP/1.1'], ['User-Agent', 'test']]
+  end
+
+  def test_combine
+    combined     = CacheRules.combine.call @duplicate_headers
+    not_combined = CacheRules.combine.call @non_duplicate_headers
+
+    assert_equal combined, [['Accept', 'text/html, application/json']]
+    assert_equal not_combined, [['Age', '12345']]
+  end
+
+  def test_normalize_fields
+    normalized = CacheRules.normalize_fields.call @request_headers
+
+    assert_kind_of Array, normalized
+    assert_equal normalized, @normalized_fields
+  end
+
+  def test_unnormalize_fields
+    unnormalized = CacheRules.unnormalize_fields.call @cached_headers
+
+    assert_kind_of Hash, unnormalized
+    assert_equal unnormalized, @unnormalized_fields
+  end
+
+  def test_format_field
+    httpdate        = CacheRules.format_field.call 'If-Modified-Since', @request_headers['If-Modified-Since']
+    cache_control   = CacheRules.format_field.call 'Cache-Control', @request_headers['Cache-Control']
+    csv             = CacheRules.format_field.call 'Accept', 'text/html, application/json'
+    retry_after     = CacheRules.format_field.call 'Retry-After', 60
+    retry_after_abs = CacheRules.format_field.call 'Retry-After', -100
+    retry_after_date= CacheRules.format_field.call 'Retry-After', 'Thu, 01 Jan 2015 07:03:42 GMT', false
+    other           = CacheRules.format_field.call 'Version', @request_headers['Version'], false
+
+    cur_time  = Time.now.gmtime.to_i
+    baddate   = CacheRules.format_field.call 'If-Modified-Since', 'invalid date'
+
+    assert_kind_of Array, baddate
+
+    assert_equal httpdate,          ["If-Modified-Since", {"httpdate"=>"Thu, 01 Jan 2015 07:03:42 GMT", "timestamp"=>1420095822}]
+    assert_equal cache_control,     ["Cache-Control", {"max-stale"=>{"token"=>"1000", "quoted_string"=>nil}, "no-cache"=>{"token"=>nil, "quoted_string"=>"Cookie"}, "no-store"=>{"token"=>nil, "quoted_string"=>nil}}]
+    assert_equal csv,               ["Accept", ["text/html", "application/json"]]
+    assert_equal retry_after,       ["Retry-After", 60]
+    assert_equal retry_after_abs,   ["Retry-After", 100]
+    assert_equal retry_after_date,  ["Retry-After", {"httpdate"=>"Thu, 01 Jan 2015 07:03:42 GMT", "timestamp"=>1420095822}]
+    assert_equal other,             ["Version", "HTTP/1.1"]
+
+    assert_in_delta baddate[1]["timestamp"], (cur_time - 300), 2, "Check the httpdate_helper, ensure it's 300 seconds, or increase the delta"
+  end
+
+  def test_format_field_string
+    cache_control = CacheRules.format_field.call 'Cache-Control', @cached_headers['Cache-Control'], true
+    csv           = CacheRules.format_field.call 'Accept', ["text/html", "application/json"], true
+
+    assert_equal cache_control, ["Cache-Control", "public, max-stale=1000, no-cache=\"Cookie\""]
+    assert_equal csv,           ["Accept", "text/html, application/json"]
+  end
+
+  def test_httpdate_helper
+    httpdate = "Sun, 06 Nov 1994 08:49:37 GMT"
+    rfc850   = "Sunday, 06-Nov-94 08:49:37 GMT"
+    ansi_c   = "Sun Nov 6 08:49:37 1994"
+    result   = 784111777
+
+    timestamp1 = CacheRules.httpdate_helper httpdate
+    timestamp2 = CacheRules.httpdate_helper rfc850
+    timestamp3 = CacheRules.httpdate_helper ansi_c
+
+    assert_equal timestamp1, result
+    assert_equal timestamp2, result
+    assert_equal timestamp3, result
+  end
+
+end