adamwiggins-sinatra 0.8.9 → 0.10.1

data/test/filter_test.rb

@@ -1,28 +1,24 @@
-require 'test/spec'
-require 'sinatra/base'
-require 'sinatra/test'
-
-describe "Filters" do
-  include Sinatra::Test
+require File.dirname(__FILE__) + '/helper'
 
+class FilterTest < Test::Unit::TestCase
   it "executes filters in the order defined" do
     count = 0
     mock_app do
       get('/') { 'Hello World' }
       before {
-        count.should.be 0
+        assert_equal 0, count
         count = 1
       }
       before {
-        count.should.be 1
+        assert_equal 1, count
         count = 2
       }
     end
 
     get '/'
-    should.be.ok
-    count.should.be 2
-    body.should.equal 'Hello World'
+    assert ok?
+    assert_equal 2, count
+    assert_equal 'Hello World', body
   end
 
   it "allows filters to modify the request" do
@@ -33,7 +29,83 @@ describe "Filters" do
     }
 
     get '/foo'
-    should.be.ok
-    body.should.be == 'bar'
+    assert ok?
+    assert_equal 'bar', body
+  end
+
+  it "can modify instance variables available to routes" do
+    mock_app {
+      before { @foo = 'bar' }
+      get('/foo') { @foo }
+    }
+
+    get '/foo'
+    assert ok?
+    assert_equal 'bar', body
+  end
+
+  it "allows redirects in filters" do
+    mock_app {
+      before { redirect '/bar' }
+      get('/foo') do
+        fail 'before block should have halted processing'
+        'ORLY?!'
+      end
+    }
+
+    get '/foo'
+    assert redirect?
+    assert_equal '/bar', response['Location']
+    assert_equal '', body
+  end
+
+  it "does not modify the response with its return value" do
+    mock_app {
+      before { 'Hello World!' }
+      get '/foo' do
+        assert_equal [], response.body
+        'cool'
+      end
+    }
+
+    get '/foo'
+    assert ok?
+    assert_equal 'cool', body
+  end
+
+  it "does modify the response with halt" do
+    mock_app {
+      before { halt 302, 'Hi' }
+      get '/foo' do
+        "should not happen"
+      end
+    }
+
+    get '/foo'
+    assert_equal 302, response.status
+    assert_equal 'Hi', body
+  end
+
+  it "gives you access to params" do
+    mock_app {
+      before { @foo = params['foo'] }
+      get('/foo') { @foo }
+    }
+
+    get '/foo?foo=cool'
+    assert ok?
+    assert_equal 'cool', body
+  end
+
+  it "runs filters defined in superclasses" do
+    base = Class.new(Sinatra::Base)
+    base.before { @foo = 'hello from superclass' }
+
+    mock_app(base) {
+      get('/foo') { @foo }
+    }
+
+    get '/foo'
+    assert_equal 'hello from superclass', body
   end
 end

data/test/haml_test.rb

@@ -1,10 +1,7 @@
-require 'test/spec'
-require 'sinatra/base'
-require 'sinatra/test'
-
-describe "HAML Templates" do
-  include Sinatra::Test
+require File.dirname(__FILE__) + '/helper'
+require 'haml'
 
+class HAMLTest < Test::Unit::TestCase
   def haml_app(&block)
     mock_app {
       set :views, File.dirname(__FILE__) + '/views'
@@ -15,14 +12,14 @@ describe "HAML Templates" do
 
   it 'renders inline HAML strings' do
     haml_app { haml '%h1 Hiya' }
-    should.be.ok
-    body.should.equal "<h1>Hiya</h1>\n"
+    assert ok?
+    assert_equal "<h1>Hiya</h1>\n", body
   end
 
   it 'renders .haml files in views path' do
     haml_app { haml :hello }
-    should.be.ok
-    body.should.equal "<h1>Hello From Haml</h1>\n"
+    assert ok?
+    assert_equal "<h1>Hello From Haml</h1>\n", body
   end
 
   it "renders with inline layouts" do
@@ -31,31 +28,34 @@ describe "HAML Templates" do
       get('/') { haml '%em Sparta' }
     }
     get '/'
-    should.be.ok
-    body.should.equal "<h1>THIS. IS. <EM>SPARTA</EM></h1>\n"
+    assert ok?
+    assert_equal "<h1>THIS. IS. <EM>SPARTA</EM></h1>\n", body
   end
 
   it "renders with file layouts" do
     haml_app {
       haml 'Hello World', :layout => :layout2
     }
-    should.be.ok
-    body.should.equal "<h1>HAML Layout!</h1>\n<p>Hello World</p>\n"
+    assert ok?
+    assert_equal "<h1>HAML Layout!</h1>\n<p>Hello World</p>\n", body
   end
 
   it "raises error if template not found" do
     mock_app {
       get('/') { haml :no_such_template }
     }
-    lambda { get('/') }.should.raise(Errno::ENOENT)
+    assert_raise(Errno::ENOENT) { get('/') }
   end
 
   it "passes HAML options to the Haml engine" do
-    haml_app {
-      haml "!!!\n%h1 Hello World", :options => {:format => :html5}
+    mock_app {
+      get '/' do
+        haml "!!!\n%h1 Hello World", :format => :html5
+      end
     }
-    should.be.ok
-    body.should.equal "<!DOCTYPE html>\n<h1>Hello World</h1>\n"
+    get '/'
+    assert ok?
+    assert_equal "<!DOCTYPE html>\n<h1>Hello World</h1>\n", body
   end
 
   it "passes default HAML options to the Haml engine" do
@@ -66,7 +66,25 @@ describe "HAML Templates" do
       end
     }
     get '/'
-    should.be.ok
-    body.should.equal "<!DOCTYPE html>\n<h1>Hello World</h1>\n"
+    assert ok?
+    assert_equal "<!DOCTYPE html>\n<h1>Hello World</h1>\n", body
+  end
+
+  it "merges the default HAML options with the overrides and passes them to the Haml engine" do
+    mock_app {
+      set :haml, {:format => :html5, :attr_wrapper => '"'} # default HAML attr are <tag attr='single-quoted'>
+      get '/' do
+        haml "!!!\n%h1{:class => :header} Hello World"
+      end
+      get '/html4' do
+        haml "!!!\n%h1{:class => 'header'} Hello World", :format => :html4
+      end
+    }
+    get '/'
+    assert ok?
+    assert_equal "<!DOCTYPE html>\n<h1 class=\"header\">Hello World</h1>\n", body
+    get '/html4'
+    assert ok?
+    assert_match(/^<!DOCTYPE html PUBLIC (.*) HTML 4.01/, body)
   end
 end

data/test/helper.rb

@@ -0,0 +1,76 @@
+ENV['RACK_ENV'] = 'test'
+
+begin
+  require 'rack'
+rescue LoadError
+  require 'rubygems'
+  require 'rack'
+end
+
+testdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift testdir unless $LOAD_PATH.include?(testdir)
+
+libdir = File.dirname(File.dirname(__FILE__)) + '/lib'
+$LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir)
+
+require 'contest'
+require 'rack/test'
+require 'sinatra/base'
+
+class Sinatra::Base
+  # Allow assertions in request context
+  include Test::Unit::Assertions
+end
+
+Sinatra::Base.set :environment, :test
+
+class Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  class << self
+    alias_method :it, :test
+  end
+
+  alias_method :response, :last_response
+
+  setup do
+    Sinatra::Base.set :environment, :test
+  end
+
+  # Sets up a Sinatra::Base subclass defined with the block
+  # given. Used in setup or individual spec methods to establish
+  # the application.
+  def mock_app(base=Sinatra::Base, &block)
+    @app = Sinatra.new(base, &block)
+  end
+
+  def app
+    Rack::Lint.new(@app)
+  end
+
+  def body
+    response.body.to_s
+  end
+
+  # Delegate other missing methods to response.
+  def method_missing(name, *args, &block)
+    if response && response.respond_to?(name)
+      response.send(name, *args, &block)
+    else
+      super
+    end
+  end
+
+  # Also check response since we delegate there.
+  def respond_to?(symbol, include_private=false)
+    super || (response && response.respond_to?(symbol, include_private))
+  end
+
+  # Do not output warnings for the duration of the block.
+  def silence_warnings
+    $VERBOSE, v = nil, $VERBOSE
+    yield
+  ensure
+    $VERBOSE = v
+  end
+end

data/test/helpers_test.rb

@@ -1,13 +1,11 @@
-require 'test/spec'
-require 'sinatra/base'
-require 'sinatra/test'
+require File.dirname(__FILE__) + '/helper'
 
-class Test::Unit::TestCase
-  include Sinatra::Test
-end
+class HelpersTest < Test::Unit::TestCase
+  def test_default
+    assert true
+  end
 
-describe 'Sinatra::Helpers' do
-  describe '#status' do
+  describe 'status' do
     setup do
       mock_app {
         get '/' do
@@ -19,11 +17,11 @@ describe 'Sinatra::Helpers' do
 
     it 'sets the response status code' do
       get '/'
-      response.status.should.equal 207
+      assert_equal 207, response.status
     end
   end
 
-  describe '#body' do
+  describe 'body' do
     it 'takes a block for defered body generation' do
       mock_app {
         get '/' do
@@ -32,7 +30,7 @@ describe 'Sinatra::Helpers' do
       }
 
       get '/'
-      body.should.equal 'Hello World'
+      assert_equal 'Hello World', body
     end
 
     it 'takes a String, Array, or other object responding to #each' do
@@ -43,11 +41,11 @@ describe 'Sinatra::Helpers' do
       }
 
       get '/'
-      body.should.equal 'Hello World'
+      assert_equal 'Hello World', body
     end
   end
 
-  describe '#redirect' do
+  describe 'redirect' do
     it 'uses a 302 when only a path is given' do
       mock_app {
         get '/' do
@@ -57,9 +55,9 @@ describe 'Sinatra::Helpers' do
       }
 
       get '/'
-      status.should.equal 302
-      body.should.be.empty
-      response['Location'].should.equal '/foo'
+      assert_equal 302, status
+      assert_equal '', body
+      assert_equal '/foo', response['Location']
     end
 
     it 'uses the code given when specified' do
@@ -71,13 +69,26 @@ describe 'Sinatra::Helpers' do
       }
 
       get '/'
-      status.should.equal 301
-      body.should.be.empty
-      response['Location'].should.equal '/foo'
+      assert_equal 301, status
+      assert_equal '', body
+      assert_equal '/foo', response['Location']
+    end
+
+    it 'redirects back to request.referer when passed back' do
+      mock_app {
+        get '/try_redirect' do
+          redirect back
+        end
+      }
+
+      request = Rack::MockRequest.new(@app)
+      response = request.get('/try_redirect', 'HTTP_REFERER' => '/foo')
+      assert_equal 302, response.status
+      assert_equal '/foo', response['Location']
     end
   end
 
-  describe '#error' do
+  describe 'error' do
     it 'sets a status code and halts' do
       mock_app {
         get '/' do
@@ -87,8 +98,8 @@ describe 'Sinatra::Helpers' do
       }
 
       get '/'
-      status.should.equal 501
-      body.should.be.empty
+      assert_equal 501, status
+      assert_equal '', body
     end
 
     it 'takes an optional body' do
@@ -100,8 +111,8 @@ describe 'Sinatra::Helpers' do
       }
 
       get '/'
-      status.should.equal 501
-      body.should.equal 'FAIL'
+      assert_equal 501, status
+      assert_equal 'FAIL', body
     end
 
     it 'uses a 500 status code when first argument is a body' do
@@ -113,12 +124,12 @@ describe 'Sinatra::Helpers' do
       }
 
       get '/'
-      status.should.equal 500
-      body.should.equal 'FAIL'
+      assert_equal 500, status
+      assert_equal 'FAIL', body
     end
   end
 
-  describe '#not_found' do
+  describe 'not_found' do
     it 'halts with a 404 status' do
       mock_app {
         get '/' do
@@ -128,12 +139,42 @@ describe 'Sinatra::Helpers' do
       }
 
       get '/'
-      status.should.equal 404
-      body.should.be.empty
+      assert_equal 404, status
+      assert_equal '', body
+    end
+  end
+
+  describe 'headers' do
+    it 'sets headers on the response object when given a Hash' do
+      mock_app {
+        get '/' do
+          headers 'X-Foo' => 'bar', 'X-Baz' => 'bling'
+          'kthx'
+        end
+      }
+
+      get '/'
+      assert ok?
+      assert_equal 'bar', response['X-Foo']
+      assert_equal 'bling', response['X-Baz']
+      assert_equal 'kthx', body
+    end
+
+    it 'returns the response headers hash when no hash provided' do
+      mock_app {
+        get '/' do
+          headers['X-Foo'] = 'bar'
+          'kthx'
+        end
+      }
+
+      get '/'
+      assert ok?
+      assert_equal 'bar', response['X-Foo']
     end
   end
 
-  describe '#session' do
+  describe 'session' do
     it 'uses the existing rack.session' do
       mock_app {
         get '/' do
@@ -141,44 +182,48 @@ describe 'Sinatra::Helpers' do
         end
       }
 
-      get '/', :env => { 'rack.session' => { :foo => 'bar' } }
-      body.should.equal 'bar'
+      get '/', {}, { 'rack.session' => { :foo => 'bar' } }
+      assert_equal 'bar', body
     end
 
     it 'creates a new session when none provided' do
       mock_app {
         get '/' do
-          session.should.be.empty
+          assert session.empty?
           session[:foo] = 'bar'
           'Hi'
         end
       }
 
       get '/'
-      body.should.equal 'Hi'
+      assert_equal 'Hi', body
     end
   end
 
-  describe '#media_type' do
+  describe 'media_type' do
     include Sinatra::Helpers
+
     it "looks up media types in Rack's MIME registry" do
       Rack::Mime::MIME_TYPES['.foo'] = 'application/foo'
-      media_type('foo').should.equal 'application/foo'
-      media_type('.foo').should.equal 'application/foo'
-      media_type(:foo).should.equal 'application/foo'
+      assert_equal 'application/foo', media_type('foo')
+      assert_equal 'application/foo', media_type('.foo')
+      assert_equal 'application/foo', media_type(:foo)
     end
+
     it 'returns nil when given nil' do
-      media_type(nil).should.be.nil
+      assert media_type(nil).nil?
     end
+
     it 'returns nil when media type not registered' do
-      media_type(:bizzle).should.be.nil
+      assert media_type(:bizzle).nil?
     end
+
     it 'returns the argument when given a media type string' do
-      media_type('text/plain').should.equal 'text/plain'
+      assert_equal 'text/plain', media_type('text/plain')
     end
   end
 
-  describe '#content_type' do
+  describe 'content_type' do
     it 'sets the Content-Type header' do
       mock_app {
         get '/' do
@@ -188,8 +233,8 @@ describe 'Sinatra::Helpers' do
       }
 
       get '/'
-      response['Content-Type'].should.equal 'text/plain'
-      body.should.equal 'Hello World'
+      assert_equal 'text/plain', response['Content-Type']
+      assert_equal 'Hello World', body
     end
 
     it 'takes media type parameters (like charset=)' do
@@ -201,9 +246,9 @@ describe 'Sinatra::Helpers' do
       }
 
       get '/'
-      should.be.ok
-      response['Content-Type'].should.equal 'text/html;charset=utf-8'
-      body.should.equal "<h1>Hello, World</h1>"
+      assert ok?
+      assert_equal 'text/html;charset=utf-8', response['Content-Type']
+      assert_equal "<h1>Hello, World</h1>", body
     end
 
     it "looks up symbols in Rack's mime types dictionary" do
@@ -216,9 +261,9 @@ describe 'Sinatra::Helpers' do
       }
 
       get '/foo.xml'
-      should.be.ok
-      response['Content-Type'].should.equal 'application/foo'
-      body.should.equal 'I AM FOO'
+      assert ok?
+      assert_equal 'application/foo', response['Content-Type']
+      assert_equal 'I AM FOO', body
     end
 
     it 'fails when no mime type is registered for the argument provided' do
@@ -229,25 +274,26 @@ describe 'Sinatra::Helpers' do
         end
       }
 
-      lambda { get '/foo.xml' }.should.raise RuntimeError
+      assert_raise(RuntimeError) { get '/foo.xml' }
     end
   end
 
-  describe '#send_file' do
-    before {
+  describe 'send_file' do
+    setup do
       @file = File.dirname(__FILE__) + '/file.txt'
       File.open(@file, 'wb') { |io| io.write('Hello World') }
-    }
-    after {
+    end
+
+    def teardown
       File.unlink @file
       @file = nil
-    }
+    end
 
-    def send_file_app
+    def send_file_app(opts={})
       path = @file
       mock_app {
         get '/file.txt' do
-          send_file path
+          send_file path, opts
         end
       }
     end
@@ -255,26 +301,26 @@ describe 'Sinatra::Helpers' do
     it "sends the contents of the file" do
       send_file_app
       get '/file.txt'
-      should.be.ok
-      body.should.equal 'Hello World'
+      assert ok?
+      assert_equal 'Hello World', body
     end
 
     it 'sets the Content-Type response header if a mime-type can be located' do
       send_file_app
       get '/file.txt'
-      response['Content-Type'].should.equal 'text/plain'
+      assert_equal 'text/plain', response['Content-Type']
     end
 
     it 'sets the Content-Length response header' do
       send_file_app
       get '/file.txt'
-      response['Content-Length'].should.equal 'Hello World'.length.to_s
+      assert_equal 'Hello World'.length.to_s, response['Content-Length']
     end
 
     it 'sets the Last-Modified response header' do
       send_file_app
       get '/file.txt'
-      response['Last-Modified'].should.equal File.mtime(@file).httpdate
+      assert_equal File.mtime(@file).httpdate, response['Last-Modified']
     end
 
     it "returns a 404 when not found" do
@@ -284,12 +330,30 @@ describe 'Sinatra::Helpers' do
         end
       }
       get '/'
-      should.be.not_found
+      assert not_found?
+    end
+
+    it "does not set the Content-Disposition header by default" do
+      send_file_app
+      get '/file.txt'
+      assert_nil response['Content-Disposition']
+    end
+
+    it "sets the Content-Disposition header when :disposition set to 'attachment'" do
+      send_file_app :disposition => 'attachment'
+      get '/file.txt'
+      assert_equal 'attachment; filename="file.txt"', response['Content-Disposition']
+    end
+
+    it "sets the Content-Disposition header when :filename provided" do
+      send_file_app :filename => 'foo.txt'
+      get '/file.txt'
+      assert_equal 'attachment; filename="foo.txt"', response['Content-Disposition']
     end
   end
 
-  describe '#last_modified' do
-    before do
+  describe 'last_modified' do
+    setup do
       now = Time.now
       mock_app {
         get '/' do
@@ -303,24 +367,24 @@ describe 'Sinatra::Helpers' do
 
     it 'sets the Last-Modified header to a valid RFC 2616 date value' do
       get '/'
-      response['Last-Modified'].should.equal @now.httpdate
+      assert_equal @now.httpdate, response['Last-Modified']
     end
 
     it 'returns a body when conditional get misses' do
       get '/'
-      status.should.be 200
-      body.should.equal 'Boo!'
+      assert_equal 200, status
+      assert_equal 'Boo!', body
     end
 
     it 'halts when a conditional GET matches' do
-      get '/', :env => { 'HTTP_IF_MODIFIED_SINCE' => @now.httpdate }
-      status.should.be 304
-      body.should.be.empty
+      get '/', {}, { 'HTTP_IF_MODIFIED_SINCE' => @now.httpdate }
+      assert_equal 304, status
+      assert_equal '', body
     end
   end
 
-  describe '#etag' do
-    before do
+  describe 'etag' do
+    setup do
       mock_app {
         get '/' do
           body { 'Hello World' }
@@ -332,25 +396,25 @@ describe 'Sinatra::Helpers' do
 
     it 'sets the ETag header' do
       get '/'
-      response['ETag'].should.equal '"FOO"'
+      assert_equal '"FOO"', response['ETag']
     end
 
     it 'returns a body when conditional get misses' do
       get '/'
-      status.should.be 200
-      body.should.equal 'Boo!'
+      assert_equal 200, status
+      assert_equal 'Boo!', body
     end
 
     it 'halts when a conditional GET matches' do
-      get '/', :env => { 'HTTP_IF_NONE_MATCH' => '"FOO"' }
-      status.should.be 304
-      body.should.be.empty
+      get '/', {}, { 'HTTP_IF_NONE_MATCH' => '"FOO"' }
+      assert_equal 304, status
+      assert_equal '', body
     end
 
     it 'should handle multiple ETag values in If-None-Match header' do
-      get '/', :env => { 'HTTP_IF_NONE_MATCH' => '"BAR", *' }
-      status.should.be 304
-      body.should.be.empty
+      get '/', {}, { 'HTTP_IF_NONE_MATCH' => '"BAR", *' }
+      assert_equal 304, status
+      assert_equal '', body
     end
 
     it 'uses a weak etag with the :weak option' do
@@ -361,8 +425,79 @@ describe 'Sinatra::Helpers' do
         end
       }
       get '/'
-      response['ETag'].should.equal 'W/"FOO"'
+      assert_equal 'W/"FOO"', response['ETag']
     end
+  end
+
+  describe 'back' do
+    it "makes redirecting back pretty" do
+      mock_app {
+        get '/foo' do
+          redirect back
+        end
+      }
+
+      get '/foo', {}, 'HTTP_REFERER' => 'http://github.com'
+      assert redirect?
+      assert_equal "http://github.com", response.location
+    end
+  end
 
+  module ::HelperOne; def one; '1'; end; end
+  module ::HelperTwo; def two; '2'; end; end
+
+  describe 'Adding new helpers' do
+    it 'takes a list of modules to mix into the app' do
+      mock_app {
+        helpers ::HelperOne, ::HelperTwo
+
+        get '/one' do
+          one
+        end
+
+        get '/two' do
+          two
+        end
+      }
+
+      get '/one'
+      assert_equal '1', body
+
+      get '/two'
+      assert_equal '2', body
+    end
+
+    it 'takes a block to mix into the app' do
+      mock_app {
+        helpers do
+          def foo
+            'foo'
+          end
+        end
+
+        get '/' do
+          foo
+        end
+      }
+
+      get '/'
+      assert_equal 'foo', body
+    end
+
+    it 'evaluates the block in class context so that methods can be aliased' do
+      mock_app {
+        helpers do
+          alias_method :h, :escape_html
+        end
+
+        get '/' do
+          h('42 < 43')
+        end
+      }
+
+      get '/'
+      assert ok?
+      assert_equal '42 &lt; 43', body
+    end
   end
 end