adamwiggins-sinatra 0.8.9 → 0.10.1

data/test/render_backtrace_test.rb

@@ -0,0 +1,145 @@
+require File.dirname(__FILE__) + '/helper'
+
+require 'sass/error'
+
+class RenderBacktraceTest < Test::Unit::TestCase
+  VIEWS = File.dirname(__FILE__) + '/views'
+
+  def assert_raise_at(filename, line, exception = RuntimeError)
+    f, l = nil
+    assert_raise(exception) do
+      begin
+        get('/')
+      rescue => e
+        f, l = e.backtrace.first.split(':')
+        raise
+      end
+    end
+    assert_equal(filename, f, "expected #{exception.name} in #{filename}, was #{f}")
+    assert_equal(line, l.to_i, "expected #{exception.name} in #{filename} at line #{line}, was at line #{l}")
+  end
+
+  def backtrace_app(&block)
+    mock_app {
+      use_in_file_templates!
+      set :views, RenderBacktraceTest::VIEWS
+      template :builder_template do
+        'raise "error"'
+      end
+      template :erb_template do
+        '<% raise "error" %>'
+      end
+      template :haml_template do
+        '%h1= raise "error"'
+      end
+      template :sass_template do
+        '+syntax-error'
+      end
+      get '/', &block
+    }
+  end
+
+  it "provides backtrace for Builder template" do
+    backtrace_app { builder :error }
+    assert_raise_at(File.join(VIEWS,'error.builder'), 2)
+  end
+
+  it "provides backtrace for ERB template" do
+    backtrace_app { erb :error }
+    assert_raise_at(File.join(VIEWS,'error.erb'), 2)
+  end
+
+  it "provides backtrace for HAML template" do
+    backtrace_app { haml :error }
+    assert_raise_at(File.join(VIEWS,'error.haml'), 2)
+  end
+
+  it "provides backtrace for Sass template" do
+    backtrace_app { sass :error }
+    assert_raise_at(File.join(VIEWS,'error.sass'), 2, Sass::SyntaxError)
+  end
+
+  it "provides backtrace for ERB template with locals" do
+    backtrace_app { erb :error, {}, :french => true }
+    assert_raise_at(File.join(VIEWS,'error.erb'), 3)
+  end
+
+  it "provides backtrace for HAML template with locals" do
+    backtrace_app { haml :error, {}, :french => true }
+    assert_raise_at(File.join(VIEWS,'error.haml'), 3)
+  end
+
+  it "provides backtrace for inline Builder string" do
+    backtrace_app { builder "raise 'Ack! Thbbbt!'"}
+    assert_raise_at(__FILE__, (__LINE__-1))
+  end
+
+  it "provides backtrace for inline ERB string" do
+    backtrace_app { erb "<% raise 'bidi-bidi-bidi' %>" }
+    assert_raise_at(__FILE__, (__LINE__-1))
+  end
+
+  it "provides backtrace for inline HAML string" do
+    backtrace_app { haml "%h1= raise 'Lions and tigers and bears! Oh, my!'" }
+    assert_raise_at(__FILE__, (__LINE__-1))
+  end
+
+  # it "provides backtrace for inline Sass string" do
+  #   backtrace_app { sass '+buh-bye' }
+  #   assert_raise_at(__FILE__, (__LINE__-1), Sass::SyntaxError)
+  # end
+
+  it "provides backtrace for named Builder template" do
+    backtrace_app { builder :builder_template }
+    assert_raise_at(__FILE__, (__LINE__-68))
+  end
+
+  it "provides backtrace for named ERB template" do
+    backtrace_app { erb :erb_template }
+    assert_raise_at(__FILE__, (__LINE__-70))
+  end
+
+  it "provides backtrace for named HAML template" do
+    backtrace_app { haml :haml_template }
+    assert_raise_at(__FILE__, (__LINE__-72))
+  end
+
+  # it "provides backtrace for named Sass template" do
+  #   backtrace_app { sass :sass_template }
+  #   assert_raise_at(__FILE__, (__LINE__-74), Sass::SyntaxError)
+  # end
+
+  it "provides backtrace for in file Builder template" do
+    backtrace_app { builder :builder_in_file }
+    assert_raise_at(__FILE__, (__LINE__+22))
+  end
+
+  it "provides backtrace for in file ERB template" do
+    backtrace_app { erb :erb_in_file }
+    assert_raise_at(__FILE__, (__LINE__+20))
+  end
+
+  it "provides backtrace for in file HAML template" do
+    backtrace_app { haml :haml_in_file }
+    assert_raise_at(__FILE__, (__LINE__+18))
+  end
+
+  # it "provides backtrace for in file Sass template" do
+  #   backtrace_app { sass :sass_in_file }
+  #   assert_raise_at(__FILE__, (__LINE__+16), Sass::SyntaxError)
+  # end
+end
+
+__END__
+
+@@ builder_in_file
+raise "bif"
+
+@@ erb_in_file
+<% raise "bam" %>
+
+@@ haml_in_file
+%h1= raise "pow"
+
+@@ sass_in_file
++blam

data/test/request_test.rb

@@ -1,11 +1,33 @@
-require 'test/spec'
-require 'sinatra/base'
-require 'sinatra/test'
+require File.dirname(__FILE__) + '/helper'
 
-describe 'Sinatra::Request' do
+class RequestTest < Test::Unit::TestCase
   it 'responds to #user_agent' do
     request = Sinatra::Request.new({'HTTP_USER_AGENT' => 'Test'})
-    request.should.respond_to :user_agent
-    request.user_agent.should.equal 'Test'
+    assert request.respond_to?(:user_agent)
+    assert_equal 'Test', request.user_agent
+  end
+
+  it 'parses POST params when Content-Type is form-dataish' do
+    request = Sinatra::Request.new(
+      'REQUEST_METHOD' => 'PUT',
+      'CONTENT_TYPE' => 'application/x-www-form-urlencoded',
+      'rack.input' => StringIO.new('foo=bar')
+    )
+    assert_equal 'bar', request.params['foo']
+  end
+
+  it 'is secure when the url scheme is https' do
+    request = Sinatra::Request.new('rack.url_scheme' => 'https')
+    assert request.secure?
+  end
+
+  it 'is not secure when the url scheme is http' do
+    request = Sinatra::Request.new('rack.url_scheme' => 'http')
+    assert !request.secure?
+  end
+
+  it 'respects X-Forwarded-Proto header for proxied SSL' do
+    request = Sinatra::Request.new('HTTP_X_FORWARDED_PROTO' => 'https')
+    assert request.secure?
   end
 end

data/test/response_test.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/helper'
+
+class ResponseTest < Test::Unit::TestCase
+  setup do
+    @response = Sinatra::Response.new
+  end
+
+  it "initializes with 200, text/html, and empty body" do
+    assert_equal 200, @response.status
+    assert_equal 'text/html', @response['Content-Type']
+    assert_equal [], @response.body
+  end
+
+  it 'uses case insensitive headers' do
+    @response['content-type'] = 'application/foo'
+    assert_equal 'application/foo', @response['Content-Type']
+    assert_equal 'application/foo', @response['CONTENT-TYPE']
+  end
+
+  it 'writes to body' do
+    @response.body = 'Hello'
+    @response.write ' World'
+    assert_equal 'Hello World', @response.body
+  end
+
+  [204, 304].each do |status_code|
+    it "removes the Content-Type header and body when response status is #{status_code}" do
+      @response.status = status_code
+      @response.body = ['Hello World']
+      assert_equal [status_code, {}, []], @response.finish
+    end
+  end
+
+  it 'Calculates the Content-Length using the bytesize of the body' do
+    @response.body = ['Hello', 'World!', '✈']
+    status, headers, body = @response.finish
+    assert_equal '14', headers['Content-Length']
+    assert_equal @response.body, body
+  end
+end

data/test/result_test.rb

@@ -1,10 +1,6 @@
-require 'test/spec'
-require 'sinatra/base'
-require 'sinatra/test'
-
-describe 'Result Handling' do
-  include Sinatra::Test
+require File.dirname(__FILE__) + '/helper'
 
+class ResultTest < Test::Unit::TestCase
   it "sets response.body when result is a String" do
     mock_app {
       get '/' do
@@ -13,8 +9,8 @@ describe 'Result Handling' do
     }
 
     get '/'
-    should.be.ok
-    body.should.equal 'Hello World'
+    assert ok?
+    assert_equal 'Hello World', body
   end
 
   it "sets response.body when result is an Array of Strings" do
@@ -25,8 +21,8 @@ describe 'Result Handling' do
     }
 
     get '/'
-    should.be.ok
-    body.should.equal 'HelloWorld'
+    assert ok?
+    assert_equal 'HelloWorld', body
   end
 
   it "sets response.body when result responds to #each" do
@@ -39,8 +35,8 @@ describe 'Result Handling' do
     }
 
     get '/'
-    should.be.ok
-    body.should.equal 'Hello World'
+    assert ok?
+    assert_equal 'Hello World', body
   end
 
   it "sets response.body to [] when result is nil" do
@@ -51,8 +47,8 @@ describe 'Result Handling' do
     }
 
     get '/'
-    should.be.ok
-    body.should.equal ''
+    assert ok?
+    assert_equal '', body
   end
 
   it "sets status, headers, and body when result is a Rack response tuple" do
@@ -63,9 +59,9 @@ describe 'Result Handling' do
     }
 
     get '/'
-    status.should.equal 205
-    response['Content-Type'].should.equal 'foo/bar'
-    body.should.equal 'Hello World'
+    assert_equal 205, status
+    assert_equal 'foo/bar', response['Content-Type']
+    assert_equal 'Hello World', body
   end
 
   it "sets status and body when result is a two-tuple" do
@@ -76,8 +72,18 @@ describe 'Result Handling' do
     }
 
     get '/'
-    status.should.equal 409
-    body.should.equal 'formula of'
+    assert_equal 409, status
+    assert_equal 'formula of', body
+  end
+
+  it "raises a TypeError when result is a non two or three tuple Array" do
+    mock_app {
+      get '/' do
+        [409, 'formula of', 'something else', 'even more']
+      end
+    }
+
+    assert_raise(TypeError) { get '/' }
   end
 
   it "sets status when result is a Fixnum status code" do
@@ -86,7 +92,7 @@ describe 'Result Handling' do
     }
 
     get '/'
-    status.should.equal 205
-    body.should.be.empty
+    assert_equal 205, status
+    assert_equal '', body
   end
 end

data/test/route_added_hook_test.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/helper'
+
+module RouteAddedTest
+  @routes, @procs = [], []
+  def self.routes ; @routes ; end
+  def self.procs ; @procs ; end
+  def self.route_added(verb, path, proc)
+    @routes << [verb, path]
+    @procs << proc
+  end
+end
+
+class RouteAddedHookTest < Test::Unit::TestCase
+  setup { 
+    RouteAddedTest.routes.clear
+    RouteAddedTest.procs.clear
+  }
+
+  it "should be notified of an added route" do
+    mock_app(Class.new(Sinatra::Base)) {
+      register RouteAddedTest
+      get('/') {}
+    }
+
+    assert_equal [["GET", "/"], ["HEAD", "/"]],
+      RouteAddedTest.routes
+  end
+
+  it "should include hooks from superclass" do
+    a = Class.new(Class.new(Sinatra::Base))
+    b = Class.new(a)
+
+    a.register RouteAddedTest
+    b.class_eval { post("/sub_app_route") {} }
+
+    assert_equal [["POST", "/sub_app_route"]],
+      RouteAddedTest.routes
+  end
+
+  it "should only run once per extension" do
+    mock_app(Class.new(Sinatra::Base)) {
+      register RouteAddedTest
+      register RouteAddedTest
+      get('/') {}
+    }
+
+    assert_equal [["GET", "/"], ["HEAD", "/"]],
+      RouteAddedTest.routes
+  end
+  
+  it "should pass route blocks as an argument" do
+    mock_app(Class.new(Sinatra::Base)) {
+      register RouteAddedTest
+      get('/') {}
+    }
+
+    assert_kind_of Proc, RouteAddedTest.procs.first    
+  end
+end

data/test/routing_test.rb

@@ -1,11 +1,28 @@
-require 'test/spec'
-require 'sinatra/base'
-require 'sinatra/test'
+require File.dirname(__FILE__) + '/helper'
 
-describe "Routing" do
-  include Sinatra::Test
+# Helper method for easy route pattern matching testing
+def route_def(pattern)
+  mock_app { get(pattern) { } }
+end
+
+class RegexpLookAlike
+  class MatchData
+    def captures
+      ["this", "is", "a", "test"]
+    end
+  end
+
+  def match(string)
+    ::RegexpLookAlike::MatchData.new if string == "/this/is/a/test/"
+  end
+
+  def keys
+    ["one", "two", "three", "four"]
+  end
+end
 
-  %w[get put post delete head].each do |verb|
+class RoutingTest < Test::Unit::TestCase
+  %w[get put post delete].each do |verb|
     it "defines #{verb.upcase} request handlers with #{verb}" do
       mock_app {
         send verb, '/hello' do
@@ -15,40 +32,91 @@ describe "Routing" do
 
       request = Rack::MockRequest.new(@app)
       response = request.request(verb.upcase, '/hello', {})
-      response.should.be.ok
-      response.body.should.equal 'Hello World'
+      assert response.ok?
+      assert_equal 'Hello World', response.body
     end
   end
 
+  it "defines HEAD request handlers with HEAD" do
+    mock_app {
+      head '/hello' do
+        response['X-Hello'] = 'World!'
+        'remove me'
+      end
+    }
+
+    request = Rack::MockRequest.new(@app)
+    response = request.request('HEAD', '/hello', {})
+    assert response.ok?
+    assert_equal 'World!', response['X-Hello']
+    assert_equal '', response.body
+  end
+
   it "404s when no route satisfies the request" do
     mock_app {
       get('/foo') { }
     }
     get '/bar'
-    status.should.equal 404
+    assert_equal 404, status
+  end
+
+  it "overrides the content-type in error handlers" do
+    mock_app {
+      before { content_type 'text/plain' }
+      error Sinatra::NotFound do
+        content_type "text/html"
+        "<h1>Not Found</h1>"
+      end
+    }
+
+    get '/foo'
+    assert_equal 404, status
+    assert_equal 'text/html', response["Content-Type"]
+    assert_equal "<h1>Not Found</h1>", response.body
+  end
+
+  it 'takes multiple definitions of a route' do
+    mock_app {
+      user_agent(/Foo/)
+      get '/foo' do
+        'foo'
+      end
+
+      get '/foo' do
+        'not foo'
+      end
+    }
+
+    get '/foo', {}, 'HTTP_USER_AGENT' => 'Foo'
+    assert ok?
+    assert_equal 'foo', body
+
+    get '/foo'
+    assert ok?
+    assert_equal 'not foo', body
   end
 
   it "exposes params with indifferent hash" do
     mock_app {
       get '/:foo' do
-        params['foo'].should.equal 'bar'
-        params[:foo].should.equal 'bar'
+        assert_equal 'bar', params['foo']
+        assert_equal 'bar', params[:foo]
         'well, alright'
       end
     }
     get '/bar'
-    body.should.equal 'well, alright'
+    assert_equal 'well, alright', body
   end
 
   it "merges named params and query string params in params" do
     mock_app {
       get '/:foo' do
-        params['foo'].should.equal 'bar'
-        params['baz'].should.equal 'biz'
+        assert_equal 'bar', params['foo']
+        assert_equal 'biz', params['baz']
       end
     }
     get '/bar?baz=biz'
-    should.be.ok
+    assert ok?
   end
 
   it "supports named params like /hello/:person" do
@@ -58,7 +126,7 @@ describe "Routing" do
       end
     }
     get '/hello/Frank'
-    body.should.equal 'Hello Frank'
+    assert_equal 'Hello Frank', body
   end
 
   it "supports optional named params like /?:foo?/?:bar?" do
@@ -69,61 +137,181 @@ describe "Routing" do
     }
 
     get '/hello/world'
-    should.be.ok
-    body.should.equal "foo=hello;bar=world"
+    assert ok?
+    assert_equal "foo=hello;bar=world", body
 
     get '/hello'
-    should.be.ok
-    body.should.equal "foo=hello;bar="
+    assert ok?
+    assert_equal "foo=hello;bar=", body
 
     get '/'
-    should.be.ok
-    body.should.equal "foo=;bar="
+    assert ok?
+    assert_equal "foo=;bar=", body
   end
 
   it "supports single splat params like /*" do
     mock_app {
       get '/*' do
-        params['splat'].should.be.kind_of Array
+        assert params['splat'].kind_of?(Array)
         params['splat'].join "\n"
       end
     }
 
     get '/foo'
-    body.should.equal "foo"
+    assert_equal "foo", body
 
     get '/foo/bar/baz'
-    body.should.equal "foo/bar/baz"
+    assert_equal "foo/bar/baz", body
   end
 
   it "supports mixing multiple splat params like /*/foo/*/*" do
     mock_app {
       get '/*/foo/*/*' do
-        params['splat'].should.be.kind_of Array
+        assert params['splat'].kind_of?(Array)
         params['splat'].join "\n"
       end
     }
 
     get '/bar/foo/bling/baz/boom'
-    body.should.equal "bar\nbling\nbaz/boom"
+    assert_equal "bar\nbling\nbaz/boom", body
 
     get '/bar/foo/baz'
-    should.be.not_found
+    assert not_found?
   end
 
   it "supports mixing named and splat params like /:foo/*" do
     mock_app {
       get '/:foo/*' do
-        params['foo'].should.equal 'foo'
-        params['splat'].should.equal ['bar/baz']
+        assert_equal 'foo', params['foo']
+        assert_equal ['bar/baz'], params['splat']
       end
     }
 
     get '/foo/bar/baz'
-    should.be.ok
+    assert ok?
+  end
+
+  it "matches a dot ('.') as part of a named param" do
+    mock_app {
+      get '/:foo/:bar' do
+        params[:foo]
+      end
+    }
+
+    get '/user@example.com/name'
+    assert_equal 200, response.status
+    assert_equal 'user@example.com', body
+  end
+
+  it "matches a literal dot ('.') outside of named params" do
+    mock_app {
+      get '/:file.:ext' do
+        assert_equal 'pony', params[:file]
+        assert_equal 'jpg', params[:ext]
+        'right on'
+      end
+    }
+
+    get '/pony.jpg'
+    assert_equal 200, response.status
+    assert_equal 'right on', body
+  end
+
+  it "literally matches . in paths" do
+    route_def '/test.bar'
+
+    get '/test.bar'
+    assert ok?
+    get 'test0bar'
+    assert not_found?
+  end
+
+  it "literally matches $ in paths" do
+    route_def '/test$/'
+
+    get '/test$/'
+    assert ok?
+  end
+
+  it "literally matches + in paths" do
+    route_def '/te+st/'
+
+    get '/te%2Bst/'
+    assert ok?
+    get '/teeeeeeest/'
+    assert not_found?
+  end
+
+  it "literally matches () in paths" do
+    route_def '/test(bar)/'
+
+    get '/test(bar)/'
+    assert ok?
+  end
+
+  it "supports basic nested params" do
+    mock_app {
+      get '/hi' do
+        params["person"]["name"]
+      end
+    }
+
+    get "/hi?person[name]=John+Doe"
+    assert ok?
+    assert_equal "John Doe", body
+  end
+
+  it "exposes nested params with indifferent hash" do
+    mock_app {
+      get '/testme' do
+        assert_equal 'baz', params['bar']['foo']
+        assert_equal 'baz', params['bar'][:foo]
+        'well, alright'
+      end
+    }
+    get '/testme?bar[foo]=baz'
+    assert_equal 'well, alright', body
   end
 
-  it "supports paths that include spaces" do
+  it "supports deeply nested params" do
+    expected_params = {
+      "emacs" => {
+        "map"     => { "goto-line" => "M-g g" },
+        "version" => "22.3.1"
+      },
+      "browser" => {
+        "firefox" => {"engine" => {"name"=>"spidermonkey", "version"=>"1.7.0"}},
+        "chrome"  => {"engine" => {"name"=>"V8", "version"=>"1.0"}}
+      },
+      "paste" => {"name"=>"hello world", "syntax"=>"ruby"}
+    }
+    mock_app {
+      get '/foo' do
+        assert_equal expected_params, params
+        'looks good'
+      end
+    }
+    get '/foo', expected_params
+    assert ok?
+    assert_equal 'looks good', body
+  end
+
+  it "preserves non-nested params" do
+    mock_app {
+      get '/foo' do
+        assert_equal "2", params["article_id"]
+        assert_equal "awesome", params['comment']['body']
+        assert_nil params['comment[body]']
+        'looks good'
+      end
+    }
+
+    get '/foo?article_id=2&comment[body]=awesome'
+    assert ok?
+    assert_equal 'looks good', body
+  end
+
+  it "matches paths that include spaces encoded with %20" do
     mock_app {
       get '/path with spaces' do
         'looks good'
@@ -131,21 +319,33 @@ describe "Routing" do
     }
 
     get '/path%20with%20spaces'
-    should.be.ok
-    body.should.equal 'looks good'
+    assert ok?
+    assert_equal 'looks good', body
+  end
+
+  it "matches paths that include spaces encoded with +" do
+    mock_app {
+      get '/path with spaces' do
+        'looks good'
+      end
+    }
+
+    get '/path+with+spaces'
+    assert ok?
+    assert_equal 'looks good', body
   end
 
   it "URL decodes named parameters and splats" do
     mock_app {
       get '/:foo/*' do
-        params['foo'].should.equal 'hello world'
-        params['splat'].should.equal ['how are you']
+        assert_equal 'hello world', params['foo']
+        assert_equal ['how are you'], params['splat']
         nil
       end
     }
 
     get '/hello%20world/how%20are%20you'
-    should.be.ok
+    assert ok?
   end
 
   it 'supports regular expressions' do
@@ -156,21 +356,43 @@ describe "Routing" do
     }
 
     get '/foooom/bar'
-    should.be.ok
-    body.should.equal 'Hello World'
+    assert ok?
+    assert_equal 'Hello World', body
   end
 
   it 'makes regular expression captures available in params[:captures]' do
     mock_app {
       get(/^\/fo(.*)\/ba(.*)/) do
-        params[:captures].should.equal ['orooomma', 'f']
+        assert_equal ['orooomma', 'f'], params[:captures]
         'right on'
       end
     }
 
     get '/foorooomma/baf'
-    should.be.ok
-    body.should.equal 'right on'
+    assert ok?
+    assert_equal 'right on', body
+  end
+
+  it 'supports regular expression look-alike routes' do
+    mock_app {
+      get(RegexpLookAlike.new) do
+        assert_equal 'this', params[:one]
+        assert_equal 'is', params[:two]
+        assert_equal 'a', params[:three]
+        assert_equal 'test', params[:four]
+        'right on'
+      end
+    }
+
+    get '/this/is/a/test/'
+    assert ok?
+    assert_equal 'right on', body
+  end
+
+  it 'raises a TypeError when pattern is not a String or Regexp' do
+    assert_raise(TypeError) {
+      mock_app { get(42){} }
+    }
   end
 
   it "returns response immediately on halt" do
@@ -182,8 +404,32 @@ describe "Routing" do
     }
 
     get '/'
-    should.be.ok
-    body.should.equal 'Hello World'
+    assert ok?
+    assert_equal 'Hello World', body
+  end
+
+  it "halts with a response tuple" do
+    mock_app {
+      get '/' do
+        halt 295, {'Content-Type' => 'text/plain'}, 'Hello World'
+      end
+    }
+
+    get '/'
+    assert_equal 295, status
+    assert_equal 'text/plain', response['Content-Type']
+    assert_equal 'Hello World', body
+  end
+
+  it "halts with an array of strings" do
+    mock_app {
+      get '/' do
+        halt %w[Hello World How Are You]
+      end
+    }
+
+    get '/'
+    assert_equal 'HelloWorldHowAreYou', body
   end
 
   it "transitions to the next matching route on pass" do
@@ -194,14 +440,14 @@ describe "Routing" do
       end
 
       get '/*' do
-        params.should.not.include 'foo'
+        assert !params.include?('foo')
         'Hello World'
       end
     }
 
     get '/bar'
-    should.be.ok
-    body.should.equal 'Hello World'
+    assert ok?
+    assert_equal 'Hello World', body
   end
 
   it "transitions to 404 when passed and no subsequent route matches" do
@@ -213,7 +459,7 @@ describe "Routing" do
     }
 
     get '/bar'
-    should.be.not_found
+    assert not_found?
   end
 
   it "passes when matching condition returns false" do
@@ -225,11 +471,11 @@ describe "Routing" do
     }
 
     get '/bar'
-    should.be.ok
-    body.should.equal 'Hello World'
+    assert ok?
+    assert_equal 'Hello World', body
 
     get '/foo'
-    should.be.not_found
+    assert not_found?
   end
 
   it "does not pass when matching condition returns nil" do
@@ -241,8 +487,8 @@ describe "Routing" do
     }
 
     get '/bar'
-    should.be.ok
-    body.should.equal 'Hello World'
+    assert ok?
+    assert_equal 'Hello World', body
   end
 
   it "passes to next route when condition calls pass explicitly" do
@@ -254,11 +500,11 @@ describe "Routing" do
     }
 
     get '/bar'
-    should.be.ok
-    body.should.equal 'Hello World'
+    assert ok?
+    assert_equal 'Hello World', body
 
     get '/foo'
-    should.be.not_found
+    assert not_found?
   end
 
   it "passes to the next route when host_name does not match" do
@@ -269,11 +515,11 @@ describe "Routing" do
       end
     }
     get '/foo'
-    should.be.not_found
+    assert not_found?
 
-    get '/foo', :env => { 'HTTP_HOST' => 'example.com' }
-    status.should.equal 200
-    body.should.equal 'Hello World'
+    get '/foo', {}, { 'HTTP_HOST' => 'example.com' }
+    assert_equal 200, status
+    assert_equal 'Hello World', body
   end
 
   it "passes to the next route when user_agent does not match" do
@@ -284,11 +530,11 @@ describe "Routing" do
       end
     }
     get '/foo'
-    should.be.not_found
+    assert not_found?
 
-    get '/foo', :env => { 'HTTP_USER_AGENT' => 'Foo Bar' }
-    status.should.equal 200
-    body.should.equal 'Hello World'
+    get '/foo', {}, { 'HTTP_USER_AGENT' => 'Foo Bar' }
+    assert_equal 200, status
+    assert_equal 'Hello World', body
   end
 
   it "makes captures in user agent pattern available in params[:agent]" do
@@ -298,9 +544,9 @@ describe "Routing" do
         'Hello ' + params[:agent].first
       end
     }
-    get '/foo', :env => { 'HTTP_USER_AGENT' => 'Foo Bar' }
-    status.should.equal 200
-    body.should.equal 'Hello Bar'
+    get '/foo', {}, { 'HTTP_USER_AGENT' => 'Foo Bar' }
+    assert_equal 200, status
+    assert_equal 'Hello Bar', body
   end
 
   it "filters by accept header" do
@@ -310,13 +556,13 @@ describe "Routing" do
       end
     }
 
-    get '/', :env => { :accept => 'application/xml' }
-    should.be.ok
-    body.should.equal 'application/xml'
-    response.headers['Content-Type'].should.equal 'application/xml'
+    get '/', {}, { 'HTTP_ACCEPT' => 'application/xml' }
+    assert ok?
+    assert_equal 'application/xml', body
+    assert_equal 'application/xml', response.headers['Content-Type']
 
-    get '/', :env => { :accept => 'text/html' }
-    should.not.be.ok
+    get '/', {}, { :accept => 'text/html' }
+    assert !ok?
   end
 
   it "allows multiple mime types for accept header" do
@@ -329,10 +575,245 @@ describe "Routing" do
     }
 
     types.each do |type|
-      get '/', :env => { :accept => type }
-      should.be.ok
-      body.should.equal type
-      response.headers['Content-Type'].should.equal type
+      get '/', {}, { 'HTTP_ACCEPT' => type }
+      assert ok?
+      assert_equal type, body
+      assert_equal type, response.headers['Content-Type']
     end
   end
+
+  it 'degrades gracefully when optional accept header is not provided' do
+    mock_app {
+      get '/', :provides => :xml do
+        request.env['HTTP_ACCEPT']
+      end
+      get '/' do
+        'default'
+      end
+    }
+    get '/'
+    assert ok?
+    assert_equal 'default', body
+  end
+
+  it 'passes a single url param as block parameters when one param is specified' do
+    mock_app {
+      get '/:foo' do |foo|
+        assert_equal 'bar', foo
+      end
+    }
+
+    get '/bar'
+    assert ok?
+  end
+
+  it 'passes multiple params as block parameters when many are specified' do
+    mock_app {
+      get '/:foo/:bar/:baz' do |foo, bar, baz|
+        assert_equal 'abc', foo
+        assert_equal 'def', bar
+        assert_equal 'ghi', baz
+      end
+    }
+
+    get '/abc/def/ghi'
+    assert ok?
+  end
+
+  it 'passes regular expression captures as block parameters' do
+    mock_app {
+      get(/^\/fo(.*)\/ba(.*)/) do |foo, bar|
+        assert_equal 'orooomma', foo
+        assert_equal 'f', bar
+        'looks good'
+      end
+    }
+
+    get '/foorooomma/baf'
+    assert ok?
+    assert_equal 'looks good', body
+  end
+
+  it "supports mixing multiple splat params like /*/foo/*/* as block parameters" do
+    mock_app {
+      get '/*/foo/*/*' do |foo, bar, baz|
+        assert_equal 'bar', foo
+        assert_equal 'bling', bar
+        assert_equal 'baz/boom', baz
+        'looks good'
+      end
+    }
+
+    get '/bar/foo/bling/baz/boom'
+    assert ok?
+    assert_equal 'looks good', body
+  end
+
+  it 'raises an ArgumentError with block arity > 1 and too many values' do
+    mock_app {
+      get '/:foo/:bar/:baz' do |foo, bar|
+        'quux'
+      end
+    }
+
+    assert_raise(ArgumentError) { get '/a/b/c' }
+  end
+
+  it 'raises an ArgumentError with block param arity > 1 and too few values' do
+    mock_app {
+      get '/:foo/:bar' do |foo, bar, baz|
+        'quux'
+      end
+    }
+
+    assert_raise(ArgumentError) { get '/a/b' }
+  end
+
+  it 'succeeds if no block parameters are specified' do
+    mock_app {
+      get '/:foo/:bar' do
+        'quux'
+      end
+    }
+
+    get '/a/b'
+    assert ok?
+    assert_equal 'quux', body
+  end
+
+  it 'passes all params with block param arity -1 (splat args)' do
+    mock_app {
+      get '/:foo/:bar' do |*args|
+        args.join
+      end
+    }
+
+    get '/a/b'
+    assert ok?
+    assert_equal 'ab', body
+  end
+
+  it 'allows custom route-conditions to be set via route options' do
+    protector = Module.new {
+      def protect(*args)
+        condition {
+          unless authorize(params["user"], params["password"])
+            halt 403, "go away"
+          end
+        }
+      end
+    }
+
+    mock_app {
+      register protector
+
+      helpers do
+        def authorize(username, password)
+          username == "foo" && password == "bar"
+        end
+      end
+
+      get "/", :protect => true do
+        "hey"
+      end
+    }
+
+    get "/"
+    assert forbidden?
+    assert_equal "go away", body
+
+    get "/", :user => "foo", :password => "bar"
+    assert ok?
+    assert_equal "hey", body
+  end
+
+  # NOTE Block params behaves differently under 1.8 and 1.9. Under 1.8, block
+  # param arity is lax: declaring a mismatched number of block params results
+  # in a warning. Under 1.9, block param arity is strict: mismatched block
+  # arity raises an ArgumentError.
+
+  if RUBY_VERSION >= '1.9'
+
+    it 'raises an ArgumentError with block param arity 1 and no values' do
+      mock_app {
+        get '/foo' do |foo|
+          'quux'
+        end
+      }
+
+      assert_raise(ArgumentError) { get '/foo' }
+    end
+
+    it 'raises an ArgumentError with block param arity 1 and too many values' do
+      mock_app {
+        get '/:foo/:bar/:baz' do |foo|
+          'quux'
+        end
+      }
+
+      assert_raise(ArgumentError) { get '/a/b/c' }
+    end
+
+  else
+
+    it 'does not raise an ArgumentError with block param arity 1 and no values' do
+      mock_app {
+        get '/foo' do |foo|
+          'quux'
+        end
+      }
+
+      silence_warnings { get '/foo' }
+      assert ok?
+      assert_equal 'quux', body
+    end
+
+    it 'does not raise an ArgumentError with block param arity 1 and too many values' do
+      mock_app {
+        get '/:foo/:bar/:baz' do |foo|
+          'quux'
+        end
+      }
+
+      silence_warnings { get '/a/b/c' }
+      assert ok?
+      assert_equal 'quux', body
+    end
+
+  end
+
+  it "matches routes defined in superclasses" do
+    base = Class.new(Sinatra::Base)
+    base.get('/foo') { 'foo in baseclass' }
+
+    mock_app(base) {
+      get('/bar') { 'bar in subclass' }
+    }
+
+    get '/foo'
+    assert ok?
+    assert_equal 'foo in baseclass', body
+
+    get '/bar'
+    assert ok?
+    assert_equal 'bar in subclass', body
+  end
+
+  it "matches routes in subclasses before superclasses" do
+    base = Class.new(Sinatra::Base)
+    base.get('/foo') { 'foo in baseclass' }
+    base.get('/bar') { 'bar in baseclass' }
+
+    mock_app(base) {
+      get('/foo') { 'foo in subclass' }
+    }
+
+    get '/foo'
+    assert ok?
+    assert_equal 'foo in subclass', body
+
+    get '/bar'
+    assert ok?
+    assert_equal 'bar in baseclass', body
+  end
 end