darkhelmet-sinatra 0.9.1.1 → 0.10.1

data/test/mapped_error_test.rb

@@ -6,155 +6,181 @@ end
 class FooNotFound < Sinatra::NotFound
 end
 
-describe 'Exception Mappings' do
-  it 'invokes handlers registered with ::error when raised' do
-    mock_app {
-      set :raise_errors, false
-      error(FooError) { 'Foo!' }
-      get '/' do
-        raise FooError
-      end
-    }
-    get '/'
-    assert_equal 500, status
-    assert_equal 'Foo!', body
+class MappedErrorTest < Test::Unit::TestCase
+  def test_default
+    assert true
   end
 
-  it 'uses the Exception handler if no matching handler found' do
-    mock_app {
-      set :raise_errors, false
-      error(Exception) { 'Exception!' }
-      get '/' do
-        raise FooError
-      end
-    }
-    get '/'
-    assert_equal 500, status
-    assert_equal 'Exception!', body
-  end
-
-  it "sets env['sinatra.error'] to the rescued exception" do
-    mock_app {
-      set :raise_errors, false
-      error(FooError) {
-        assert env.include?('sinatra.error')
-        assert env['sinatra.error'].kind_of?(FooError)
-        'looks good'
+  describe 'Exception Mappings' do
+    it 'invokes handlers registered with ::error when raised' do
+      mock_app {
+        set :raise_errors, false
+        error(FooError) { 'Foo!' }
+        get '/' do
+          raise FooError
+        end
+      }
+      get '/'
+      assert_equal 500, status
+      assert_equal 'Foo!', body
+    end
+
+    it 'uses the Exception handler if no matching handler found' do
+      mock_app {
+        set :raise_errors, false
+        error(Exception) { 'Exception!' }
+        get '/' do
+          raise FooError
+        end
       }
-      get '/' do
-        raise FooError
-      end
-    }
-    get '/'
-    assert_equal 'looks good', body
-  end
-
-  it 'dumps errors to rack.errors when dump_errors is enabled' do
-    mock_app {
-      set :raise_errors, false
-      set :dump_errors, true
-      get('/') { raise FooError, 'BOOM!' }
-    }
-
-    get '/'
-    assert_equal 500, status
-    assert @response.errors =~ /FooError - BOOM!:/
-  end
 
-  it "raises without calling the handler when the raise_errors options is set" do
-    mock_app {
-      set :raise_errors, true
-      error(FooError) { "she's not there." }
-      get '/' do
-        raise FooError
-      end
-    }
-    assert_raise(FooError) { get '/' }
-  end
+      get '/'
+      assert_equal 500, status
+      assert_equal 'Exception!', body
+    end
+
+    it "sets env['sinatra.error'] to the rescued exception" do
+      mock_app {
+        set :raise_errors, false
+        error(FooError) {
+          assert env.include?('sinatra.error')
+          assert env['sinatra.error'].kind_of?(FooError)
+          'looks good'
+        }
+        get '/' do
+          raise FooError
+        end
+      }
+      get '/'
+      assert_equal 'looks good', body
+    end
+
+    it "raises without calling the handler when the raise_errors options is set" do
+      mock_app {
+        set :raise_errors, true
+        error(FooError) { "she's not there." }
+        get '/' do
+          raise FooError
+        end
+      }
+      assert_raise(FooError) { get '/' }
+    end
+
+    it "never raises Sinatra::NotFound beyond the application" do
+      mock_app {
+        set :raise_errors, true
+        get '/' do
+          raise Sinatra::NotFound
+        end
+      }
+      assert_nothing_raised { get '/' }
+      assert_equal 404, status
+    end
+
+    it "cascades for subclasses of Sinatra::NotFound" do
+      mock_app {
+        set :raise_errors, true
+        error(FooNotFound) { "foo! not found." }
+        get '/' do
+          raise FooNotFound
+        end
+      }
+      assert_nothing_raised { get '/' }
+      assert_equal 404, status
+      assert_equal 'foo! not found.', body
+    end
+
+    it 'has a not_found method for backwards compatibility' do
+      mock_app {
+        not_found do
+          "Lost, are we?"
+        end
+      }
 
-  it "never raises Sinatra::NotFound beyond the application" do
-    mock_app {
-      set :raise_errors, true
-      get '/' do
-        raise Sinatra::NotFound
-      end
-    }
-    assert_nothing_raised { get '/' }
-    assert_equal 404, status
-  end
+      get '/test'
+      assert_equal 404, status
+      assert_equal "Lost, are we?", body
+    end
 
-  it "cascades for subclasses of Sinatra::NotFound" do
-    mock_app {
-      set :raise_errors, true
-      error(FooNotFound) { "foo! not found." }
-      get '/' do
-        raise FooNotFound
-      end
-    }
-    assert_nothing_raised { get '/' }
-    assert_equal 404, status
-    assert_equal 'foo! not found.', body
-  end
+    it 'inherits error mappings from base class' do
+      base = Class.new(Sinatra::Base)
+      base.error(FooError) { 'base class' }
 
-  it 'has a not_found method for backwards compatibility' do
-    mock_app {
-      not_found do
-        "Lost, are we?"
-      end
-    }
+      mock_app(base) {
+        set :raise_errors, false
+        get '/' do
+          raise FooError
+        end
+      }
 
-    get '/test'
-    assert_equal 404, status
-    assert_equal "Lost, are we?", body
-  end
-end
+      get '/'
+      assert_equal 'base class', body
+    end
 
-describe 'Custom Error Pages' do
-  it 'allows numeric status code mappings to be registered with ::error' do
-    mock_app {
-      set :raise_errors, false
-      error(500) { 'Foo!' }
-      get '/' do
-        [500, {}, 'Internal Foo Error']
-      end
-    }
-    get '/'
-    assert_equal 500, status
-    assert_equal 'Foo!', body
-  end
+    it 'overrides error mappings in base class' do
+      base = Class.new(Sinatra::Base)
+      base.error(FooError) { 'base class' }
 
-  it 'allows ranges of status code mappings to be registered with :error' do
-    mock_app {
-      set :raise_errors, false
-      error(500..550) { "Error: #{response.status}" }
-      get '/' do
-        [507, {}, 'A very special error']
-      end
-    }
-    get '/'
-    assert_equal 507, status
-    assert_equal 'Error: 507', body
-  end
+      mock_app(base) {
+        set :raise_errors, false
+        error(FooError) { 'subclass' }
+        get '/' do
+          raise FooError
+        end
+      }
 
-  class FooError < RuntimeError
+      get '/'
+      assert_equal 'subclass', body
+    end
   end
 
-  it 'runs after exception mappings and overwrites body' do
-    mock_app {
-      set :raise_errors, false
-      error FooError do
-        response.status = 502
-        'from exception mapping'
-      end
-      error(500) { 'from 500 handler' }
-      error(502) { 'from custom error page' }
-
-      get '/' do
-        raise FooError
-      end
-    }
-    get '/'
-    assert_equal 502, status
-    assert_equal 'from custom error page', body
+  describe 'Custom Error Pages' do
+    it 'allows numeric status code mappings to be registered with ::error' do
+      mock_app {
+        set :raise_errors, false
+        error(500) { 'Foo!' }
+        get '/' do
+          [500, {}, 'Internal Foo Error']
+        end
+      }
+      get '/'
+      assert_equal 500, status
+      assert_equal 'Foo!', body
+    end
+
+    it 'allows ranges of status code mappings to be registered with :error' do
+      mock_app {
+        set :raise_errors, false
+        error(500..550) { "Error: #{response.status}" }
+        get '/' do
+          [507, {}, 'A very special error']
+        end
+      }
+      get '/'
+      assert_equal 507, status
+      assert_equal 'Error: 507', body
+    end
+
+    class FooError < RuntimeError
+    end
+
+    it 'runs after exception mappings and overwrites body' do
+      mock_app {
+        set :raise_errors, false
+        error FooError do
+          response.status = 502
+          'from exception mapping'
+        end
+        error(500) { 'from 500 handler' }
+        error(502) { 'from custom error page' }
+
+        get '/' do
+          raise FooError
+        end
+      }
+      get '/'
+      assert_equal 502, status
+      assert_equal 'from custom error page', body
+    end
   end
 end

data/test/middleware_test.rb

@@ -1,8 +1,8 @@
 require File.dirname(__FILE__) + '/helper'
 
-describe "Middleware" do
-  before do
-    @app = mock_app(Sinatra::Default) {
+class MiddlewareTest < Test::Unit::TestCase
+  setup do
+    @app = mock_app(Sinatra::Application) {
       get '/*' do
         response.headers['X-Tests'] = env['test.ran'].
           map { |n| n.split('::').last }.

data/test/request_test.rb

@@ -1,6 +1,6 @@
 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'})
     assert request.respond_to?(:user_agent)
@@ -15,4 +15,19 @@ describe 'Sinatra::Request' do
     )
     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

@@ -2,8 +2,8 @@
 
 require File.dirname(__FILE__) + '/helper'
 
-describe 'Sinatra::Response' do
-  before do
+class ResponseTest < Test::Unit::TestCase
+  setup do
     @response = Sinatra::Response.new
   end
 

data/test/result_test.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
 
-describe 'Result Handling' do
+class ResultTest < Test::Unit::TestCase
   it "sets response.body when result is a String" do
     mock_app {
       get '/' do

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

@@ -5,7 +5,23 @@ def route_def(pattern)
   mock_app { get(pattern) { } }
 end
 
-describe "Routing" do
+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
+
+class RoutingTest < Test::Unit::TestCase
   %w[get put post delete].each do |verb|
     it "defines #{verb.upcase} request handlers with #{verb}" do
       mock_app {
@@ -44,6 +60,30 @@ describe "Routing" do
     assert_equal 404, status
   end
 
+  it "404s and sets X-Cascade header when no route satisfies the request" do
+    mock_app {
+      get('/foo') { }
+    }
+    get '/bar'
+    assert_equal 404, status
+    assert_equal 'pass', response.headers['X-Cascade']
+  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/)
@@ -243,17 +283,7 @@ describe "Routing" do
   end
 
   it "supports deeply nested params" do
-    input = {
-      'browser[chrome][engine][name]' => 'V8',
-      'browser[chrome][engine][version]' => '1.0',
-      'browser[firefox][engine][name]' => 'spidermonkey',
-      'browser[firefox][engine][version]' => '1.7.0',
-      'emacs[map][goto-line]' => 'M-g g',
-      'emacs[version]' => '22.3.1',
-      'paste[name]' => 'hello world',
-      'paste[syntax]' => 'ruby'
-    }
-    expected = {
+    expected_params = {
       "emacs" => {
         "map"     => { "goto-line" => "M-g g" },
         "version" => "22.3.1"
@@ -266,11 +296,11 @@ describe "Routing" do
     }
     mock_app {
       get '/foo' do
-        assert_equal expected, params
+        assert_equal expected_params, params
         'looks good'
       end
     }
-    get "/foo?#{build_query(input)}"
+    get '/foo', expected_params
     assert ok?
     assert_equal 'looks good', body
   end
@@ -352,9 +382,26 @@ describe "Routing" do
     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
-    @app = mock_app
-    assert_raise(TypeError) { @app.get(42){} }
+    assert_raise(TypeError) {
+      mock_app { get(42){} }
+    }
   end
 
   it "returns response immediately on halt" do
@@ -424,6 +471,38 @@ describe "Routing" do
     assert not_found?
   end
 
+  it "transitions to 404 and sets X-Cascade header when passed and no subsequent route matches" do
+    mock_app {
+      get '/:foo' do
+        pass
+        'Hello Foo'
+      end
+
+      get '/bar' do
+        'Hello Bar'
+      end
+    }
+
+    get '/foo'
+    assert not_found?
+    assert_equal 'pass', response.headers['X-Cascade']
+  end
+
+  it "uses optional block passed to pass as route block if no other route is found" do
+    mock_app {
+      get "/" do
+        pass do
+          "this"
+        end
+        "not this"
+      end
+    }
+
+    get "/"
+    assert ok?
+    assert "this", body
+  end
+
   it "passes when matching condition returns false" do
     mock_app {
       condition { params[:foo] == 'bar' }
@@ -479,7 +558,7 @@ describe "Routing" do
     get '/foo'
     assert not_found?
 
-    get '/foo', :env => { 'HTTP_HOST' => 'example.com' }
+    get '/foo', {}, { 'HTTP_HOST' => 'example.com' }
     assert_equal 200, status
     assert_equal 'Hello World', body
   end
@@ -494,7 +573,7 @@ describe "Routing" do
     get '/foo'
     assert not_found?
 
-    get '/foo', :env => { 'HTTP_USER_AGENT' => 'Foo Bar' }
+    get '/foo', {}, { 'HTTP_USER_AGENT' => 'Foo Bar' }
     assert_equal 200, status
     assert_equal 'Hello World', body
   end
@@ -506,7 +585,7 @@ describe "Routing" do
         'Hello ' + params[:agent].first
       end
     }
-    get '/foo', :env => { 'HTTP_USER_AGENT' => 'Foo Bar' }
+    get '/foo', {}, { 'HTTP_USER_AGENT' => 'Foo Bar' }
     assert_equal 200, status
     assert_equal 'Hello Bar', body
   end
@@ -518,12 +597,12 @@ describe "Routing" do
       end
     }
 
-    get '/', :env => { :accept => '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' }
+    get '/', {}, { :accept => 'text/html' }
     assert !ok?
   end
 
@@ -537,7 +616,7 @@ describe "Routing" do
     }
 
     types.each do |type|
-      get '/', :env => { :accept => type }
+      get '/', {}, { 'HTTP_ACCEPT' => type }
       assert ok?
       assert_equal type, body
       assert_equal type, response.headers['Content-Type']
@@ -655,6 +734,40 @@ describe "Routing" do
     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
@@ -709,4 +822,39 @@ describe "Routing" do
     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