sinatra-sinatra 0.8.9

data/test/middleware_test.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe "Middleware" do
+  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'
+    assert ok?
+    assert_equal '/HELLO-WORLD', body
+  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'
+    assert_equal "/foo", body
+    assert_equal "UpcaseMiddleware, DowncaseMiddleware", response['X-Tests']
+  end
+
+  specify "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
+end

data/test/options_test.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe 'Options' do
+  before { @app = Class.new(Sinatra::Base) }
+
+  it 'sets options to literal values' do
+    @app.set(:foo, 'bar')
+    assert @app.respond_to?(:foo)
+    assert_equal 'bar', @app.foo
+  end
+
+  it 'sets options to Procs' do
+    @app.set(:foo, Proc.new { 'baz' })
+    assert @app.respond_to?(:foo)
+    assert_equal 'baz', @app.foo
+  end
+
+  it "sets multiple options with a Hash" do
+    @app.set :foo => 1234,
+        :bar => 'Hello World',
+        :baz => Proc.new { 'bizzle' }
+    assert_equal 1234, @app.foo
+    assert_equal 'Hello World', @app.bar
+    assert_equal 'bizzle', @app.baz
+  end
+
+  it 'inherits option methods when subclassed' do
+    @app.set :foo, 'bar'
+    @app.set :biz, Proc.new { 'baz' }
+
+    sub = Class.new(@app)
+    assert sub.respond_to?(:foo)
+    assert_equal 'bar', sub.foo
+    assert sub.respond_to?(:biz)
+    assert_equal 'baz', sub.biz
+  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'
+    assert_equal 'bling', sub.foo
+    assert_equal 'bar', @app.foo
+  end
+
+  it 'creates setter methods when first defined' do
+    @app.set :foo, 'bar'
+    assert @app.respond_to?('foo=')
+    @app.foo = 'biz'
+    assert_equal 'biz', @app.foo
+  end
+
+  it 'creates predicate methods when first defined' do
+    @app.set :foo, 'hello world'
+    assert @app.respond_to?(:foo?)
+    assert @app.foo?
+    @app.set :foo, nil
+    assert !@app.foo?
+  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'
+    assert_equal 'oops', @app.foo
+  end
+
+  it "sets multiple options to true with #enable" do
+    @app.enable :sessions, :foo, :bar
+    assert @app.sessions
+    assert @app.foo
+    assert @app.bar
+  end
+
+  it "sets multiple options to false with #disable" do
+    @app.disable :sessions, :foo, :bar
+    assert !@app.sessions
+    assert !@app.foo
+    assert !@app.bar
+  end
+
+  it 'enables MethodOverride middleware when :methodoverride is enabled' do
+    @app.set :methodoverride, true
+    @app.put('/') { 'okay' }
+    post '/', {'_method'=>'PUT'}, {}
+    assert_equal 200, status
+    assert_equal 'okay', body
+  end
+end

data/test/reload_test.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/helper'
+
+$reload_count = 0
+$reload_app = nil
+
+describe "Reloading" do
+  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
+    assert_same true, @app.reload
+    assert_same true, @app.reload?
+  end
+
+  it 'is disabled by default when running in non-development environment' do
+    @app.set :app_file, __FILE__
+    @app.set :environment, :test
+    assert !@app.reload
+    assert_same false, @app.reload?
+  end
+
+  it 'is disabled by default when no app_file is available' do
+    @app.set :app_file, nil
+    @app.set :environment, :development
+    assert !@app.reload
+    assert_same false, @app.reload?
+  end
+
+  it 'can be turned off explicitly' do
+    @app.set :app_file, __FILE__
+    @app.set :environment, :development
+    assert_same true, @app.reload
+    @app.set :reload, false
+    assert_same false, @app.reload
+    assert_same false, @app.reload?
+  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 '/'
+    assert_equal 200, status
+    assert_equal 'Hello from reload file', body
+    assert_equal 1, $reload_count
+
+    get '/'
+    assert_equal 200, status
+    assert_equal 'Hello from reload file', body
+    assert_equal 2, $reload_count
+  end
+end

data/test/request_test.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe 'Sinatra::Request' do
+  it 'responds to #user_agent' do
+    request = Sinatra::Request.new({'HTTP_USER_AGENT' => 'Test'})
+    assert request.respond_to?(:user_agent)
+    assert_equal 'Test', request.user_agent
+  end
+end

data/test/result_test.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe 'Result Handling' do
+  it "sets response.body when result is a String" do
+    mock_app {
+      get '/' do
+        'Hello World'
+      end
+    }
+
+    get '/'
+    assert ok?
+    assert_equal 'Hello World', body
+  end
+
+  it "sets response.body when result is an Array of Strings" do
+    mock_app {
+      get '/' do
+        ['Hello', 'World']
+      end
+    }
+
+    get '/'
+    assert ok?
+    assert_equal 'HelloWorld', body
+  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 '/'
+    assert ok?
+    assert_equal 'Hello World', body
+  end
+
+  it "sets response.body to [] when result is nil" do
+    mock_app {
+      get '/' do
+        nil
+      end
+    }
+
+    get '/'
+    assert ok?
+    assert_equal '', body
+  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 '/'
+    assert_equal 205, status
+    assert_equal 'foo/bar', response['Content-Type']
+    assert_equal 'Hello World', body
+  end
+
+  it "sets status and body when result is a two-tuple" do
+    mock_app {
+      get '/' do
+        [409, 'formula of']
+      end
+    }
+
+    get '/'
+    assert_equal 409, status
+    assert_equal 'formula of', body
+  end
+
+  it "sets status when result is a Fixnum status code" do
+    mock_app {
+      get('/') { 205 }
+    }
+
+    get '/'
+    assert_equal 205, status
+    assert_equal '', body
+  end
+end

data/test/routing_test.rb

@@ -0,0 +1,334 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe "Routing" do
+  %w[get put post delete head].each do |verb|
+    it "defines #{verb.upcase} request handlers with #{verb}" do
+      mock_app {
+        send verb, '/hello' do
+          'Hello World'
+        end
+      }
+
+      request = Rack::MockRequest.new(@app)
+      response = request.request(verb.upcase, '/hello', {})
+      assert response.ok?
+      assert_equal 'Hello World', response.body
+    end
+  end
+
+  it "404s when no route satisfies the request" do
+    mock_app {
+      get('/foo') { }
+    }
+    get '/bar'
+    assert_equal 404, status
+  end
+
+  it "exposes params with indifferent hash" do
+    mock_app {
+      get '/:foo' do
+        fail unless params['foo'] == 'bar'
+        fail unless params[:foo] == 'bar'
+        'well, alright'
+      end
+    }
+    get '/bar'
+    assert_equal 'well, alright', body
+  end
+
+  it "merges named params and query string params in params" do
+    mock_app {
+      get '/:foo' do
+        fail unless params['foo'] == 'bar'
+        fail unless params['baz'] == 'biz'
+      end
+    }
+    get '/bar?baz=biz'
+    assert ok?
+  end
+
+  it "supports named params like /hello/:person" do
+    mock_app {
+      get '/hello/:person' do
+        "Hello #{params['person']}"
+      end
+    }
+    get '/hello/Frank'
+    assert_equal 'Hello Frank', body
+  end
+
+  it "supports optional named params like /?:foo?/?:bar?" do
+    mock_app {
+      get '/?:foo?/?:bar?' do
+        "foo=#{params[:foo]};bar=#{params[:bar]}"
+      end
+    }
+
+    get '/hello/world'
+    assert ok?
+    assert_equal "foo=hello;bar=world", body
+
+    get '/hello'
+    assert ok?
+    assert_equal "foo=hello;bar=", body
+
+    get '/'
+    assert ok?
+    assert_equal "foo=;bar=", body
+  end
+
+  it "supports single splat params like /*" do
+    mock_app {
+      get '/*' do
+        fail unless params['splat'].kind_of?(Array)
+        params['splat'].join "\n"
+      end
+    }
+
+    get '/foo'
+    assert_equal "foo", body
+
+    get '/foo/bar/baz'
+    assert_equal "foo/bar/baz", body
+  end
+
+  it "supports mixing multiple splat params like /*/foo/*/*" do
+    mock_app {
+      get '/*/foo/*/*' do
+        fail unless params['splat'].kind_of?(Array)
+        params['splat'].join "\n"
+      end
+    }
+
+    get '/bar/foo/bling/baz/boom'
+    assert_equal "bar\nbling\nbaz/boom", body
+
+    get '/bar/foo/baz'
+    assert not_found?
+  end
+
+  it "supports mixing named and splat params like /:foo/*" do
+    mock_app {
+      get '/:foo/*' do
+        fail unless params['foo'] == 'foo'
+        fail unless params['splat'] == ['bar/baz']
+      end
+    }
+
+    get '/foo/bar/baz'
+    assert ok?
+  end
+
+  it "supports paths that include spaces" do
+    mock_app {
+      get '/path with spaces' do
+        'looks good'
+      end
+    }
+
+    get '/path%20with%20spaces'
+    assert ok?
+    assert_equal 'looks good', body
+  end
+
+  it "URL decodes named parameters and splats" do
+    mock_app {
+      get '/:foo/*' do
+        fail unless params['foo'] == 'hello world'
+        fail unless params['splat'] == ['how are you']
+        nil
+      end
+    }
+
+    get '/hello%20world/how%20are%20you'
+    assert ok?
+  end
+
+  it 'supports regular expressions' do
+    mock_app {
+      get(/^\/foo...\/bar$/) do
+        'Hello World'
+      end
+    }
+
+    get '/foooom/bar'
+    assert ok?
+    assert_equal 'Hello World', body
+  end
+
+  it 'makes regular expression captures available in params[:captures]' do
+    mock_app {
+      get(/^\/fo(.*)\/ba(.*)/) do
+        fail unless params[:captures] == ['orooomma', 'f']
+        'right on'
+      end
+    }
+
+    get '/foorooomma/baf'
+    assert ok?
+    assert_equal 'right on', body
+  end
+
+  it "returns response immediately on halt" do
+    mock_app {
+      get '/' do
+        halt 'Hello World'
+        'Boo-hoo World'
+      end
+    }
+
+    get '/'
+    assert ok?
+    assert_equal 'Hello World', body
+  end
+
+  it "transitions to the next matching route on pass" do
+    mock_app {
+      get '/:foo' do
+        pass
+        'Hello Foo'
+      end
+
+      get '/*' do
+        fail if params.include?('foo')
+        'Hello World'
+      end
+    }
+
+    get '/bar'
+    assert ok?
+    assert_equal 'Hello World', body
+  end
+
+  it "transitions to 404 when passed and no subsequent route matches" do
+    mock_app {
+      get '/:foo' do
+        pass
+        'Hello Foo'
+      end
+    }
+
+    get '/bar'
+    assert not_found?
+  end
+
+  it "passes when matching condition returns false" do
+    mock_app {
+      condition { params[:foo] == 'bar' }
+      get '/:foo' do
+        'Hello World'
+      end
+    }
+
+    get '/bar'
+    assert ok?
+    assert_equal 'Hello World', body
+
+    get '/foo'
+    assert not_found?
+  end
+
+  it "does not pass when matching condition returns nil" do
+    mock_app {
+      condition { nil }
+      get '/:foo' do
+        'Hello World'
+      end
+    }
+
+    get '/bar'
+    assert ok?
+    assert_equal 'Hello World', body
+  end
+
+  it "passes to next route when condition calls pass explicitly" do
+    mock_app {
+      condition { pass unless params[:foo] == 'bar' }
+      get '/:foo' do
+        'Hello World'
+      end
+    }
+
+    get '/bar'
+    assert ok?
+    assert_equal 'Hello World', body
+
+    get '/foo'
+    assert not_found?
+  end
+
+  it "passes to the next route when host_name does not match" do
+    mock_app {
+      host_name 'example.com'
+      get '/foo' do
+        'Hello World'
+      end
+    }
+    get '/foo'
+    assert not_found?
+
+    get '/foo', :env => { 'HTTP_HOST' => 'example.com' }
+    assert_equal 200, status
+    assert_equal 'Hello World', body
+  end
+
+  it "passes to the next route when user_agent does not match" do
+    mock_app {
+      user_agent(/Foo/)
+      get '/foo' do
+        'Hello World'
+      end
+    }
+    get '/foo'
+    assert not_found?
+
+    get '/foo', :env => { 'HTTP_USER_AGENT' => 'Foo Bar' }
+    assert_equal 200, status
+    assert_equal 'Hello World', body
+  end
+
+  it "makes captures in user agent pattern available in params[:agent]" do
+    mock_app {
+      user_agent(/Foo (.*)/)
+      get '/foo' do
+        'Hello ' + params[:agent].first
+      end
+    }
+    get '/foo', :env => { 'HTTP_USER_AGENT' => 'Foo Bar' }
+    assert_equal 200, status
+    assert_equal 'Hello Bar', body
+  end
+
+  it "filters by accept header" do
+    mock_app {
+      get '/', :provides => :xml do
+        request.env['HTTP_ACCEPT']
+      end
+    }
+
+    get '/', :env => { :accept => 'application/xml' }
+    assert ok?
+    assert_equal 'application/xml', body
+    assert_equal 'application/xml', response.headers['Content-Type']
+
+    get '/', :env => { :accept => 'text/html' }
+    assert !ok?
+  end
+
+  it "allows multiple mime types for accept header" do
+    types = ['image/jpeg', 'image/pjpeg']
+
+    mock_app {
+      get '/', :provides => types do
+        request.env['HTTP_ACCEPT']
+      end
+    }
+
+    types.each do |type|
+      get '/', :env => { :accept => type }
+      assert ok?
+      assert_equal type, body
+      assert_equal type, response.headers['Content-Type']
+    end
+  end
+end

data/test/sass_test.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe "Sass Templates" do
+  def sass_app(&block)
+    mock_app {
+      set :views, File.dirname(__FILE__) + '/views'
+      get '/', &block
+    }
+    get '/'
+  end
+
+  it 'renders inline Sass strings' do
+    sass_app { sass "#sass\n  :background-color #FFF\n" }
+    assert ok?
+    assert_equal "#sass {\n  background-color: #FFF; }\n", body
+  end
+
+  it 'renders .sass files in views path' do
+    sass_app { sass :hello }
+    assert ok?
+    assert_equal "#sass {\n  background-color: #FFF; }\n", body
+  end
+
+  it 'ignores the layout option' do
+    sass_app { sass :hello, :layout => :layout2 }
+    assert ok?
+    assert_equal "#sass {\n  background-color: #FFF; }\n", body
+  end
+
+  it "raises error if template not found" do
+    mock_app {
+      get('/') { sass :no_such_template }
+    }
+    assert_raise(Errno::ENOENT) { get('/') }
+  end
+end

data/test/sinatra_test.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe 'Sinatra' do
+  it 'creates a new Sinatra::Base subclass on new' do
+    app =
+      Sinatra.new do
+        get '/' do
+          'Hello World'
+        end
+      end
+    assert_same Sinatra::Base, app.superclass
+  end
+end