sinatra 1.4.8 → 2.0.0

data/test/mapped_error_test.rb

@@ -1,285 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class FooError < RuntimeError
-end
-
-class FooNotFound < Sinatra::NotFound
-end
-
-class FooSpecialError < RuntimeError
-  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 < Minitest::Test
-  def test_default
-    assert true
-  end
-
-  describe 'Exception Mappings' do
-    it 'invokes handlers registered with ::error when raised' do
-      mock_app do
-        set :raise_errors, false
-        error(FooError) { 'Foo!' }
-        get('/') { raise FooError }
-      end
-      get '/'
-      assert_equal 500, status
-      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 do
-        set :raise_errors, false
-        error(Exception) { 'Exception!' }
-        get('/') { raise FooError }
-      end
-
-      get '/'
-      assert_equal 500, status
-      assert_equal 'Exception!', body
-    end
-
-    it 'walks down inheritance chain for errors' do
-      mock_app do
-        set :raise_errors, false
-        error(RuntimeError) { 'Exception!' }
-        get('/') { raise FooError }
-      end
-
-      get '/'
-      assert_equal 500, status
-      assert_equal 'Exception!', body
-    end
-
-    it 'favors subclass handler over superclass handler if available' do
-      mock_app do
-        set :raise_errors, false
-        error(Exception) { 'Exception!' }
-        error(FooError) { 'FooError!' }
-        error(RuntimeError) { 'Exception!' }
-        get('/') { raise FooError }
-      end
-
-      get '/'
-      assert_equal 500, status
-      assert_equal 'FooError!', body
-    end
-
-    it "sets env['sinatra.error'] to the rescued exception" do
-      mock_app do
-        set :raise_errors, false
-        error(FooError) do
-          assert env.include?('sinatra.error')
-          assert env['sinatra.error'].kind_of?(FooError)
-          'looks good'
-        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 do
-        set :raise_errors, true
-        get('/') { raise FooError }
-      end
-      assert_raises(FooError) { get '/' }
-    end
-
-    it "calls error handlers before raising errors even when raise_errors is set" do
-      mock_app do
-        set :raise_errors, true
-        error(FooError) { "she's there." }
-        get('/') { raise FooError }
-      end
-      get '/'
-      assert_equal 500, status
-    end
-
-    it "never raises Sinatra::NotFound beyond the application" do
-      mock_app(Sinatra::Application) do
-        get('/') { raise Sinatra::NotFound }
-      end
-      get '/'
-      assert_equal 404, status
-    end
-
-    it "cascades for subclasses of Sinatra::NotFound" do
-      mock_app do
-        set :raise_errors, true
-        error(FooNotFound) { "foo! not found." }
-        get('/') { raise FooNotFound }
-      end
-      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 { "Lost, are we?" } }
-
-      get '/test'
-      assert_equal 404, status
-      assert_equal "Lost, are we?", body
-    end
-
-    it 'inherits error mappings from base class' do
-      base = Class.new(Sinatra::Base)
-      base.error(FooError) { 'base class' }
-
-      mock_app(base) do
-        set :raise_errors, false
-        get('/') { raise FooError }
-      end
-
-      get '/'
-      assert_equal 'base class', body
-    end
-
-    it 'overrides error mappings in base class' do
-      base = Class.new(Sinatra::Base)
-      base.error(FooError) { 'base class' }
-
-      mock_app(base) do
-        set :raise_errors, false
-        error(FooError) { 'subclass' }
-        get('/') { raise FooError }
-      end
-
-      get '/'
-      assert_equal 'subclass', body
-    end
-
-    it 'honors Exception#http_status 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
-
-    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 do
-        set :raise_errors, false
-        error(500) { 'Foo!' }
-        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 do
-        set :raise_errors, false
-        error(500..550) { "Error: #{response.status}" }
-        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 do
-        set :raise_errors, false
-        error(409..411, 503..509) { "Error: #{response.status}" }
-        get('/') { [507, {}, 'A very special error'] }
-      end
-      get '/'
-      assert_equal 507, status
-      assert_equal 'Error: 507', body
-    end
-  end
-end

data/test/markaby_test.rb

@@ -1,80 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-begin
-require 'markaby'
-
-class MarkabyTest < Minitest::Test
-  def markaby_app(&block)
-    mock_app do
-      set :views, File.dirname(__FILE__) + '/views'
-      get('/', &block)
-    end
-    get '/'
-  end
-
-  it 'renders inline markaby strings' do
-    markaby_app { markaby 'h1 "Hiya"' }
-    assert ok?
-    assert_equal "<h1>Hiya</h1>", body
-  end
-
-  it 'renders .markaby files in views path' do
-    markaby_app { markaby :hello }
-    assert ok?
-    assert_equal "<h1>Hello From Markaby</h1>", body
-  end
-
-  it "renders with inline layouts" do
-    mock_app do
-      layout { 'h1 { text "THIS. IS. "; yield }' }
-      get('/') { markaby 'em "SPARTA"' }
-    end
-    get '/'
-    assert ok?
-    assert_equal "<h1>THIS. IS. <em>SPARTA</em></h1>", body
-  end
-
-  it "renders with file layouts" do
-    markaby_app { markaby 'text "Hello World"', :layout => :layout2 }
-    assert ok?
-    assert_equal "<h1>Markaby Layout!</h1><p>Hello World</p>", body
-  end
-
-  it 'renders inline markaby blocks' do
-    markaby_app { markaby { h1 'Hiya' } }
-    assert ok?
-    assert_equal "<h1>Hiya</h1>", body
-  end
-
-  it 'renders inline markaby blocks with inline layouts' do
-    markaby_app do
-      settings.layout { 'h1 { text "THIS. IS. "; yield }' }
-      markaby { em 'SPARTA' }
-    end
-    assert ok?
-    assert_equal "<h1>THIS. IS. <em>SPARTA</em></h1>", body
-  end
-
-  it 'renders inline markaby blocks with file layouts' do
-    markaby_app { markaby(:layout => :layout2) { text "Hello World" } }
-    assert ok?
-    assert_equal "<h1>Markaby Layout!</h1><p>Hello World</p>", body
-  end
-
-  it "raises error if template not found" do
-    mock_app { get('/') { markaby :no_such_template } }
-    assert_raises(Errno::ENOENT) { get('/') }
-  end
-
-  it "allows passing locals" do
-    markaby_app {
-      markaby 'text value', :locals => { :value => 'foo' }
-    }
-    assert ok?
-    assert_equal 'foo', body
-  end
-end
-
-rescue LoadError
-  warn "#{$!.to_s}: skipping markaby tests"
-end

data/test/markdown_test.rb

@@ -1,85 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-MarkdownTest = proc do
-  def markdown_app(&block)
-    mock_app do
-      set :views, File.dirname(__FILE__) + '/views'
-      get('/', &block)
-    end
-    get '/'
-  end
-
-  def setup
-    Tilt.prefer engine, 'markdown', 'mkd', 'md'
-    super
-  end
-
-  it 'uses the correct engine' do
-    assert_equal engine, Tilt[:md]
-    assert_equal engine, Tilt[:mkd]
-    assert_equal engine, Tilt[:markdown]
-  end
-
-  it 'renders inline markdown strings' do
-    markdown_app { markdown '# Hiya' }
-    assert ok?
-    assert_like "<h1>Hiya</h1>\n", body
-  end
-
-  it 'renders .markdown files in views path' do
-    markdown_app { markdown :hello }
-    assert ok?
-    assert_like "<h1>Hello From Markdown</h1>", body
-  end
-
-  it "raises error if template not found" do
-    mock_app { get('/') { markdown :no_such_template } }
-    assert_raises(Errno::ENOENT) { get('/') }
-  end
-
-  it "renders with inline layouts" do
-    mock_app do
-      layout { 'THIS. IS. #{yield.upcase}!' }
-      get('/') { markdown 'Sparta', :layout_engine => :str }
-    end
-    get '/'
-    assert ok?
-    assert_like 'THIS. IS. <P>SPARTA</P>!', body
-  end
-
-  it "renders with file layouts" do
-    markdown_app {
-      markdown 'Hello World', :layout => :layout2, :layout_engine => :erb
-    }
-    assert ok?
-    assert_body "ERB Layout!\n<p>Hello World</p>"
-  end
-
-  it "can be used in a nested fashion for partials and whatnot" do
-    mock_app do
-      template(:inner) { "hi" }
-      template(:outer) { "<outer><%= markdown :inner %></outer>" }
-      get('/') { erb :outer }
-    end
-
-    get '/'
-    assert ok?
-    assert_like '<outer><p>hi</p></outer>', body
-  end
-end
-
-# Will generate RDiscountTest, KramdownTest, etc.
-map = Tilt.respond_to?(:lazy_map) ? Tilt.lazy_map['md'].map(&:first) : Tilt.mappings['md']
-
-map.each do |t|
-  begin
-    t = eval(t) if t.is_a? String
-    t.new { "" }
-    klass = Class.new(Minitest::Test) { define_method(:engine) { t }}
-    klass.class_eval(&MarkdownTest)
-    name = t.name[/[^:]+$/].sub(/Template$/, '') << "Test"
-    Object.const_set name, klass
-  rescue LoadError, NameError
-    warn "#{$!}: skipping markdown tests with #{t}"
-  end
-end

data/test/mediawiki_test.rb

@@ -1,68 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-begin
-  require 'wikicloth'
-
-  class MediaWikiTest < Minitest::Test
-    def mediawiki_app(&block)
-      mock_app do
-        set :views, File.dirname(__FILE__) + '/views'
-        get('/', &block)
-      end
-      get '/'
-    end
-
-    it 'supports both .mw and .mediawiki extensions' do
-      assert_equal Tilt[:mw], Tilt[:mediawiki]
-    end
-
-    it 'renders inline mediawiki strings' do
-      mediawiki_app { mediawiki "''Hiya''" }
-      assert ok?
-      assert_include body, '<i>Hiya</i>'
-    end
-
-    it 'renders .mediawiki files in views path' do
-      mediawiki_app { mediawiki :hello }
-      assert ok?
-      assert_include body, "<i>Hello from MediaWiki</i>"
-    end
-
-    it 'raises error if template not found' do
-      mock_app { get('/') { mediawiki :no_such_template } }
-      assert_raises(Errno::ENOENT) { get('/') }
-    end
-
-    it 'renders with inline layouts' do
-      mock_app do
-        layout { 'THIS. IS. #{yield.upcase}!' }
-        get('/') { mediawiki 'Sparta', :layout_engine => :str }
-      end
-      get '/'
-      assert ok?
-      assert_like 'THIS. IS. <P>SPARTA</P>!', body
-    end
-
-    it 'renders with file layouts' do
-      mediawiki_app do
-        mediawiki 'Hello World', :layout => :layout2, :layout_engine => :erb
-      end
-      assert ok?
-      assert_body "ERB Layout!\n<p>Hello World</p>"
-    end
-
-    it 'can be used in a nested fashion for partials and whatnot' do
-      mock_app do
-        template(:inner) { "hi" }
-        template(:outer) { "<outer><%= mediawiki :inner %></outer>" }
-        get('/') { erb :outer }
-      end
-
-      get '/'
-      assert ok?
-      assert_like '<outer><p>hi</p></outer>', body
-    end
-  end
-rescue LoadError
-  warn "#{$!.to_s}: skipping mediawiki tests"
-end

data/test/middleware_test.rb

@@ -1,68 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class MiddlewareTest < Minitest::Test
-  setup do
-    @app = mock_app(Sinatra::Application) do
-      get('/*')do
-        response.headers['X-Tests'] = env['test.ran'].
-          map { |n| n.split('::').last }.
-          join(', ')
-        env['PATH_INFO']
-      end
-    end
-  end
-
-  class MockMiddleware < Struct.new(:app)
-    def call(env)
-      (env['test.ran'] ||= []) << self.class.to_s
-      app.call(env)
-    end
-  end
-
-  class UpcaseMiddleware < MockMiddleware
-    def call(env)
-      env['PATH_INFO'] = env['PATH_INFO'].upcase
-      super
-    end
-  end
-
-  it "is added with Sinatra::Application.use" do
-    @app.use UpcaseMiddleware
-    get '/hello-world'
-    assert ok?
-    assert_equal '/HELLO-WORLD', body
-  end
-
-  class DowncaseMiddleware < MockMiddleware
-    def call(env)
-      env['PATH_INFO'] = env['PATH_INFO'].downcase
-      super
-    end
-  end
-
-  it "runs in the order defined" do
-    @app.use UpcaseMiddleware
-    @app.use DowncaseMiddleware
-    get '/Foo'
-    assert_equal "/foo", body
-    assert_equal "UpcaseMiddleware, DowncaseMiddleware", response['X-Tests']
-  end
-
-  it "resets the prebuilt pipeline when new middleware is added" do
-    @app.use UpcaseMiddleware
-    get '/Foo'
-    assert_equal "/FOO", body
-    @app.use DowncaseMiddleware
-    get '/Foo'
-    assert_equal '/foo', body
-    assert_equal "UpcaseMiddleware, DowncaseMiddleware", response['X-Tests']
-  end
-
-  it "works when app is used as middleware" do
-    @app.use UpcaseMiddleware
-    @app = @app.new
-    get '/Foo'
-    assert_equal "/FOO", body
-    assert_equal "UpcaseMiddleware", response['X-Tests']
-  end
-end

data/test/nokogiri_test.rb

@@ -1,67 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-begin
-require 'nokogiri'
-
-class NokogiriTest < Minitest::Test
-  def nokogiri_app(&block)
-    mock_app do
-      set :views, File.dirname(__FILE__) + '/views'
-      get('/', &block)
-    end
-    get '/'
-  end
-
-  it 'renders inline Nokogiri strings' do
-    nokogiri_app { nokogiri 'xml' }
-    assert ok?
-    assert_body %(<?xml version="1.0"?>\n)
-  end
-
-  it 'renders inline blocks' do
-    nokogiri_app do
-      @name = "Frank & Mary"
-      nokogiri { |xml| xml.couple @name }
-    end
-    assert ok?
-    assert_body %(<?xml version="1.0"?>\n<couple>Frank &amp; Mary</couple>\n)
-  end
-
-  it 'renders .nokogiri files in views path' do
-    nokogiri_app do
-      @name = "Blue"
-      nokogiri :hello
-    end
-    assert ok?
-    assert_body "<?xml version=\"1.0\"?>\n<exclaim>You're my boy, Blue!</exclaim>\n"
-  end
-
-  it "renders with inline layouts" do
-    next if Tilt::VERSION <= "1.1"
-    mock_app do
-      layout { %(xml.layout { xml << yield }) }
-      get('/') { nokogiri %(xml.em 'Hello World') }
-    end
-    get '/'
-    assert ok?
-    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 {
-      nokogiri %(xml.em 'Hello World'), :layout => :layout2
-    }
-    assert ok?
-    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
-    mock_app { get('/') { nokogiri :no_such_template } }
-    assert_raises(Errno::ENOENT) { get('/') }
-  end
-end
-
-rescue LoadError
-  warn "#{$!.to_s}: skipping nokogiri tests"
-end

data/test/public/hello+world.txt

@@ -1 +0,0 @@
-This is a test intended for the + sign in urls for static serving