rtomayko-sinatra 0.8.10 → 0.9.0

data/test/middleware_test.rb

@@ -1,6 +1,10 @@
-require File.dirname(__FILE__) + '/helper'
+require 'test/spec'
+require 'sinatra/base'
+require 'sinatra/test'
 
 describe "Middleware" do
+  include Sinatra::Test
+
   before do
     @app = mock_app(Sinatra::Default) {
       get '/*' do
@@ -27,8 +31,8 @@ describe "Middleware" do
   it "is added with Sinatra::Application.use" do
     @app.use UpcaseMiddleware
     get '/hello-world'
-    assert ok?
-    assert_equal '/HELLO-WORLD', body
+    response.should.be.ok
+    body.should.equal '/HELLO-WORLD'
   end
 
   class DowncaseMiddleware < MockMiddleware
@@ -42,17 +46,18 @@ describe "Middleware" do
     @app.use UpcaseMiddleware
     @app.use DowncaseMiddleware
     get '/Foo'
-    assert_equal "/foo", body
-    assert_equal "UpcaseMiddleware, DowncaseMiddleware", response['X-Tests']
+    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'
-    assert_equal "/FOO", body
+    body.should.equal "/FOO"
     @app.use DowncaseMiddleware
     get '/Foo'
-    assert_equal '/foo', body
-    assert_equal "UpcaseMiddleware, DowncaseMiddleware", response['X-Tests']
+    body.should.equal '/foo'
+    response['X-Tests'].should.equal "UpcaseMiddleware, DowncaseMiddleware"
   end
+
 end

data/test/options_test.rb

@@ -1,27 +1,33 @@
-require File.dirname(__FILE__) + '/helper'
+require 'test/spec'
+require 'sinatra/base'
+require 'sinatra/test'
 
 describe 'Options' do
-  before { @app = Class.new(Sinatra::Base) }
+  include Sinatra::Test
+
+  before do
+    @app = Class.new(Sinatra::Base)
+  end
 
   it 'sets options to literal values' do
     @app.set(:foo, 'bar')
-    assert @app.respond_to?(:foo)
-    assert_equal 'bar', @app.foo
+    @app.should.respond_to? :foo
+    @app.foo.should.equal 'bar'
   end
 
   it 'sets options to Procs' do
     @app.set(:foo, Proc.new { 'baz' })
-    assert @app.respond_to?(:foo)
-    assert_equal 'baz', @app.foo
+    @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' }
-    assert_equal 1234, @app.foo
-    assert_equal 'Hello World', @app.bar
-    assert_equal 'bizzle', @app.baz
+    @app.foo.should.equal 1234
+    @app.bar.should.equal 'Hello World'
+    @app.baz.should.equal 'bizzle'
   end
 
   it 'inherits option methods when subclassed' do
@@ -29,10 +35,10 @@ describe 'Options' do
     @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
+    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
@@ -40,23 +46,23 @@ describe 'Options' do
     @app.set :biz, Proc.new { 'baz' }
     sub = Class.new(@app)
     sub.set :foo, 'bling'
-    assert_equal 'bling', sub.foo
-    assert_equal 'bar', @app.foo
+    sub.foo.should.equal 'bling'
+    @app.foo.should.equal 'bar'
   end
 
   it 'creates setter methods when first defined' do
     @app.set :foo, 'bar'
-    assert @app.respond_to?('foo=')
+    @app.should.respond_to 'foo='
     @app.foo = 'biz'
-    assert_equal 'biz', @app.foo
+    @app.foo.should.equal 'biz'
   end
 
   it 'creates predicate methods when first defined' do
     @app.set :foo, 'hello world'
-    assert @app.respond_to?(:foo?)
-    assert @app.foo?
+    @app.should.respond_to :foo?
+    @app.foo?.should.be true
     @app.set :foo, nil
-    assert !@app.foo?
+    @app.foo?.should.be false
   end
 
   it 'uses existing setter methods if detected' do
@@ -70,28 +76,28 @@ describe 'Options' do
     end
 
     @app.set :foo, 'bam'
-    assert_equal 'oops', @app.foo
+    @app.foo.should.equal 'oops'
   end
 
   it "sets multiple options to true with #enable" do
     @app.enable :sessions, :foo, :bar
-    assert @app.sessions
-    assert @app.foo
-    assert @app.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
-    assert !@app.sessions
-    assert !@app.foo
-    assert !@app.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'}, {}
-    assert_equal 200, status
-    assert_equal 'okay', body
+    status.should.equal 200
+    body.should.equal 'okay'
   end
 end

data/test/reload_test.rb

@@ -1,9 +1,13 @@
-require File.dirname(__FILE__) + '/helper'
+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
@@ -16,31 +20,31 @@ describe "Reloading" do
   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?
+    @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
-    assert !@app.reload
-    assert_same false, @app.reload?
+    @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
-    assert !@app.reload
-    assert_same false, @app.reload?
+    @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
-    assert_same true, @app.reload
+    @app.reload.should.be true
     @app.set :reload, false
-    assert_same false, @app.reload
-    assert_same false, @app.reload?
+    @app.reload.should.be false
+    @app.reload?.should.be false
   end
 
   it 'reloads the app_file each time a request is made' do
@@ -49,13 +53,13 @@ describe "Reloading" do
     @app.get('/') { 'Hello World' }
 
     get '/'
-    assert_equal 200, status
-    assert_equal 'Hello from reload file', body
-    assert_equal 1, $reload_count
+    status.should.equal 200
+    body.should.equal 'Hello from reload file'
+    $reload_count.should.equal 1
 
     get '/'
-    assert_equal 200, status
-    assert_equal 'Hello from reload file', body
-    assert_equal 2, $reload_count
+    status.should.equal 200
+    body.should.equal 'Hello from reload file'
+    $reload_count.should.equal 2
   end
 end

data/test/request_test.rb

@@ -1,18 +1,11 @@
-require File.dirname(__FILE__) + '/helper'
+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'})
-    assert request.respond_to?(:user_agent)
-    assert_equal 'Test', request.user_agent
-  end
-
-  it 'parses POST params when Content-Type is form-dataish' do
-    request = Sinatra::Request.new(
-      'REQUEST_METHOD' => 'PUT',
-      'CONTENT_TYPE' => 'application/x-www-form-urlencoded',
-      'rack.input' => StringIO.new('foo=bar')
-    )
-    assert_equal 'bar', request.params['foo']
+    request.should.respond_to :user_agent
+    request.user_agent.should.equal 'Test'
   end
 end

data/test/result_test.rb

@@ -1,6 +1,10 @@
-require File.dirname(__FILE__) + '/helper'
+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
@@ -9,8 +13,8 @@ describe 'Result Handling' do
     }
 
     get '/'
-    assert ok?
-    assert_equal 'Hello World', body
+    should.be.ok
+    body.should.equal 'Hello World'
   end
 
   it "sets response.body when result is an Array of Strings" do
@@ -21,8 +25,8 @@ describe 'Result Handling' do
     }
 
     get '/'
-    assert ok?
-    assert_equal 'HelloWorld', body
+    should.be.ok
+    body.should.equal 'HelloWorld'
   end
 
   it "sets response.body when result responds to #each" do
@@ -35,8 +39,8 @@ describe 'Result Handling' do
     }
 
     get '/'
-    assert ok?
-    assert_equal 'Hello World', body
+    should.be.ok
+    body.should.equal 'Hello World'
   end
 
   it "sets response.body to [] when result is nil" do
@@ -47,8 +51,8 @@ describe 'Result Handling' do
     }
 
     get '/'
-    assert ok?
-    assert_equal '', body
+    should.be.ok
+    body.should.equal ''
   end
 
   it "sets status, headers, and body when result is a Rack response tuple" do
@@ -59,9 +63,9 @@ describe 'Result Handling' do
     }
 
     get '/'
-    assert_equal 205, status
-    assert_equal 'foo/bar', response['Content-Type']
-    assert_equal 'Hello World', body
+    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
@@ -72,8 +76,8 @@ describe 'Result Handling' do
     }
 
     get '/'
-    assert_equal 409, status
-    assert_equal 'formula of', body
+    status.should.equal 409
+    body.should.equal 'formula of'
   end
 
   it "sets status when result is a Fixnum status code" do
@@ -82,7 +86,7 @@ describe 'Result Handling' do
     }
 
     get '/'
-    assert_equal 205, status
-    assert_equal '', body
+    status.should.equal 205
+    body.should.be.empty
   end
 end

data/test/routing_test.rb

@@ -1,6 +1,10 @@
-require File.dirname(__FILE__) + '/helper'
+require 'test/spec'
+require 'sinatra/base'
+require 'sinatra/test'
 
 describe "Routing" do
+  include Sinatra::Test
+
   %w[get put post delete head].each do |verb|
     it "defines #{verb.upcase} request handlers with #{verb}" do
       mock_app {
@@ -11,8 +15,8 @@ describe "Routing" do
 
       request = Rack::MockRequest.new(@app)
       response = request.request(verb.upcase, '/hello', {})
-      assert response.ok?
-      assert_equal 'Hello World', response.body
+      response.should.be.ok
+      response.body.should.equal 'Hello World'
     end
   end
 
@@ -21,30 +25,30 @@ describe "Routing" do
       get('/foo') { }
     }
     get '/bar'
-    assert_equal 404, status
+    status.should.equal 404
   end
 
   it "exposes params with indifferent hash" do
     mock_app {
       get '/:foo' do
-        assert_equal 'bar', params['foo']
-        assert_equal 'bar', params[:foo]
+        params['foo'].should.equal 'bar'
+        params[:foo].should.equal 'bar'
         'well, alright'
       end
     }
     get '/bar'
-    assert_equal 'well, alright', body
+    body.should.equal 'well, alright'
   end
 
   it "merges named params and query string params in params" do
     mock_app {
       get '/:foo' do
-        assert_equal 'bar', params['foo']
-        assert_equal 'biz', params['baz']
+        params['foo'].should.equal 'bar'
+        params['baz'].should.equal 'biz'
       end
     }
     get '/bar?baz=biz'
-    assert ok?
+    should.be.ok
   end
 
   it "supports named params like /hello/:person" do
@@ -54,7 +58,7 @@ describe "Routing" do
       end
     }
     get '/hello/Frank'
-    assert_equal 'Hello Frank', body
+    body.should.equal 'Hello Frank'
   end
 
   it "supports optional named params like /?:foo?/?:bar?" do
@@ -65,115 +69,58 @@ describe "Routing" do
     }
 
     get '/hello/world'
-    assert ok?
-    assert_equal "foo=hello;bar=world", body
+    should.be.ok
+    body.should.equal "foo=hello;bar=world"
 
     get '/hello'
-    assert ok?
-    assert_equal "foo=hello;bar=", body
+    should.be.ok
+    body.should.equal "foo=hello;bar="
 
     get '/'
-    assert ok?
-    assert_equal "foo=;bar=", body
+    should.be.ok
+    body.should.equal "foo=;bar="
   end
 
   it "supports single splat params like /*" do
     mock_app {
       get '/*' do
-        assert params['splat'].kind_of?(Array)
+        params['splat'].should.be.kind_of Array
         params['splat'].join "\n"
       end
     }
 
     get '/foo'
-    assert_equal "foo", body
+    body.should.equal "foo"
 
     get '/foo/bar/baz'
-    assert_equal "foo/bar/baz", body
+    body.should.equal "foo/bar/baz"
   end
 
   it "supports mixing multiple splat params like /*/foo/*/*" do
     mock_app {
       get '/*/foo/*/*' do
-        assert params['splat'].kind_of?(Array)
+        params['splat'].should.be.kind_of Array
         params['splat'].join "\n"
       end
     }
 
     get '/bar/foo/bling/baz/boom'
-    assert_equal "bar\nbling\nbaz/boom", body
+    body.should.equal "bar\nbling\nbaz/boom"
 
     get '/bar/foo/baz'
-    assert not_found?
+    should.be.not_found
   end
 
   it "supports mixing named and splat params like /:foo/*" do
     mock_app {
       get '/:foo/*' do
-        assert_equal 'foo', params['foo']
-        assert_equal ['bar/baz'], params['splat']
+        params['foo'].should.equal 'foo'
+        params['splat'].should.equal ['bar/baz']
       end
     }
 
     get '/foo/bar/baz'
-    assert ok?
-  end
-
-  it "supports basic nested params" do
-    mock_app {
-      get '/hi' do
-        params["person"]["name"]
-      end
-    }
-
-    get "/hi?person[name]=John+Doe"
-    assert ok?
-    assert_equal "John Doe", body
-  end
-
-  it "exposes nested params with indifferent hash" do
-    mock_app {
-      get '/testme' do
-        assert_equal 'baz', params['bar']['foo']
-        assert_equal 'baz', params['bar'][:foo]
-        'well, alright'
-      end
-    }
-    get '/testme?bar[foo]=baz'
-    assert_equal 'well, alright', body
-  end
-
-  it "supports deeply nested params" do
-    input = {
-      'browser[chrome][engine][name]' => 'V8',
-      'browser[chrome][engine][version]' => '1.0',
-      'browser[firefox][engine][name]' => 'spidermonkey',
-      'browser[firefox][engine][version]' => '1.7.0',
-      'emacs[map][goto-line]' => 'M-g g',
-      'emacs[version]' => '22.3.1',
-      'paste[name]' => 'hello world',
-      'paste[syntax]' => 'ruby'
-    }
-    expected = {
-      "emacs" => {
-        "map"     => { "goto-line" => "M-g g" },
-        "version" => "22.3.1"
-      },
-      "browser" => {
-        "firefox" => {"engine" => {"name"=>"spidermonkey", "version"=>"1.7.0"}},
-        "chrome"  => {"engine" => {"name"=>"V8", "version"=>"1.0"}}
-      },
-      "paste" => {"name"=>"hello world", "syntax"=>"ruby"}
-    }
-    mock_app {
-      get '/foo' do
-        assert_equal expected, params
-        'looks good'
-      end
-    }
-    get "/foo?#{param_string(input)}"
-    assert ok?
-    assert_equal 'looks good', body
+    should.be.ok
   end
 
   it "supports paths that include spaces" do
@@ -184,21 +131,21 @@ describe "Routing" do
     }
 
     get '/path%20with%20spaces'
-    assert ok?
-    assert_equal 'looks good', body
+    should.be.ok
+    body.should.equal 'looks good'
   end
 
   it "URL decodes named parameters and splats" do
     mock_app {
       get '/:foo/*' do
-        assert_equal 'hello world', params['foo']
-        assert_equal ['how are you'], params['splat']
+        params['foo'].should.equal 'hello world'
+        params['splat'].should.equal ['how are you']
         nil
       end
     }
 
     get '/hello%20world/how%20are%20you'
-    assert ok?
+    should.be.ok
   end
 
   it 'supports regular expressions' do
@@ -209,21 +156,21 @@ describe "Routing" do
     }
 
     get '/foooom/bar'
-    assert ok?
-    assert_equal 'Hello World', body
+    should.be.ok
+    body.should.equal 'Hello World'
   end
 
   it 'makes regular expression captures available in params[:captures]' do
     mock_app {
       get(/^\/fo(.*)\/ba(.*)/) do
-        assert_equal ['orooomma', 'f'], params[:captures]
+        params[:captures].should.equal ['orooomma', 'f']
         'right on'
       end
     }
 
     get '/foorooomma/baf'
-    assert ok?
-    assert_equal 'right on', body
+    should.be.ok
+    body.should.equal 'right on'
   end
 
   it "returns response immediately on halt" do
@@ -235,8 +182,8 @@ describe "Routing" do
     }
 
     get '/'
-    assert ok?
-    assert_equal 'Hello World', body
+    should.be.ok
+    body.should.equal 'Hello World'
   end
 
   it "transitions to the next matching route on pass" do
@@ -247,14 +194,14 @@ describe "Routing" do
       end
 
       get '/*' do
-        assert !params.include?('foo')
+        params.should.not.include 'foo'
         'Hello World'
       end
     }
 
     get '/bar'
-    assert ok?
-    assert_equal 'Hello World', body
+    should.be.ok
+    body.should.equal 'Hello World'
   end
 
   it "transitions to 404 when passed and no subsequent route matches" do
@@ -266,7 +213,7 @@ describe "Routing" do
     }
 
     get '/bar'
-    assert not_found?
+    should.be.not_found
   end
 
   it "passes when matching condition returns false" do
@@ -278,11 +225,11 @@ describe "Routing" do
     }
 
     get '/bar'
-    assert ok?
-    assert_equal 'Hello World', body
+    should.be.ok
+    body.should.equal 'Hello World'
 
     get '/foo'
-    assert not_found?
+    should.be.not_found
   end
 
   it "does not pass when matching condition returns nil" do
@@ -294,8 +241,8 @@ describe "Routing" do
     }
 
     get '/bar'
-    assert ok?
-    assert_equal 'Hello World', body
+    should.be.ok
+    body.should.equal 'Hello World'
   end
 
   it "passes to next route when condition calls pass explicitly" do
@@ -307,11 +254,11 @@ describe "Routing" do
     }
 
     get '/bar'
-    assert ok?
-    assert_equal 'Hello World', body
+    should.be.ok
+    body.should.equal 'Hello World'
 
     get '/foo'
-    assert not_found?
+    should.be.not_found
   end
 
   it "passes to the next route when host_name does not match" do
@@ -322,70 +269,37 @@ describe "Routing" do
       end
     }
     get '/foo'
-    assert not_found?
+    should.be.not_found
 
     get '/foo', :env => { 'HTTP_HOST' => 'example.com' }
-    assert_equal 200, status
-    assert_equal 'Hello World', body
+    status.should.equal 200
+    body.should.equal 'Hello World'
   end
 
   it "passes to the next route when user_agent does not match" do
     mock_app {
-      user_agent(/Foo/)
+      user_agent /Foo/
       get '/foo' do
         'Hello World'
       end
     }
     get '/foo'
-    assert not_found?
+    should.be.not_found
 
     get '/foo', :env => { 'HTTP_USER_AGENT' => 'Foo Bar' }
-    assert_equal 200, status
-    assert_equal 'Hello World', body
+    status.should.equal 200
+    body.should.equal 'Hello World'
   end
 
   it "makes captures in user agent pattern available in params[:agent]" do
     mock_app {
-      user_agent(/Foo (.*)/)
+      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
+    status.should.equal 200
+    body.should.equal 'Hello Bar'
   end
 end