rack-cache 1.2 → 1.3.0

data/test/options_test.rb

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

@@ -1,19 +0,0 @@
-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')
-    request.should.be.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')
-    request.should.be.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')
-    request.should.not.be.no_cache
-  end
-end

data/test/response_test.rb

@@ -1,184 +0,0 @@
-require "#{File.dirname(__FILE__)}/spec_setup"
-
-describe 'Rack::Cache::Response' do
-  before do
-    @now = Time.httpdate(Time.now.httpdate)
-    @one_hour_ago = Time.httpdate((Time.now - (60**2)).httpdate)
-    @one_hour_later = Time.httpdate((Time.now + (60**2)).httpdate)
-    @res = Rack::Cache::Response.new(200, {'Date' => @now.httpdate}, [])
-  end
-
-  after do
-    @now, @res, @one_hour_ago = nil
-  end
-
-  it 'marks Rack tuples with string typed statuses as cacheable' do
-    @res = Rack::Cache::Response.new('200',{'Date' => @now.httpdate},[])
-    @res.headers['Expires'] = @one_hour_later.httpdate
-    @res.should.be.cacheable
-  end
-
-  it 'responds to #to_a with a Rack response tuple' do
-    @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.to_i.should.be.close Time.now.to_i, 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
-
-  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
-
-  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

data/test/spec_setup.rb

@@ -1,232 +0,0 @@
-require 'pp'
-require 'tmpdir'
-require 'stringio'
-
-[STDOUT, STDERR].each { |io| io.sync = true }
-
-begin
-  require 'bacon'
-rescue LoadError => boom
-  require 'rubygems' rescue nil
-  require 'bacon'
-end
-
-# Set the MEMCACHED environment variable as follows to enable testing
-# of the MemCached meta and entity stores.
-ENV['MEMCACHED'] ||= 'localhost:11211'
-$memcached = nil
-$dalli = nil
-
-def have_memcached?(server=ENV['MEMCACHED'])
-  return $memcached unless $memcached.nil?
-
-  # silence warnings from memcached
-  begin
-    v, $VERBOSE = $VERBOSE, nil
-    require 'memcached'
-  ensure
-    $VERBOSE = v
-  end
-
-  $memcached = Memcached.new(server)
-  $memcached.set('ping', '')
-  true
-rescue LoadError => boom
-  warn "memcached library not available. related tests will be skipped."
-  $memcached = false
-  false
-rescue => boom
-  warn "memcached not working. related tests will be skipped."
-  $memcached = false
-  false
-end
-
-have_memcached?
-
-def have_dalli?(server=ENV['MEMCACHED'])
-  return $dalli unless $dalli.nil?
-  require 'dalli'
-  $dalli = Dalli::Client.new(server)
-  $dalli.set('ping', '')
-  true
-rescue LoadError => boom
-  warn "dalli library not available. related tests will be skipped."
-  $dalli = false
-  false
-rescue => boom
-  warn "dalli not working. related tests will be skipped."
-  $dalli = false
-  false
-end
-
-have_dalli?
-
-def need_dalli(forwhat)
-  yield if have_dalli?
-end
-
-def need_memcached(forwhat)
-  yield if have_memcached?
-end
-
-def need_java(forwhat)
-  yield if RUBY_PLATFORM =~ /java/
-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, @cache_prototype = nil
-  end
-
-  # A basic response with 200 status code and a tiny body.
-  def respond_with(status=200, headers={}, body=['Hello World'], &bk)
-    called = false
-    @app =
-      lambda do |env|
-        called = true
-        response = Rack::Response.new(body, status, headers)
-        request = Rack::Request.new(env)
-        bk.call(request, response) if bk
-        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.request(method.to_s.upcase, uri, opts)
-    @responses << @response
-    @response
-  end
-
-  def get(stem, env={}, &b)
-    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
-
-
-module TestHelpers
-  include FileUtils
-  F = File
-
-  @@temp_dir_count = 0
-
-  def create_temp_directory
-    @@temp_dir_count += 1
-    path = F.join(Dir.tmpdir, "rack-cache-#{$$}-#{@@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 Bacon::Context
-  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
-
-  # True when the Object is neither false or nil.
-  def truthy?
-    !!self
-  end
-end

data/test/storage_test.rb

@@ -1,94 +0,0 @@
-require "#{File.dirname(__FILE__)}/spec_setup"
-require 'rack/cache/storage'
-
-describe 'Rack::Cache::Storage' do
-  before do
-    @storage = Rack::Cache::Storage.new
-  end
-
-  it "fails when an unknown URI scheme is provided" do
-    lambda { @storage.resolve_metastore_uri('foo:/') }.should.raise
-  end
-  it "creates a new MetaStore for URI if none exists" do
-    @storage.resolve_metastore_uri('heap:/').
-      should.be.kind_of Rack::Cache::MetaStore
-  end
-  it "returns an existing MetaStore instance for URI that exists" do
-    store = @storage.resolve_metastore_uri('heap:/')
-    @storage.resolve_metastore_uri('heap:/').should.be.same_as store
-  end
-  it "creates a new EntityStore for URI if none exists" do
-    @storage.resolve_entitystore_uri('heap:/').
-      should.be.kind_of Rack::Cache::EntityStore
-  end
-  it "returns an existing EntityStore instance for URI that exists" do
-    store = @storage.resolve_entitystore_uri('heap:/')
-    @storage.resolve_entitystore_uri('heap:/').should.be.same_as store
-  end
-  it "clears all URI -> store mappings with #clear" do
-    meta = @storage.resolve_metastore_uri('heap:/')
-    entity = @storage.resolve_entitystore_uri('heap:/')
-    @storage.clear
-    @storage.resolve_metastore_uri('heap:/').should.not.be.same_as meta
-    @storage.resolve_entitystore_uri('heap:/').should.not.be.same_as entity
-  end
-
-  describe 'Heap Store URIs' do
-    %w[heap:/ mem:/].each do |uri|
-      it "resolves #{uri} meta store URIs" do
-        @storage.resolve_metastore_uri(uri).
-          should.be.kind_of Rack::Cache::MetaStore
-      end
-      it "resolves #{uri} entity store URIs" do
-        @storage.resolve_entitystore_uri(uri).
-          should.be.kind_of Rack::Cache::EntityStore
-      end
-    end
-  end
-
-  describe 'Disk Store URIs' do
-    before do
-      @temp_dir = create_temp_directory
-    end
-    after do
-      remove_entry_secure @temp_dir
-      @temp_dir = nil
-    end
-
-    %w[file: disk:].each do |uri|
-      it "resolves #{uri} meta store URIs" do
-        @storage.resolve_metastore_uri(uri + @temp_dir).
-          should.be.kind_of Rack::Cache::MetaStore
-      end
-      it "resolves #{uri} entity store URIs" do
-        @storage.resolve_entitystore_uri(uri + @temp_dir).
-          should.be.kind_of Rack::Cache::EntityStore
-      end
-    end
-  end
-
-  if have_memcached?
-
-    describe 'MemCache Store URIs' do
-      %w[memcache: memcached:].each do |scheme|
-        it "resolves #{scheme} meta store URIs" do
-          uri = scheme + '//' + ENV['MEMCACHED']
-          @storage.resolve_metastore_uri(uri).
-            should.be.kind_of Rack::Cache::MetaStore
-        end
-        it "resolves #{scheme} entity store URIs" do
-          uri = scheme + '//' + ENV['MEMCACHED']
-          @storage.resolve_entitystore_uri(uri).
-            should.be.kind_of Rack::Cache::EntityStore
-        end
-      end
-      it 'supports namespaces in memcached: URIs' do
-        uri = "memcached://" + ENV['MEMCACHED'] + "/namespace"
-        @storage.resolve_metastore_uri(uri).
-           should.be.kind_of Rack::Cache::MetaStore
-      end
-    end
-
-  end
-
-end