rack-cache 0.3.0 → 0.4

data/test/entitystore_test.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require "#{File.dirname(__FILE__)}/spec_setup"
 require 'rack/cache/entitystore'
 
@@ -16,7 +17,7 @@ describe_shared 'A Rack::Cache::EntityStore Implementation' do
   end
 
   it 'stores bodies with #write' do
-    key, size = @store.write('My wild love went riding,')
+    key, size = @store.write(['My wild love went riding,'])
     key.should.not.be.nil
     key.should.be.sha_like
 
@@ -25,19 +26,19 @@ describe_shared 'A Rack::Cache::EntityStore Implementation' do
   end
 
   it 'correctly determines whether cached body exists for key with #exist?' do
-    key, size = @store.write('She rode to the devil,')
+    key, size = @store.write(['She rode to the devil,'])
     @store.should.exist key
     @store.should.not.exist '938jasddj83jasdh4438021ksdfjsdfjsdsf'
   end
 
   it 'can read data written with #write' do
-    key, size = @store.write('And asked him to pay.')
+    key, size = @store.write(['And asked him to pay.'])
     data = @store.read(key)
     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, size = @store.write(['she rode to the sea;'])
     key.should.not.be.nil
     key.length.should.equal 40
     key.should.be =~ /^[0-9a-z]+$/
@@ -45,7 +46,7 @@ describe_shared 'A Rack::Cache::EntityStore Implementation' do
   end
 
   it 'returns the entire body as a String from #read' do
-    key, size = @store.write('She gathered together')
+    key, size = @store.write(['She gathered together'])
     @store.read(key).should.equal 'She gathered together'
   end
 
@@ -54,7 +55,7 @@ describe_shared 'A Rack::Cache::EntityStore Implementation' do
   end
 
   it 'returns a Rack compatible body from #open' do
-    key, size = @store.write('Some shells for her hair.')
+    key, size = @store.write(['Some shells for her hair.'])
     body = @store.open(key)
     body.should.respond_to :each
     buf = ''
@@ -67,8 +68,8 @@ describe_shared 'A Rack::Cache::EntityStore Implementation' do
   end
 
   it 'can store largish bodies with binary data' do
-    pony = File.read(File.dirname(__FILE__) + '/pony.jpg')
-    key, size = @store.write(pony)
+    pony = File.open(File.dirname(__FILE__) + '/pony.jpg', 'rb') { |f| f.read }
+    key, size = @store.write([pony])
     key.should.equal 'd0f30d8659b4d268c5c64385d9790024c2d78deb'
     data = @store.read(key)
     data.length.should.equal pony.length
@@ -76,7 +77,7 @@ describe_shared 'A Rack::Cache::EntityStore Implementation' do
   end
 
   it 'deletes stored entries with #purge' do
-    key, size = @store.write('My wild love went riding,')
+    key, size = @store.write(['My wild love went riding,'])
     @store.purge(key).should.be.nil
     @store.read(key).should.be.nil
   end
@@ -112,14 +113,14 @@ describe 'Rack::Cache::EntityStore' do
       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.')
+      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 }
+      (<<-PROSE).each_line { |line| @store.write([line]).first.should.be.sha_like }
         My wild love went riding,
         She rode all the day;
         She rode to the devil,

data/test/key_test.rb

@@ -0,0 +1,50 @@
+require "#{File.dirname(__FILE__)}/spec_setup"
+require 'rack/cache/key'
+
+describe 'A Rack::Cache::Key' do
+  it "sorts params" do
+    request = mock_request('/test?z=last&a=first')
+    new_key(request).should.include('a=first&z=last')
+  end
+
+  it "includes the scheme" do
+    request = mock_request(
+      '/test',
+      'rack.url_scheme' => 'https',
+      'HTTP_HOST' => 'www2.example.org'
+    )
+    new_key(request).should.include('https://')
+  end
+
+  it "includes host" do
+    request = mock_request('/test', "HTTP_HOST" => 'www2.example.org')
+    new_key(request).should.include('www2.example.org')
+  end
+
+  it "includes path" do
+    request = mock_request('/test')
+    new_key(request).should.include('/test')
+  end
+
+  it "sorts the query string by key/value after decoding" do
+    request = mock_request('/test?x=q&a=b&%78=c')
+    new_key(request).should.match(/\?a=b&x=c&x=q$/)
+  end
+
+  it "is in order of scheme, host, path, params" do
+    request = mock_request('/test?x=y', "HTTP_HOST" => 'www2.example.org')
+    new_key(request).should.equal "http://www2.example.org/test?x=y"
+  end
+
+  # Helper Methods =============================================================
+
+  define_method :mock_request do |*args|
+    uri, opts = args
+    env = Rack::MockRequest.env_for(uri, opts || {})
+    Rack::Cache::Request.new(env)
+  end
+
+  define_method :new_key do |request|
+    Rack::Cache::Key.call(request)
+  end
+end

data/test/metastore_test.rb

@@ -60,24 +60,43 @@ describe_shared 'A Rack::Cache::MetaStore Implementation' do
     @store.read(key).should.equal [[{},{}]]
   end
 
+  it "allows custom cache keys from block" do
+    request = mock_request('/test', {})
+    request.env['rack-cache.cache_key'] =
+      lambda { |request| request.path_info.reverse }
+    @store.cache_key(request).should == 'tset/'
+  end
+
+  it "allows custom cache keys from class" do
+    request = mock_request('/test', {})
+    request.env['rack-cache.cache_key'] = Class.new do
+      def self.call(request); request.path_info.reverse end
+    end
+    @store.cache_key(request).should == 'tset/'
+  end
+
   # Abstract methods ===========================================================
 
-  define_method :store_simple_entry do
-    @request = mock_request('/test', {})
+  # Stores an entry for the given request args, returns a url encoded cache key
+  # for the request.
+  define_method :store_simple_entry do |*request_args|
+    path, headers = request_args
+    @request = mock_request(path || '/test', headers || {})
     @response = mock_response(200, {'Cache-Control' => 'max-age=420'}, ['test'])
     body = @response.body
-    @store.store(@request, @response, @entity_store)
+    cache_key = @store.store(@request, @response, @entity_store)
     @response.body.should.not.be body
+    cache_key
   end
 
   it 'stores a cache entry' do
-    store_simple_entry
-    @store.read('/test').should.not.be.empty
+    cache_key = store_simple_entry
+    @store.read(cache_key).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
+    cache_key = store_simple_entry
+    req, res = @store.read(cache_key).first
     res['X-Content-Digest'].should.equal 'a94a8fe5ccb19ba61c4c0873d391e987982fbbd3'
   end
 
@@ -93,10 +112,20 @@ describe_shared 'A Rack::Cache::MetaStore Implementation' do
     @store.lookup(req, @entity_store).should.be.nil
   end
 
+  it "canonizes urls for cache keys" do
+    store_simple_entry(path='/test?x=y&p=q')
+
+    hits_req = mock_request(path, {})
+    miss_req = mock_request('/test?p=x', {})
+
+    @store.lookup(hits_req, @entity_store).should.not.be.nil
+    @store.lookup(miss_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'])
+    @response.headers['X-Content-Digest'].should.not.be.nil
+    @entity_store.purge(@response.headers['X-Content-Digest'])
     @store.lookup(@request, @entity_store).should.be.nil
   end
 
@@ -104,7 +133,7 @@ describe_shared 'A Rack::Cache::MetaStore Implementation' do
     store_simple_entry
     response = @store.lookup(@request, @entity_store)
     response.headers.
-      should.equal @response.headers.merge('Age' => '0', 'Content-Length' => '4')
+      should.equal @response.headers.merge('Content-Length' => '4')
   end
 
   it 'restores response body from entity store with #lookup' do
@@ -114,6 +143,20 @@ describe_shared 'A Rack::Cache::MetaStore Implementation' do
     body.should.equal 'test'
   end
 
+  it 'invalidates meta and entity store entries with #invalidate' do
+    store_simple_entry
+    @store.invalidate(@request, @entity_store)
+    response = @store.lookup(@request, @entity_store)
+    response.should.be.kind_of Rack::Cache::Response
+    response.should.not.be.fresh
+  end
+
+  it 'succeeds quietly when #invalidate called with no matching entries' do
+    req = mock_request('/test', {})
+    @store.invalidate(req, @entity_store)
+    @store.lookup(@request, @entity_store).should.be.nil
+  end
+
   # Vary =======================================================================
 
   it 'does not return entries that Vary with #lookup' do
@@ -128,7 +171,7 @@ describe_shared 'A Rack::Cache::MetaStore Implementation' do
   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)
+    key = @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'])
@@ -142,13 +185,13 @@ describe_shared 'A Rack::Cache::MetaStore Implementation' do
     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.equal 3
+    @store.read(key).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)
+    key = @store.store(req1, res1, @entity_store)
     slurp(@store.lookup(req1, @entity_store).body).should.equal 'test 1'
 
     req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
@@ -161,7 +204,7 @@ describe_shared 'A Rack::Cache::MetaStore Implementation' do
     @store.store(req3, res3, @entity_store)
     slurp(@store.lookup(req1, @entity_store).body).should.equal 'test 3'
 
-    @store.read('/test').length.should.equal 2
+    @store.read(key).length.should.equal 2
   end
 
   # Helper Methods =============================================================

data/test/options_test.rb

@@ -45,6 +45,17 @@ describe 'Rack::Cache::Options' do
     @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=

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

@@ -1,37 +1,178 @@
 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}, '')
+  before :each do
+    @now = Time.httpdate(Time.now.httpdate)
     @one_hour_ago = Time.httpdate((Time.now - (60**2)).httpdate)
-  }
-
-  after(:each) {
-    @now, @response, @one_hour_ago = nil
-  }
+    @one_hour_later = Time.httpdate((Time.now + (60**2)).httpdate)
+    @res = Rack::Cache::Response.new(200, {'Date' => @now.httpdate}, [])
+  end
 
-  it 'responds to cache-related methods' do
-    @response.should.respond_to :ttl
-    @response.should.respond_to :age
-    @response.should.respond_to :date
+  after :each do
+    @now, @res, @one_hour_ago = nil
   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}, '']
+    @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
 
-  it 'retrieves headers with #[]' do
-    @response.headers['X-Foo'] = 'bar'
-    @response.should.respond_to :[]
-    @response['X-Foo'].should.be == 'bar'
+  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
 
-  it 'sets headers with #[]=' do
-    @response.should.respond_to :[]=
-    @response['X-Foo'] = 'bar'
-    @response.headers['X-Foo'].should.be == 'bar'
+  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