rack-accept_headers 0.5.0

data/lib/rack/accept_headers/media_type.rb

@@ -0,0 +1,73 @@
+module Rack::AcceptHeaders
+  # Represents an HTTP Accept header according to the HTTP 1.1 specification,
+  # and provides several convenience methods for determining acceptable media
+  # types.
+  #
+  # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+  class MediaType
+    include Header
+
+    attr_accessor :extensions
+
+    # The name of this header.
+    def name
+      'Accept'
+    end
+
+    # Determines the quality factor (qvalue) of the given +media_type+.
+    def qvalue(media_type)
+      return 1 if @qvalues.empty?
+      m = matches(media_type)
+      return 0 if m.empty?
+      normalize_qvalue(@qvalues[m.first])
+    end
+
+    # Returns an array of media types from this header that match the given
+    # +media_type+, ordered by precedence.
+    def matches(media_type)
+      type, subtype, params = parse_media_type(media_type)
+      values.select {|v|
+        if v == media_type || v == '*/*'
+          true
+        else
+          t, s, p = parse_media_type(v)
+          t == type && (s == '*' || s == subtype) && (p == '' || params_match?(params, p))
+        end
+      }.sort_by {|v|
+        # Most specific gets precedence.
+        v.length
+      }.reverse
+    end
+
+    # Returns a params hash for the media type that matches
+    def params(media_type)
+      return {} unless media_type
+      key = matches(media_type).first
+      @extensions[key] || {}
+    end
+
+  private
+
+    def initialize(header)
+      @extensions = {}
+      @qvalues = {}
+
+      header.to_s.split(',').each do |part|
+        type, subtype, raw_params = parse_media_type(part)
+        raise InvalidHeader, "Invalid header value: #{part.inspect}" if !type || !subtype
+        media_type = "#{type}/#{subtype}"
+        params = parse_range_params(raw_params)
+        @extensions[media_type] = params
+        @qvalues[media_type] = normalize_qvalue(params['q']).to_f
+      end
+    end
+
+    # Returns true if all parameters and values in +match+ are also present in
+    # +params+.
+    def params_match?(params, match)
+      return true if params == match
+      parsed = parse_range_params(params)
+      parsed == parsed.merge(parse_range_params(match))
+    end
+  end
+end

data/lib/rack/accept_headers/request.rb

@@ -0,0 +1,90 @@
+require 'rack/request'
+
+module Rack::AcceptHeaders
+  # A container class for convenience methods when Rack::AcceptHeaders is used on the
+  # request level as Rack middleware. Instances of this class also manage a
+  # lightweight cache of various header instances to speed up execution.
+  class Request < Rack::Request
+    attr_reader :env
+
+    def initialize(env)
+      @env = env
+    end
+
+    # Provides access to the Rack::AcceptHeaders::MediaType instance for this request.
+    def media_type
+      @media_type ||= MediaType.new(env['HTTP_ACCEPT'])
+    end
+
+    # Provides access to the Rack::AcceptHeaders::Charset instance for this request.
+    def charset
+      @charset ||= Charset.new(env['HTTP_ACCEPT_CHARSET'])
+    end
+
+    # Provides access to the Rack::AcceptHeaders::Encoding instance for this request.
+    def encoding
+      @encoding ||= Encoding.new(env['HTTP_ACCEPT_ENCODING'])
+    end
+
+    # Provides access to the Rack::AcceptHeaders::Language instance for this request.
+    def language
+      @language ||= Language.new(env['HTTP_ACCEPT_LANGUAGE'])
+    end
+
+    # Returns true if the +Accept+ request header indicates the given media
+    # type is acceptable, false otherwise.
+    def media_type?(value)
+      media_type.accept?(value)
+    end
+
+    # Returns true if the +Accept-Charset+ request header indicates the given
+    # character set is acceptable, false otherwise.
+    def charset?(value)
+      charset.accept?(value)
+    end
+
+    # Returns true if the +Accept-Encoding+ request header indicates the given
+    # encoding is acceptable, false otherwise.
+    def encoding?(value)
+      encoding.accept?(value)
+    end
+
+    # Returns true if the +Accept-Language+ request header indicates the given
+    # language is acceptable, false otherwise.
+    def language?(value)
+      language.accept?(value)
+    end
+
+    # Determines the best media type to use in a response from the given media
+    # types, if any is acceptable. For more information on how this value is
+    # determined, see the documentation for
+    # Rack::AcceptHeaders::Header::PublicInstanceMethods#sort.
+    def best_media_type(values)
+      media_type.best_of(values)
+    end
+
+    # Determines the best character set to use in a response from the given
+    # character sets, if any is acceptable. For more information on how this
+    # value is determined, see the documentation for
+    # Rack::AcceptHeaders::Header::PublicInstanceMethods#sort.
+    def best_charset(values)
+      charset.best_of(values)
+    end
+
+    # Determines the best encoding to use in a response from the given
+    # encodings, if any is acceptable. For more information on how this value
+    # is determined, see the documentation for
+    # Rack::AcceptHeaders::Header::PublicInstanceMethods#sort.
+    def best_encoding(values)
+      encoding.best_of(values)
+    end
+
+    # Determines the best language to use in a response from the given
+    # languages, if any is acceptable. For more information on how this value
+    # is determined, see the documentation for
+    # Rack::AcceptHeaders::Header::PublicInstanceMethods#sort.
+    def best_language(values)
+      language.best_of(values)
+    end
+  end
+end

data/lib/rack/accept_headers/response.rb

@@ -0,0 +1,18 @@
+require 'rack/response'
+
+module Rack::AcceptHeaders
+  # The base class for responses issued by Rack::AcceptHeaders.
+  class Response < Rack::Response
+    # Marks this response as being unacceptable and clears the response body.
+    #
+    # Note: The HTTP spec advises servers to respond with an "entity" that
+    # describes acceptable parameters, but it fails to go into detail about its
+    # implementation. Thus, it is up to the user of this library to create such
+    # an entity if one is desired.
+    def not_acceptable!
+      self.status = 406
+      self.body = []
+      header['Content-Length'] = '0'
+    end
+  end
+end

data/lib/rack/accept_headers/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  module AcceptHeaders
+    VERSION = '0.5.0'
+  end
+end

data/lib/rack/accept_headers.rb

@@ -0,0 +1,16 @@
+require 'rack'
+require 'rack/accept_headers/header'
+require 'rack/accept_headers/charset'
+require 'rack/accept_headers/context'
+require 'rack/accept_headers/encoding'
+require 'rack/accept_headers/language'
+require 'rack/accept_headers/media_type'
+require 'rack/accept_headers/request'
+require 'rack/accept_headers/response'
+
+module Rack::AcceptHeaders
+  # Enables Rack::AcceptHeaders to be used as a Rack middleware.
+  def self.new(app, &block)
+    Context.new(app, &block)
+  end
+end

data/rack-accept_headers.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rack/accept_headers/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rack-accept_headers"
+  spec.version       = Rack::AcceptHeaders::VERSION
+  spec.authors       = ["Jack Chu", "Michael Jackson"]
+  spec.email         = ["kamuigt@gmail.com", "mjijackson@gmail.com"]
+  spec.summary       = %q{HTTP Accept* for Ruby/Rack}
+  spec.description   = %q{HTTP Accept, Accept-Charset, Accept-Encoding, and Accept-Language for Ruby/Rack}
+  spec.homepage      = "https://github.com/kamui/rack-accept_headers"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'rack'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-minitest'
+end

data/test/charset_test.rb

@@ -0,0 +1,43 @@
+require_relative 'test_helper'
+
+class CharsetTest < Minitest::Test
+  C = Rack::AcceptHeaders::Charset
+
+  def test_qvalue
+    c = C.new('')
+    assert_equal(0, c.qvalue('unicode-1-1'))
+    assert_equal(1, c.qvalue('iso-8859-1'))
+
+    c = C.new('unicode-1-1')
+    assert_equal(1, c.qvalue('unicode-1-1'))
+    assert_equal(0, c.qvalue('iso-8859-5'))
+    assert_equal(1, c.qvalue('iso-8859-1'))
+
+    c = C.new('unicode-1-1, *;q=0.5')
+    assert_equal(1, c.qvalue('unicode-1-1'))
+    assert_equal(0.5, c.qvalue('iso-8859-5'))
+    assert_equal(0.5, c.qvalue('iso-8859-1'))
+
+    c = C.new('iso-8859-1;q=0, *;q=0.5')
+    assert_equal(0.5, c.qvalue('iso-8859-5'))
+    assert_equal(0, c.qvalue('iso-8859-1'))
+
+    c = C.new('*;q=0')
+    assert_equal(0, c.qvalue('iso-8859-1'))
+  end
+
+  def test_matches
+    c = C.new('iso-8859-1, iso-8859-5, *')
+    assert_equal(%w{*}, c.matches(''))
+    assert_equal(%w{iso-8859-1 *}, c.matches('iso-8859-1'))
+    assert_equal(%w{*}, c.matches('unicode-1-1'))
+  end
+
+  def test_best_of
+    c = C.new('iso-8859-5, unicode-1-1;q=0.8')
+    assert_equal('iso-8859-5', c.best_of(%w< iso-8859-5 unicode-1-1 >))
+    assert_equal('iso-8859-5', c.best_of(%w< iso-8859-5 utf-8 >))
+    assert_equal('iso-8859-1', c.best_of(%w< iso-8859-1 utf-8 >))
+    assert_equal(nil, c.best_of(%w< utf-8 >))
+  end
+end

data/test/context_test.rb

@@ -0,0 +1,57 @@
+require_relative 'test_helper'
+
+class ContextTest < Minitest::Test
+  def media_types; Proc.new {|c| c.media_types = %w< text/html > } end
+  def charsets;    Proc.new {|c| c.charsets = %w< iso-8859-5 > }   end
+  def encodings;   Proc.new {|c| c.encodings = %w< gzip > }        end
+  def languages;   Proc.new {|c| c.languages = %w< en > }          end
+
+  def test_empty
+    request
+    assert_equal(200, status)
+  end
+
+  def test_media_types
+    request('HTTP_ACCEPT' => 'text/html')
+    assert_equal(200, status)
+
+    request('HTTP_ACCEPT' => 'text/html', &media_types)
+    assert_equal(200, status)
+
+    request('HTTP_ACCEPT' => 'text/plain', &media_types)
+    assert_equal(406, status)
+  end
+
+  def test_charsets
+    request('HTTP_ACCEPT_CHARSET' => 'iso-8859-5')
+    assert_equal(200, status)
+
+    request('HTTP_ACCEPT_CHARSET' => 'iso-8859-5', &charsets)
+    assert_equal(200, status)
+
+    request('HTTP_ACCEPT_CHARSET' => 'unicode-1-1', &charsets)
+    assert_equal(406, status)
+  end
+
+  def test_encodings
+    request('HTTP_ACCEPT_ENCODING' => 'gzip')
+    assert_equal(200, status)
+
+    request('HTTP_ACCEPT_ENCODING' => 'gzip', &encodings)
+    assert_equal(200, status)
+
+    request('HTTP_ACCEPT_ENCODING' => 'compress', &encodings)
+    assert_equal(406, status)
+  end
+
+  def test_languages
+    request('HTTP_ACCEPT_LANGUAGE' => 'en')
+    assert_equal(200, status)
+
+    request('HTTP_ACCEPT_LANGUAGE' => 'en', &languages)
+    assert_equal(200, status)
+
+    request('HTTP_ACCEPT_LANGUAGE' => 'jp', &languages)
+    assert_equal(406, status)
+  end
+end

data/test/encoding_test.rb

@@ -0,0 +1,29 @@
+require_relative 'test_helper'
+
+class EncodingTest < Minitest::Test
+  E = Rack::AcceptHeaders::Encoding
+
+  def test_qvalue
+    e = E.new('')
+    assert_equal(0, e.qvalue('gzip'))
+    assert_equal(1, e.qvalue('identity'))
+
+    e = E.new('gzip, *;q=0.5')
+    assert_equal(1, e.qvalue('gzip'))
+    assert_equal(0.5, e.qvalue('identity'))
+  end
+
+  def test_matches
+    e = E.new('gzip, identity, *')
+    assert_equal(%w{*}, e.matches(''))
+    assert_equal(%w{gzip *}, e.matches('gzip'))
+    assert_equal(%w{*}, e.matches('compress'))
+  end
+
+  def test_best_of
+    e = E.new('gzip, compress')
+    assert_equal('gzip', e.best_of(%w< gzip compress >))
+    assert_equal('identity', e.best_of(%w< identity compress >))
+    assert_equal(nil, e.best_of(%w< zip >))
+  end
+end

data/test/header_test.rb

@@ -0,0 +1,69 @@
+require_relative 'test_helper'
+
+class HeaderTest < Minitest::Test
+  H = Rack::AcceptHeaders::Header
+
+  def test_parse_and_join
+    # Accept
+    header = 'text/plain; q=0.5, text/html, text/html;level=2, text/html;level=1;q=0.3, text/x-c, image/*; q=0.2'
+    expect = {
+      'text/plain'        => 0.5,
+      'text/html'         => 1,
+      'text/html;level=2' => 1,
+      'text/html;level=1' => 0.3,
+      'text/x-c'          => 1,
+      'image/*'           => 0.2
+    }
+    assert_equal(expect, H.parse(header))
+    assert_equal(expect, H.parse(H.join(expect)))
+
+    # Accept-Charset
+    header = 'iso-8859-5, unicode-1-1;q=0.8'
+    expect = { 'iso-8859-5' => 1, 'unicode-1-1' => 0.8 }
+    assert_equal(expect, H.parse(header))
+    assert_equal(expect, H.parse(H.join(expect)))
+
+    # Accept-Encoding
+    header = 'gzip;q=1.0, identity; q=0.5, *;q=0'
+    expect = { 'gzip' => 1, 'identity' => 0.5, '*' => 0 }
+    assert_equal(expect, H.parse(header))
+    assert_equal(expect, H.parse(H.join(expect)))
+
+    # Accept-Language
+    header = 'da, en-gb;q=0.8, en;q=0.7'
+    expect = { 'da' => 1, 'en-gb' => 0.8, 'en' => 0.7 }
+    assert_equal(expect, H.parse(header))
+    assert_equal(expect, H.parse(H.join(expect)))
+  end
+
+  def test_parse_media_type
+    assert_equal([], H.parse_media_type(''))
+    assert_equal(['*', '*', ''], H.parse_media_type('*/*'))
+    assert_equal(['text', '*', ''], H.parse_media_type('text/*'))
+    assert_equal(['text', 'html', ''], H.parse_media_type('text/html'))
+    assert_equal(['text', 'html', 'level=1'], H.parse_media_type('text/html;level=1'))
+    assert_equal(['text', 'html', 'level=1;answer=42'], H.parse_media_type('text/html;level=1;answer=42'))
+    assert_equal(['text', 'x-dvi', ''], H.parse_media_type('text/x-dvi'))
+  end
+
+  def test_parse_range_params
+    assert_equal({'q' => '1'}, H.parse_range_params(''))
+    assert_equal({'q' => '1'}, H.parse_range_params('a'))
+    assert_equal({'q' => '1', 'a' => 'a'}, H.parse_range_params('a=a'))
+    assert_equal({'q' => '1', 'a' => 'a', 'b' => 'b'}, H.parse_range_params('a=a;b=b'))
+  end
+
+  def test_normalize_qvalue
+    assert_equal(1, H.normalize_qvalue(1.0))
+    assert_equal(0, H.normalize_qvalue(0.0))
+    assert_equal(1, H.normalize_qvalue(1))
+    assert_equal(0, H.normalize_qvalue(0))
+    assert_equal(0.5, H.normalize_qvalue(0.5))
+  end
+
+  def test_invalid_header
+    assert_raises Rack::AcceptHeaders::Header::InvalidHeader do
+      h = H.parse(' / ')
+    end
+  end
+end

data/test/language_test.rb

@@ -0,0 +1,47 @@
+require_relative 'test_helper'
+
+class LanguageTest < Minitest::Test
+  L = Rack::AcceptHeaders::Language
+
+  def test_qvalue
+    l = L.new('')
+    assert_equal(1, l.qvalue('en'))
+
+    l = L.new('en;q=0.5, en-gb')
+    assert_equal(0.5, l.qvalue('en'))
+    assert_equal(1, l.qvalue('en-gb'))
+    assert_equal(0, l.qvalue('da'))
+  end
+
+  def test_matches
+    l = L.new('da, *, en')
+    assert_equal(%w{*}, l.matches(''))
+    assert_equal(%w{da *}, l.matches('da'))
+    assert_equal(%w{en *}, l.matches('en'))
+    assert_equal(%w{en *}, l.matches('en-gb'))
+    assert_equal(%w{*}, l.matches('eng'))
+
+    l = L.new('en, en-gb')
+    assert_equal(%w{en-gb en}, l.matches('en-gb'))
+  end
+
+  def test_best_of
+    l = L.new('en;q=0.5, en-gb')
+    assert_equal('en-gb', l.best_of(%w< en en-gb >))
+    assert_equal('en', l.best_of(%w< en da >))
+    assert_equal('en-us', l.best_of(%w< en-us en-au >))
+    assert_equal(nil, l.best_of(%w< da >))
+
+    l = L.new('en;q=0.5, en-GB, fr-CA')
+    assert_equal('en-gb', l.best_of(%w< en en-gb >))
+
+    l = L.new('en-gb;q=0.5, EN, fr-CA')
+    assert_equal('en', l.best_of(%w< en en-gb >))
+
+    l = L.new('en;q=0.5, fr-ca')
+    assert_equal('en', l.best_of(%w< en fr >))
+
+    l.first_level_match = true
+    assert_equal('fr', l.best_of(%w< en fr >))
+  end
+end

data/test/media_type_test.rb

@@ -0,0 +1,80 @@
+require_relative 'test_helper'
+
+class MediaTypeTest < Minitest::Test
+  M = Rack::AcceptHeaders::MediaType
+
+  def test_qvalue
+    m = M.new('text/html, text/*;q=0.3, */*;q=0.5')
+    assert_equal(0.5, m.qvalue('image/png'))
+    assert_equal(0.3, m.qvalue('text/plain'))
+    assert_equal(1, m.qvalue('text/html'))
+
+    m = M.new('text/html')
+    assert_equal(0, m.qvalue('image/png'))
+
+    m = M.new('')
+    assert_equal(1, m.qvalue('text/html'))
+  end
+
+  def test_invalid_media_type
+    assert_raises Rack::AcceptHeaders::Header::InvalidHeader do
+      m = M.new('')
+      m = M.new('text')
+      m = M.new('text;q=1')
+    end
+  end
+
+  def test_matches
+    m = M.new('text/*, text/html, text/html;level=1, */*')
+    assert_equal(%w{*/*}, m.matches(''))
+    assert_equal(%w{*/*}, m.matches('image/jpeg'))
+    assert_equal(%w{text/* */*}, m.matches('text/plain'))
+    assert_equal(%w{text/html text/* */*}, m.matches('text/html'))
+    assert_equal(%w{text/html text/* */*}, m.matches('text/html;level=1'))
+    assert_equal(%w{text/html text/* */*}, m.matches('text/html;level=1;answer=42'))
+  end
+
+  def test_best_of
+    m = M.new('text/*;q=0.5, text/html')
+    assert_equal('text/html', m.best_of(%w< text/plain text/html >))
+    assert_equal('text/plain', m.best_of(%w< text/plain image/png >))
+    assert_equal('text/plain', m.best_of(%w< text/plain text/javascript >))
+    assert_equal(nil, m.best_of(%w< image/png >))
+
+    m = M.new('text/*')
+    assert_equal('text/html', m.best_of(%w< text/html text/xml >))
+    assert_equal('text/xml', m.best_of(%w< text/xml text/html >))
+
+    m = M.new('TEXT/*')
+    assert_equal('text/html', m.best_of(%w< text/html text/xml >))
+    assert_equal('text/xml', m.best_of(%w< text/xml text/html >))
+  end
+
+  def test_extensions
+    m = M.new('text/plain')
+    assert_equal({'text/plain' => {'q' => '1'}}, m.extensions)
+    m = M.new('text/*;q=0.5;a=42')
+    assert_equal({'text/*' => {'q' => '0.5', 'a' => '42'}}, m.extensions)
+  end
+
+  def test_params
+    m = M.new('text/plain;q=0.7;version=1.0')
+    assert_equal({'q' => '0.7', 'version' => '1.0'}, m.params('text/plain'))
+    m = M.new('text/*;q=0.5;a=42, application/json;b=12')
+    assert_equal({'q' => '0.5', 'a' => '42'}, m.params('text/plain'))
+    assert_equal({'q' => '1', 'b' => '12'}, m.params('application/json'))
+  end
+
+  def test_vendored_types
+    m = M.new("application/vnd.ms-excel")
+    assert_equal(nil, m.best_of(%w< application/vnd.ms-powerpoint >))
+
+    m = M.new("application/vnd.api-v1+json")
+    assert_equal(false, m.accept?("application/vnd.api-v2+json"))
+
+    v1, v2 = "application/vnd.api-v1+json", "application/vnd.api-v2+json"
+    m = M.new("#{v1},#{v2}")
+    assert_equal(v1, m.best_of([v1, v2]))
+    assert_equal(v2, m.best_of([v2, v1]))
+  end
+end

data/test/request_test.rb

@@ -0,0 +1,60 @@
+require_relative 'test_helper'
+
+class RequestTest < Minitest::Test
+  R = Rack::AcceptHeaders::Request
+
+  def test_media_type
+    r = R.new('HTTP_ACCEPT' => 'text/*;q=0, text/html')
+    assert(r.media_type?('text/html'))
+    assert(r.media_type?('text/html;level=1'))
+    assert(!r.media_type?('text/plain'))
+    assert(!r.media_type?('image/png'))
+
+    request = R.new('HTTP_ACCEPT' => '*/*')
+    assert(request.media_type?('image/png'))
+  end
+
+  def test_charset
+    r = R.new('HTTP_ACCEPT_CHARSET' => 'iso-8859-5, unicode-1-1;q=0.8')
+    assert(r.charset?('iso-8859-5'))
+    assert(r.charset?('unicode-1-1'))
+    assert(r.charset?('iso-8859-1'))
+    assert(!r.charset?('utf-8'))
+
+    r = R.new('HTTP_ACCEPT_CHARSET' => 'iso-8859-1;q=0')
+    assert(!r.charset?('iso-8859-1'))
+  end
+
+  def test_encoding
+    r = R.new('HTTP_ACCEPT_ENCODING' => '')
+    assert(r.encoding?('identity'))
+    assert(!r.encoding?('gzip'))
+
+    r = R.new('HTTP_ACCEPT_ENCODING' => 'gzip')
+    assert(r.encoding?('identity'))
+    assert(r.encoding?('gzip'))
+    assert(!r.encoding?('compress'))
+
+    r = R.new('HTTP_ACCEPT_ENCODING' => 'gzip;q=0, *')
+    assert(r.encoding?('compress'))
+    assert(r.encoding?('identity'))
+    assert(!r.encoding?('gzip'))
+
+    r = R.new('HTTP_ACCEPT_ENCODING' => 'identity;q=0')
+    assert(!r.encoding?('identity'))
+
+    r = R.new('HTTP_ACCEPT_ENCODING' => '*;q=0')
+    assert(!r.encoding?('identity'))
+  end
+
+  def test_language
+    request = R.new({})
+    assert(request.language?('en'))
+    assert(request.language?('da'))
+
+    request = R.new('HTTP_ACCEPT_LANGUAGE' => 'en;q=0.5, en-gb')
+    assert(request.language?('en'))
+    assert(request.language?('en-gb'))
+    assert(!request.language?('da'))
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,26 @@
+ENV['RACK_ENV'] = 'test'
+
+require 'rack'
+require 'minitest/autorun'
+require 'rack/accept_headers'
+
+class Minitest::Test
+  attr_reader :context
+  attr_reader :response
+
+  def status
+    @response && @response.status
+  end
+
+  def request(env={}, method='GET', uri='/')
+    @context = Rack::AcceptHeaders.new(fake_app)
+    yield @context if block_given?
+    mock_request = Rack::MockRequest.new(@context)
+    @response = mock_request.request(method.to_s.upcase, uri, env)
+    @response
+  end
+
+  def fake_app(status=200, headers={}, body=[])
+    lambda {|env| Rack::Response.new(body, status, headers).finish }
+  end
+end