RubyGems - sinatra-sinatra - Versions diffs - 0.9.1.2 → 0.9.1.3 - Mend

sinatra-sinatra 0.9.1.2 → 0.9.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (39) hide show

data/LICENSE +1 -1
data/README.rdoc +42 -0
data/Rakefile +15 -3
data/compat/haml_test.rb +7 -4
data/compat/helper.rb +4 -0
data/compat/sass_test.rb +10 -0
data/lib/sinatra/base.rb +136 -121
data/lib/sinatra/compat.rb +16 -0
data/lib/sinatra/showexceptions.rb +303 -0
data/sinatra.gemspec +11 -3
data/test/base_test.rb +117 -101
data/test/builder_test.rb +1 -1
data/test/contest.rb +62 -0
data/test/erb_test.rb +1 -1
data/test/extensions_test.rb +1 -1
data/test/filter_test.rb +1 -1
data/test/haml_test.rb +25 -3
data/test/helper.rb +14 -46
data/test/helpers_test.rb +444 -442
data/test/mapped_error_test.rb +147 -144
data/test/middleware_test.rb +2 -2
data/test/options_test.rb +247 -206
data/test/render_backtrace_test.rb +145 -0
data/test/request_test.rb +1 -1
data/test/response_test.rb +2 -2
data/test/result_test.rb +1 -1
data/test/route_added_hook_test.rb +59 -0
data/test/routing_test.rb +12 -1
data/test/sass_test.rb +43 -1
data/test/server_test.rb +5 -3
data/test/sinatra_test.rb +1 -1
data/test/static_test.rb +2 -2
data/test/templates_test.rb +16 -4
data/test/test_test.rb +5 -5
data/test/views/error.builder +3 -0
data/test/views/error.erb +3 -0
data/test/views/error.haml +3 -0
data/test/views/error.sass +2 -0
metadata +12 -5

data/test/builder_test.rb CHANGED

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
-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 ADDED

@@ -0,0 +1,62 @@
+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
+  def empty?
+    false
+  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 CHANGED

@@ -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 CHANGED

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
-describe 'Registering extensions' do
+class ExtensionsTest < Test::Unit::TestCase
   module FooExtensions
     def foo
     end

data/test/filter_test.rb CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -5,71 +5,39 @@ 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 'contest'
 require 'sinatra/test'
+require 'haml'
+require 'sass'
+require 'builder'
 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
+  class << self
+    alias_method :it, :test
+  end
   # Sets up a Sinatra::Base subclass defined with the block
   # given. Used in setup or individual spec methods to establish
   # the application.
   def mock_app(base=Sinatra::Base, &block)
     @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? }
-    )
-  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)
-    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)
-  end
-  klass
 end
 # Do not output warnings for the duration of the block.

data/test/helpers_test.rb CHANGED

@@ -1,497 +1,499 @@
 require File.dirname(__FILE__) + '/helper'
-describe 'Helpers#status' do
-  before do
-    mock_app {
-      get '/' do
-        status 207
-        nil
-      end
-    }
-  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
+class HelpersTest < Test::Unit::TestCase
+  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 '/', :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
+      }
-  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 '/', :env => { '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 '/', :env => { '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 '/', :env => { '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