sinatra-base 1.0 → 1.4.0

data/test/creole_test.rb

@@ -0,0 +1,65 @@
+require File.expand_path('../helper', __FILE__)
+
+begin
+require 'creole'
+
+class CreoleTest < Test::Unit::TestCase
+  def creole_app(&block)
+    mock_app do
+      set :views, File.dirname(__FILE__) + '/views'
+      get '/', &block
+    end
+    get '/'
+  end
+
+  it 'renders inline creole strings' do
+    creole_app { creole '= Hiya' }
+    assert ok?
+    assert_body "<h1>Hiya</h1>"
+  end
+
+  it 'renders .creole files in views path' do
+    creole_app { creole :hello }
+    assert ok?
+    assert_body "<h1>Hello From Creole</h1>"
+  end
+
+  it "raises error if template not found" do
+    mock_app { get('/') { creole :no_such_template } }
+    assert_raise(Errno::ENOENT) { get('/') }
+  end
+
+  it "renders with inline layouts" do
+    mock_app do
+      layout { 'THIS. IS. #{yield.upcase}!' }
+      get('/') { creole 'Sparta', :layout_engine => :str }
+    end
+    get '/'
+    assert ok?
+    assert_like 'THIS. IS. <P>SPARTA</P>!', body
+  end
+
+  it "renders with file layouts" do
+    creole_app { creole 'Hello World', :layout => :layout2, :layout_engine => :erb }
+    assert ok?
+    assert_body "ERB Layout!\n<p>Hello World</p>"
+  end
+
+  it "can be used in a nested fashion for partials and whatnot" do
+    mock_app do
+      template(:inner) { "hi" }
+      template(:outer) { "<outer><%= creole :inner %></outer>" }
+      get '/' do
+        erb :outer
+      end
+    end
+
+    get '/'
+    assert ok?
+    assert_like '<outer><p>hi</p></outer>', body
+  end
+end
+
+rescue LoadError
+  warn "#{$!.to_s}: skipping creole tests"
+end

data/test/delegator_test.rb

@@ -0,0 +1,162 @@
+require File.expand_path('../helper', __FILE__)
+
+class DelegatorTest < Test::Unit::TestCase
+  class Mirror
+    attr_reader :last_call
+    def method_missing(*a, &b)
+      @last_call = [*a.map(&:to_s)]
+      @last_call << b if b
+    end
+  end
+
+  def self.delegates(name)
+    it "delegates #{name}" do
+      m = mirror { send name }
+      assert_equal [name.to_s], m.last_call
+    end
+
+    it "delegates #{name} with arguments" do
+      m = mirror { send name, "foo", "bar" }
+      assert_equal [name.to_s, "foo", "bar"], m.last_call
+    end
+
+    it "delegates #{name} with block" do
+      block = proc { }
+      m = mirror { send(name, &block) }
+      assert_equal [name.to_s, block], m.last_call
+    end
+  end
+
+  setup do
+    @target_was = Sinatra::Delegator.target
+  end
+
+  def teardown
+    Sinatra::Delegator.target = @target_was
+  end
+
+  def delegation_app(&block)
+    mock_app { Sinatra::Delegator.target = self }
+    delegate(&block)
+  end
+
+  def mirror(&block)
+    mirror = Mirror.new
+    Sinatra::Delegator.target = mirror
+    delegate(&block)
+  end
+
+  def delegate(&block)
+    assert Sinatra::Delegator.target != Sinatra::Application
+    Object.new.extend(Sinatra::Delegator).instance_eval(&block) if block
+    Sinatra::Delegator.target
+  end
+
+  def target
+    Sinatra::Delegator.target
+  end
+
+  it 'defaults to Sinatra::Application as target' do
+    assert_equal Sinatra::Application, Sinatra::Delegator.target
+  end
+
+  %w[get put post delete options patch].each do |verb|
+    it "delegates #{verb} correctly" do
+      delegation_app do
+        send verb, '/hello' do
+          'Hello World'
+        end
+      end
+
+      request = Rack::MockRequest.new(@app)
+      response = request.request(verb.upcase, '/hello', {})
+      assert response.ok?
+      assert_equal 'Hello World', response.body
+    end
+  end
+
+  it "delegates head correctly" do
+    delegation_app do
+      head '/hello' do
+        response['X-Hello'] = 'World!'
+        'remove me'
+      end
+    end
+
+    request = Rack::MockRequest.new(@app)
+    response = request.request('HEAD', '/hello', {})
+    assert response.ok?
+    assert_equal 'World!', response['X-Hello']
+    assert_equal '', response.body
+  end
+
+  it "registers extensions with the delegation target" do
+    app, mixin = mirror, Module.new
+    Sinatra.register mixin
+    assert_equal ["register", mixin.to_s], app.last_call
+  end
+
+  it "registers helpers with the delegation target" do
+    app, mixin = mirror, Module.new
+    Sinatra.helpers mixin
+    assert_equal ["helpers", mixin.to_s], app.last_call
+  end
+
+  it "registers helpers with the delegation target" do
+    app, mixin = mirror, Module.new
+    Sinatra.use mixin
+    assert_equal ["use", mixin.to_s], app.last_call
+  end
+
+  it "should work with method_missing proxies for options" do
+    mixin = Module.new do
+      def respond_to?(method, *)
+        method.to_sym == :options or super
+      end
+
+      def method_missing(method, *args, &block)
+        return super unless method.to_sym == :options
+        {:some => :option}
+      end
+    end
+
+    value = nil
+    mirror do
+      extend mixin
+      value = options
+    end
+
+    assert_equal({:some => :option}, value)
+  end
+
+  it "delegates crazy method names" do
+    Sinatra::Delegator.delegate "foo:bar:"
+    method = mirror { send "foo:bar:" }.last_call.first
+    assert_equal "foo:bar:", method
+  end
+
+  delegates 'get'
+  delegates 'patch'
+  delegates 'put'
+  delegates 'post'
+  delegates 'delete'
+  delegates 'head'
+  delegates 'options'
+  delegates 'template'
+  delegates 'layout'
+  delegates 'before'
+  delegates 'after'
+  delegates 'error'
+  delegates 'not_found'
+  delegates 'configure'
+  delegates 'set'
+  delegates 'mime_type'
+  delegates 'enable'
+  delegates 'disable'
+  delegates 'use'
+  delegates 'development?'
+  delegates 'test?'
+  delegates 'production?'
+  delegates 'helpers'
+  delegates 'settings'
+end

data/test/encoding_test.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+require File.expand_path('../helper', __FILE__)
+require 'erb'
+
+class BaseTest < Test::Unit::TestCase
+  setup do
+    @base = Sinatra.new(Sinatra::Base)
+    @base.set :views, File.dirname(__FILE__) + "/views"
+  end
+
+  it 'allows unicode strings in ascii templates per default (1.9)' do
+    next unless defined? Encoding
+    @base.new!.erb(File.read(@base.views + "/ascii.erb").encode("ASCII"), {}, :value => "åkej")
+  end
+
+  it 'allows ascii strings in unicode templates per default (1.9)' do
+    next unless defined? Encoding
+    @base.new!.erb(:utf8, {}, :value => "Some Lyrics".encode("ASCII"))
+  end
+end

data/test/erb_test.rb

@@ -1,6 +1,15 @@
-require File.dirname(__FILE__) + '/helper'
+require File.expand_path('../helper', __FILE__)
 
 class ERBTest < Test::Unit::TestCase
+  def engine
+    Tilt::ERBTemplate
+  end
+
+  def setup
+    Tilt.prefer engine, :erb
+    super
+  end
+
   def erb_app(&block)
     mock_app {
       set :views, File.dirname(__FILE__) + '/views'
@@ -9,6 +18,10 @@ class ERBTest < Test::Unit::TestCase
     get '/'
   end
 
+  it 'uses the correct engine' do
+    assert_equal engine, Tilt[:erb]
+  end
+
   it 'renders inline ERB strings' do
     erb_app { erb '<%= 1 + 1 %>' }
     assert ok?
@@ -45,7 +58,7 @@ class ERBTest < Test::Unit::TestCase
       erb 'Hello World', :layout => :layout2
     }
     assert ok?
-    assert_equal "ERB Layout!\nHello World\n", body
+    assert_body "ERB Layout!\nHello World"
   end
 
   it "renders erb with blocks" do
@@ -79,3 +92,13 @@ class ERBTest < Test::Unit::TestCase
     assert_equal '<outer><inner>hi</inner></outer>', body
   end
 end
+
+
+begin
+  require 'erubis'
+  class ErubisTest < ERBTest
+    def engine; Tilt::ErubisTemplate end
+  end
+rescue LoadError
+  warn "#{$!.to_s}: skipping erubis tests"
+end

data/test/extensions_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/helper'
+require File.expand_path('../helper', __FILE__)
 
 class ExtensionsTest < Test::Unit::TestCase
   module FooExtensions

data/test/filter_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/helper'
+require File.expand_path('../helper', __FILE__)
 
 class BeforeFilterTest < Test::Unit::TestCase
   it "executes filters in the order defined" do
@@ -55,7 +55,7 @@ class BeforeFilterTest < Test::Unit::TestCase
 
     get '/foo'
     assert redirect?
-    assert_equal '/bar', response['Location']
+    assert_equal 'http://example.org/bar', response['Location']
     assert_equal '', body
   end
 
@@ -97,6 +97,17 @@ class BeforeFilterTest < Test::Unit::TestCase
     assert_equal 'cool', body
   end
 
+  it "properly unescapes parameters" do
+    mock_app {
+      before { @foo = params['foo'] }
+      get('/foo') { @foo }
+    }
+
+    get '/foo?foo=bar%3Abaz%2Fbend'
+    assert ok?
+    assert_equal 'bar:baz/bend', body
+  end
+
   it "runs filters defined in superclasses" do
     base = Class.new(Sinatra::Base)
     base.before { @foo = 'hello from superclass' }
@@ -114,13 +125,36 @@ class BeforeFilterTest < Test::Unit::TestCase
     mock_app {
       before { ran_filter = true }
       set :static, true
-      set :public, File.dirname(__FILE__)
+      set :public_folder, File.dirname(__FILE__)
     }
     get "/#{File.basename(__FILE__)}"
     assert ok?
     assert_equal File.read(__FILE__), body
     assert !ran_filter
   end
+
+  it 'takes an optional route pattern' do
+    ran_filter = false
+    mock_app do
+      before("/b*") { ran_filter = true }
+      get('/foo') { }
+      get('/bar') { }
+    end
+    get '/foo'
+    assert !ran_filter
+    get '/bar'
+    assert ran_filter
+  end
+
+  it 'generates block arguments from route pattern' do
+    subpath = nil
+    mock_app do
+      before("/foo/:sub") { |s| subpath = s }
+      get('/foo/*') { }
+    end
+    get '/foo/bar'
+    assert_equal subpath, 'bar'
+  end
 end
 
 class AfterFilterTest < Test::Unit::TestCase
@@ -166,7 +200,7 @@ class AfterFilterTest < Test::Unit::TestCase
 
     get '/foo'
     assert redirect?
-    assert_equal '/bar', response['Location']
+    assert_equal 'http://example.org/bar', response['Location']
     assert_equal '', body
   end
 
@@ -198,9 +232,12 @@ class AfterFilterTest < Test::Unit::TestCase
     count = 2
     base = Class.new(Sinatra::Base)
     base.after { count *= 2 }
-    mock_app(base) {
-      get('/foo') { count += 2 }
-    }
+    mock_app(base) do
+      get('/foo') do
+        count += 2
+        "ok"
+      end
+    end
 
     get '/foo'
     assert_equal 8, count
@@ -211,11 +248,192 @@ class AfterFilterTest < Test::Unit::TestCase
     mock_app {
       after { ran_filter = true }
       set :static, true
-      set :public, File.dirname(__FILE__)
+      set :public_folder, File.dirname(__FILE__)
     }
     get "/#{File.basename(__FILE__)}"
     assert ok?
     assert_equal File.read(__FILE__), body
     assert !ran_filter
   end
+
+  it 'takes an optional route pattern' do
+    ran_filter = false
+    mock_app do
+      after("/b*") { ran_filter = true }
+      get('/foo') { }
+      get('/bar') { }
+    end
+    get '/foo'
+    assert !ran_filter
+    get '/bar'
+    assert ran_filter
+  end
+
+  it 'changes to path_info from a pattern matching before filter are respoected when routing' do
+    mock_app do
+      before('/foo') { request.path_info = '/bar' }
+      get('/bar') { 'blah' }
+    end
+    get '/foo'
+    assert ok?
+    assert_equal 'blah', body
+  end
+
+  it 'generates block arguments from route pattern' do
+    subpath = nil
+    mock_app do
+      after("/foo/:sub") { |s| subpath = s }
+      get('/foo/*') { }
+    end
+    get '/foo/bar'
+    assert_equal subpath, 'bar'
+  end
+
+  it 'is possible to access url params from the route param' do
+    ran = false
+    mock_app do
+      get('/foo/*') { }
+      before('/foo/:sub') do
+        assert_equal params[:sub], 'bar'
+        ran = true
+      end
+    end
+    get '/foo/bar'
+    assert ran
+  end
+
+  it 'is possible to apply host_name conditions to before filters with no path' do
+    ran = false
+    mock_app do
+      before(:host_name => 'example.com') { ran = true }
+      get('/') { 'welcome' }
+    end
+    get '/', {}, { 'HTTP_HOST' => 'example.org' }
+    assert !ran
+    get '/', {}, { 'HTTP_HOST' => 'example.com' }
+    assert ran
+  end
+
+  it 'is possible to apply host_name conditions to before filters with a path' do
+    ran = false
+    mock_app do
+      before('/foo', :host_name => 'example.com') { ran = true }
+      get('/') { 'welcome' }
+    end
+    get '/', {}, { 'HTTP_HOST' => 'example.com' }
+    assert !ran
+    get '/foo', {}, { 'HTTP_HOST' => 'example.org' }
+    assert !ran
+    get '/foo', {}, { 'HTTP_HOST' => 'example.com' }
+    assert ran
+  end
+
+  it 'is possible to apply host_name conditions to after filters with no path' do
+    ran = false
+    mock_app do
+      after(:host_name => 'example.com') { ran = true }
+      get('/') { 'welcome' }
+    end
+    get '/', {}, { 'HTTP_HOST' => 'example.org' }
+    assert !ran
+    get '/', {}, { 'HTTP_HOST' => 'example.com' }
+    assert ran
+  end
+
+  it 'is possible to apply host_name conditions to after filters with a path' do
+    ran = false
+    mock_app do
+      after('/foo', :host_name => 'example.com') { ran = true }
+      get('/') { 'welcome' }
+    end
+    get '/', {}, { 'HTTP_HOST' => 'example.com' }
+    assert !ran
+    get '/foo', {}, { 'HTTP_HOST' => 'example.org' }
+    assert !ran
+    get '/foo', {}, { 'HTTP_HOST' => 'example.com' }
+    assert ran
+  end
+
+  it 'is possible to apply user_agent conditions to before filters with no path' do
+    ran = false
+    mock_app do
+      before(:user_agent => /foo/) { ran = true }
+      get('/') { 'welcome' }
+    end
+    get '/', {}, { 'HTTP_USER_AGENT' => 'bar' }
+    assert !ran
+    get '/', {}, { 'HTTP_USER_AGENT' => 'foo' }
+    assert ran
+  end
+
+  it 'is possible to apply user_agent conditions to before filters with a path' do
+    ran = false
+    mock_app do
+      before('/foo', :user_agent => /foo/) { ran = true }
+      get('/') { 'welcome' }
+    end
+    get '/', {}, { 'HTTP_USER_AGENT' => 'foo' }
+    assert !ran
+    get '/foo', {}, { 'HTTP_USER_AGENT' => 'bar' }
+    assert !ran
+    get '/foo', {}, { 'HTTP_USER_AGENT' => 'foo' }
+    assert ran
+  end
+
+  it 'can add params' do
+    mock_app do
+      before { params['foo'] = 'bar' }
+      get('/') { params['foo'] }
+    end
+
+    get '/'
+    assert_body 'bar'
+  end
+
+  it 'can remove params' do
+    mock_app do
+      before { params.delete('foo') }
+      get('/') { params['foo'].to_s }
+    end
+
+    get '/?foo=bar'
+    assert_body ''
+  end
+
+  it 'is possible to apply user_agent conditions to after filters with no path' do
+    ran = false
+    mock_app do
+      after(:user_agent => /foo/) { ran = true }
+      get('/') { 'welcome' }
+    end
+    get '/', {}, { 'HTTP_USER_AGENT' => 'bar' }
+    assert !ran
+    get '/', {}, { 'HTTP_USER_AGENT' => 'foo' }
+    assert ran
+  end
+
+  it 'is possible to apply user_agent conditions to before filters with a path' do
+    ran = false
+    mock_app do
+      after('/foo', :user_agent => /foo/) { ran = true }
+      get('/') { 'welcome' }
+    end
+    get '/', {}, { 'HTTP_USER_AGENT' => 'foo' }
+    assert !ran
+    get '/foo', {}, { 'HTTP_USER_AGENT' => 'bar' }
+    assert !ran
+    get '/foo', {}, { 'HTTP_USER_AGENT' => 'foo' }
+    assert ran
+  end
+
+  it 'only triggeres provides condition if conforms with current Content-Type' do
+    mock_app do
+      before(:provides => :txt)  { @type = 'txt' }
+      before(:provides => :html) { @type = 'html' }
+      get('/') { @type }
+    end
+
+    get '/', {}, { 'HTTP_ACCEPT' => '*' }
+    assert_body 'txt'
+  end
 end