rtomayko-sinatra 0.3.3 → 0.8.9

data/test/mapped_error_test.rb

@@ -1,72 +1,164 @@
-require File.dirname(__FILE__) + '/helper'
+require 'test/spec'
+require 'sinatra/base'
+require 'sinatra/test'
 
-class FooError < RuntimeError; end
+describe 'Exception Mappings' do
+  include Sinatra::Test
 
-context "Mapped errors" do
-
-  setup do
-    Sinatra.application = nil
-    Sinatra.application.options.raise_errors = false
+  class FooError < RuntimeError
   end
 
-  specify "are rescued and run in context" do
-
-    error FooError do
-      'MAPPED ERROR!'
-    end
-
-    get '/' do
-      raise FooError
-    end
-
-    get_it '/'
-
-    should.be.server_error
-    body.should.equal 'MAPPED ERROR!'
-
+  it 'invokes handlers registered with ::error when raised' do
+    mock_app {
+      set :raise_errors, false
+      error(FooError) { 'Foo!' }
+      get '/' do
+        raise FooError
+      end
+    }
+    get '/'
+    status.should.equal 500
+    body.should.equal 'Foo!'
   end
 
-  specify "renders empty if no each method on result" do
+  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 '/'
+    status.should.equal 500
+    body.should.equal 'Exception!'
+  end
 
-    error FooError do
-      nil
-    end
+  it "sets env['sinatra.error'] to the rescued exception" do
+    mock_app {
+      set :raise_errors, false
+      error(FooError) {
+        env.should.include 'sinatra.error'
+        env['sinatra.error'].should.be.kind_of FooError
+        'looks good'
+      }
+      get '/' do
+        raise FooError
+      end
+    }
+    get '/'
+    body.should.equal 'looks good'
+  end
 
-    get '/' do
-      raise FooError
-    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_it '/'
+    get '/'
+    status.should.equal 500
+    @response.errors.should.match(/FooError - BOOM!:/)
+  end
 
-    should.be.server_error
-    body.should.be.empty
+  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
+    }
+    lambda { get '/' }.should.raise FooError
+  end
 
+  it "never raises Sinatra::NotFound beyond the application" do
+    mock_app {
+      set :raise_errors, true
+      get '/' do
+        raise Sinatra::NotFound
+      end
+    }
+    lambda { get '/' }.should.not.raise Sinatra::NotFound
+    status.should.equal 404
   end
 
-  specify "doesn't override status if set" do
+  class FooNotFound < Sinatra::NotFound
+  end
 
-    error FooError do
-      status(200)
-    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
+    }
+    lambda { get '/' }.should.not.raise FooNotFound
+    status.should.equal 404
+    body.should.equal 'foo! not found.'
+  end
 
-    get '/' do
-      raise FooError
-    end
+  it 'has a not_found method for backwards compatibility' do
+    mock_app {
+      not_found do
+        "Lost, are we?"
+      end
+    }
 
-    get_it '/'
+    get '/test'
+    status.should.equal 404
+    body.should.equal "Lost, are we?"
+  end
+end
 
-    should.be.ok
+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 '/'
+    status.should.equal 500
+    body.should.equal 'Foo!'
+  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 '/'
+    status.should.equal 507
+    body.should.equal 'Error: 507'
   end
 
-  specify "raises errors when the raise_errors option is set" do
-    Sinatra.application.options.raise_errors = true
-    error FooError do
-    end
-    get '/' do
-      raise FooError
-    end
-    assert_raises(FooError) { get_it('/') }
+  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 '/'
+    status.should.equal 502
+    body.should.equal 'from custom error page'
+  end
 end

data/test/middleware_test.rb

@@ -0,0 +1,63 @@
+require 'test/spec'
+require 'sinatra/base'
+require 'sinatra/test'
+
+describe "Middleware" do
+  include Sinatra::Test
+
+  before do
+    @app = mock_app(Sinatra::Default) {
+      get '/*' do
+        response.headers['X-Tests'] = env['test.ran'].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'
+    response.should.be.ok
+    body.should.equal '/HELLO-WORLD'
+  end
+
+  class DowncaseMiddleware < MockMiddleware
+    def call(env)
+      env['PATH_INFO'] = env['PATH_INFO'].downcase
+      super
+    end
+  end
+
+  specify "runs in the order defined" do
+    @app.use UpcaseMiddleware
+    @app.use DowncaseMiddleware
+    get '/Foo'
+    body.should.equal "/foo"
+    response['X-Tests'].should.equal "UpcaseMiddleware, DowncaseMiddleware"
+  end
+
+  specify "resets the prebuilt pipeline when new middleware is added" do
+    @app.use UpcaseMiddleware
+    get '/Foo'
+    body.should.equal "/FOO"
+    @app.use DowncaseMiddleware
+    get '/Foo'
+    body.should.equal '/foo'
+    response['X-Tests'].should.equal "UpcaseMiddleware, DowncaseMiddleware"
+  end
+
+end

data/test/options_test.rb

@@ -0,0 +1,103 @@
+require 'test/spec'
+require 'sinatra/base'
+require 'sinatra/test'
+
+describe 'Options' do
+  include Sinatra::Test
+
+  before do
+    @app = Class.new(Sinatra::Base)
+  end
+
+  it 'sets options to literal values' do
+    @app.set(:foo, 'bar')
+    @app.should.respond_to? :foo
+    @app.foo.should.equal 'bar'
+  end
+
+  it 'sets options to Procs' do
+    @app.set(:foo, Proc.new { 'baz' })
+    @app.should.respond_to? :foo
+    @app.foo.should.equal 'baz'
+  end
+
+  it "sets multiple options with a Hash" do
+    @app.set :foo => 1234,
+        :bar => 'Hello World',
+        :baz => Proc.new { 'bizzle' }
+    @app.foo.should.equal 1234
+    @app.bar.should.equal 'Hello World'
+    @app.baz.should.equal 'bizzle'
+  end
+
+  it 'inherits option methods when subclassed' do
+    @app.set :foo, 'bar'
+    @app.set :biz, Proc.new { 'baz' }
+
+    sub = Class.new(@app)
+    sub.should.respond_to :foo
+    sub.foo.should.equal 'bar'
+    sub.should.respond_to :biz
+    sub.biz.should.equal 'baz'
+  end
+
+  it 'overrides options in subclass' do
+    @app.set :foo, 'bar'
+    @app.set :biz, Proc.new { 'baz' }
+    sub = Class.new(@app)
+    sub.set :foo, 'bling'
+    sub.foo.should.equal 'bling'
+    @app.foo.should.equal 'bar'
+  end
+
+  it 'creates setter methods when first defined' do
+    @app.set :foo, 'bar'
+    @app.should.respond_to 'foo='
+    @app.foo = 'biz'
+    @app.foo.should.equal 'biz'
+  end
+
+  it 'creates predicate methods when first defined' do
+    @app.set :foo, 'hello world'
+    @app.should.respond_to :foo?
+    @app.foo?.should.be true
+    @app.set :foo, nil
+    @app.foo?.should.be false
+  end
+
+  it 'uses existing setter methods if detected' do
+    class << @app
+      def foo
+        @foo
+      end
+      def foo=(value)
+        @foo = 'oops'
+      end
+    end
+
+    @app.set :foo, 'bam'
+    @app.foo.should.equal 'oops'
+  end
+
+  it "sets multiple options to true with #enable" do
+    @app.enable :sessions, :foo, :bar
+    @app.sessions.should.be true
+    @app.foo.should.be true
+    @app.bar.should.be true
+  end
+
+  it "sets multiple options to false with #disable" do
+    @app.disable :sessions, :foo, :bar
+    @app.sessions.should.be false
+    @app.foo.should.be false
+    @app.bar.should.be false
+  end
+
+  it 'enables MethodOverride middleware when :methodoverride is enabled' do
+    @app.set :methodoverride, true
+    @app.put('/') { 'okay' }
+    post '/', {'_method'=>'PUT'}, {}
+    status.should.equal 200
+    body.should.equal 'okay'
+  end
+end

data/test/reload_test.rb

@@ -0,0 +1,65 @@
+require 'test/spec'
+require 'sinatra/base'
+require 'sinatra/test'
+
+$reload_count = 0
+$reload_app = nil
+
+describe "Reloading" do
+  include Sinatra::Test
+
+  before {
+    @app = mock_app(Sinatra::Default)
+    $reload_app = @app
+  }
+
+  after {
+    $reload_app = nil
+  }
+
+  it 'is enabled by default when in development and the app_file is set' do
+    @app.set :app_file, __FILE__
+    @app.set :environment, :development
+    @app.reload.should.be true
+    @app.reload?.should.be true
+  end
+
+  it 'is disabled by default when running in non-development environment' do
+    @app.set :app_file, __FILE__
+    @app.set :environment, :test
+    @app.reload.should.not.be true
+    @app.reload?.should.be false
+  end
+
+  it 'is disabled by default when no app_file is available' do
+    @app.set :app_file, nil
+    @app.set :environment, :development
+    @app.reload.should.not.be true
+    @app.reload?.should.be false
+  end
+
+  it 'can be turned off explicitly' do
+    @app.set :app_file, __FILE__
+    @app.set :environment, :development
+    @app.reload.should.be true
+    @app.set :reload, false
+    @app.reload.should.be false
+    @app.reload?.should.be false
+  end
+
+  it 'reloads the app_file each time a request is made' do
+    @app.set :app_file, File.dirname(__FILE__) + '/data/reload_app_file.rb'
+    @app.set :reload, true
+    @app.get('/') { 'Hello World' }
+
+    get '/'
+    status.should.equal 200
+    body.should.equal 'Hello from reload file'
+    $reload_count.should.equal 1
+
+    get '/'
+    status.should.equal 200
+    body.should.equal 'Hello from reload file'
+    $reload_count.should.equal 2
+  end
+end

data/test/request_test.rb

@@ -0,0 +1,11 @@
+require 'test/spec'
+require 'sinatra/base'
+require 'sinatra/test'
+
+describe 'Sinatra::Request' do
+  it 'responds to #user_agent' do
+    request = Sinatra::Request.new({'HTTP_USER_AGENT' => 'Test'})
+    request.should.respond_to :user_agent
+    request.user_agent.should.equal 'Test'
+  end
+end

data/test/result_test.rb

@@ -0,0 +1,92 @@
+require 'test/spec'
+require 'sinatra/base'
+require 'sinatra/test'
+
+describe 'Result Handling' do
+  include Sinatra::Test
+
+  it "sets response.body when result is a String" do
+    mock_app {
+      get '/' do
+        'Hello World'
+      end
+    }
+
+    get '/'
+    should.be.ok
+    body.should.equal 'Hello World'
+  end
+
+  it "sets response.body when result is an Array of Strings" do
+    mock_app {
+      get '/' do
+        ['Hello', 'World']
+      end
+    }
+
+    get '/'
+    should.be.ok
+    body.should.equal 'HelloWorld'
+  end
+
+  it "sets response.body when result responds to #each" do
+    mock_app {
+      get '/' do
+        res = lambda { 'Hello World' }
+        def res.each ; yield call ; end
+        res
+      end
+    }
+
+    get '/'
+    should.be.ok
+    body.should.equal 'Hello World'
+  end
+
+  it "sets response.body to [] when result is nil" do
+    mock_app {
+      get '/' do
+        nil
+      end
+    }
+
+    get '/'
+    should.be.ok
+    body.should.equal ''
+  end
+
+  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']
+      end
+    }
+
+    get '/'
+    status.should.equal 205
+    response['Content-Type'].should.equal 'foo/bar'
+    body.should.equal 'Hello World'
+  end
+
+  it "sets status and body when result is a two-tuple" do
+    mock_app {
+      get '/' do
+        [409, 'formula of']
+      end
+    }
+
+    get '/'
+    status.should.equal 409
+    body.should.equal 'formula of'
+  end
+
+  it "sets status when result is a Fixnum status code" do
+    mock_app {
+      get('/') { 205 }
+    }
+
+    get '/'
+    status.should.equal 205
+    body.should.be.empty
+  end
+end