jellyfish 0.4.0 → 0.5.0

data/sinatra/mapped_error_test.rb

@@ -0,0 +1,259 @@
+require File.expand_path('../helper', __FILE__)
+
+class FooError < RuntimeError
+end
+
+class FooNotFound < Sinatra::NotFound
+end
+
+class FooSpecialError < RuntimeError
+  def code; 501 end
+end
+
+class MappedErrorTest < Test::Unit::TestCase
+  def test_default
+    assert true
+  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
+    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
+        error(Exception) { 'Exception!' }
+        get '/' do
+          raise FooError
+        end
+      }
+
+      get '/'
+      assert_equal 500, status
+      assert_equal 'Exception!', body
+    end
+
+    it 'walks down inheritance chain for errors' do
+      mock_app {
+        set :raise_errors, false
+        error(RuntimeError) { 'Exception!' }
+        get '/' do
+          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 {
+        set :raise_errors, false
+        error(Exception) { 'Exception!' }
+        error(FooError) { 'FooError!' }
+        error(RuntimeError) { 'Exception!' }
+        get '/' do
+          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 {
+        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 errors from the app when raise_errors set and no handler defined" do
+      mock_app {
+        set :raise_errors, true
+        get '/' do
+          raise FooError
+        end
+      }
+      assert_raise(FooError) { get '/' }
+    end
+
+    it "calls error handlers before raising errors even when raise_errors is set" do
+      mock_app {
+        set :raise_errors, true
+        error(FooError) { "she's there." }
+        get '/' do
+          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 }}
+      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
+      }
+
+      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) {
+        set :raise_errors, false
+        get '/' do
+          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) {
+        set :raise_errors, false
+        error(FooError) { 'subclass' }
+        get '/' do
+          raise FooError
+        end
+      }
+
+      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
+    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
+
+    it 'allows passing more than one range' do
+      mock_app {
+        set :raise_errors, false
+        error(409..411, 503..509) { "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/sinatra/markaby_test.rb

@@ -0,0 +1,80 @@
+require File.expand_path('../helper', __FILE__)
+
+begin
+require 'markaby'
+
+class MarkabyTest < Test::Unit::TestCase
+  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_raise(Errno::ENOENT) { get('/') }
+  end
+  
+  it "allows passing locals" do
+    markaby_app do
+      markaby 'text value', :locals => { :value => 'foo' }
+    end
+    assert ok?
+    assert_equal 'foo', body
+  end
+end
+
+rescue LoadError
+  warn "#{$!.to_s}: skipping markaby tests"
+end

data/sinatra/markdown_test.rb

@@ -0,0 +1,81 @@
+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_raise(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 '/' do
+        erb :outer
+      end
+    end
+
+    get '/'
+    assert ok?
+    assert_like '<outer><p>hi</p></outer>', body
+  end
+end
+
+# Will generate RDiscountTest, KramdownTest, etc.
+Tilt.mappings['md'].each do |t|
+  begin
+    t.new { "" }
+    klass = Class.new(Test::Unit::TestCase) { define_method(:engine) { t }}
+    klass.class_eval(&MarkdownTest)
+    Object.const_set t.name[/[^:]+(?=Template$)/] << "Test", klass
+  rescue LoadError
+    warn "#{$!}: skipping markdown tests with #{t}"
+  end
+end

data/sinatra/middleware_test.rb

@@ -0,0 +1,68 @@
+require File.expand_path('../helper', __FILE__)
+
+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 }.
+          join(', ')
+        env['PATH_INFO']
+      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