swipe-rails 0.0.4 → 0.0.5

data/vendor/bundle/gems/rack-cache-1.2/test/entitystore_test.rb

@@ -0,0 +1,268 @@
+# 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/vendor/bundle/gems/rack-cache-1.2/test/key_test.rb

@@ -0,0 +1,50 @@
+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/vendor/bundle/gems/rack-cache-1.2/test/metastore_test.rb

@@ -0,0 +1,338 @@
+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