sinatra 0.9.1.1 → 0.9.2

data/test/render_backtrace_test.rb

@@ -0,0 +1,145 @@
+require File.dirname(__FILE__) + '/helper'
+
+require 'sass/error'
+
+class RenderBacktraceTest < Test::Unit::TestCase
+  VIEWS = File.dirname(__FILE__) + '/views'
+
+  def assert_raise_at(filename, line, exception = RuntimeError)
+    f, l = nil
+    assert_raise(exception) do
+      begin
+        get('/')
+      rescue => e
+        f, l = e.backtrace.first.split(':')
+        raise
+      end
+    end
+    assert_equal(filename, f, "expected #{exception.name} in #{filename}, was #{f}")
+    assert_equal(line, l.to_i, "expected #{exception.name} in #{filename} at line #{line}, was at line #{l}")
+  end
+
+  def backtrace_app(&block)
+    mock_app {
+      use_in_file_templates!
+      set :views, RenderBacktraceTest::VIEWS
+      template :builder_template do
+        'raise "error"'
+      end
+      template :erb_template do
+        '<% raise "error" %>'
+      end
+      template :haml_template do
+        '%h1= raise "error"'
+      end
+      template :sass_template do
+        '+syntax-error'
+      end
+      get '/', &block
+    }
+  end
+
+  it "provides backtrace for Builder template" do
+    backtrace_app { builder :error }
+    assert_raise_at(File.join(VIEWS,'error.builder'), 2)
+  end
+
+  it "provides backtrace for ERB template" do
+    backtrace_app { erb :error }
+    assert_raise_at(File.join(VIEWS,'error.erb'), 2)
+  end
+
+  it "provides backtrace for HAML template" do
+    backtrace_app { haml :error }
+    assert_raise_at(File.join(VIEWS,'error.haml'), 2)
+  end
+
+  it "provides backtrace for Sass template" do
+    backtrace_app { sass :error }
+    assert_raise_at(File.join(VIEWS,'error.sass'), 2, Sass::SyntaxError)
+  end
+
+  it "provides backtrace for ERB template with locals" do
+    backtrace_app { erb :error, {}, :french => true }
+    assert_raise_at(File.join(VIEWS,'error.erb'), 3)
+  end
+
+  it "provides backtrace for HAML template with locals" do
+    backtrace_app { haml :error, {}, :french => true }
+    assert_raise_at(File.join(VIEWS,'error.haml'), 3)
+  end
+
+  it "provides backtrace for inline Builder string" do
+    backtrace_app { builder "raise 'Ack! Thbbbt!'"}
+    assert_raise_at(__FILE__, (__LINE__-1))
+  end
+
+  it "provides backtrace for inline ERB string" do
+    backtrace_app { erb "<% raise 'bidi-bidi-bidi' %>" }
+    assert_raise_at(__FILE__, (__LINE__-1))
+  end
+
+  it "provides backtrace for inline HAML string" do
+    backtrace_app { haml "%h1= raise 'Lions and tigers and bears! Oh, my!'" }
+    assert_raise_at(__FILE__, (__LINE__-1))
+  end
+
+  # it "provides backtrace for inline Sass string" do
+  #   backtrace_app { sass '+buh-bye' }
+  #   assert_raise_at(__FILE__, (__LINE__-1), Sass::SyntaxError)
+  # end
+
+  it "provides backtrace for named Builder template" do
+    backtrace_app { builder :builder_template }
+    assert_raise_at(__FILE__, (__LINE__-68))
+  end
+
+  it "provides backtrace for named ERB template" do
+    backtrace_app { erb :erb_template }
+    assert_raise_at(__FILE__, (__LINE__-70))
+  end
+
+  it "provides backtrace for named HAML template" do
+    backtrace_app { haml :haml_template }
+    assert_raise_at(__FILE__, (__LINE__-72))
+  end
+
+  # it "provides backtrace for named Sass template" do
+  #   backtrace_app { sass :sass_template }
+  #   assert_raise_at(__FILE__, (__LINE__-74), Sass::SyntaxError)
+  # end
+
+  it "provides backtrace for in file Builder template" do
+    backtrace_app { builder :builder_in_file }
+    assert_raise_at(__FILE__, (__LINE__+22))
+  end
+
+  it "provides backtrace for in file ERB template" do
+    backtrace_app { erb :erb_in_file }
+    assert_raise_at(__FILE__, (__LINE__+20))
+  end
+
+  it "provides backtrace for in file HAML template" do
+    backtrace_app { haml :haml_in_file }
+    assert_raise_at(__FILE__, (__LINE__+18))
+  end
+
+  # it "provides backtrace for in file Sass template" do
+  #   backtrace_app { sass :sass_in_file }
+  #   assert_raise_at(__FILE__, (__LINE__+16), Sass::SyntaxError)
+  # end
+end
+
+__END__
+
+@@ builder_in_file
+raise "bif"
+
+@@ erb_in_file
+<% raise "bam" %>
+
+@@ haml_in_file
+%h1= raise "pow"
+
+@@ sass_in_file
++blam

data/test/request_test.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
 
-describe 'Sinatra::Request' do
+class RequestTest < Test::Unit::TestCase
   it 'responds to #user_agent' do
     request = Sinatra::Request.new({'HTTP_USER_AGENT' => 'Test'})
     assert request.respond_to?(:user_agent)

data/test/response_test.rb

@@ -2,8 +2,8 @@
 
 require File.dirname(__FILE__) + '/helper'
 
-describe 'Sinatra::Response' do
-  before do
+class ResponseTest < Test::Unit::TestCase
+  setup do
     @response = Sinatra::Response.new
   end
 

data/test/result_test.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
 
-describe 'Result Handling' do
+class ResultTest < Test::Unit::TestCase
   it "sets response.body when result is a String" do
     mock_app {
       get '/' do

data/test/route_added_hook_test.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/helper'
+
+module RouteAddedTest
+  @routes, @procs = [], []
+  def self.routes ; @routes ; end
+  def self.procs ; @procs ; end
+  def self.route_added(verb, path, proc)
+    @routes << [verb, path]
+    @procs << proc
+  end
+end
+
+class RouteAddedHookTest < Test::Unit::TestCase
+  setup { 
+    RouteAddedTest.routes.clear
+    RouteAddedTest.procs.clear
+  }
+
+  it "should be notified of an added route" do
+    mock_app(Class.new(Sinatra::Base)) {
+      register RouteAddedTest
+      get('/') {}
+    }
+
+    assert_equal [["GET", "/"], ["HEAD", "/"]],
+      RouteAddedTest.routes
+  end
+
+  it "should include hooks from superclass" do
+    a = Class.new(Class.new(Sinatra::Base))
+    b = Class.new(a)
+
+    a.register RouteAddedTest
+    b.class_eval { post("/sub_app_route") {} }
+
+    assert_equal [["POST", "/sub_app_route"]],
+      RouteAddedTest.routes
+  end
+
+  it "should only run once per extension" do
+    mock_app(Class.new(Sinatra::Base)) {
+      register RouteAddedTest
+      register RouteAddedTest
+      get('/') {}
+    }
+
+    assert_equal [["GET", "/"], ["HEAD", "/"]],
+      RouteAddedTest.routes
+  end
+  
+  it "should pass route blocks as an argument" do
+    mock_app(Class.new(Sinatra::Base)) {
+      register RouteAddedTest
+      get('/') {}
+    }
+
+    assert_kind_of Proc, RouteAddedTest.procs.first    
+  end
+end

data/test/routing_test.rb

@@ -5,7 +5,23 @@ def route_def(pattern)
   mock_app { get(pattern) { } }
 end
 
-describe "Routing" do
+class RegexpLookAlike
+  class MatchData
+    def captures
+      ["this", "is", "a", "test"]
+    end
+  end
+
+  def match(string)
+    ::RegexpLookAlike::MatchData.new if string == "/this/is/a/test/"
+  end
+
+  def keys
+    ["one", "two", "three", "four"]
+  end
+end
+
+class RoutingTest < Test::Unit::TestCase
   %w[get put post delete].each do |verb|
     it "defines #{verb.upcase} request handlers with #{verb}" do
       mock_app {
@@ -44,6 +60,21 @@ describe "Routing" do
     assert_equal 404, status
   end
 
+  it "overrides the content-type in error handlers" do
+    mock_app {
+      before { content_type 'text/plain' }
+      error Sinatra::NotFound do
+        content_type "text/html"
+        "<h1>Not Found</h1>"
+      end
+    }
+
+    get '/foo'
+    assert_equal 404, status
+    assert_equal 'text/html', response["Content-Type"]
+    assert_equal "<h1>Not Found</h1>", response.body
+  end
+
   it 'takes multiple definitions of a route' do
     mock_app {
       user_agent(/Foo/)
@@ -243,17 +274,7 @@ describe "Routing" do
   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 = {
+    expected_params = {
       "emacs" => {
         "map"     => { "goto-line" => "M-g g" },
         "version" => "22.3.1"
@@ -266,11 +287,11 @@ describe "Routing" do
     }
     mock_app {
       get '/foo' do
-        assert_equal expected, params
+        assert_equal expected_params, params
         'looks good'
       end
     }
-    get "/foo?#{build_query(input)}"
+    get '/foo', expected_params
     assert ok?
     assert_equal 'looks good', body
   end
@@ -352,9 +373,26 @@ describe "Routing" do
     assert_equal 'right on', body
   end
 
+  it 'supports regular expression look-alike routes' do
+    mock_app {
+      get(RegexpLookAlike.new) do
+        assert_equal 'this', params[:one]
+        assert_equal 'is', params[:two]
+        assert_equal 'a', params[:three]
+        assert_equal 'test', params[:four]
+        'right on'
+      end
+    }
+
+    get '/this/is/a/test/'
+    assert ok?
+    assert_equal 'right on', body
+  end
+
   it 'raises a TypeError when pattern is not a String or Regexp' do
-    @app = mock_app
-    assert_raise(TypeError) { @app.get(42){} }
+    assert_raise(TypeError) {
+      mock_app { get(42){} }
+    }
   end
 
   it "returns response immediately on halt" do
@@ -479,7 +517,7 @@ describe "Routing" do
     get '/foo'
     assert not_found?
 
-    get '/foo', :env => { 'HTTP_HOST' => 'example.com' }
+    get '/foo', {}, { 'HTTP_HOST' => 'example.com' }
     assert_equal 200, status
     assert_equal 'Hello World', body
   end
@@ -494,7 +532,7 @@ describe "Routing" do
     get '/foo'
     assert not_found?
 
-    get '/foo', :env => { 'HTTP_USER_AGENT' => 'Foo Bar' }
+    get '/foo', {}, { 'HTTP_USER_AGENT' => 'Foo Bar' }
     assert_equal 200, status
     assert_equal 'Hello World', body
   end
@@ -506,7 +544,7 @@ describe "Routing" do
         'Hello ' + params[:agent].first
       end
     }
-    get '/foo', :env => { 'HTTP_USER_AGENT' => 'Foo Bar' }
+    get '/foo', {}, { 'HTTP_USER_AGENT' => 'Foo Bar' }
     assert_equal 200, status
     assert_equal 'Hello Bar', body
   end
@@ -518,12 +556,12 @@ describe "Routing" do
       end
     }
 
-    get '/', :env => { :accept => 'application/xml' }
+    get '/', {}, { 'HTTP_ACCEPT' => 'application/xml' }
     assert ok?
     assert_equal 'application/xml', body
     assert_equal 'application/xml', response.headers['Content-Type']
 
-    get '/', :env => { :accept => 'text/html' }
+    get '/', {}, { :accept => 'text/html' }
     assert !ok?
   end
 
@@ -537,7 +575,7 @@ describe "Routing" do
     }
 
     types.each do |type|
-      get '/', :env => { :accept => type }
+      get '/', {}, { 'HTTP_ACCEPT' => type }
       assert ok?
       assert_equal type, body
       assert_equal type, response.headers['Content-Type']
@@ -655,6 +693,40 @@ describe "Routing" do
     assert_equal 'ab', body
   end
 
+  it 'allows custom route-conditions to be set via route options' do
+    protector = Module.new {
+      def protect(*args)
+        condition {
+          unless authorize(params["user"], params["password"])
+            halt 403, "go away"
+          end
+        }
+      end
+    }
+
+    mock_app {
+      register protector
+
+      helpers do
+        def authorize(username, password)
+          username == "foo" && password == "bar"
+        end
+      end
+
+      get "/", :protect => true do
+        "hey"
+      end
+    }
+
+    get "/"
+    assert forbidden?
+    assert_equal "go away", body
+
+    get "/", :user => "foo", :password => "bar"
+    assert ok?
+    assert_equal "hey", body
+  end
+
   # NOTE Block params behaves differently under 1.8 and 1.9. Under 1.8, block
   # param arity is lax: declaring a mismatched number of block params results
   # in a warning. Under 1.9, block param arity is strict: mismatched block

data/test/sass_test.rb

@@ -1,6 +1,7 @@
 require File.dirname(__FILE__) + '/helper'
+require 'sass'
 
-describe "Sass Templates" do
+class SassTest < Test::Unit::TestCase
   def sass_app(&block)
     mock_app {
       set :views, File.dirname(__FILE__) + '/views'
@@ -33,4 +34,46 @@ describe "Sass Templates" do
     }
     assert_raise(Errno::ENOENT) { get('/') }
   end
+
+  it "passes SASS options to the Sass engine" do
+    sass_app {
+      sass "#sass\n  :background-color #FFF\n  :color #000\n", :style => :compact
+    }
+    assert ok?
+    assert_equal "#sass { background-color: #FFF; color: #000; }\n", body
+  end
+
+  it "passes default SASS options to the Sass engine" do
+    mock_app {
+      set :sass, {:style => :compact} # default Sass style is :nested
+      get '/' do
+        sass "#sass\n  :background-color #FFF\n  :color #000\n"
+      end
+    }
+    get '/'
+    assert ok?
+    assert_equal "#sass { background-color: #FFF; color: #000; }\n", body
+  end
+
+  it "merges the default SASS options with the overrides and passes them to the Sass engine" do
+    mock_app {
+      set :sass, {:style => :compact, :attribute_syntax => :alternate } # default Sass attribute_syntax is :normal (with : in front)
+      get '/' do
+        sass "#sass\n  background-color: #FFF\n  color: #000\n"
+      end
+      get '/raised' do
+        sass "#sass\n  :background-color #FFF\n  :color #000\n", :style => :expanded # retains global attribute_syntax settings
+      end
+      get '/expanded_normal' do
+        sass "#sass\n  :background-color #FFF\n  :color #000\n", :style => :expanded, :attribute_syntax => :normal
+      end
+    }
+    get '/'
+    assert ok?
+    assert_equal "#sass { background-color: #FFF; color: #000; }\n", body
+    assert_raise(Sass::SyntaxError) { get('/raised') }
+    get '/expanded_normal'
+    assert ok?
+    assert_equal "#sass {\n  background-color: #FFF;\n  color: #000;\n}\n", body
+  end
 end