rack-cache 1.2 → 1.3.0

data/test/entitystore_test.rb

@@ -1,268 +0,0 @@
-# coding: utf-8
-require "#{File.dirname(__FILE__)}/spec_setup"
-require 'rack/cache/entitystore'
-
-class Object
-  def sha_like?
-    length == 40 && self =~ /^[0-9a-z]+$/
-  end
-end
-
-shared 'A Rack::Cache::EntityStore Implementation' do
-  it 'responds to all required messages' do
-    %w[read open write exist?].each do |message|
-      @store.should.respond_to message
-    end
-  end
-
-  it 'stores bodies with #write' do
-    key, size = @store.write(['My wild love went riding,'])
-    key.should.not.be.nil
-    key.should.be.sha_like
-
-    data = @store.read(key)
-    data.should.equal 'My wild love went riding,'
-  end
-
-  it 'takes a ttl parameter for #write' do
-    key, size = @store.write(['My wild love went riding,'], 0)
-    key.should.not.be.nil
-    key.should.be.sha_like
-
-    data = @store.read(key)
-    data.should.equal 'My wild love went riding,'
-  end
-
-  it 'correctly determines whether cached body exists for key with #exist?' do
-    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.'])
-    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.should.not.be.nil
-    key.length.should.equal 40
-    key.should.be =~ /^[0-9a-z]+$/
-    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.equal 'She gathered together'
-  end
-
-  it 'returns nil from #read when key does not exist' do
-    @store.read('87fe0a1ae82a518592f6b12b0183e950b4541c62').should.be.nil
-  end
-
-  it 'returns a Rack compatible body from #open' do
-    key, size = @store.write(['Some shells for her hair.'])
-    body = @store.open(key)
-    body.should.respond_to :each
-    buf = ''
-    body.each { |part| buf << part }
-    buf.should.equal 'Some shells for her hair.'
-  end
-
-  it 'returns nil from #open when key does not exist' do
-    @store.open('87fe0a1ae82a518592f6b12b0183e950b4541c62').should.be.nil
-  end
-
-  it 'can store largish bodies with binary data' do
-    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
-    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
-
-  describe 'Heap' do
-    before { @store = Rack::Cache::EntityStore::Heap.new }
-    behaves_like 'A Rack::Cache::EntityStore Implementation'
-    it 'takes a Hash to ::new' do
-      @store = Rack::Cache::EntityStore::Heap.new('foo' => ['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
-    end
-  end
-
-  describe 'Disk' do
-    before do
-      @temp_dir = create_temp_directory
-      @store = Rack::Cache::EntityStore::Disk.new(@temp_dir)
-    end
-    after do
-      @store = nil
-      remove_entry_secure @temp_dir
-    end
-    behaves_like 'A Rack::Cache::EntityStore Implementation'
-
-    it 'takes a path to ::new and creates the directory' do
-      path = @temp_dir + '/foo'
-      @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 { |line| @store.write([line]).first.should.be.sha_like }
-        My wild love went riding,
-        She rode all the day;
-        She rode to the devil,
-        And asked him to pay.
-
-        The devil was wiser
-        It's time to repent;
-        He asked her to give back
-        The money she spent
-
-        My wild love went riding,
-        She rode to sea;
-        She gathered together
-        Some shells for her hair
-
-        She rode on to Christmas,
-        She rode to the farm;
-        She rode to Japan
-        And re-entered a town
-
-        My wild love is crazy
-        She screams like a bird;
-        She moans like a cat
-        When she wants to be heard
-
-        She rode and she rode on
-        She rode for a while,
-        Then stopped for an evening
-        And laid her head down
-
-        By this time the weather
-        Had changed one degree,
-        She asked for the people
-        To let her go free
-
-        My wild love went riding,
-        She rode for an hour;
-        She rode and she rested,
-        And then she rode on
-        My wild love went riding,
-      PROSE
-      subdirs = Dir["#{@temp_dir}/*"]
-      subdirs.each do |subdir|
-        File.basename(subdir).should.be =~ /^[0-9a-z]{2}$/
-        files = Dir["#{subdir}/*"]
-        files.each do |filename|
-          File.basename(filename).should.be =~ /^[0-9a-z]{38}$/
-        end
-        files.length.should.be > 0
-      end
-      subdirs.length.should.equal 28
-    end
-  end
-
-  need_memcached 'entity store tests' do
-    describe 'MemCached' do
-      before do
-        @store = Rack::Cache::EntityStore::MemCached.new($memcached)
-      end
-      after do
-        @store = nil
-      end
-      behaves_like 'A Rack::Cache::EntityStore Implementation'
-    end
-
-    describe 'options parsing' do
-      before do
-        uri = URI.parse("memcached://#{ENV['MEMCACHED']}/obj_ns1?show_backtraces=true")
-        @memcached_metastore = Rack::Cache::MetaStore::MemCached.resolve uri
-      end
-
-      it 'passes options from uri' do
-        @memcached_metastore.cache.instance_variable_get(:@options)[:show_backtraces].should.equal true
-      end
-
-      it 'takes namespace into account' do
-        @memcached_metastore.cache.instance_variable_get(:@options)[:prefix_key].should.equal 'obj_ns1'
-      end
-    end
-  end
-
-
-  need_dalli 'entity store tests' do
-    describe 'Dalli' do
-      before do
-        $dalli.flush_all
-        @store = Rack::Cache::EntityStore::Dalli.new($dalli)
-      end
-      after do
-        @store = nil
-      end
-      behaves_like 'A Rack::Cache::EntityStore Implementation'
-    end
-
-    describe 'options parsing' do
-      before do
-        uri = URI.parse("memcached://#{ENV['MEMCACHED']}/obj_ns1?show_backtraces=true")
-        @dalli_metastore = Rack::Cache::MetaStore::Dalli.resolve uri
-      end
-
-      it 'passes options from uri' do
-        @dalli_metastore.cache.instance_variable_get(:@options)[:show_backtraces].should.equal true
-      end
-
-      it 'takes namespace into account' do
-        @dalli_metastore.cache.instance_variable_get(:@options)[:namespace].should.equal 'obj_ns1'
-      end
-    end
-  end
-
-  need_java 'entity store testing' do
-    module Rack::Cache::AppEngine
-      module MC
-        class << (Service = {})
-          def contains(key); include?(key); end
-          def get(key); self[key]; end;
-          def put(key, value, ttl = nil)
-            self[key] = value
-          end
-        end
-
-      end
-    end
-
-    describe 'GAEStore' do
-      before do
-        puts Rack::Cache::AppEngine::MC::Service.inspect
-        @store = Rack::Cache::EntityStore::GAEStore.new
-      end
-      after do
-        @store = nil
-      end
-      behaves_like 'A Rack::Cache::EntityStore Implementation'
-    end
-  end
-end

data/test/key_test.rb

@@ -1,50 +0,0 @@
-require "#{File.dirname(__FILE__)}/spec_setup"
-require 'rack/cache/key'
-
-describe 'A Rack::Cache::Key' do
-  # Helper Methods =============================================================
-
-  def mock_request(*args)
-    uri, opts = args
-    env = Rack::MockRequest.env_for(uri, opts || {})
-    Rack::Cache::Request.new(env)
-  end
-
-  def new_key(request)
-    Rack::Cache::Key.call(request)
-  end
-
-  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
-end

data/test/metastore_test.rb

@@ -1,338 +0,0 @@
-require "#{File.dirname(__FILE__)}/spec_setup"
-require 'rack/cache/metastore'
-require 'rack/cache/entitystore'
-
-shared 'A Rack::Cache::MetaStore Implementation' do
-
-  ###
-  # Helpers
-
-  def mock_request(uri, opts)
-    env = Rack::MockRequest.env_for(uri, opts || {})
-    Rack::Cache::Request.new(env)
-  end
-
-  def mock_response(status, headers, body)
-    headers ||= {}
-    body = Array(body).compact
-    Rack::Cache::Response.new(status, headers, body)
-  end
-
-  def slurp(body)
-    buf = ''
-    body.each { |part| buf << part }
-    buf
-  end
-
-  # Stores an entry for the given request args, returns a url encoded cache key
-  # for the request.
-  def store_simple_entry(*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
-    cache_key = @store.store(@request, @response, @entity_store)
-    @response.body.should.not.be.same_as body
-    cache_key
-  end
-
-  before do
-    @request = mock_request('/', {})
-    @response = mock_response(200, {}, ['hello world'])
-  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.equal [ [{},{}], [{},{}] ]
-  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.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.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.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
-
-  it 'does not blow up when given a non-marhsalable object with an ALL_CAPS key' do
-    store_simple_entry('/bad', { 'SOME_THING' => Proc.new {} })
-  end
-
-  # Abstract methods ===========================================================
-
-  it 'stores a cache entry' do
-    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
-    cache_key = store_simple_entry
-    req, res = @store.read(cache_key).first
-    res['X-Content-Digest'].should.equal '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 '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 "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.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
-
-  it 'restores response headers properly with #lookup' do
-    store_simple_entry
-    response = @store.lookup(@request, @entity_store)
-    response.headers.
-      should.equal @response.headers.merge('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.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
-    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'])
-    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'])
-    @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.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(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'])
-    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'})
-    res2 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 2'])
-    @store.store(req2, res2, @entity_store)
-    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.equal 'test 3'
-
-    @store.read(key).length.should.equal 2
-  end
-end
-
-
-describe 'Rack::Cache::MetaStore' do
-  describe 'Heap' do
-    before do
-      @store = Rack::Cache::MetaStore::Heap.new
-      @entity_store = Rack::Cache::EntityStore::Heap.new
-    end
-    behaves_like 'A Rack::Cache::MetaStore Implementation'
-  end
-
-  describe 'Disk' do
-    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
-    behaves_like 'A Rack::Cache::MetaStore Implementation'
-  end
-
-  need_memcached 'metastore tests' do
-    describe 'MemCached' do
-      before do
-        @temp_dir = create_temp_directory
-        $memcached.flush
-        @store = Rack::Cache::MetaStore::MemCached.new($memcached)
-        @entity_store = Rack::Cache::EntityStore::Heap.new
-      end
-      behaves_like 'A Rack::Cache::MetaStore Implementation'
-    end
-
-    describe 'options parsing' do
-      before do
-        uri = URI.parse("memcached://#{ENV['MEMCACHED']}/meta_ns1?show_backtraces=true")
-        @memcached_metastore = Rack::Cache::MetaStore::MemCached.resolve uri
-      end
-
-      it 'passes options from uri' do
-        @memcached_metastore.cache.instance_variable_get(:@options)[:show_backtraces].should.equal true
-      end
-
-      it 'takes namespace into account' do
-        @memcached_metastore.cache.instance_variable_get(:@options)[:prefix_key].should.equal 'meta_ns1'
-      end
-    end
-  end
-
-  need_dalli 'metastore tests' do
-    describe 'Dalli' do
-      before do
-        @temp_dir = create_temp_directory
-        $dalli.flush_all
-        @store = Rack::Cache::MetaStore::Dalli.new($dalli)
-        @entity_store = Rack::Cache::EntityStore::Heap.new
-      end
-      behaves_like 'A Rack::Cache::MetaStore Implementation'
-    end
-
-    describe 'options parsing' do
-      before do
-        uri = URI.parse("memcached://#{ENV['MEMCACHED']}/meta_ns1?show_backtraces=true")
-        @dalli_metastore = Rack::Cache::MetaStore::Dalli.resolve uri
-      end
-
-      it 'passes options from uri' do
-        @dalli_metastore.cache.instance_variable_get(:@options)[:show_backtraces].should.equal true
-      end
-
-      it 'takes namespace into account' do
-        @dalli_metastore.cache.instance_variable_get(:@options)[:namespace].should.equal 'meta_ns1'
-      end
-    end
-  end
-
-  need_java 'entity store testing' do
-    module Rack::Cache::AppEngine
-      module MC
-        class << (Service = {})
-
-          def contains(key); include?(key); end
-          def get(key); self[key]; end;
-          def put(key, value, ttl = nil)
-            self[key] = value
-          end
-
-        end
-      end
-    end
-
-    describe 'GAEStore' do
-      before :each do
-        Rack::Cache::AppEngine::MC::Service.clear
-        @store = Rack::Cache::MetaStore::GAEStore.new
-        @entity_store = Rack::Cache::EntityStore::Heap.new
-      end
-      behaves_like 'A Rack::Cache::MetaStore Implementation'
-    end
-
-  end
-
-end