sinatra 0.9.1.1 → 0.9.2

data/test/builder_test.rb

@@ -1,6 +1,7 @@
 require File.dirname(__FILE__) + '/helper'
+require 'builder'
 
-describe "Builder Templates" do
+class BuilderTest < Test::Unit::TestCase
   def builder_app(&block)
     mock_app {
       set :views, File.dirname(__FILE__) + '/views'

data/test/contest.rb

@@ -0,0 +1,64 @@
+require "test/unit"
+
+# Test::Unit loads a default test if the suite is empty, and the only
+# purpose of that test is to fail. As having empty contexts is a common
+# practice, we decided to overwrite TestSuite#empty? in order to
+# allow them. Having a failure when no tests have been defined seems
+# counter-intuitive.
+class Test::Unit::TestSuite
+  unless method_defined?(:empty?)
+    def empty?
+      false
+    end
+  end
+end
+
+# We added setup, test and context as class methods, and the instance
+# method setup now iterates on the setup blocks. Note that all setup
+# blocks must be defined with the block syntax. Adding a setup instance
+# method defeats the purpose of this library.
+class Test::Unit::TestCase
+  def self.setup(&block)
+    setup_blocks << block
+  end
+
+  def setup
+    self.class.setup_blocks.each do |block|
+      instance_eval(&block)
+    end
+  end
+
+  def self.context(name, &block)
+    subclass = Class.new(self.superclass)
+    subclass.setup_blocks.unshift(*setup_blocks)
+    subclass.class_eval(&block)
+    const_set(context_name(name), subclass)
+  end
+
+  def self.test(name, &block)
+    define_method(test_name(name), &block)
+  end
+
+  class << self
+    alias_method :should, :test
+    alias_method :describe, :context
+  end
+
+private
+
+  def self.setup_blocks
+    @setup_blocks ||= []
+  end
+
+  def self.context_name(name)
+    "Test#{sanitize_name(name).gsub(/(^| )(\w)/) { $2.upcase }}".to_sym
+  end
+
+  def self.test_name(name)
+    "test_#{sanitize_name(name).gsub(/\s+/,'_')}".to_sym
+  end
+
+  def self.sanitize_name(name)
+    name.gsub(/\W+/, ' ').strip
+  end
+end

data/test/erb_test.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
 
-describe "ERB Templates" do
+class ERBTest < Test::Unit::TestCase
   def erb_app(&block)
     mock_app {
       set :views, File.dirname(__FILE__) + '/views'

data/test/extensions_test.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
 
-describe 'Registering extensions' do
+class ExtensionsTest < Test::Unit::TestCase
   module FooExtensions
     def foo
     end
@@ -25,6 +25,12 @@ describe 'Registering extensions' do
     end
   end
 
+  module PainExtensions
+    def foo=(name); end
+    def bar?(name); end
+    def fizz!(name); end
+  end
+
   it 'will add the methods to the DSL for the class in which you register them and its subclasses' do
     Sinatra::Base.register FooExtensions
     assert Sinatra::Base.respond_to?(:foo)
@@ -50,6 +56,16 @@ describe 'Registering extensions' do
       map { |m| m.to_sym }.include?(:im_hiding_in_ur_foos)
   end
 
+  it 'will handle special method names' do
+    Sinatra::Default.register PainExtensions
+    assert Sinatra::Delegator.private_instance_methods.
+      map { |m| m.to_sym }.include?(:foo=)
+    assert Sinatra::Delegator.private_instance_methods.
+      map { |m| m.to_sym }.include?(:bar?)
+    assert Sinatra::Delegator.private_instance_methods.
+      map { |m| m.to_sym }.include?(:fizz!)
+  end
+
   it 'will not delegate methods on Base#register' do
     Sinatra::Base.register QuuxExtensions
     assert !Sinatra::Delegator.private_instance_methods.include?("quux")

data/test/filter_test.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
 
-describe "Filters" do
+class FilterTest < Test::Unit::TestCase
   it "executes filters in the order defined" do
     count = 0
     mock_app do

data/test/haml_test.rb

@@ -1,6 +1,7 @@
 require File.dirname(__FILE__) + '/helper'
+require 'haml'
 
-describe "HAML Templates" do
+class HAMLTest < Test::Unit::TestCase
   def haml_app(&block)
     mock_app {
       set :views, File.dirname(__FILE__) + '/views'
@@ -47,9 +48,12 @@ describe "HAML Templates" do
   end
 
   it "passes HAML options to the Haml engine" do
-    haml_app {
-      haml "!!!\n%h1 Hello World", :options => {:format => :html5}
+    mock_app {
+      get '/' do
+        haml "!!!\n%h1 Hello World", :format => :html5
+      end
     }
+    get '/'
     assert ok?
     assert_equal "<!DOCTYPE html>\n<h1>Hello World</h1>\n", body
   end
@@ -65,4 +69,22 @@ describe "HAML Templates" do
     assert ok?
     assert_equal "<!DOCTYPE html>\n<h1>Hello World</h1>\n", body
   end
+
+  it "merges the default HAML options with the overrides and passes them to the Haml engine" do
+    mock_app {
+      set :haml, {:format => :html5, :attr_wrapper => '"'} # default HAML attr are <tag attr='single-quoted'>
+      get '/' do
+        haml "!!!\n%h1{:class => :header} Hello World"
+      end
+      get '/html4' do
+        haml "!!!\n%h1{:class => 'header'} Hello World", :format => :html4
+      end
+    }
+    get '/'
+    assert ok?
+    assert_equal "<!DOCTYPE html>\n<h1 class=\"header\">Hello World</h1>\n", body
+    get '/html4'
+    assert ok?
+    assert_match(/^<!DOCTYPE html PUBLIC (.*) HTML 4.01/, body)
+  end
 end

data/test/helper.rb

@@ -1,3 +1,5 @@
+ENV['RACK_ENV'] = 'test'
+
 begin
   require 'rack'
 rescue LoadError
@@ -5,19 +7,35 @@ rescue LoadError
   require 'rack'
 end
 
+testdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift testdir unless $LOAD_PATH.include?(testdir)
+
 libdir = File.dirname(File.dirname(__FILE__)) + '/lib'
 $LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir)
 
-require 'test/unit'
-require 'sinatra/test'
+require 'contest'
+require 'rack/test'
+require 'sinatra/base'
 
 class Sinatra::Base
   # Allow assertions in request context
   include Test::Unit::Assertions
 end
 
+Sinatra::Base.set :environment, :test
+
 class Test::Unit::TestCase
-  include Sinatra::Test
+  include Rack::Test::Methods
+
+  class << self
+    alias_method :it, :test
+  end
+
+  alias_method :response, :last_response
+
+  setup do
+    Sinatra::Base.set :environment, :test
+  end
 
   # Sets up a Sinatra::Base subclass defined with the block
   # given. Used in setup or individual spec methods to establish
@@ -26,56 +44,33 @@ class Test::Unit::TestCase
     @app = Sinatra.new(base, &block)
   end
 
-  def restore_default_options
-    Sinatra::Default.set(
-      :environment => :development,
-      :raise_errors => Proc.new { test? },
-      :dump_errors => true,
-      :sessions => false,
-      :logging => Proc.new { ! test? },
-      :methodoverride => true,
-      :static => true,
-      :run => Proc.new { ! test? }
-    )
+  def app
+    Rack::Lint.new(@app)
+  end
+
+  def body
+    response.body.to_s
   end
-end
 
-##
-# test/spec/mini
-# http://pastie.caboo.se/158871
-# chris@ozmm.org
-#
-def describe(*args, &block)
-  return super unless (name = args.first.capitalize) && block
-  name = "#{name.gsub(/\W/, '')}Test"
-  Object.send :const_set, name, Class.new(Test::Unit::TestCase)
-  klass = Object.const_get(name)
-  klass.class_eval do
-    def self.it(name, &block)
-      define_method("test_#{name.gsub(/\W/,'_').downcase}", &block)
+  # Delegate other missing methods to response.
+  def method_missing(name, *args, &block)
+    if response && response.respond_to?(name)
+      response.send(name, *args, &block)
+    else
+      super
     end
-    def self.xspecify(*args) end
-    def self.before(&block) define_method(:setup, &block)    end
-    def self.after(&block)  define_method(:teardown, &block) end
   end
-  klass.class_eval &block
-  klass
-end
 
-def describe_option(name, &block)
-  klass = describe("Option #{name}", &block)
-  klass.before do
-    restore_default_options
-    @base    = Sinatra.new
-    @default = Class.new(Sinatra::Default)
+  # Also check response since we delegate there.
+  def respond_to?(symbol, include_private=false)
+    super || (response && response.respond_to?(symbol, include_private))
   end
-  klass
-end
 
-# Do not output warnings for the duration of the block.
-def silence_warnings
-  $VERBOSE, v = nil, $VERBOSE
-  yield
-ensure
-  $VERBOSE = v
+  # Do not output warnings for the duration of the block.
+  def silence_warnings
+    $VERBOSE, v = nil, $VERBOSE
+    yield
+  ensure
+    $VERBOSE = v
+  end
 end

data/test/helpers_test.rb

@@ -1,497 +1,503 @@
 require File.dirname(__FILE__) + '/helper'
 
-describe 'Helpers#status' do
-  before do
-    mock_app {
-      get '/' do
-        status 207
-        nil
-      end
-    }
+class HelpersTest < Test::Unit::TestCase
+  def test_default
+    assert true
   end
 
-  it 'sets the response status code' do
-    get '/'
-    assert_equal 207, response.status
-  end
-end
-
-describe 'Helpers#body' do
-  it 'takes a block for defered body generation' do
-    mock_app {
-      get '/' do
-        body { 'Hello World' }
-      end
-    }
-
-    get '/'
-    assert_equal 'Hello World', body
-  end
-
-  it 'takes a String, Array, or other object responding to #each' do
-    mock_app {
-      get '/' do
-        body 'Hello World'
-      end
-    }
-
-    get '/'
-    assert_equal 'Hello World', body
-  end
-end
-
-describe 'Helpers#redirect' do
-  it 'uses a 302 when only a path is given' do
-    mock_app {
-      get '/' do
-        redirect '/foo'
-        fail 'redirect should halt'
-      end
-    }
-
-    get '/'
-    assert_equal 302, status
-    assert_equal '', body
-    assert_equal '/foo', response['Location']
-  end
-
-  it 'uses the code given when specified' do
-    mock_app {
-      get '/' do
-        redirect '/foo', 301
-        fail 'redirect should halt'
-      end
-    }
-
-    get '/'
-    assert_equal 301, status
-    assert_equal '', body
-    assert_equal '/foo', response['Location']
-  end
-
-  it 'redirects back to request.referer when passed back' do
-    mock_app {
-      get '/try_redirect' do
-        redirect back
-      end
-    }
-
-    request = Rack::MockRequest.new(@app)
-    response = request.get('/try_redirect', 'HTTP_REFERER' => '/foo')
-    assert_equal 302, response.status
-    assert_equal '/foo', response['Location']
-  end
-
-end
-
-describe 'Helpers#error' do
-  it 'sets a status code and halts' do
-    mock_app {
-      get '/' do
-        error 501
-        fail 'error should halt'
-      end
-    }
-
-    get '/'
-    assert_equal 501, status
-    assert_equal '', body
-  end
-
-  it 'takes an optional body' do
-    mock_app {
-      get '/' do
-        error 501, 'FAIL'
-        fail 'error should halt'
-      end
-    }
-
-    get '/'
-    assert_equal 501, status
-    assert_equal 'FAIL', body
-  end
-
-  it 'uses a 500 status code when first argument is a body' do
-    mock_app {
-      get '/' do
-        error 'FAIL'
-        fail 'error should halt'
-      end
-    }
-
-    get '/'
-    assert_equal 500, status
-    assert_equal 'FAIL', body
-  end
-end
-
-describe 'Helpers#not_found' do
-  it 'halts with a 404 status' do
-    mock_app {
-      get '/' do
-        not_found
-        fail 'not_found should halt'
-      end
-    }
-
-    get '/'
-    assert_equal 404, status
-    assert_equal '', body
-  end
-end
-
-describe 'Helpers#headers' do
-  it 'sets headers on the response object when given a Hash' do
-    mock_app {
-      get '/' do
-        headers 'X-Foo' => 'bar', 'X-Baz' => 'bling'
-        'kthx'
-      end
-    }
-
-    get '/'
-    assert ok?
-    assert_equal 'bar', response['X-Foo']
-    assert_equal 'bling', response['X-Baz']
-    assert_equal 'kthx', body
-  end
-
-  it 'returns the response headers hash when no hash provided' do
-    mock_app {
-      get '/' do
-        headers['X-Foo'] = 'bar'
-        'kthx'
-      end
-    }
-
-    get '/'
-    assert ok?
-    assert_equal 'bar', response['X-Foo']
-  end
-end
-
-describe 'Helpers#session' do
-  it 'uses the existing rack.session' do
-    mock_app {
-      get '/' do
-        session[:foo]
-      end
-    }
-
-    get '/', :env => { 'rack.session' => { :foo => 'bar' } }
-    assert_equal 'bar', body
-  end
-
-  it 'creates a new session when none provided' do
-    mock_app {
-      get '/' do
-        assert session.empty?
-        session[:foo] = 'bar'
-        'Hi'
-      end
-    }
-
-    get '/'
-    assert_equal 'Hi', body
-  end
-end
-
-describe 'Helpers#media_type' do
-  include Sinatra::Helpers
-
-  it "looks up media types in Rack's MIME registry" do
-    Rack::Mime::MIME_TYPES['.foo'] = 'application/foo'
-    assert_equal 'application/foo', media_type('foo')
-    assert_equal 'application/foo', media_type('.foo')
-    assert_equal 'application/foo', media_type(:foo)
-  end
-
-  it 'returns nil when given nil' do
-    assert media_type(nil).nil?
-  end
-
-  it 'returns nil when media type not registered' do
-    assert media_type(:bizzle).nil?
-  end
+  describe 'status' do
+    setup do
+      mock_app {
+        get '/' do
+          status 207
+          nil
+        end
+      }
+    end
 
-  it 'returns the argument when given a media type string' do
-    assert_equal 'text/plain', media_type('text/plain')
+    it 'sets the response status code' do
+      get '/'
+      assert_equal 207, response.status
+    end
   end
-end
 
-describe 'Helpers#content_type' do
-  it 'sets the Content-Type header' do
-    mock_app {
-      get '/' do
-        content_type 'text/plain'
-        'Hello World'
-      end
-    }
-
-    get '/'
-    assert_equal 'text/plain', response['Content-Type']
-    assert_equal 'Hello World', body
-  end
+  describe 'body' do
+    it 'takes a block for defered body generation' do
+      mock_app {
+        get '/' do
+          body { 'Hello World' }
+        end
+      }
 
-  it 'takes media type parameters (like charset=)' do
-    mock_app {
-      get '/' do
-        content_type 'text/html', :charset => 'utf-8'
-        "<h1>Hello, World</h1>"
-      end
-    }
-
-    get '/'
-    assert ok?
-    assert_equal 'text/html;charset=utf-8', response['Content-Type']
-    assert_equal "<h1>Hello, World</h1>", body
-  end
+      get '/'
+      assert_equal 'Hello World', body
+    end
 
-  it "looks up symbols in Rack's mime types dictionary" do
-    Rack::Mime::MIME_TYPES['.foo'] = 'application/foo'
-    mock_app {
-      get '/foo.xml' do
-        content_type :foo
-        "I AM FOO"
-      end
-    }
-
-    get '/foo.xml'
-    assert ok?
-    assert_equal 'application/foo', response['Content-Type']
-    assert_equal 'I AM FOO', body
-  end
+    it 'takes a String, Array, or other object responding to #each' do
+      mock_app {
+        get '/' do
+          body 'Hello World'
+        end
+      }
 
-  it 'fails when no mime type is registered for the argument provided' do
-    mock_app {
-      get '/foo.xml' do
-        content_type :bizzle
-        "I AM FOO"
-      end
-    }
-    assert_raise(RuntimeError) { get '/foo.xml' }
+      get '/'
+      assert_equal 'Hello World', body
+    end
   end
-end
 
-describe 'Helpers#send_file' do
-  before do
-    @file = File.dirname(__FILE__) + '/file.txt'
-    File.open(@file, 'wb') { |io| io.write('Hello World') }
-  end
+  describe 'redirect' do
+    it 'uses a 302 when only a path is given' do
+      mock_app {
+        get '/' do
+          redirect '/foo'
+          fail 'redirect should halt'
+        end
+      }
+
+      get '/'
+      assert_equal 302, status
+      assert_equal '', body
+      assert_equal '/foo', response['Location']
+    end
+
+    it 'uses the code given when specified' do
+      mock_app {
+        get '/' do
+          redirect '/foo', 301
+          fail 'redirect should halt'
+        end
+      }
+
+      get '/'
+      assert_equal 301, status
+      assert_equal '', body
+      assert_equal '/foo', response['Location']
+    end
+
+    it 'redirects back to request.referer when passed back' do
+      mock_app {
+        get '/try_redirect' do
+          redirect back
+        end
+      }
 
-  after do
-    File.unlink @file
-    @file = nil
+      request = Rack::MockRequest.new(@app)
+      response = request.get('/try_redirect', 'HTTP_REFERER' => '/foo')
+      assert_equal 302, response.status
+      assert_equal '/foo', response['Location']
+    end
   end
 
-  def send_file_app(opts={})
-    path = @file
-    mock_app {
-      get '/file.txt' do
-        send_file path, opts
-      end
-    }
-  end
+  describe 'error' do
+    it 'sets a status code and halts' do
+      mock_app {
+        get '/' do
+          error 501
+          fail 'error should halt'
+        end
+      }
+
+      get '/'
+      assert_equal 501, status
+      assert_equal '', body
+    end
+
+    it 'takes an optional body' do
+      mock_app {
+        get '/' do
+          error 501, 'FAIL'
+          fail 'error should halt'
+        end
+      }
+
+      get '/'
+      assert_equal 501, status
+      assert_equal 'FAIL', body
+    end
+
+    it 'uses a 500 status code when first argument is a body' do
+      mock_app {
+        get '/' do
+          error 'FAIL'
+          fail 'error should halt'
+        end
+      }
 
-  it "sends the contents of the file" do
-    send_file_app
-    get '/file.txt'
-    assert ok?
-    assert_equal 'Hello World', body
+      get '/'
+      assert_equal 500, status
+      assert_equal 'FAIL', body
+    end
   end
 
-  it 'sets the Content-Type response header if a mime-type can be located' do
-    send_file_app
-    get '/file.txt'
-    assert_equal 'text/plain', response['Content-Type']
-  end
+  describe 'not_found' do
+    it 'halts with a 404 status' do
+      mock_app {
+        get '/' do
+          not_found
+          fail 'not_found should halt'
+        end
+      }
 
-  it 'sets the Content-Length response header' do
-    send_file_app
-    get '/file.txt'
-    assert_equal 'Hello World'.length.to_s, response['Content-Length']
+      get '/'
+      assert_equal 404, status
+      assert_equal '', body
+    end
   end
 
-  it 'sets the Last-Modified response header' do
-    send_file_app
-    get '/file.txt'
-    assert_equal File.mtime(@file).httpdate, response['Last-Modified']
-  end
+  describe 'headers' do
+    it 'sets headers on the response object when given a Hash' do
+      mock_app {
+        get '/' do
+          headers 'X-Foo' => 'bar', 'X-Baz' => 'bling'
+          'kthx'
+        end
+      }
+
+      get '/'
+      assert ok?
+      assert_equal 'bar', response['X-Foo']
+      assert_equal 'bling', response['X-Baz']
+      assert_equal 'kthx', body
+    end
+
+    it 'returns the response headers hash when no hash provided' do
+      mock_app {
+        get '/' do
+          headers['X-Foo'] = 'bar'
+          'kthx'
+        end
+      }
 
-  it "returns a 404 when not found" do
-    mock_app {
-      get '/' do
-        send_file 'this-file-does-not-exist.txt'
-      end
-    }
-    get '/'
-    assert not_found?
+      get '/'
+      assert ok?
+      assert_equal 'bar', response['X-Foo']
+    end
   end
 
-  it "does not set the Content-Disposition header by default" do
-    send_file_app
-    get '/file.txt'
-    assert_nil response['Content-Disposition']
-  end
+  describe 'session' do
+    it 'uses the existing rack.session' do
+      mock_app {
+        get '/' do
+          session[:foo]
+        end
+      }
+
+      get '/', {}, { 'rack.session' => { :foo => 'bar' } }
+      assert_equal 'bar', body
+    end
+
+    it 'creates a new session when none provided' do
+      mock_app {
+        get '/' do
+          assert session.empty?
+          session[:foo] = 'bar'
+          'Hi'
+        end
+      }
 
-  it "sets the Content-Disposition header when :disposition set to 'attachment'" do
-    send_file_app :disposition => 'attachment'
-    get '/file.txt'
-    assert_equal 'attachment; filename="file.txt"', response['Content-Disposition']
+      get '/'
+      assert_equal 'Hi', body
+    end
   end
 
-  it "sets the Content-Disposition header when :filename provided" do
-    send_file_app :filename => 'foo.txt'
-    get '/file.txt'
-    assert_equal 'attachment; filename="foo.txt"', response['Content-Disposition']
-  end
-end
+  describe 'media_type' do
+    include Sinatra::Helpers
 
-describe 'Helpers#last_modified' do
-  before do
-    now = Time.now
-    mock_app {
-      get '/' do
-        body { 'Hello World' }
-        last_modified now
-        'Boo!'
-      end
-    }
-    @now = now
-  end
+    it "looks up media types in Rack's MIME registry" do
+      Rack::Mime::MIME_TYPES['.foo'] = 'application/foo'
+      assert_equal 'application/foo', media_type('foo')
+      assert_equal 'application/foo', media_type('.foo')
+      assert_equal 'application/foo', media_type(:foo)
+    end
 
-  it 'sets the Last-Modified header to a valid RFC 2616 date value' do
-    get '/'
-    assert_equal @now.httpdate, response['Last-Modified']
-  end
+    it 'returns nil when given nil' do
+      assert media_type(nil).nil?
+    end
 
-  it 'returns a body when conditional get misses' do
-    get '/'
-    assert_equal 200, status
-    assert_equal 'Boo!', body
-  end
+    it 'returns nil when media type not registered' do
+      assert media_type(:bizzle).nil?
+    end
 
-  it 'halts when a conditional GET matches' do
-    get '/', :env => { 'HTTP_IF_MODIFIED_SINCE' => @now.httpdate }
-    assert_equal 304, status
-    assert_equal '', body
+    it 'returns the argument when given a media type string' do
+      assert_equal 'text/plain', media_type('text/plain')
+    end
   end
-end
 
-describe 'Helpers#etag' do
-  before do
-    mock_app {
-      get '/' do
-        body { 'Hello World' }
-        etag 'FOO'
-        'Boo!'
-      end
-    }
-  end
+  describe 'content_type' do
+    it 'sets the Content-Type header' do
+      mock_app {
+        get '/' do
+          content_type 'text/plain'
+          'Hello World'
+        end
+      }
+
+      get '/'
+      assert_equal 'text/plain', response['Content-Type']
+      assert_equal 'Hello World', body
+    end
+
+    it 'takes media type parameters (like charset=)' do
+      mock_app {
+        get '/' do
+          content_type 'text/html', :charset => 'utf-8'
+          "<h1>Hello, World</h1>"
+        end
+      }
+
+      get '/'
+      assert ok?
+      assert_equal 'text/html;charset=utf-8', response['Content-Type']
+      assert_equal "<h1>Hello, World</h1>", body
+    end
+
+    it "looks up symbols in Rack's mime types dictionary" do
+      Rack::Mime::MIME_TYPES['.foo'] = 'application/foo'
+      mock_app {
+        get '/foo.xml' do
+          content_type :foo
+          "I AM FOO"
+        end
+      }
+
+      get '/foo.xml'
+      assert ok?
+      assert_equal 'application/foo', response['Content-Type']
+      assert_equal 'I AM FOO', body
+    end
+
+    it 'fails when no mime type is registered for the argument provided' do
+      mock_app {
+        get '/foo.xml' do
+          content_type :bizzle
+          "I AM FOO"
+        end
+      }
 
-  it 'sets the ETag header' do
-    get '/'
-    assert_equal '"FOO"', response['ETag']
+      assert_raise(RuntimeError) { get '/foo.xml' }
+    end
   end
 
-  it 'returns a body when conditional get misses' do
-    get '/'
-    assert_equal 200, status
-    assert_equal 'Boo!', body
-  end
+  describe 'send_file' do
+    setup do
+      @file = File.dirname(__FILE__) + '/file.txt'
+      File.open(@file, 'wb') { |io| io.write('Hello World') }
+    end
 
-  it 'halts when a conditional GET matches' do
-    get '/', :env => { 'HTTP_IF_NONE_MATCH' => '"FOO"' }
-    assert_equal 304, status
-    assert_equal '', body
-  end
+    def teardown
+      File.unlink @file
+      @file = nil
+    end
 
-  it 'should handle multiple ETag values in If-None-Match header' do
-    get '/', :env => { 'HTTP_IF_NONE_MATCH' => '"BAR", *' }
-    assert_equal 304, status
-    assert_equal '', body
+    def send_file_app(opts={})
+      path = @file
+      mock_app {
+        get '/file.txt' do
+          send_file path, opts
+        end
+      }
+    end
+
+    it "sends the contents of the file" do
+      send_file_app
+      get '/file.txt'
+      assert ok?
+      assert_equal 'Hello World', body
+    end
+
+    it 'sets the Content-Type response header if a mime-type can be located' do
+      send_file_app
+      get '/file.txt'
+      assert_equal 'text/plain', response['Content-Type']
+    end
+
+    it 'sets the Content-Length response header' do
+      send_file_app
+      get '/file.txt'
+      assert_equal 'Hello World'.length.to_s, response['Content-Length']
+    end
+
+    it 'sets the Last-Modified response header' do
+      send_file_app
+      get '/file.txt'
+      assert_equal File.mtime(@file).httpdate, response['Last-Modified']
+    end
+
+    it "returns a 404 when not found" do
+      mock_app {
+        get '/' do
+          send_file 'this-file-does-not-exist.txt'
+        end
+      }
+      get '/'
+      assert not_found?
+    end
+
+    it "does not set the Content-Disposition header by default" do
+      send_file_app
+      get '/file.txt'
+      assert_nil response['Content-Disposition']
+    end
+
+    it "sets the Content-Disposition header when :disposition set to 'attachment'" do
+      send_file_app :disposition => 'attachment'
+      get '/file.txt'
+      assert_equal 'attachment; filename="file.txt"', response['Content-Disposition']
+    end
+
+    it "sets the Content-Disposition header when :filename provided" do
+      send_file_app :filename => 'foo.txt'
+      get '/file.txt'
+      assert_equal 'attachment; filename="foo.txt"', response['Content-Disposition']
+    end
+  end
+
+  describe 'last_modified' do
+    setup do
+      now = Time.now
+      mock_app {
+        get '/' do
+          body { 'Hello World' }
+          last_modified now
+          'Boo!'
+        end
+      }
+      @now = now
+    end
+
+    it 'sets the Last-Modified header to a valid RFC 2616 date value' do
+      get '/'
+      assert_equal @now.httpdate, response['Last-Modified']
+    end
+
+    it 'returns a body when conditional get misses' do
+      get '/'
+      assert_equal 200, status
+      assert_equal 'Boo!', body
+    end
+
+    it 'halts when a conditional GET matches' do
+      get '/', {}, { 'HTTP_IF_MODIFIED_SINCE' => @now.httpdate }
+      assert_equal 304, status
+      assert_equal '', body
+    end
+  end
+
+  describe 'etag' do
+    setup do
+      mock_app {
+        get '/' do
+          body { 'Hello World' }
+          etag 'FOO'
+          'Boo!'
+        end
+      }
+    end
+
+    it 'sets the ETag header' do
+      get '/'
+      assert_equal '"FOO"', response['ETag']
+    end
+
+    it 'returns a body when conditional get misses' do
+      get '/'
+      assert_equal 200, status
+      assert_equal 'Boo!', body
+    end
+
+    it 'halts when a conditional GET matches' do
+      get '/', {}, { 'HTTP_IF_NONE_MATCH' => '"FOO"' }
+      assert_equal 304, status
+      assert_equal '', body
+    end
+
+    it 'should handle multiple ETag values in If-None-Match header' do
+      get '/', {}, { 'HTTP_IF_NONE_MATCH' => '"BAR", *' }
+      assert_equal 304, status
+      assert_equal '', body
+    end
+
+    it 'uses a weak etag with the :weak option' do
+      mock_app {
+        get '/' do
+          etag 'FOO', :weak
+          "that's weak, dude."
+        end
+      }
+      get '/'
+      assert_equal 'W/"FOO"', response['ETag']
+    end
   end
 
-  it 'uses a weak etag with the :weak option' do
-    mock_app {
-      get '/' do
-        etag 'FOO', :weak
-        "that's weak, dude."
-      end
-    }
-    get '/'
-    assert_equal 'W/"FOO"', response['ETag']
-  end
-end
+  describe 'back' do
+    it "makes redirecting back pretty" do
+      mock_app {
+        get '/foo' do
+          redirect back
+        end
+      }
 
-describe 'Helpers#back' do
-  it "makes redirecting back pretty" do
-    mock_app {
-      get '/foo' do
-        redirect back
-      end
-    }
-
-    get '/foo', {}, 'HTTP_REFERER' => 'http://github.com'
-    assert redirect?
-    assert_equal "http://github.com", response.location
+      get '/foo', {}, 'HTTP_REFERER' => 'http://github.com'
+      assert redirect?
+      assert_equal "http://github.com", response.location
+    end
   end
-end
 
-module HelperOne; def one; '1'; end; end
-module HelperTwo; def two; '2'; end; end
+  module ::HelperOne; def one; '1'; end; end
+  module ::HelperTwo; def two; '2'; end; end
 
-describe 'Adding new helpers' do
-  it 'takes a list of modules to mix into the app' do
-    mock_app {
-      helpers HelperOne, HelperTwo
+  describe 'Adding new helpers' do
+    it 'takes a list of modules to mix into the app' do
+      mock_app {
+        helpers ::HelperOne, ::HelperTwo
 
-      get '/one' do
-        one
-      end
+        get '/one' do
+          one
+        end
 
-      get '/two' do
-        two
-      end
-    }
+        get '/two' do
+          two
+        end
+      }
 
-    get '/one'
-    assert_equal '1', body
+      get '/one'
+      assert_equal '1', body
 
-    get '/two'
-    assert_equal '2', body
-  end
+      get '/two'
+      assert_equal '2', body
+    end
 
-  it 'takes a block to mix into the app' do
-    mock_app {
-      helpers do
-        def foo
-          'foo'
+    it 'takes a block to mix into the app' do
+      mock_app {
+        helpers do
+          def foo
+            'foo'
+          end
         end
-      end
 
-      get '/' do
-        foo
-      end
-    }
+        get '/' do
+          foo
+        end
+      }
 
-    get '/'
-    assert_equal 'foo', body
-  end
+      get '/'
+      assert_equal 'foo', body
+    end
 
-  it 'evaluates the block in class context so that methods can be aliased' do
-    mock_app {
-      helpers do
-        alias_method :h, :escape_html
-      end
+    it 'evaluates the block in class context so that methods can be aliased' do
+      mock_app {
+        helpers do
+          alias_method :h, :escape_html
+        end
 
-      get '/' do
-        h('42 < 43')
-      end
-    }
+        get '/' do
+          h('42 < 43')
+        end
+      }
 
-    get '/'
-    assert ok?
-    assert_equal '42 &lt; 43', body
+      get '/'
+      assert ok?
+      assert_equal '42 &lt; 43', body
+    end
   end
 end