sinatra 1.3.0.e → 1.3.0.f

data/test/mapped_error_test.rb

@@ -6,6 +6,10 @@ end
 class FooNotFound < Sinatra::NotFound
 end
 
+class FooSpecialError < RuntimeError
+  def code; 501 end
+end
+
 class MappedErrorTest < Test::Unit::TestCase
   def test_default
     assert true
@@ -25,6 +29,15 @@ class MappedErrorTest < Test::Unit::TestCase
       assert_equal 'Foo!', body
     end
 
+    it 'passes the exception object to the error handler' do
+      mock_app do
+        set :raise_errors, false
+        error(FooError) { |e| assert_equal(FooError, e.class) }
+        get('/') { raise FooError }
+      end
+      get('/')
+    end
+
     it 'uses the Exception handler if no matching handler found' do
       mock_app {
         set :raise_errors, false
@@ -108,12 +121,7 @@ class MappedErrorTest < Test::Unit::TestCase
     end
 
     it "never raises Sinatra::NotFound beyond the application" do
-      mock_app {
-        set :raise_errors, true
-        get '/' do
-          raise Sinatra::NotFound
-        end
-      }
+      mock_app(Sinatra::Application) { get('/') { raise Sinatra::NotFound }}
       assert_nothing_raised { get '/' }
       assert_equal 404, status
     end
@@ -173,6 +181,17 @@ class MappedErrorTest < Test::Unit::TestCase
       get '/'
       assert_equal 'subclass', body
     end
+
+    it 'honors Exception#code if present' do
+      mock_app do
+        set :raise_errors, false
+        error(501) { 'Foo!' }
+        get('/') { raise FooSpecialError }
+      end
+      get '/'
+      assert_equal 501, status
+      assert_equal 'Foo!', body
+    end
   end
 
   describe 'Custom Error Pages' do

data/test/nokogiri_test.rb

@@ -15,7 +15,7 @@ class NokogiriTest < Test::Unit::TestCase
   it 'renders inline Nokogiri strings' do
     nokogiri_app { nokogiri 'xml' }
     assert ok?
-    assert_body %{<?xml version="1.0"?>\n}
+    assert_body %(<?xml version="1.0"?>\n)
   end
 
   it 'renders inline blocks' do
@@ -26,7 +26,7 @@ class NokogiriTest < Test::Unit::TestCase
       end
     end
     assert ok?
-    assert_body "<?xml version=\"1.0\"?>\n<couple>Frank &amp; Mary</couple>\n"
+    assert_body %(<?xml version="1.0"?>\n<couple>Frank &amp; Mary</couple>\n)
   end
 
   it 'renders .nokogiri files in views path' do
@@ -35,7 +35,7 @@ class NokogiriTest < Test::Unit::TestCase
       nokogiri :hello
     end
     assert ok?
-    assert_body %(<?xml version="1.0"?>\n<exclaim>You're my boy, Blue!</exclaim>\n)
+    assert_body "<?xml version=\"1.0\"?>\n<exclaim>You're my boy, Blue!</exclaim>\n"
   end
 
   it "renders with inline layouts" do
@@ -46,17 +46,16 @@ class NokogiriTest < Test::Unit::TestCase
     end
     get '/'
     assert ok?
-    assert_body "<?xml version=\"1.0\"?>\n<layout>\n  <em>Hello World</em>\n</layout>\n"
+    assert_body %(<?xml version="1.0"?>\n<layout>\n  <em>Hello World</em>\n</layout>\n)
   end
 
   it "renders with file layouts" do
     next if Tilt::VERSION <= "1.1"
     nokogiri_app do
-      @name = "Blue"
       nokogiri %(xml.em 'Hello World'), :layout => :layout2
     end
     assert ok?
-    assert_body "<?xml version=\"1.0\"?>\n<layout>\n  <em>Hello World</em>\n</layout>\n"
+    assert_body %(<?xml version="1.0"?>\n<layout>\n  <em>Hello World</em>\n</layout>\n)
   end
 
   it "raises error if template not found" do

data/test/response_test.rb

@@ -37,7 +37,16 @@ class ResponseTest < Test::Unit::TestCase
     @response.body = ['Hello', 'World!', '✈']
     status, headers, body = @response.finish
     assert_equal '14', headers['Content-Length']
-    assert_equal @response.body, body.body
+    assert_equal @response.body, body
+  end
+
+  it 'does not call #to_ary or #inject on the body' do
+    object = Object.new
+    def object.inject(*) fail 'called' end
+    def object.to_ary(*) fail 'called' end
+    def object.each(*) end
+    @response.body = object
+    assert @response.finish
   end
 
   it 'does not nest a Sinatra::Response' do

data/test/result_test.rb

@@ -54,12 +54,12 @@ class ResultTest < Test::Unit::TestCase
   it "sets status, headers, and body when result is a Rack response tuple" do
     mock_app {
       get '/' do
-        [205, {'Content-Type' => 'foo/bar'}, 'Hello World']
+        [203, {'Content-Type' => 'foo/bar'}, 'Hello World']
       end
     }
 
     get '/'
-    assert_equal 205, status
+    assert_equal 203, status
     assert_equal 'foo/bar', response['Content-Type']
     assert_equal 'Hello World', body
   end

data/test/routing_test.rb

@@ -1080,4 +1080,17 @@ class RoutingTest < Test::Unit::TestCase
     assert ok?
     assert_body 'hello'
   end
+
+  it 'returns the route signature' do
+    signature = list = nil
+
+    mock_app do
+      signature = post('/') { }
+      list = routes['POST']
+    end
+
+    assert_equal Array, signature.class
+    assert_equal 4, signature.length
+    assert list.include?(signature)
+  end
 end

data/test/server_test.rb

@@ -1,4 +1,5 @@
 require File.expand_path('../helper', __FILE__)
+require 'stringio'
 
 module Rack::Handler
   class Mock
@@ -25,11 +26,11 @@ class ServerTest < Test::Unit::TestCase
       set :bind, 'foo.local'
       set :port, 9001
     }
-    $stdout = File.open('/dev/null', 'wb')
+    $stderr = StringIO.new
   end
 
   def teardown
-    $stdout = STDOUT
+    $stderr = STDERR
   end
 
   it "locates the appropriate Rack handler and calls ::run" do

data/test/settings_test.rb

@@ -306,6 +306,29 @@ class SettingsTest < Test::Unit::TestCase
       get '/'
       assert body.include?("RuntimeError") && body.include?("settings_test.rb")
     end
+
+    it 'does not dump 404 errors' do
+      klass = Sinatra.new(Sinatra::Application)
+
+      mock_app(klass) {
+        enable :dump_errors
+        disable :raise_errors
+
+        error do
+          error = @env['rack.errors'].instance_variable_get(:@error)
+          error.rewind
+
+          error.read
+        end
+
+        get '/' do
+          raise Sinatra::NotFound
+        end
+      }
+
+      get '/'
+      assert !body.include?("NotFound") && !body.include?("settings_test.rb")
+    end
   end
 
   describe 'sessions' do
@@ -336,13 +359,13 @@ class SettingsTest < Test::Unit::TestCase
       assert ! @base.static?
     end
 
-    it 'is enabled on Base when public is set and exists' do
+    it 'is enabled on Base when public_folder is set and exists' do
       @base.set :environment, :development
-      @base.set :public, File.dirname(__FILE__)
+      @base.set :public_folder, File.dirname(__FILE__)
       assert @base.static?
     end
 
-    it 'is enabled on Base when root is set and root/public exists' do
+    it 'is enabled on Base when root is set and root/public_folder exists' do
       @base.set :environment, :development
       @base.set :root, File.dirname(__FILE__)
       assert @base.static?
@@ -352,17 +375,36 @@ class SettingsTest < Test::Unit::TestCase
       assert ! @application.static?
     end
 
-    it 'is enabled on Application when public is set and exists' do
+    it 'is enabled on Application when public_folder is set and exists' do
       @application.set :environment, :development
-      @application.set :public, File.dirname(__FILE__)
+      @application.set :public_folder, File.dirname(__FILE__)
       assert @application.static?
     end
 
-    it 'is enabled on Application when root is set and root/public exists' do
+    it 'is enabled on Application when root is set and root/public_folder exists' do
       @application.set :environment, :development
       @application.set :root, File.dirname(__FILE__)
       assert @application.static?
     end
+
+    it 'is possible to use Module#public' do
+      @base.send(:define_method, :foo) { }
+      @base.send(:private, :foo)
+      assert !@base.public_method_defined?(:foo)
+      @base.send(:public, :foo)
+      assert @base.public_method_defined?(:foo)
+    end
+
+    it 'is possible to use the keyword public in a sinatra app' do
+      app = Sinatra.new do
+        private
+        def priv; end
+        public
+        def pub; end
+      end
+      assert !app.public_method_defined?(:priv)
+      assert app.public_method_defined?(:pub)
+    end
   end
 
   describe 'bind' do
@@ -427,18 +469,18 @@ class SettingsTest < Test::Unit::TestCase
     end
   end
 
-  describe 'public' do
+  describe 'public_folder' do
     it 'is nil if root is not set' do
-      assert @base.public.nil?
-      assert @application.public.nil?
+      assert @base.public_folder.nil?
+      assert @application.public_folder.nil?
     end
 
     it 'is set to root joined with public/' do
       @base.root = File.dirname(__FILE__)
-      assert_equal File.dirname(__FILE__) + "/public", @base.public
+      assert_equal File.dirname(__FILE__) + "/public", @base.public_folder
 
       @application.root = File.dirname(__FILE__)
-      assert_equal File.dirname(__FILE__) + "/public", @application.public
+      assert_equal File.dirname(__FILE__) + "/public", @application.public_folder
     end
   end
 
@@ -448,4 +490,49 @@ class SettingsTest < Test::Unit::TestCase
       assert ! @application.lock?
     end
   end
+
+  describe 'protection' do
+    class MiddlewareTracker < Rack::Builder
+      def self.track
+        Rack.send :remove_const, :Builder
+        Rack.const_set :Builder, MiddlewareTracker
+        MiddlewareTracker.used.clear
+        yield
+      ensure
+        Rack.send :remove_const, :Builder
+        Rack.const_set :Builder, MiddlewareTracker.superclass
+      end
+
+      def self.used
+        @used ||= []
+      end
+
+      def use(middleware, *)
+        MiddlewareTracker.used << middleware
+        super
+      end
+    end
+
+    it 'sets up Rack::Protection' do
+      MiddlewareTracker.track do
+        Sinatra::Base.new
+        assert_include MiddlewareTracker.used, Rack::Protection
+      end
+    end
+
+    it 'sets up Rack::Protection::PathTraversal' do
+      MiddlewareTracker.track do
+        Sinatra::Base.new
+        assert_include MiddlewareTracker.used, Rack::Protection::PathTraversal
+      end
+    end
+
+    it 'does not set up Rack::Protection::PathTraversal when disabling it' do
+      MiddlewareTracker.track do
+        Sinatra.new { set :protection, :except => :path_traversal }.new
+        assert_include MiddlewareTracker.used, Rack::Protection
+        assert !MiddlewareTracker.used.include?(Rack::Protection::PathTraversal)
+      end
+    end
+  end
 end

data/test/slim_test.rb

@@ -52,44 +52,34 @@ class SlimTest < Test::Unit::TestCase
   HTML4_DOCTYPE = "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">"
   
   it "passes slim options to the slim engine" do
-    mock_app {
-      get '/' do
-        slim "! doctype html\nh1 Hello World", :format => :html4
-      end
-    }
+    mock_app { get('/') { slim "x foo='bar'", :attr_wrapper => "'" }}
     get '/'
     assert ok?
-    assert_equal "#{HTML4_DOCTYPE}<h1>Hello World</h1>", body
+    assert_body "<x foo='bar'></x>"
   end
   
   it "passes default slim options to the slim engine" do
-    mock_app {
-      set :slim, {:format => :html4}
-      get '/' do
-        slim "! doctype html\nh1 Hello World"
-      end
-    }
+    mock_app do
+      set :slim, :attr_wrapper => "'"
+      get('/') { slim "x foo='bar'" }
+    end
     get '/'
     assert ok?
-    assert_equal "#{HTML4_DOCTYPE}<h1>Hello World</h1>", body
+    assert_body "<x foo='bar'></x>"
   end
   
   it "merges the default slim options with the overrides and passes them to the slim engine" do
-    mock_app {
-      set :slim, {:format => :html4}
-      get '/' do
-        slim "! doctype html\nh1.header Hello World"
-      end
-      get '/html5' do
-        slim "! doctype html\nh1.header Hello World", :format => :html5
-      end
-    }
+    mock_app do
+      set :slim, :attr_wrapper => "'"
+      get('/') { slim "x foo='bar'" }
+      get('/other') { slim "x foo='bar'", :attr_wrapper => '"' }
+    end
     get '/'
     assert ok?
-    assert_match(/^#{HTML4_DOCTYPE}/, body)
-    get '/html5'
+    assert_body "<x foo='bar'></x>"
+    get '/other'
     assert ok?
-    assert_equal "<!DOCTYPE html><h1 class=\"header\">Hello World</h1>", body
+    assert_body '<x foo="bar"></x>'
   end
 end
 

data/test/static_test.rb

@@ -4,7 +4,7 @@ class StaticTest < Test::Unit::TestCase
   setup do
     mock_app {
       set :static, true
-      set :public, File.dirname(__FILE__)
+      set :public_folder, File.dirname(__FILE__)
     }
   end
 
@@ -66,7 +66,7 @@ class StaticTest < Test::Unit::TestCase
   end
 
   it 'passes to the next handler when the public option is nil' do
-    @app.set :public, nil
+    @app.set :public_folder, nil
     get "/#{File.basename(__FILE__)}"
     assert not_found?
   end
@@ -85,7 +85,7 @@ class StaticTest < Test::Unit::TestCase
   it '404s when .. path traverses outside of public directory' do
     mock_app {
       set :static, true
-      set :public, File.dirname(__FILE__) + '/data'
+      set :public_folder, File.dirname(__FILE__) + '/data'
     }
     get "/../#{File.basename(__FILE__)}"
     assert not_found?

data/test/streaming_test.rb

@@ -0,0 +1,100 @@
+require File.expand_path('../helper', __FILE__)
+
+class StreamingTest < Test::Unit::TestCase
+  Stream = Sinatra::Helpers::Stream
+
+  it 'returns the concatinated body' do
+    mock_app do
+      get '/' do
+        stream do |out|
+          out << "Hello" << " "
+          out << "World!"
+        end
+      end
+    end
+
+    get('/')
+    assert_body "Hello World!"
+  end
+
+  it 'always yields strings' do
+    stream = Stream.new { |out| out << :foo }
+    stream.each { |str| assert_equal 'foo', str }
+  end
+
+  it 'postpones body generation' do
+    step = 0
+
+    stream = Stream.new do |out|
+      10.times do
+        out << step
+        step += 1
+      end
+    end
+
+    stream.each do |s|
+      assert_equal s, step.to_s
+      step += 1
+    end
+  end
+
+  it 'calls the callback after it is done' do
+    step   = 0
+    final  = 0
+    stream = Stream.new { |o| 10.times { step += 1 }}
+    stream.callback { final = step }
+    stream.each { |str| }
+    assert_equal 10, final
+  end
+
+  it 'does not trigger the callback if close is set to :keep_open' do
+    step   = 0
+    final  = 0
+    stream = Stream.new(Stream, :keep_open) { |o| 10.times { step += 1 } }
+    stream.callback { final = step }
+    stream.each { |str| }
+    assert_equal 0, final
+  end
+
+  class MockScheduler
+    def initialize(*)     @schedule, @defer = [], []                end
+    def schedule(&block)  @schedule << block                        end
+    def defer(&block)     @defer    << block                        end
+    def schedule!(*)      @schedule.pop.call until @schedule.empty? end
+    def defer!(*)         @defer.pop.call    until @defer.empty?    end
+  end
+
+  it 'allows dropping in another scheduler' do
+    scheduler  = MockScheduler.new
+    processing = sending = done = false
+
+    stream = Stream.new(scheduler) do |out|
+      processing = true
+      out << :foo
+    end
+
+    stream.each { sending = true}
+    stream.callback { done = true }
+
+    scheduler.schedule!
+    assert !processing
+    assert !sending
+    assert !done
+
+    scheduler.defer!
+    assert processing
+    assert !sending
+    assert !done
+
+    scheduler.schedule!
+    assert sending
+    assert done
+  end
+
+  it 'schedules exceptions to be raised on the main thread/event loop/...' do
+    scheduler = MockScheduler.new
+    Stream.new(scheduler) { fail 'should be caught' }.each { }
+    scheduler.defer!
+    assert_raise(RuntimeError) { scheduler.schedule! }
+  end
+end