Syd-sinatra 0.9.0.2 → 0.9.0.4

data/lib/sinatra/compat.rb

@@ -51,6 +51,17 @@ module Sinatra
   module Compat
   end
 
+  # Make Sinatra::EventContext an alias for Sinatra::Default to unbreak plugins.
+  def self.const_missing(const_name)
+    if const_name == :EventContext
+      const_set :EventContext, Sinatra::Default
+      sinatra_warn 'Sinatra::EventContext is deprecated; use Sinatra::Default instead.'
+      Sinatra::Default
+    else
+      super
+    end
+  end
+
   # The ServerError exception is deprecated. Any exception is considered an
   # internal server error.
   class ServerError < RuntimeError
@@ -93,21 +104,10 @@ module Sinatra
       etag(*args, &block)
     end
 
-    # The :disposition option is deprecated; use: #attachment. This method
-    # setting the Content-Transfer-Encoding header is deprecated.
-    #--
-    # TODO deprecation warning for :disposition argument.
-    def send_file(path, opts={})
-      opts[:disposition] = 'attachment' if !opts.key?(:disposition)
-      attachment opts[:filename] || path if opts[:filename] || opts[:disposition]
-      response['Content-Transfer-Encoding'] = 'binary' if opts[:disposition]
-      super(path, opts)
-    end
-
     # Throwing halt with a Symbol and the to_result convention are
     # deprecated. Override the invoke method to detect those types of return
     # values.
-    def invoke(handler)
+    def invoke(&block)
       res = super
       case
       when res.kind_of?(Symbol)

data/lib/sinatra/main.rb

@@ -9,7 +9,7 @@ module Sinatra
         /custom_require\.rb$/  # rubygems require hacks
       ]
       path =
-        caller.map{ |line| line.split(':', 2).first }.find do |file|
+        caller.map{ |line| line.split(/:\d/, 2).first }.find do |file|
           next if ignore.any? { |pattern| file =~ pattern }
           file
         end
@@ -17,7 +17,6 @@ module Sinatra
     }.call
 
     set :run, Proc.new { $0 == app_file }
-    set :reload, Proc.new{ app_file? && development? }
 
     if run? && ARGV.any?
       require 'optparse'
@@ -33,10 +32,6 @@ end
 
 include Sinatra::Delegator
 
-def helpers(&block)
-  Sinatra::Application.send :class_eval, &block
-end
-
 def mime(ext, type)
   ext = ".#{ext}" unless ext.to_s[0] == ?.
   Rack::Mime::MIME_TYPES[ext.to_s] = type

data/lib/sinatra/test.rb

@@ -75,20 +75,26 @@ module Sinatra
     }
 
     def rack_opts(opts)
-      opts.inject({}) do |hash,(key,val)|
+      opts.merge(:lint => true).inject({}) do |hash,(key,val)|
         key = RACK_OPT_NAMES[key] || key
         hash[key] = val
         hash
       end
     end
 
-    def env_for(opts={})
-      opts = rack_opts(opts)
-      Rack::MockRequest.env_for(opts)
-    end
-
-    def param_string(hash)
-      hash.map { |pair| pair.map{|v|escape(v)}.join('=') }.join('&')
+    def param_string(value, prefix = nil)
+      case value
+      when Array
+        value.map { |v|
+          param_string(v, "#{prefix}[]")
+        } * "&"
+      when Hash
+        value.map { |k, v|
+          param_string(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+        } * "&"
+      else
+        "#{prefix}=#{escape(value)}"
+      end
     end
 
     if defined? Sinatra::Compat

data/lib/sinatra/test/bacon.rb

@@ -2,7 +2,7 @@ require 'bacon'
 require 'sinatra/test'
 
 Sinatra::Default.set(
-  :env => :test,
+  :environment => :test,
   :run => false,
   :raise_errors => true,
   :logging => false

data/lib/sinatra/test/rspec.rb

@@ -1,8 +1,10 @@
 require 'sinatra/test'
+require 'sinatra/test/unit'
+require 'spec'
 require 'spec/interop/test'
 
 Sinatra::Default.set(
-  :env => :test,
+  :environment => :test,
   :run => false,
   :raise_errors => true,
   :logging => false

data/lib/sinatra/test/unit.rb

@@ -4,7 +4,7 @@ require 'test/unit'
 Test::Unit::TestCase.send :include, Sinatra::Test
 
 Sinatra::Default.set(
-  :env => :test,
+  :environment => :test,
   :run => false,
   :raise_errors => true,
   :logging => false

data/sinatra.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
   s.name = 'sinatra'
-  s.version = '0.9.0.2'
-  s.date = '2009-01-18'
+  s.version = '0.9.0.4'
+  s.date = '2009-01-25'
 
   s.description = "Classy web-development dressed in a DSL"
   s.summary     = "Classy web-development dressed in a DSL"

data/test/filter_test.rb

@@ -72,4 +72,28 @@ describe "Filters" do
     assert ok?
     assert_equal 'cool', body
   end
+
+  it "does modify the response with halt" do
+    mock_app {
+      before { halt 302, 'Hi' }
+      get '/foo' do
+        "should not happen"
+      end
+    }
+
+    get '/foo'
+    assert_equal 302, response.status
+    assert_equal 'Hi', body
+  end
+
+  it "gives you access to params" do
+    mock_app {
+      before { @foo = params['foo'] }
+      get('/foo') { @foo }
+    }
+
+    get '/foo?foo=cool'
+    assert ok?
+    assert_equal 'cool', body
+  end
 end

data/test/helper.rb

@@ -1,14 +1,15 @@
 begin
-  require 'test/spec'
+  require 'rack'
 rescue LoadError
   require 'rubygems'
-  require 'test/spec'
+  require 'rack'
 end
 
-$:.unshift File.dirname(File.dirname(__FILE__)) + '/lib'
+libdir = File.dirname(File.dirname(__FILE__)) + '/lib'
+$LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir)
+
 require 'sinatra/base'
-require 'sinatra/test'
-require 'sinatra/test/spec'
+require 'sinatra/test/unit'
 
 module Sinatra::Test
   # Sets up a Sinatra::Base subclass defined with the block
@@ -23,3 +24,21 @@ class Sinatra::Base
   # Allow assertions in request context
   include Test::Unit::Assertions
 end
+
+##
+# test/spec/mini
+# http://pastie.caboo.se/158871
+# chris@ozmm.org
+#
+def describe(*args, &block)
+  return super unless (name = args.first) && block
+  klass = Class.new(Test::Unit::TestCase) do
+    def self.it(name, &block)
+      define_method("test_#{name.gsub(/\W/,'_')}", &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
+end

data/test/helpers_test.rb

@@ -1,361 +1,423 @@
 require File.dirname(__FILE__) + '/helper'
 
-describe 'Sinatra::Helpers' do
-  describe '#status' do
-    setup do
-      mock_app {
-        get '/' do
-          status 207
-          nil
-        end
-      }
-    end
+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
+  it 'sets the response status code' do
+    get '/'
+    assert_equal 207, response.status
   end
+end
 
-  describe '#body' do
-    it 'takes a block for defered body generation' do
-      mock_app {
-        get '/' do
-          body { 'Hello World' }
-        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
+    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
-      }
+  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
+    get '/'
+    assert_equal 'Hello World', body
   end
+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
-      }
+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 301, status
-      assert_equal '', body
-      assert_equal '/foo', response['Location']
-    end
+    get '/'
+    assert_equal 302, status
+    assert_equal '', body
+    assert_equal '/foo', response['Location']
   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 'uses the code given when specified' do
+    mock_app {
+      get '/' do
+        redirect '/foo', 301
+        fail 'redirect should halt'
+      end
+    }
 
-      get '/'
-      assert_equal 500, status
-      assert_equal 'FAIL', body
-    end
+    get '/'
+    assert_equal 301, status
+    assert_equal '', body
+    assert_equal '/foo', response['Location']
   end
+end
 
-  describe '#not_found' do
-    it 'halts with a 404 status' do
-      mock_app {
-        get '/' do
-          not_found
-          fail 'not_found should halt'
-        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 404, status
-      assert_equal '', body
-    end
+    get '/'
+    assert_equal 501, status
+    assert_equal '', body
   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
-      }
-
-      get '/'
-      assert_equal 'Hi', body
-    end
-  end
-
-  describe '#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
-    it 'returns the argument when given a media type string' do
-      assert_equal 'text/plain', media_type('text/plain')
-    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
-      }
-      assert_raise(RuntimeError) { get '/foo.xml' }
-    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
 
-  describe '#send_file' do
-    before {
-      @file = File.dirname(__FILE__) + '/file.txt'
-      File.open(@file, 'wb') { |io| io.write('Hello World') }
+  it 'uses a 500 status code when first argument is a body' do
+    mock_app {
+      get '/' do
+        error 'FAIL'
+        fail 'error should halt'
+      end
     }
-    after {
-      File.unlink @file
-      @file = nil
+
+    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
     }
 
-    def send_file_app
-      path = @file
-      mock_app {
-        get '/file.txt' do
-          send_file path
-        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
-  end
-
-  describe '#last_modified' do
-    before 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
-    before 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."
+    get '/'
+    assert_equal 404, status
+    assert_equal '', body
+  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
+
+  it 'returns the argument when given a media type string' do
+    assert_equal 'text/plain', media_type('text/plain')
+  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
+
+  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
+    }
+    assert_raise(RuntimeError) { get '/foo.xml' }
+  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
+
+  after do
+    File.unlink @file
+    @file = nil
+  end
+
+  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 '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 '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 'Helpers#etag' do
+  before 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
+
+describe 'Adding new helpers' do
+  module HelperOne; def one; '1'; end; end
+  module HelperTwo; def two; '2'; end; end
+
+  it 'should allow passing a list of modules' do
+    mock_app {
+      helpers HelperOne, HelperTwo
+
+      get '/one' do
+        one
+      end
+
+      get '/two' do
+        two
+      end
+    }
+
+    get '/one'
+    assert_equal '1', body
+
+    get '/two'
+    assert_equal '2', body
+  end
+
+  it 'should take a block and mix it into the app' do
+    mock_app {
+      helpers do
+        def foo
+          'foo'
         end
-      }
-      get '/'
-      assert_equal 'W/"FOO"', response['ETag']
-    end
+      end
+
+      get '/' do
+        foo
+      end
+    }
 
+    get '/'
+    assert_equal 'foo', body
   end
 end