rtomayko-rack-cache 0.2.0 → 0.3.0

data/test/core_test.rb

@@ -24,15 +24,15 @@ describe 'Rack::Cache::Core' do
   it 'executes multiple handlers in LIFO order' do
     x = 'nothing executed'
     @core.on :foo do
-      x.should.be == 'bottom executed'
+      x.should.equal 'bottom executed'
       x = 'top executed'
     end
     @core.on :foo do
-      x.should.be == 'nothing executed'
+      x.should.equal 'nothing executed'
       x = 'bottom executed'
     end
     @core.trigger :foo
-    x.should.be == 'top executed'
+    x.should.equal 'top executed'
   end
   it 'records event execution history' do
     @core.on(:foo) {}
@@ -59,8 +59,8 @@ describe 'Rack::Cache::Core' do
     @core.on(:bar) {}
     @core.on(:foo) { throw(:transition, [:bar, 1, 2, 3]) }
     result = @core.transition(from=:foo, to=[:bar])
-    passed.should.be == [1,2,3]
-    result.should.be == 'hi'
+    passed.should.equal [1,2,3]
+    result.should.equal 'hi'
   end
   it 'fully transitions out of handlers when the next event is invoked' do
     x = []
@@ -70,15 +70,15 @@ describe 'Rack::Cache::Core' do
       x << 'in foo, after transitioning to bar'
     }
     @core.on(:bar) { x << 'in bar' }
-    @core.trigger(:foo).should.be == [:bar]
+    @core.trigger(:foo).should.equal [:bar]
     @core.trigger(:bar).should.be.nil
-    x.should.be == [
+    x.should.equal [
       'in foo, before transitioning to bar',
       'in bar'
     ]
   end
   it 'returns the transition event name' do
     @core.on(:foo) { throw(:transition, [:bar]) }
-    @core.trigger(:foo).should.be == [:bar]
+    @core.trigger(:foo).should.equal [:bar]
   end
 end

data/test/entitystore_test.rb

@@ -21,7 +21,7 @@ describe_shared 'A Rack::Cache::EntityStore Implementation' do
     key.should.be.sha_like
 
     data = @store.read(key)
-    data.should.be == 'My wild love went riding,'
+    data.should.equal 'My wild love went riding,'
   end
 
   it 'correctly determines whether cached body exists for key with #exist?' do
@@ -33,20 +33,20 @@ describe_shared 'A Rack::Cache::EntityStore Implementation' do
   it 'can read data written with #write' do
     key, size = @store.write('And asked him to pay.')
     data = @store.read(key)
-    data.should.be == 'And asked him to pay.'
+    data.should.equal 'And asked him to pay.'
   end
 
   it 'gives a 40 character SHA1 hex digest from #write' do
     key, size = @store.write('she rode to the sea;')
     key.should.not.be.nil
-    key.length.should.be == 40
+    key.length.should.equal 40
     key.should.be =~ /^[0-9a-z]+$/
-    key.should.be == '90a4c84d51a277f3dafc34693ca264531b9f51b6'
+    key.should.equal '90a4c84d51a277f3dafc34693ca264531b9f51b6'
   end
 
   it 'returns the entire body as a String from #read' do
     key, size = @store.write('She gathered together')
-    @store.read(key).should.be == 'She gathered together'
+    @store.read(key).should.equal 'She gathered together'
   end
 
   it 'returns nil from #read when key does not exist' do
@@ -59,7 +59,7 @@ describe_shared 'A Rack::Cache::EntityStore Implementation' do
     body.should.respond_to :each
     buf = ''
     body.each { |part| buf << part }
-    buf.should.be == 'Some shells for her hair.'
+    buf.should.equal 'Some shells for her hair.'
   end
 
   it 'returns nil from #open when key does not exist' do
@@ -69,12 +69,17 @@ describe_shared 'A Rack::Cache::EntityStore Implementation' do
   it 'can store largish bodies with binary data' do
     pony = File.read(File.dirname(__FILE__) + '/pony.jpg')
     key, size = @store.write(pony)
-    key.should.be == 'd0f30d8659b4d268c5c64385d9790024c2d78deb'
+    key.should.equal 'd0f30d8659b4d268c5c64385d9790024c2d78deb'
     data = @store.read(key)
-    data.length.should.be == pony.length
-    data.hash.should.be == pony.hash
+    data.length.should.equal pony.length
+    data.hash.should.equal pony.hash
   end
 
+  it 'deletes stored entries with #purge' do
+    key, size = @store.write('My wild love went riding,')
+    @store.purge(key).should.be.nil
+    @store.read(key).should.be.nil
+  end
 end
 
 describe 'Rack::Cache::EntityStore' do
@@ -84,7 +89,7 @@ describe 'Rack::Cache::EntityStore' do
     before { @store = Rack::Cache::EntityStore::Heap.new }
     it 'takes a Hash to ::new' do
       @store = Rack::Cache::EntityStore::Heap.new('foo' => ['bar'])
-      @store.read('foo').should.be == 'bar'
+      @store.read('foo').should.equal 'bar'
     end
     it 'uses its own Hash with no args to ::new' do
       @store.read('foo').should.be.nil
@@ -106,6 +111,13 @@ describe 'Rack::Cache::EntityStore' do
       @store = Rack::Cache::EntityStore::Disk.new(path)
       File.should.be.a.directory path
     end
+    it 'produces a body that responds to #to_path' do
+      key, size = @store.write('Some shells for her hair.')
+      body = @store.open(key)
+      body.should.respond_to :to_path
+      path = "#{@temp_dir}/#{key[0..1]}/#{key[2..-1]}"
+      body.to_path.should.equal path
+    end
     it 'spreads data over a 36² hash radius' do
       (<<-PROSE).each { |line| @store.write(line).first.should.be.sha_like }
         My wild love went riding,
@@ -158,7 +170,7 @@ describe 'Rack::Cache::EntityStore' do
         end
         files.length.should.be > 0
       end
-      subdirs.length.should.be == 28
+      subdirs.length.should.equal 28
     end
   end
 

data/test/environment_headers_test.rb

@@ -21,27 +21,27 @@ describe 'Rack::Utils::EnvironmentHeaders' do
 
   it 'retrieves headers with #[]' do
     @h.should.respond_to :[]
-    @h['X-Foo'].should.be == 'BAR'
-    @h['If-Modified-Since'].should.be == @now
+    @h['X-Foo'].should.equal 'BAR'
+    @h['If-Modified-Since'].should.equal @now
   end
 
   it 'sets headers with #[]=' do
     @h.should.respond_to :[]=
     @h['X-Foo'] = 'BAZZLE'
-    @h['X-Foo'].should.be == 'BAZZLE'
+    @h['X-Foo'].should.equal 'BAZZLE'
   end
 
   it 'sets values on the underlying environment hash' do
     @h['X-Something-Else'] = 'FOO'
-    @env['HTTP_X_SOMETHING_ELSE'].should.be == 'FOO'
+    @env['HTTP_X_SOMETHING_ELSE'].should.equal 'FOO'
   end
 
   it 'handles Content-Type special case' do
-    @h['Content-Type'].should.be == 'text/plain'
+    @h['Content-Type'].should.equal 'text/plain'
   end
 
   it 'handles Content-Length special case' do
-    @h['Content-Length'].should.be == '0x1A4'
+    @h['Content-Length'].should.equal '0x1A4'
   end
 
   it 'implements #include? with RFC 2616 header name' do
@@ -60,12 +60,10 @@ describe 'Rack::Utils::EnvironmentHeaders' do
   it 'iterates over all headers with #each' do
     hash = {}
     @h.each { |name,value| hash[name] = value }
-    hash.should.be == {
-      'Content-Type'           => 'text/plain',
-      'Content-Length'         => '0x1A4',
-      'X-Foo'                  => 'BAR',
-      'If-Modified-Since'      => @now
-    }
+    hash.should.equal 'Content-Type' => 'text/plain',
+      'Content-Length' => '0x1A4',
+      'X-Foo' => 'BAR',
+      'If-Modified-Since' => @now
   end
 
 end

data/test/headers_test.rb

@@ -19,13 +19,13 @@ describe 'Rack::Cache::Headers' do
   describe '#cache_control' do
     it 'handles single name=value pair' do
       @res.headers['Cache-Control'] = 'max-age=600'
-      @res.cache_control['max-age'].should.be == '600'
+      @res.cache_control['max-age'].should.equal '600'
     end
     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.be == '600'
-      @res.cache_control['max-stale'].should.be == '300'
-      @res.cache_control['min-fresh'].should.be == '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 'handles a single flag value' do
       @res.headers['Cache-Control'] = 'no-cache'
@@ -34,15 +34,15 @@ describe 'Rack::Cache::Headers' do
     end
     it 'handles a bunch of all kinds of stuff' do
       @res.headers['Cache-Control'] = 'max-age=600,must-revalidate,min-fresh=3000,foo=bar,baz'
-      @res.cache_control['max-age'].should.be == '600'
+      @res.cache_control['max-age'].should.equal '600'
       @res.cache_control['must-revalidate'].should.be true
-      @res.cache_control['min-fresh'].should.be == '3000'
-      @res.cache_control['foo'].should.be == 'bar'
+      @res.cache_control['min-fresh'].should.equal '3000'
+      @res.cache_control['foo'].should.equal 'bar'
       @res.cache_control['baz'].should.be true
     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.be == '600'
+      @res.cache_control['max-age'].should.equal '600'
       @res.cache_control = {}
       @res.headers.should.not.include 'Cache-Control'
     end
@@ -82,7 +82,7 @@ describe 'Rack::Cache::ResponseHeaders' do
     it 'uses the Date header if present' do
       @res = MockResponse.new(200, { 'Date' => @one_hour_ago.httpdate }, '')
       @res.extend Rack::Cache::ResponseHeaders
-      @res.date.should.be == @one_hour_ago
+      @res.date.should.equal @one_hour_ago
     end
     it 'uses the current time when no Date header present' do
       @res = MockResponse.new(200, {}, '')
@@ -92,20 +92,20 @@ describe 'Rack::Cache::ResponseHeaders' do
     it 'returns the correct date when the header is modified directly' do
       @res = MockResponse.new(200, { 'Date' => @one_hour_ago.httpdate }, '')
       @res.extend Rack::Cache::ResponseHeaders
-      @res.date.should.be == @one_hour_ago
+      @res.date.should.equal @one_hour_ago
       @res.headers['Date'] = @now.httpdate
-      @res.date.should.be == @now
+      @res.date.should.equal @now
     end
   end
 
   describe '#expires_at' do
     it 'returns #date + #max_age when Cache-Control/max-age is present' do
       @res.headers['Cache-Control'] = 'max-age=500'
-      @res.expires_at.should.be == @res.date + 500
+      @res.expires_at.should.equal @res.date + 500
     end
     it 'uses the Expires header when present and no Cache-Control/max-age' do
       @res.headers['Expires'] = @one_hour_ago.httpdate
-      @res.expires_at.should.be == @one_hour_ago
+      @res.expires_at.should.equal @one_hour_ago
     end
     it 'returns nil when no Expires or Cache-Control provided' do
       @res.expires_at.should.be nil
@@ -113,14 +113,18 @@ describe 'Rack::Cache::ResponseHeaders' do
   end
 
   describe '#max_age' do
-    it 'uses Cache-Control to calculate #max_age when present' 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.be == 600
+      @res.max_age.should.equal 600
     end
-    it 'uses Expires for #max_age if no Cache-Control max-age present' do
+    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.be == 60 ** 2
+      @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
@@ -136,18 +140,90 @@ describe 'Rack::Cache::ResponseHeaders' do
       @res.headers['Cache-Control'] = 'max-age=500'
       @res.freshness_information?.should.be true
     end
+    it 'is true when a Cache-Control s-maxage directive is present' do
+      @res.headers['Cache-Control'] = 's-maxage=500'
+      @res.freshness_information?.should.be true
+    end
     it 'is not true otherwise' do
       @res.freshness_information?.should.be false
     end
   end
 
+  describe '#public=' do
+    it 'adds the public Cache-Control directive when set true' do
+      @res.headers['Cache-Control'] = 'max-age=100'
+      @res.public = true
+      @res.headers['Cache-Control'].should.equal 'public, max-age=100'
+    end
+    it 'removes the private Cache-Control directive' do
+      @res.headers['Cache-Control'] = 'private, max-age=100'
+      @res.public = true
+      @res.headers['Cache-Control'].should.equal 'public, max-age=100'
+    end
+  end
+
+  describe '#public?' do
+    it 'is true when the public directive is present' do
+      @res.headers['Cache-Control'] = 'public'
+      @res.should.be.public
+    end
+    it 'is false when only the private directive is present' do
+      @res.headers['Cache-Control'] = 'private'
+      @res.should.not.be.public
+    end
+    it 'is false when no Cache-Control header is present' do
+      @res.should.not.be.public
+    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'].should.equal 'private, max-age=100'
+    end
+    it 'removes the public Cache-Control directive' do
+      @res.headers['Cache-Control'] = 'public, max-age=100'
+      @res.private = true
+      @res.headers['Cache-Control'].should.equal 'private, max-age=100'
+    end
+  end
+
+  describe '#private?' do
+    it 'is true when the private directive is present' do
+      @res.headers['Cache-Control'] = 'private'
+      @res.should.be.private
+    end
+    it 'is false when the private directive is not present' do
+      @res.headers['Cache-Control'] = 'public'
+      @res.should.not.be.private
+    end
+    it 'is false when no Cache-Control header is present' do
+      @res.should.not.be.private
+    end
+  end
+
   describe '#no_cache?' do
     it 'is true when a Cache-Control no-cache directive is present' do
       @res.headers['Cache-Control'] = 'no-cache'
-      @res.no_cache?.should.be true
+      assert @res.no_cache?
+    end
+    it 'is false otherwise' do
+      assert !@res.no_cache?
+    end
+  end
+
+  describe '#must_revalidate?' do
+    it 'is true when a Cache-Control must-revalidate directive is present' do
+      @res.headers['Cache-Control'] = 'private, must-revalidate'
+      assert @res.must_revalidate?
+    end
+    it 'is true when a Cache-Control proxy-revalidate directive is present' do
+      @res.headers['Cache-Control'] = 'public, proxy-revalidate'
+      assert @res.must_revalidate?
     end
     it 'is false otherwise' do
-      @res.no_cache?.should.be false
+      assert !@res.must_revalidate?
     end
   end
 
@@ -190,7 +266,7 @@ describe 'Rack::Cache::ResponseHeaders' do
     end
     it 'returns the literal value of the Vary header' do
       @res.headers['Vary'] = 'Foo Bar Baz'
-      @res.vary.should.be == '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?
@@ -206,16 +282,16 @@ describe 'Rack::Cache::ResponseHeaders' do
     end
     it 'parses a single header name value' do
       @res.headers['Vary'] = 'Accept-Language'
-      @res.vary_header_names.should.be == ['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.be ==
+      @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.be ==
+      @res.vary_header_names.should.equal \
         ['Accept-Language', 'User-Agent', 'X-Foo']
     end
   end

data/test/metastore_test.rb

@@ -2,7 +2,6 @@ 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'])
@@ -22,7 +21,7 @@ describe_shared 'A Rack::Cache::MetaStore Implementation' do
   it 'reads a list of negotation tuples with #read' do
     @store.write('/test', [[{},{}],[{},{}]])
     tuples = @store.read('/test')
-    tuples.should.be == [ [{},{}], [{},{}] ]
+    tuples.should.equal [ [{},{}], [{},{}] ]
   end
 
   it 'reads an empty list with #read when nothing cached at key' do
@@ -45,20 +44,20 @@ describe_shared 'A Rack::Cache::MetaStore Implementation' do
   it 'returns nil from #purge' do
     @store.write('/test', [[{},{}]])
     @store.purge('/test').should.be nil
-    @store.read('/test').should.be == []
+    @store.read('/test').should.equal []
   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 == [[{},{}]]
+      @store.read(key).should.equal [[{},{}]]
     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 == [[{},{}]]
+    @store.read(key).should.equal [[{},{}]]
   end
 
   # Abstract methods ===========================================================
@@ -79,7 +78,7 @@ describe_shared 'A Rack::Cache::MetaStore Implementation' do
   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'
+    res['X-Content-Digest'].should.equal 'a94a8fe5ccb19ba61c4c0873d391e987982fbbd3'
   end
 
   it 'finds a stored entry with #lookup' do
@@ -89,18 +88,30 @@ describe_shared 'A Rack::Cache::MetaStore Implementation' do
     response.should.be.kind_of Rack::Cache::Response
   end
 
+  it 'does not find an entry with #lookup when none exists' do
+    req = mock_request('/test', {'HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'})
+    @store.lookup(req, @entity_store).should.be.nil
+  end
+
+  it 'does not find an entry with #lookup when the body does not exist' do
+    store_simple_entry
+    @response['X-Content-Digest'].should.not.be.nil
+    @entity_store.purge(@response['X-Content-Digest'])
+    @store.lookup(@request, @entity_store).should.be.nil
+  end
+
   it 'restores response headers properly with #lookup' do
     store_simple_entry
     response = @store.lookup(@request, @entity_store)
     response.headers.
-      should.be == @response.headers.merge('Age' => '0', 'Content-Length' => '4')
+      should.equal @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'
+    body.should.equal 'test'
   end
 
   # Vary =======================================================================
@@ -127,30 +138,30 @@ describe_shared 'A Rack::Cache::MetaStore Implementation' do
     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'
+    slurp(@store.lookup(req3, @entity_store).body).should.equal 'test 3'
+    slurp(@store.lookup(req1, @entity_store).body).should.equal 'test 1'
+    slurp(@store.lookup(req2, @entity_store).body).should.equal 'test 2'
 
-    @store.read('/test').length.should.be == 3
+    @store.read('/test').length.should.equal 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'
+    slurp(@store.lookup(req1, @entity_store).body).should.equal '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'
+    slurp(@store.lookup(req2, @entity_store).body).should.equal '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'
+    slurp(@store.lookup(req1, @entity_store).body).should.equal 'test 3'
 
-    @store.read('/test').length.should.be == 2
+    @store.read('/test').length.should.equal 2
   end
 
   # Helper Methods =============================================================
@@ -171,7 +182,6 @@ describe_shared 'A Rack::Cache::MetaStore Implementation' do
     body.each {|part| buf << part }
     buf
   end
-
 end
 
 

data/test/options_test.rb

@@ -7,7 +7,10 @@ end
 
 class MockOptions
   include Rack::Cache::Options
-  alias_method :initialize, :initialize_options
+  def initialize
+    @env = nil
+    initialize_options
+  end
 end
 
 describe 'Rack::Cache::Options' do
@@ -16,30 +19,30 @@ describe 'Rack::Cache::Options' do
   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'
+      @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.be == '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.be == 'bar'
-      @options.options['rack-cache.bar'].should.be == 'baz'
-      @options.options['foo.bar'].should.be == '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.be == '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.be == 'bar'
-    @options.options['foo.bar'].should.be == 'bling'
-    @options.options['rack-cache.bar'].should.be == 'baz'
+    @options.foo.should.equal 'bar'
+    @options.options['foo.bar'].should.equal 'bling'
+    @options.options['rack-cache.bar'].should.equal 'baz'
   end
 
   it 'allows the meta store to be configured' do

data/test/spec_setup.rb

@@ -16,19 +16,23 @@ ENV['MEMCACHED'] ||= 'localhost:11215'
 $memcached = nil
 
 def have_memcached?(server=ENV['MEMCACHED'])
-  return true if $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 = nil
+  $memcached = false
   false
 rescue => boom
-  $memcached = nil
+  $memcached = false
   false
 end
 
+have_memcached?
+
 def need_memcached(forwhat)
   if have_memcached?
     yield
@@ -125,7 +129,7 @@ module CacheContextHelpers
     @caches << @cache
     @request = Rack::MockRequest.new(@cache)
     yield @cache if block_given?
-    @response = @request.send(method, uri, opts)
+    @response = @request.request(method.to_s.upcase, uri, opts)
     @responses << @response
     @response
   end
@@ -134,10 +138,13 @@ module CacheContextHelpers
     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
 
 
@@ -149,7 +156,7 @@ module TestHelpers
 
   def create_temp_directory
     @@temp_dir_count += 1
-    path = F.join(Dir.tmpdir, "rcl-#{$$}-#{@@temp_dir_count}")
+    path = F.join(Dir.tmpdir, "rack-cache-#{$$}-#{@@temp_dir_count}")
     mkdir_p path
     if block_given?
       yield path
@@ -186,4 +193,3 @@ class Object
     class_eval { define_method name, &blk }
   end
 end
-