josh-rack-cache 0.5.1

data/test/options_test.rb

@@ -0,0 +1,77 @@
+require "#{File.dirname(__FILE__)}/spec_setup"
+require 'rack/cache/options'
+
+module Rack::Cache::Options
+  option_accessor :foo
+end
+
+class MockOptions
+  include Rack::Cache::Options
+  def initialize
+    @env = nil
+    initialize_options
+  end
+end
+
+describe 'Rack::Cache::Options' do
+  before { @options = MockOptions.new }
+
+  describe '#set' do
+    it 'sets a Symbol option as rack-cache.symbol' do
+      @options.set :bar, 'baz'
+      @options.options['rack-cache.bar'].should.equal 'baz'
+    end
+    it 'sets a String option as string' do
+      @options.set 'foo.bar', 'bling'
+      @options.options['foo.bar'].should.equal 'bling'
+    end
+    it 'sets all key/value pairs when given a Hash' do
+      @options.set :foo => 'bar', :bar => 'baz', 'foo.bar' => 'bling'
+      @options.foo.should.equal 'bar'
+      @options.options['rack-cache.bar'].should.equal 'baz'
+      @options.options['foo.bar'].should.equal 'bling'
+    end
+  end
+
+  it 'makes options declared with option_accessor available as attributes' do
+    @options.set :foo, 'bar'
+    @options.foo.should.equal 'bar'
+  end
+
+  it 'allows setting multiple options via assignment' do
+    @options.options = { :foo => 'bar', :bar => 'baz', 'foo.bar' => 'bling' }
+    @options.foo.should.equal 'bar'
+    @options.options['foo.bar'].should.equal 'bling'
+    @options.options['rack-cache.bar'].should.equal 'baz'
+  end
+
+  it "allows storing the value as a block" do
+    block = Proc.new { "bar block" }
+    @options.set(:foo, &block)
+    @options.options['rack-cache.foo'].should.equal block
+  end
+
+  it 'allows the cache key generator to be configured' do
+    @options.should.respond_to :cache_key
+    @options.should.respond_to :cache_key=
+  end
+
+  it 'allows the meta store to be configured' do
+    @options.should.respond_to :metastore
+    @options.should.respond_to :metastore=
+    @options.metastore.should.not.be nil
+  end
+
+  it 'allows the entity store to be configured' do
+    @options.should.respond_to :entitystore
+    @options.should.respond_to :entitystore=
+    @options.entitystore.should.not.be nil
+  end
+
+  it 'allows log verbosity to be configured' do
+    @options.should.respond_to :verbose
+    @options.should.respond_to :verbose=
+    @options.should.respond_to :verbose?
+    @options.verbose.should.not.be.nil
+  end
+end

data/test/request_test.rb

@@ -0,0 +1,19 @@
+require "#{File.dirname(__FILE__)}/spec_setup"
+require 'rack/cache/request'
+
+describe 'Rack::Cache::Request' do
+  it 'is marked as no_cache when the Cache-Control header includes the no-cache directive' do
+    request = Rack::Cache::Request.new('HTTP_CACHE_CONTROL' => 'public, no-cache')
+    assert request.no_cache?
+  end
+
+  it 'is marked as no_cache when request should not be loaded from cache' do
+    request = Rack::Cache::Request.new('HTTP_PRAGMA' => 'no-cache')
+    assert request.no_cache?
+  end
+
+  it 'is not marked as no_cache when neither no-cache directive is specified' do
+    request = Rack::Cache::Request.new('HTTP_CACHE_CONTROL' => 'public')
+    assert !request.no_cache?
+  end
+end

data/test/response_test.rb

@@ -0,0 +1,178 @@
+require "#{File.dirname(__FILE__)}/spec_setup"
+
+describe 'Rack::Cache::Response' do
+  before :each do
+    @now = Time.httpdate(Time.now.httpdate)
+    @one_hour_ago = Time.httpdate((Time.now - (60**2)).httpdate)
+    @one_hour_later = Time.httpdate((Time.now + (60**2)).httpdate)
+    @res = Rack::Cache::Response.new(200, {'Date' => @now.httpdate}, [])
+  end
+
+  after :each do
+    @now, @res, @one_hour_ago = nil
+  end
+
+  it 'responds to #to_a with a Rack response tuple' do
+    @res.should.respond_to :to_a
+    @res.to_a.should.equal [200, {'Date' => @now.httpdate}, []]
+  end
+
+  describe '#cache_control' do
+    it 'handles multiple name=value pairs' do
+      @res.headers['Cache-Control'] = 'max-age=600, max-stale=300, min-fresh=570'
+      @res.cache_control['max-age'].should.equal '600'
+      @res.cache_control['max-stale'].should.equal '300'
+      @res.cache_control['min-fresh'].should.equal '570'
+    end
+    it 'removes the header when given an empty hash' do
+      @res.headers['Cache-Control'] = 'max-age=600, must-revalidate'
+      @res.cache_control['max-age'].should.equal '600'
+      @res.cache_control = {}
+      @res.headers.should.not.include 'Cache-Control'
+    end
+  end
+
+  describe '#validateable?' do
+    it 'is true when Last-Modified header present' do
+      @res = Rack::Cache::Response.new(200, {'Last-Modified' => @one_hour_ago.httpdate}, [])
+      @res.should.be.validateable
+    end
+    it 'is true when ETag header present' do
+      @res = Rack::Cache::Response.new(200, {'ETag' => '"12345"'}, [])
+      @res.should.be.validateable
+    end
+    it 'is false when no validator is present' do
+      @res = Rack::Cache::Response.new(200, {}, [])
+      @res.should.not.be.validateable
+    end
+  end
+
+  describe '#date' do
+    it 'uses the Date header if present' do
+      @res = Rack::Cache::Response.new(200, {'Date' => @one_hour_ago.httpdate}, [])
+      @res.date.should.equal @one_hour_ago
+    end
+    it 'uses the current time when no Date header present' do
+      @res = Rack::Cache::Response.new(200, {}, [])
+      @res.date.should.be.close Time.now, 1
+    end
+    it 'returns the correct date when the header is modified directly' do
+      @res = Rack::Cache::Response.new(200, { 'Date' => @one_hour_ago.httpdate }, [])
+      @res.date.should.equal @one_hour_ago
+      @res.headers['Date'] = @now.httpdate
+      @res.date.should.equal @now
+    end
+  end
+
+  describe '#max_age' do
+    it 'uses s-maxage cache control directive when present' do
+      @res.headers['Cache-Control'] = 's-maxage=600, max-age=0'
+      @res.max_age.should.equal 600
+    end
+    it 'falls back to max-age when no s-maxage directive present' do
+      @res.headers['Cache-Control'] = 'max-age=600'
+      @res.max_age.should.equal 600
+    end
+    it 'falls back to Expires when no max-age or s-maxage directive present' do
+      @res.headers['Cache-Control'] = 'must-revalidate'
+      @res.headers['Expires'] = @one_hour_later.httpdate
+      @res.max_age.should.equal 60 ** 2
+    end
+    it 'gives a #max_age of nil when no freshness information available' do
+      @res.max_age.should.be.nil
+    end
+  end
+
+  describe '#private=' do
+    it 'adds the private Cache-Control directive when set true' do
+      @res.headers['Cache-Control'] = 'max-age=100'
+      @res.private = true
+      @res.headers['Cache-Control'].split(', ').sort.
+        should.equal ['max-age=100', 'private']
+    end
+    it 'removes the public Cache-Control directive' do
+      @res.headers['Cache-Control'] = 'public, max-age=100'
+      @res.private = true
+      @res.headers['Cache-Control'].split(', ').sort.
+        should.equal ['max-age=100', 'private']
+    end
+  end
+
+  describe '#expire!' do
+    it 'sets the Age to be equal to the max-age' do
+      @res.headers['Cache-Control'] = 'max-age=100'
+      @res.expire!
+      @res.headers['Age'].should.equal '100'
+    end
+    it 'sets the Age to be equal to the s-maxage when both max-age and s-maxage present' do
+      @res.headers['Cache-Control'] = 'max-age=100, s-maxage=500'
+      @res.expire!
+      @res.headers['Age'].should.equal '500'
+    end
+    it 'does nothing when the response is already stale/expired' do
+      @res.headers['Cache-Control'] = 'max-age=5, s-maxage=500'
+      @res.headers['Age'] = '1000'
+      @res.expire!
+      @res.headers['Age'].should.equal '1000'
+    end
+    it 'does nothing when the response does not include freshness information' do
+      @res.expire!
+      @res.headers.should.not.include 'Age'
+    end
+  end
+
+  describe '#ttl' do
+    it 'is nil when no Expires or Cache-Control headers present' do
+      @res.ttl.should.be.nil
+    end
+    it 'uses the Expires header when no max-age is present' do
+      @res.headers['Expires'] = (@res.now + (60**2)).httpdate
+      @res.ttl.should.be.close(60**2, 1)
+    end
+    it 'returns negative values when Expires is in part' do
+      @res.ttl.should.be.nil
+      @res.headers['Expires'] = @one_hour_ago.httpdate
+      @res.ttl.should.be < 0
+    end
+    it 'uses the Cache-Control max-age value when present' do
+      @res.headers['Cache-Control'] = 'max-age=60'
+      @res.ttl.should.be.close(60, 1)
+    end
+  end
+
+  describe '#vary' do
+    it 'is nil when no Vary header is present' do
+      @res.vary.should.be.nil
+    end
+    it 'returns the literal value of the Vary header' do
+      @res.headers['Vary'] = 'Foo Bar Baz'
+      @res.vary.should.equal 'Foo Bar Baz'
+    end
+    it 'can be checked for existence using the #vary? method' do
+      @res.should.respond_to :vary?
+      @res.should.not.vary
+      @res.headers['Vary'] = '*'
+      @res.should.vary
+    end
+  end
+
+  describe '#vary_header_names' do
+    it 'returns an empty Array when no Vary header is present' do
+      @res.vary_header_names.should.be.empty
+    end
+    it 'parses a single header name value' do
+      @res.headers['Vary'] = 'Accept-Language'
+      @res.vary_header_names.should.equal ['Accept-Language']
+    end
+    it 'parses multiple header name values separated by spaces' do
+      @res.headers['Vary'] = 'Accept-Language User-Agent    X-Foo'
+      @res.vary_header_names.should.equal \
+        ['Accept-Language', 'User-Agent', 'X-Foo']
+    end
+    it 'parses multiple header name values separated by commas' do
+      @res.headers['Vary'] = 'Accept-Language,User-Agent,    X-Foo'
+      @res.vary_header_names.should.equal \
+        ['Accept-Language', 'User-Agent', 'X-Foo']
+    end
+  end
+end

data/test/spec_setup.rb

@@ -0,0 +1,237 @@
+require 'pp'
+require 'tmpdir'
+require 'stringio'
+
+[ STDOUT, STDERR ].each { |io| io.sync = true }
+
+begin
+  require 'test/spec'
+rescue LoadError => boom
+  require 'rubygems' rescue nil
+  require 'test/spec'
+end
+
+# Set the MEMCACHED environment variable as follows to enable testing
+# of the MemCached meta and entity stores.
+ENV['MEMCACHED'] ||= 'localhost:11211'
+$memcached = nil
+$memcache = nil
+
+def have_memcached?(server=ENV['MEMCACHED'])
+  return $memcached unless $memcached.nil?
+  v, $VERBOSE = $VERBOSE, nil # silence warnings from memcached
+  require 'memcached'
+  $VERBOSE = v
+  $memcached = Memcached.new(server)
+  $memcached.set('ping', '')
+  true
+rescue LoadError => boom
+  $memcached = false
+  false
+rescue => boom
+  STDERR.puts "memcached not working. related tests will be skipped."
+  $memcached = false
+  false
+end
+
+have_memcached?
+
+def have_memcache?(server=ENV['MEMCACHED'])
+  return $memcache unless $memcache.nil?
+  require 'memcache'
+  $memcache = MemCache.new(server)
+  $memcache.set('ping', '')
+  true
+rescue LoadError => boom
+  $memcache = false
+  false
+rescue => boom
+  STDERR.puts "memcache not working. related tests will be skipped."
+  $memcache = false
+  false
+end
+
+have_memcache?
+
+def need_memcached(forwhat)
+  if have_memcached?
+    yield
+  else
+    STDERR.puts "skipping memcached #{forwhat}"
+  end
+end
+
+def need_memcache(forwhat)
+  if have_memcache?
+    yield
+  else
+    STDERR.puts "skipping memcache #{forwhat}"
+  end
+end
+
+def need_java(forwhat)
+  if RUBY_PLATFORM =~ /java/
+    yield
+  else
+    STDERR.puts "skipping app engine #{forwhat}"
+  end
+end
+
+
+# Setup the load path ..
+$LOAD_PATH.unshift File.dirname(File.dirname(__FILE__)) + '/lib'
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require 'rack/cache'
+
+
+# Methods for constructing downstream applications / response
+# generators.
+module CacheContextHelpers
+
+  # The Rack::Cache::Context instance used for the most recent
+  # request.
+  attr_reader :cache
+
+  # An Array of Rack::Cache::Context instances used for each request, in
+  # request order.
+  attr_reader :caches
+
+  # The Rack::Response instance result of the most recent request.
+  attr_reader :response
+
+  # An Array of Rack::Response instances for each request, in request order.
+  attr_reader :responses
+
+  # The backend application object.
+  attr_reader :app
+
+  def setup_cache_context
+    # holds each Rack::Cache::Context
+    @app = nil
+
+    # each time a request is made, a clone of @cache_template is used
+    # and appended to @caches.
+    @cache_template = nil
+    @cache = nil
+    @caches = []
+    @errors = StringIO.new
+    @cache_config = nil
+
+    @called = false
+    @request = nil
+    @response = nil
+    @responses = []
+
+    @storage = Rack::Cache::Storage.new
+  end
+
+  def teardown_cache_context
+    @app, @cache_template, @cache, @caches, @called,
+    @request, @response, @responses, @cache_config = nil
+  end
+
+  # A basic response with 200 status code and a tiny body.
+  def respond_with(status=200, headers={}, body=['Hello World'])
+    called = false
+    @app =
+      lambda do |env|
+        called = true
+        response = Rack::Response.new(body, status, headers)
+        request = Rack::Request.new(env)
+        yield request, response if block_given?
+        response.finish
+      end
+    @app.meta_def(:called?) { called }
+    @app.meta_def(:reset!) { called = false }
+    @app
+  end
+
+  def cache_config(&block)
+    @cache_config = block
+  end
+
+  def request(method, uri='/', opts={})
+    opts = {
+      'rack.run_once' => true,
+      'rack.errors' => @errors,
+      'rack-cache.storage' => @storage
+    }.merge(opts)
+
+    fail 'response not specified (use respond_with)' if @app.nil?
+    @app.reset! if @app.respond_to?(:reset!)
+
+    @cache_prototype ||= Rack::Cache::Context.new(@app, &@cache_config)
+    @cache = @cache_prototype.clone
+    @caches << @cache
+    @request = Rack::MockRequest.new(@cache)
+    yield @cache if block_given?
+    @response = @request.request(method.to_s.upcase, uri, opts)
+    @responses << @response
+    @response
+  end
+
+  def get(stem, env={}, &b)
+    request(:get, stem, env, &b)
+  end
+
+  def head(stem, env={}, &b)
+    request(:head, stem, env, &b)
+  end
+
+  def post(*args, &b)
+    request(:post, *args, &b)
+  end
+end
+
+
+module TestHelpers
+  include FileUtils
+  F = File
+
+  @@temp_dir_count = 0
+
+  def create_temp_directory
+    @@temp_dir_count += 1
+    path = F.join(Dir.tmpdir, "rack-cache-#{$$}-#{@@temp_dir_count}")
+    mkdir_p path
+    if block_given?
+      yield path
+      remove_entry_secure path
+    end
+    path
+  end
+
+  def create_temp_file(root, file, data='')
+    path = F.join(root, file)
+    mkdir_p F.dirname(path)
+    F.open(path, 'w') { |io| io.write(data) }
+  end
+
+end
+
+class Test::Unit::TestCase
+  include TestHelpers
+  include CacheContextHelpers
+end
+
+# Metaid == a few simple metaclass helper
+# (See http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html.)
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass; class << self; self; end; end
+  def meta_eval(&blk); metaclass.instance_eval(&blk); end
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+
+  # True when the Object is neither false or nil.
+  def truthy?
+    !!self
+  end
+end