rack-cache 0.2.0

data/test/logging_test.rb

@@ -0,0 +1,45 @@
+require "#{File.dirname(__FILE__)}/spec_setup"
+require 'rack/cache/context'
+
+describe "Rack::Cache::Context logging" do
+
+  before(:each) do
+    respond_with 200
+    @errors = StringIO.new
+    @cache = Rack::Cache::Context.new(@app)
+    @cache.errors = @errors
+    @cache.metaclass.send :public, :log, :trace, :warn, :info
+  end
+
+  it 'responds to #log by writing message to #errors' do
+    @cache.log :test, 'is this thing on?'
+    @errors.string.should.be == "[cache] test: is this thing on?\n"
+  end
+
+  it 'allows printf formatting arguments' do
+    @cache.log :test, '%s %p %i %x', 'hello', 'goodbye', 42, 66
+    @errors.string.should.be == "[cache] test: hello \"goodbye\" 42 42\n"
+  end
+
+  it 'responds to #info by logging an :info message' do
+    @cache.info 'informative stuff'
+    @errors.string.should.be == "[cache] info: informative stuff\n"
+  end
+
+  it 'responds to #warn by logging an :warn message' do
+    @cache.warn 'kinda/maybe bad stuff'
+    @errors.string.should.be == "[cache] warn: kinda/maybe bad stuff\n"
+  end
+
+  it 'responds to #trace by logging a :trace message' do
+    @cache.trace 'some insignifacant event'
+    @errors.string.should.be == "[cache] trace: some insignifacant event\n"
+  end
+
+  it "doesn't log trace messages when not in verbose mode" do
+    @cache.verbose = false
+    @cache.trace 'some insignifacant event'
+    @errors.string.should.be == ""
+  end
+
+end

data/test/metastore_test.rb

@@ -0,0 +1,210 @@
+require "#{File.dirname(__FILE__)}/spec_setup"
+require 'rack/cache/metastore'
+
+describe_shared 'A Rack::Cache::MetaStore Implementation' do
+
+  before do
+    @request = mock_request('/', {})
+    @response = mock_response(200, {}, ['hello world'])
+    @entity_store = nil
+  end
+  after do
+    @store = nil
+    @entity_store = nil
+  end
+
+  # Low-level implementation methods ===========================================
+
+  it 'writes a list of negotation tuples with #write' do
+    lambda { @store.write('/test', [[{}, {}]]) }.should.not.raise
+  end
+
+  it 'reads a list of negotation tuples with #read' do
+    @store.write('/test', [[{},{}],[{},{}]])
+    tuples = @store.read('/test')
+    tuples.should.be == [ [{},{}], [{},{}] ]
+  end
+
+  it 'reads an empty list with #read when nothing cached at key' do
+    @store.read('/nothing').should.be.empty
+  end
+
+  it 'removes entries for key with #purge' do
+    @store.write('/test', [[{},{}]])
+    @store.read('/test').should.not.be.empty
+
+    @store.purge('/test')
+    @store.read('/test').should.be.empty
+  end
+
+  it 'succeeds when purging non-existing entries' do
+    @store.read('/test').should.be.empty
+    @store.purge('/test')
+  end
+
+  it 'returns nil from #purge' do
+    @store.write('/test', [[{},{}]])
+    @store.purge('/test').should.be nil
+    @store.read('/test').should.be == []
+  end
+
+  %w[/test http://example.com:8080/ /test?x=y /test?x=y&p=q].each do |key|
+    it "can read and write key: '#{key}'" do
+      lambda { @store.write(key, [[{},{}]]) }.should.not.raise
+      @store.read(key).should.be == [[{},{}]]
+    end
+  end
+
+  it "can read and write fairly large keys" do
+    key = "b" * 4096
+    lambda { @store.write(key, [[{},{}]]) }.should.not.raise
+    @store.read(key).should.be == [[{},{}]]
+  end
+
+  # Abstract methods ===========================================================
+
+  define_method :store_simple_entry do
+    @request = mock_request('/test', {})
+    @response = mock_response(200, {'Cache-Control' => 'max-age=420'}, ['test'])
+    body = @response.body
+    @store.store(@request, @response, @entity_store)
+    @response.body.should.not.be body
+  end
+
+  it 'stores a cache entry' do
+    store_simple_entry
+    @store.read('/test').should.not.be.empty
+  end
+
+  it 'sets the X-Content-Digest response header before storing' do
+    store_simple_entry
+    req, res = @store.read('/test').first
+    res['X-Content-Digest'].should.be == 'a94a8fe5ccb19ba61c4c0873d391e987982fbbd3'
+  end
+
+  it 'finds a stored entry with #lookup' do
+    store_simple_entry
+    response = @store.lookup(@request, @entity_store)
+    response.should.not.be.nil
+    response.should.be.kind_of Rack::Cache::Response
+  end
+
+  it 'restores response headers properly with #lookup' do
+    store_simple_entry
+    response = @store.lookup(@request, @entity_store)
+    response.headers.reject{|k,v| k =~ /^X-/}.
+      should.be == @response.headers.merge('Age' => '0', 'Content-Length' => '4')
+  end
+
+  it 'restores response body from entity store with #lookup' do
+    store_simple_entry
+    response = @store.lookup(@request, @entity_store)
+    body = '' ; response.body.each {|p| body << p}
+    body.should.be == 'test'
+  end
+
+  # Vary =======================================================================
+
+  it 'does not return entries that Vary with #lookup' do
+    req1 = mock_request('/test', {'HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'})
+    req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
+    res = mock_response(200, {'Vary' => 'Foo Bar'}, ['test'])
+    @store.store(req1, res, @entity_store)
+
+    @store.lookup(req2, @entity_store).should.be.nil
+  end
+
+  it 'stores multiple responses for each Vary combination' do
+    req1 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
+    res1 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 1'])
+    @store.store(req1, res1, @entity_store)
+
+    req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
+    res2 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 2'])
+    @store.store(req2, res2, @entity_store)
+
+    req3 = mock_request('/test', {'HTTP_FOO' => 'Baz',   'HTTP_BAR' => 'Boom'})
+    res3 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 3'])
+    @store.store(req3, res3, @entity_store)
+
+    slurp(@store.lookup(req3, @entity_store).body).should.be == 'test 3'
+    slurp(@store.lookup(req1, @entity_store).body).should.be == 'test 1'
+    slurp(@store.lookup(req2, @entity_store).body).should.be == 'test 2'
+
+    @store.read('/test').length.should.be == 3
+  end
+
+  it 'overwrites non-varying responses with #store' do
+    req1 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
+    res1 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 1'])
+    @store.store(req1, res1, @entity_store)
+    slurp(@store.lookup(req1, @entity_store).body).should.be == 'test 1'
+
+    req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
+    res2 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 2'])
+    @store.store(req2, res2, @entity_store)
+    slurp(@store.lookup(req2, @entity_store).body).should.be == 'test 2'
+
+    req3 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
+    res3 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 3'])
+    @store.store(req3, res3, @entity_store)
+    slurp(@store.lookup(req1, @entity_store).body).should.be == 'test 3'
+
+    @store.read('/test').length.should.be == 2
+  end
+
+  # Helper Methods =============================================================
+
+  define_method :mock_request do |uri,opts|
+    env = Rack::MockRequest.env_for(uri, opts || {})
+    Rack::Cache::Request.new(env)
+  end
+
+  define_method :mock_response do |status,headers,body|
+    headers ||= {}
+    body = Array(body).compact
+    Rack::Cache::Response.new(status, headers, body)
+  end
+
+  define_method :slurp do |body|
+    buf = ''
+    body.each {|part| buf << part }
+    buf
+  end
+
+end
+
+
+describe 'Rack::Cache::MetaStore' do
+  describe 'Heap' do
+    it_should_behave_like 'A Rack::Cache::MetaStore Implementation'
+    before do
+      @store = Rack::Cache::MetaStore::Heap.new
+      @entity_store = Rack::Cache::EntityStore::Heap.new
+    end
+  end
+
+  describe 'Disk' do
+    it_should_behave_like 'A Rack::Cache::MetaStore Implementation'
+    before do
+      @temp_dir = create_temp_directory
+      @store = Rack::Cache::MetaStore::Disk.new("#{@temp_dir}/meta")
+      @entity_store = Rack::Cache::EntityStore::Disk.new("#{@temp_dir}/entity")
+    end
+    after do
+      remove_entry_secure @temp_dir
+    end
+  end
+
+  need_memcached 'metastore tests' do
+    describe 'MemCache' do
+      it_should_behave_like 'A Rack::Cache::MetaStore Implementation'
+      before :each do
+        @temp_dir = create_temp_directory
+        $memcached.flush
+        @store = Rack::Cache::MetaStore::MemCache.new($memcached)
+        @entity_store = Rack::Cache::EntityStore::Heap.new
+      end
+    end
+  end
+end

data/test/options_test.rb

@@ -0,0 +1,64 @@
+require "#{File.dirname(__FILE__)}/spec_setup"
+require 'rack/cache/options'
+
+module Rack::Cache::Options
+  option_accessor :foo
+end
+
+class MockOptions
+  include Rack::Cache::Options
+  alias_method :initialize, :initialize_options
+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.be == 'baz'
+    end
+    it 'sets a String option as string' do
+      @options.set 'foo.bar', 'bling'
+      @options.options['foo.bar'].should.be == '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.be == 'bar'
+      @options.options['rack-cache.bar'].should.be == 'baz'
+      @options.options['foo.bar'].should.be == 'bling'
+    end
+  end
+
+  it 'makes options declared with option_accessor available as attributes' do
+    @options.set :foo, 'bar'
+    @options.foo.should.be == 'bar'
+  end
+
+  it 'allows setting multiple options via assignment' do
+    @options.options = { :foo => 'bar', :bar => 'baz', 'foo.bar' => 'bling' }
+    @options.foo.should.be == 'bar'
+    @options.options['foo.bar'].should.be == 'bling'
+    @options.options['rack-cache.bar'].should.be == 'baz'
+  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/response_test.rb

@@ -0,0 +1,37 @@
+require "#{File.dirname(__FILE__)}/spec_setup"
+
+describe 'Rack::Cache::Response' do
+
+  before(:each) {
+    @now = Time.now
+    @response = Rack::Cache::Response.new(200, {'Date' => @now.httpdate}, '')
+    @one_hour_ago = Time.httpdate((Time.now - (60**2)).httpdate)
+  }
+
+  after(:each) {
+    @now, @response, @one_hour_ago = nil
+  }
+
+  it 'responds to cache-related methods' do
+    @response.should.respond_to :ttl
+    @response.should.respond_to :age
+    @response.should.respond_to :date
+  end
+
+  it 'responds to #to_a with a Rack response tuple' do
+    @response.should.respond_to :to_a
+    @response.to_a.should.be == [200, {'Date' => @now.httpdate}, '']
+  end
+
+  it 'retrieves headers with #[]' do
+    @response.headers['X-Foo'] = 'bar'
+    @response.should.respond_to :[]
+    @response['X-Foo'].should.be == 'bar'
+  end
+
+  it 'sets headers with #[]=' do
+    @response.should.respond_to :[]=
+    @response['X-Foo'] = 'bar'
+    @response.headers['X-Foo'].should.be == 'bar'
+  end
+end

data/test/spec_setup.rb

@@ -0,0 +1,189 @@
+require 'pp'
+require 'tmpdir'
+
+[ 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:11215'
+$memcached = nil
+
+def have_memcached?(server=ENV['MEMCACHED'])
+  return true if $memcached
+  require 'memcached'
+  $memcached = Memcached.new(server)
+  $memcached.set('ping', '')
+  true
+rescue LoadError => boom
+  $memcached = nil
+  false
+rescue => boom
+  $memcached = nil
+  false
+end
+
+def need_memcached(forwhat)
+  if have_memcached?
+    yield
+  else
+    STDERR.puts "skipping memcached #{forwhat} (MEMCACHED environment variable not set)"
+  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.send(method, uri, opts)
+    @responses << @response
+    @response
+  end
+
+  def get(stem, env={}, &b)
+    request(:get, 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, "rcl-#{$$}-#{@@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
+end
+