sinatra 1.3.6 → 1.4.0.a

data/test/integration_helper.rb

@@ -126,6 +126,14 @@ module IntegrationHelper
       name.to_s == "thin"
     end
 
+    def puma?
+      name.to_s == "puma"
+    end
+
+    def trinidad?
+      name.to_s == "trinidad"
+    end
+
     def warnings
       log.scan(%r[(?:\(eval|lib/sinatra).*warning:.*$])
     end

data/test/integration_test.rb

@@ -10,8 +10,10 @@ class IntegrationTest < Test::Unit::TestCase
   attr_accessor :server
 
   it('sets the app_file') { assert_equal server.app_file, server.get("/app_file") }
+  it('only extends main') { assert_equal "true", server.get("/mainonly") }
 
   it 'logs once in development mode' do
+    next if server.puma? or RUBY_ENGINE == 'jruby'
     random = "%064x" % Kernel.rand(2**256-1)
     server.get "/ping?x=#{random}"
     count = server.log.scan("GET /ping?x=#{random}").count
@@ -19,7 +21,7 @@ class IntegrationTest < Test::Unit::TestCase
   end
 
   it 'streams' do
-    next if server.webrick?
+    next if server.webrick? or server.trinidad?
     times, chunks = [Time.now], []
     server.get_stream do |chunk|
       next if chunk.empty?

data/test/less_test.rb

@@ -5,22 +5,26 @@ require 'less'
 
 class LessTest < Test::Unit::TestCase
   def less_app(options = {}, &block)
-    mock_app {
+    mock_app do
       set :views, File.dirname(__FILE__) + '/views'
       set options
-      get '/', &block
-    }
+      get('/', &block)
+    end
     get '/'
   end
 
   it 'renders inline Less strings' do
-    less_app { less "@white_color: #fff; #main { background-color: @white_color }" }
+    less_app {
+      less "@white_color: #fff; #main { background-color: @white_color }"
+    }
     assert ok?
     assert_equal "#main{background-color:#ffffff;}", body.gsub(/\s/, "")
   end
 
   it 'defaults content type to css' do
-    less_app { less "@white_color: #fff; #main { background-color: @white_color }" }
+    less_app {
+      less "@white_color: #fff; #main { background-color: @white_color }"
+    }
     assert ok?
     assert_equal "text/css;charset=utf-8", response['Content-Type']
   end
@@ -55,9 +59,7 @@ class LessTest < Test::Unit::TestCase
   end
 
   it "raises error if template not found" do
-    mock_app {
-      get('/') { less :no_such_template }
-    }
+    mock_app { get('/') { less :no_such_template } }
     assert_raise(Errno::ENOENT) { get('/') }
   end
 end

data/test/liquid_test.rb

@@ -7,7 +7,7 @@ class LiquidTest < Test::Unit::TestCase
   def liquid_app(&block)
     mock_app do
       set :views, File.dirname(__FILE__) + '/views'
-      get '/', &block
+      get('/', &block)
     end
     get '/'
   end
@@ -44,14 +44,32 @@ class LiquidTest < Test::Unit::TestCase
     mock_app { get('/') { liquid :no_such_template } }
     assert_raise(Errno::ENOENT) { get('/') }
   end
-  
+
   it "allows passing locals" do
-    liquid_app do
+    liquid_app {
       liquid '{{ value }}', :locals => { :value => 'foo' }
-    end
+    }
     assert ok?
     assert_equal 'foo', body
   end
+
+  it "can rendere truly nested layouts by accepting a layout and a block with the contents" do
+    mock_app do
+      template(:main_outer_layout) { "<h1>Title</h1>\n{{ yield }}" }
+      template(:an_inner_layout) { "<h2>Subtitle</h2>\n{{ yield }}" }
+      template(:a_page) { "<p>Contents.</p>\n" }
+      get('/') do
+        liquid :main_outer_layout, :layout => false do
+          liquid :an_inner_layout do
+            liquid :a_page
+          end
+        end
+      end
+    end
+    get '/'
+    assert ok?
+    assert_body "<h1>Title</h1>\n<h2>Subtitle</h2>\n<p>Contents.</p>\n"
+  end
 end
 
 rescue LoadError

data/test/mapped_error_test.rb

@@ -7,9 +7,20 @@ class FooNotFound < Sinatra::NotFound
 end
 
 class FooSpecialError < RuntimeError
-  def code; 501 end
+  def http_status; 501 end
 end
 
+class FooStatusOutOfRangeError < RuntimeError
+  def code; 4000 end
+end
+
+class FooWithCode < RuntimeError
+  def code; 419 end
+end
+
+class FirstError < RuntimeError; end
+class SecondError < RuntimeError; end
+
 class MappedErrorTest < Test::Unit::TestCase
   def test_default
     assert true
@@ -17,13 +28,11 @@ class MappedErrorTest < Test::Unit::TestCase
 
   describe 'Exception Mappings' do
     it 'invokes handlers registered with ::error when raised' do
-      mock_app {
+      mock_app do
         set :raise_errors, false
         error(FooError) { 'Foo!' }
-        get '/' do
-          raise FooError
-        end
-      }
+        get('/') { raise FooError }
+      end
       get '/'
       assert_equal 500, status
       assert_equal 'Foo!', body
@@ -39,13 +48,11 @@ class MappedErrorTest < Test::Unit::TestCase
     end
 
     it 'uses the Exception handler if no matching handler found' do
-      mock_app {
+      mock_app do
         set :raise_errors, false
         error(Exception) { 'Exception!' }
-        get '/' do
-          raise FooError
-        end
-      }
+        get('/') { raise FooError }
+      end
 
       get '/'
       assert_equal 500, status
@@ -53,13 +60,11 @@ class MappedErrorTest < Test::Unit::TestCase
     end
 
     it 'walks down inheritance chain for errors' do
-      mock_app {
+      mock_app do
         set :raise_errors, false
         error(RuntimeError) { 'Exception!' }
-        get '/' do
-          raise FooError
-        end
-      }
+        get('/') { raise FooError }
+      end
 
       get '/'
       assert_equal 500, status
@@ -67,15 +72,13 @@ class MappedErrorTest < Test::Unit::TestCase
     end
 
     it 'favors subclass handler over superclass handler if available' do
-      mock_app {
+      mock_app do
         set :raise_errors, false
         error(Exception) { 'Exception!' }
         error(FooError) { 'FooError!' }
         error(RuntimeError) { 'Exception!' }
-        get '/' do
-          raise FooError
-        end
-      }
+        get('/') { raise FooError }
+      end
 
       get '/'
       assert_equal 500, status
@@ -83,68 +86,58 @@ class MappedErrorTest < Test::Unit::TestCase
     end
 
     it "sets env['sinatra.error'] to the rescued exception" do
-      mock_app {
+      mock_app do
         set :raise_errors, false
-        error(FooError) {
+        error(FooError) do
           assert env.include?('sinatra.error')
           assert env['sinatra.error'].kind_of?(FooError)
           'looks good'
-        }
-        get '/' do
-          raise FooError
         end
-      }
+        get('/') { raise FooError }
+      end
       get '/'
       assert_equal 'looks good', body
     end
 
     it "raises errors from the app when raise_errors set and no handler defined" do
-      mock_app {
+      mock_app do
         set :raise_errors, true
-        get '/' do
-          raise FooError
-        end
-      }
+        get('/') { raise FooError }
+      end
       assert_raise(FooError) { get '/' }
     end
 
     it "calls error handlers before raising errors even when raise_errors is set" do
-      mock_app {
+      mock_app do
         set :raise_errors, true
         error(FooError) { "she's there." }
-        get '/' do
-          raise FooError
-        end
-      }
+        get('/') { raise FooError }
+      end
       assert_nothing_raised { get '/' }
       assert_equal 500, status
     end
 
     it "never raises Sinatra::NotFound beyond the application" do
-      mock_app(Sinatra::Application) { get('/') { raise Sinatra::NotFound }}
+      mock_app(Sinatra::Application) do
+        get('/') { raise Sinatra::NotFound }
+      end
       assert_nothing_raised { get '/' }
       assert_equal 404, status
     end
 
     it "cascades for subclasses of Sinatra::NotFound" do
-      mock_app {
+      mock_app do
         set :raise_errors, true
         error(FooNotFound) { "foo! not found." }
-        get '/' do
-          raise FooNotFound
-        end
-      }
+        get('/') { 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
-      }
+      mock_app { not_found { "Lost, are we?" } }
 
       get '/test'
       assert_equal 404, status
@@ -155,12 +148,10 @@ class MappedErrorTest < Test::Unit::TestCase
       base = Class.new(Sinatra::Base)
       base.error(FooError) { 'base class' }
 
-      mock_app(base) {
+      mock_app(base) do
         set :raise_errors, false
-        get '/' do
-          raise FooError
-        end
-      }
+        get('/') { raise FooError }
+      end
 
       get '/'
       assert_equal 'base class', body
@@ -170,19 +161,17 @@ class MappedErrorTest < Test::Unit::TestCase
       base = Class.new(Sinatra::Base)
       base.error(FooError) { 'base class' }
 
-      mock_app(base) {
+      mock_app(base) do
         set :raise_errors, false
         error(FooError) { 'subclass' }
-        get '/' do
-          raise FooError
-        end
-      }
+        get('/') { raise FooError }
+      end
 
       get '/'
       assert_equal 'subclass', body
     end
 
-    it 'honors Exception#code if present' do
+    it 'honors Exception#http_status if present' do
       mock_app do
         set :raise_errors, false
         error(501) { 'Foo!' }
@@ -192,68 +181,105 @@ class MappedErrorTest < Test::Unit::TestCase
       assert_equal 501, status
       assert_equal 'Foo!', body
     end
+
+    it 'does not use Exception#code by default' do
+      mock_app do
+        set :raise_errors, false
+        get('/') { raise FooWithCode }
+      end
+      get '/'
+      assert_equal 500, status
+    end
+
+    it 'uses Exception#code if use_code is enabled' do
+      mock_app do
+        set :raise_errors, false
+        set :use_code, true
+        get('/') { raise FooWithCode }
+      end
+      get '/'
+      assert_equal 419, status
+    end
+
+    it 'does not rely on Exception#code for invalid codes' do
+      mock_app do
+        set :raise_errors, false
+        set :use_code, true
+        get('/') { raise FooStatusOutOfRangeError }
+      end
+      get '/'
+      assert_equal 500, status
+    end
+
+    it "allows a stack of exception_handlers" do
+      mock_app do
+        set :raise_errors, false
+        error(FirstError) { 'First!' }
+        error(SecondError) { 'Second!' }
+        get('/'){ raise SecondError }
+      end
+      get '/'
+      assert_equal 500, status
+      assert_equal 'Second!', body
+    end
+
+    it "allows an exception handler to pass control to the next exception handler" do
+      mock_app do
+        set :raise_errors, false
+        error(500, FirstError) { 'First!' }
+        error(500, SecondError) { pass }
+        get('/') { raise 500 }
+      end
+      get '/'
+      assert_equal 500, status
+      assert_equal 'First!', body
+    end
+
+    it "allows an exception handler to handle the exception" do
+      mock_app do
+        set :raise_errors, false
+        error(500, FirstError) { 'First!' }
+        error(500, SecondError) { 'Second!' }
+        get('/') { raise 500 }
+      end
+      get '/'
+      assert_equal 500, status
+      assert_equal 'Second!', body
+    end
   end
 
   describe 'Custom Error Pages' do
     it 'allows numeric status code mappings to be registered with ::error' do
-      mock_app {
+      mock_app do
         set :raise_errors, false
         error(500) { 'Foo!' }
-        get '/' do
-          [500, {}, 'Internal Foo Error']
-        end
-      }
+        get('/') { [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 {
+      mock_app do
         set :raise_errors, false
         error(500..550) { "Error: #{response.status}" }
-        get '/' do
-          [507, {}, 'A very special error']
-        end
-      }
+        get('/') { [507, {}, 'A very special error'] }
+      end
       get '/'
       assert_equal 507, status
       assert_equal 'Error: 507', body
     end
 
     it 'allows passing more than one range' do
-      mock_app {
+      mock_app do
         set :raise_errors, false
         error(409..411, 503..509) { "Error: #{response.status}" }
-        get '/' do
-          [507, {}, 'A very special error']
-        end
-      }
+        get('/') { [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