sinatra-sinatra 0.9.0.4 → 0.9.0.5

data/lib/sinatra/test.rb

@@ -7,7 +7,7 @@ module Sinatra
 
     attr_reader :app, :request, :response
 
-    def test_request(verb, path, *args)
+    def make_request(verb, path, *args)
       @app = Sinatra::Application if @app.nil? && defined?(Sinatra::Application)
       fail "@app not set - cannot make request" if @app.nil?
       @request = Rack::MockRequest.new(@app)
@@ -38,14 +38,14 @@ module Sinatra
       @response = @request.request(verb, path, opts)
     end
 
-    def get(path, *args, &b)  ; test_request('GET', path, *args, &b) ; end
-    def head(path, *args, &b) ; test_request('HEAD', path, *args, &b) ; end
-    def post(path, *args, &b) ; test_request('POST', path, *args, &b) ; end
-    def put(path, *args, &b)  ; test_request('PUT', path, *args, &b) ; end
-    def delete(path, *args, &b) ; test_request('DELETE', path, *args, &b) ; end
+    def get(path, *args, &b)  ; make_request('GET', path, *args, &b) ; end
+    def head(path, *args, &b) ; make_request('HEAD', path, *args, &b) ; end
+    def post(path, *args, &b) ; make_request('POST', path, *args, &b) ; end
+    def put(path, *args, &b)  ; make_request('PUT', path, *args, &b) ; end
+    def delete(path, *args, &b) ; make_request('DELETE', path, *args, &b) ; end
 
     def follow!
-      test_request 'GET', @response.location
+      make_request 'GET', @response.location
     end
 
     def body ; @response.body ; end
@@ -65,6 +65,8 @@ module Sinatra
       super || (@response && @response.respond_to?(symbol, include_private))
     end
 
+  private
+
     RACK_OPT_NAMES = {
       :accept => "HTTP_ACCEPT",
       :agent => "HTTP_USER_AGENT",
@@ -103,7 +105,7 @@ module Sinatra
         eval <<-RUBY, binding, __FILE__, __LINE__
         def #{verb}_it(*args, &block)
           sinatra_warn "The #{verb}_it method is deprecated; use #{verb} instead."
-          test_request('#{verb.upcase}', *args, &block)
+          make_request('#{verb.upcase}', *args, &block)
         end
         RUBY
       end

data/sinatra.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
   s.name = 'sinatra'
-  s.version = '0.9.0.4'
-  s.date = '2009-01-25'
+  s.version = '0.9.0.5'
+  s.date = '2009-02-10'
 
   s.description = "Classy web-development dressed in a DSL"
   s.summary     = "Classy web-development dressed in a DSL"
@@ -22,6 +22,7 @@ Gem::Specification.new do |s|
     compat/app_test.rb
     compat/application_test.rb
     compat/builder_test.rb
+    compat/compat_test.rb
     compat/custom_error_test.rb
     compat/erb_test.rb
     compat/events_test.rb
@@ -69,6 +70,7 @@ Gem::Specification.new do |s|
     test/builder_test.rb
     test/data/reload_app_file.rb
     test/erb_test.rb
+    test/extensions_test.rb
     test/filter_test.rb
     test/haml_test.rb
     test/helper.rb
@@ -78,12 +80,15 @@ Gem::Specification.new do |s|
     test/options_test.rb
     test/reload_test.rb
     test/request_test.rb
+    test/response_test.rb
     test/result_test.rb
     test/routing_test.rb
     test/sass_test.rb
+    test/server_test.rb
     test/sinatra_test.rb
     test/static_test.rb
     test/templates_test.rb
+    test/test_test.rb
     test/views/hello.builder
     test/views/hello.erb
     test/views/hello.haml

data/test/base_test.rb

@@ -65,4 +65,17 @@ describe 'Sinatra::Base' do
     assert response.ok?
     assert_equal 'not foo', response.body
   end
+
+  it "makes redirecting back pretty" do
+    app = mock_app {
+      get '/foo' do
+        redirect back
+      end
+    }
+
+    request  = Rack::MockRequest.new(app)
+    response = request.get('/foo', 'HTTP_REFERER' => 'http://github.com')
+    assert response.redirect?
+    assert_equal "http://github.com", response.location
+  end
 end

data/test/extensions_test.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe 'Registering extensions' do
+  module FooExtensions
+    def foo
+    end
+
+    private
+      def im_hiding_in_ur_foos
+      end
+  end
+
+  module BarExtensions
+    def bar
+    end
+  end
+
+  module BazExtensions
+    def baz
+    end
+  end
+
+  module QuuxExtensions
+    def quux
+    end
+  end
+
+  it 'will add the methods to the DSL for the class in which you register them and its subclasses' do
+    Sinatra::Base.register FooExtensions
+    assert Sinatra::Base.respond_to?(:foo)
+
+    Sinatra::Default.register BarExtensions
+    assert Sinatra::Default.respond_to?(:bar)
+    assert Sinatra::Default.respond_to?(:foo)
+    assert !Sinatra::Base.respond_to?(:bar)
+  end
+
+  it 'allows extending by passing a block' do
+    Sinatra::Base.register {
+      def im_in_ur_anonymous_module; end
+    }
+    assert Sinatra::Base.respond_to?(:im_in_ur_anonymous_module)
+  end
+
+  it 'will make sure any public methods added via Default#register are delegated to Sinatra::Delegator' do
+    Sinatra::Default.register FooExtensions
+    assert Sinatra::Delegator.private_instance_methods.
+      map { |m| m.to_sym }.include?(:foo)
+    assert !Sinatra::Delegator.private_instance_methods.
+      map { |m| m.to_sym }.include?(:im_hiding_in_ur_foos)
+  end
+
+  it 'will not delegate methods on Base#register' do
+    Sinatra::Base.register QuuxExtensions
+    assert !Sinatra::Delegator.private_instance_methods.include?("quux")
+  end
+
+  it 'will extend the Sinatra::Default application by default' do
+    Sinatra.register BazExtensions
+    assert !Sinatra::Base.respond_to?(:baz)
+    assert Sinatra::Default.respond_to?(:baz)
+  end
+end

data/test/helper.rb

@@ -32,9 +32,12 @@ end
 #
 def describe(*args, &block)
   return super unless (name = args.first) && block
-  klass = Class.new(Test::Unit::TestCase) do
+  name = "#{name.gsub(/\W/, '')}Test"
+  Object.send :const_set, name, Class.new(Test::Unit::TestCase)
+  klass = Object.const_get(name)
+  klass.class_eval do
     def self.it(name, &block)
-      define_method("test_#{name.gsub(/\W/,'_')}", &block)
+      define_method("test_#{name.gsub(/\W/,'_').downcase}", &block)
     end
     def self.xspecify(*args) end
     def self.before(&block) define_method(:setup, &block)    end
@@ -42,3 +45,11 @@ def describe(*args, &block)
   end
   klass.class_eval &block
 end
+
+# Do not output warnings for the duration of the block.
+def silence_warnings
+  $VERBOSE, v = nil, $VERBOSE
+  yield
+ensure
+  $VERBOSE = v
+end

data/test/helpers_test.rb

@@ -379,3 +379,61 @@ describe 'Helpers#etag' do
     assert_equal 'W/"FOO"', response['ETag']
   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

data/test/mapped_error_test.rb

@@ -1,9 +1,12 @@
 require File.dirname(__FILE__) + '/helper'
 
-describe 'Exception Mappings' do
-  class FooError < RuntimeError
-  end
+class FooError < RuntimeError
+end
 
+class FooNotFound < Sinatra::NotFound
+end
+
+describe 'Exception Mappings' do
   it 'invokes handlers registered with ::error when raised' do
     mock_app {
       set :raise_errors, false
@@ -80,9 +83,6 @@ describe 'Exception Mappings' do
     assert_equal 404, status
   end
 
-  class FooNotFound < Sinatra::NotFound
-  end
-
   it "cascades for subclasses of Sinatra::NotFound" do
     mock_app {
       set :raise_errors, true

data/test/middleware_test.rb

@@ -4,7 +4,9 @@ describe "Middleware" do
   before do
     @app = mock_app(Sinatra::Default) {
       get '/*' do
-        response.headers['X-Tests'] = env['test.ran'].join(', ')
+        response.headers['X-Tests'] = env['test.ran'].
+          map { |n| n.split('::').last }.
+          join(', ')
         env['PATH_INFO']
       end
     }

data/test/response_test.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/helper'
+
+describe 'Sinatra::Response' do
+  before do
+    @response = Sinatra::Response.new
+  end
+
+  it "initializes with 200, text/html, and empty body" do
+    assert_equal 200, @response.status
+    assert_equal 'text/html', @response['Content-Type']
+    assert_equal [], @response.body
+  end
+
+  it 'uses case insensitive headers' do
+    @response['content-type'] = 'application/foo'
+    assert_equal 'application/foo', @response['Content-Type']
+    assert_equal 'application/foo', @response['CONTENT-TYPE']
+  end
+
+  it 'writes to body' do
+    @response.body = 'Hello'
+    @response.write ' World'
+    assert_equal 'Hello World', @response.body
+  end
+
+  [204, 304].each do |status_code|
+    it "removes the Content-Type header and body when response status is #{status_code}" do
+      @response.status = status_code
+      @response.body = ['Hello World']
+      assert_equal [status_code, {}, []], @response.finish
+    end
+  end
+
+  it 'Calculates the Content-Length using the bytesize of the body' do
+    @response.body = ['Hello', 'World!', '✈']
+    status, headers, body = @response.finish
+    assert_equal '14', headers['Content-Length']
+    assert_equal @response.body, body
+  end
+end

data/test/routing_test.rb

@@ -484,4 +484,170 @@ describe "Routing" do
       assert_equal type, response.headers['Content-Type']
     end
   end
+
+  it 'degrades gracefully when optional accept header is not provided' do
+    mock_app {
+      get '/', :provides => :xml do
+        request.env['HTTP_ACCEPT']
+      end
+      get '/' do
+        'default'
+      end
+    }
+    get '/'
+    assert ok?
+    assert_equal 'default', body
+  end
+
+  it 'passes a single url param as block parameters when one param is specified' do
+    mock_app {
+      get '/:foo' do |foo|
+        assert_equal 'bar', foo
+      end
+    }
+
+    get '/bar'
+    assert ok?
+  end
+
+  it 'passes multiple params as block parameters when many are specified' do
+    mock_app {
+      get '/:foo/:bar/:baz' do |foo, bar, baz|
+        assert_equal 'abc', foo
+        assert_equal 'def', bar
+        assert_equal 'ghi', baz
+      end
+    }
+
+    get '/abc/def/ghi'
+    assert ok?
+  end
+
+  it 'passes regular expression captures as block parameters' do
+    mock_app {
+      get(/^\/fo(.*)\/ba(.*)/) do |foo, bar|
+        assert_equal 'orooomma', foo
+        assert_equal 'f', bar
+        'looks good'
+      end
+    }
+
+    get '/foorooomma/baf'
+    assert ok?
+    assert_equal 'looks good', body
+  end
+
+  it "supports mixing multiple splat params like /*/foo/*/* as block parameters" do
+    mock_app {
+      get '/*/foo/*/*' do |foo, bar, baz|
+        assert_equal 'bar', foo
+        assert_equal 'bling', bar
+        assert_equal 'baz/boom', baz
+        'looks good'
+      end
+    }
+
+    get '/bar/foo/bling/baz/boom'
+    assert ok?
+    assert_equal 'looks good', body
+  end
+
+  it 'raises an ArgumentError with block arity > 1 and too many values' do
+    mock_app {
+      get '/:foo/:bar/:baz' do |foo, bar|
+        'quux'
+      end
+    }
+
+    assert_raise(ArgumentError) { get '/a/b/c' }
+  end
+
+  it 'raises an ArgumentError with block param arity > 1 and too few values' do
+    mock_app {
+      get '/:foo/:bar' do |foo, bar, baz|
+        'quux'
+      end
+    }
+
+    assert_raise(ArgumentError) { get '/a/b' }
+  end
+
+  it 'succeeds if no block parameters are specified' do
+    mock_app {
+      get '/:foo/:bar' do
+        'quux'
+      end
+    }
+
+    get '/a/b'
+    assert ok?
+    assert_equal 'quux', body
+  end
+
+  it 'passes all params with block param arity -1 (splat args)' do
+    mock_app {
+      get '/:foo/:bar' do |*args|
+        args.join
+      end
+    }
+
+    get '/a/b'
+    assert ok?
+    assert_equal 'ab', 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
+  # arity raises an ArgumentError.
+
+  if RUBY_VERSION >= '1.9'
+
+    it 'raises an ArgumentError with block param arity 1 and no values' do
+      mock_app {
+        get '/foo' do |foo|
+          'quux'
+        end
+      }
+
+      assert_raise(ArgumentError) { get '/foo' }
+    end
+
+    it 'raises an ArgumentError with block param arity 1 and too many values' do
+      mock_app {
+        get '/:foo/:bar/:baz' do |foo|
+          'quux'
+        end
+      }
+
+      assert_raise(ArgumentError) { get '/a/b/c' }
+    end
+
+  else
+
+    it 'does not raise an ArgumentError with block param arity 1 and no values' do
+      mock_app {
+        get '/foo' do |foo|
+          'quux'
+        end
+      }
+
+      silence_warnings { get '/foo' }
+      assert ok?
+      assert_equal 'quux', body
+    end
+
+    it 'does not raise an ArgumentError with block param arity 1 and too many values' do
+      mock_app {
+        get '/:foo/:bar/:baz' do |foo|
+          'quux'
+        end
+      }
+
+      silence_warnings { get '/a/b/c' }
+      assert ok?
+      assert_equal 'quux', body
+    end
+
+  end
 end

data/test/server_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/helper'
+
+class Rack::Handler::Mock
+  extend Test::Unit::Assertions
+
+  def self.run(app, options={})
+    assert(app < Sinatra::Base)
+    assert_equal 9001, options[:Port]
+    assert_equal 'foo.local', options[:Host]
+    yield new
+  end
+
+  def stop
+  end
+end
+
+describe 'Sinatra::Base.run!' do
+  before do
+    mock_app {
+      set :server, 'mock'
+      set :host, 'foo.local'
+      set :port, 9001
+    }
+    $stdout = File.open('/dev/null', 'wb')
+  end
+
+  after { $stdout = STDOUT }
+
+  it "locates the appropriate Rack handler and calls ::run" do
+    @app.run!
+  end
+
+  it "sets options on the app before running" do
+    @app.run! :sessions => true
+    assert @app.sessions?
+  end
+
+  it "falls back on the next server handler when not found" do
+    @app.run! :server => %w[foo bar mock]
+  end
+end

data/test/static_test.rb

@@ -1,17 +1,15 @@
 require File.dirname(__FILE__) + '/helper'
 
 describe 'Static' do
-  F = ::File
-
   before do
     mock_app {
       set :static, true
-      set :public, F.dirname(__FILE__)
+      set :public, File.dirname(__FILE__)
     }
   end
 
   it 'serves GET requests for files in the public directory' do
-    get "/#{F.basename(__FILE__)}"
+    get "/#{File.basename(__FILE__)}"
     assert ok?
     assert_equal File.read(__FILE__), body
     assert_equal File.size(__FILE__).to_s, response['Content-Length']
@@ -19,7 +17,7 @@ describe 'Static' do
   end
 
   it 'produces a body that can be iterated over multiple times' do
-    env = Rack::MockRequest.env_for("/#{F.basename(__FILE__)}")
+    env = Rack::MockRequest.env_for("/#{File.basename(__FILE__)}")
     status, headers, body = @app.call(env)
     buf1, buf2 = [], []
     body.each { |part| buf1 << part }
@@ -29,7 +27,7 @@ describe 'Static' do
   end
 
   it 'serves HEAD requests for files in the public directory' do
-    head "/#{F.basename(__FILE__)}"
+    head "/#{File.basename(__FILE__)}"
     assert ok?
     assert_equal '', body
     assert_equal File.size(__FILE__).to_s, response['Content-Length']
@@ -37,8 +35,8 @@ describe 'Static' do
   end
 
   it 'serves files in preference to custom routes' do
-    @app.get("/#{F.basename(__FILE__)}") { 'Hello World' }
-    get "/#{F.basename(__FILE__)}"
+    @app.get("/#{File.basename(__FILE__)}") { 'Hello World' }
+    get "/#{File.basename(__FILE__)}"
     assert ok?
     assert body != 'Hello World'
   end
@@ -50,13 +48,13 @@ describe 'Static' do
 
   it 'passes to the next handler when the static option is disabled' do
     @app.set :static, false
-    get "/#{F.basename(__FILE__)}"
+    get "/#{File.basename(__FILE__)}"
     assert not_found?
   end
 
   it 'passes to the next handler when the public option is nil' do
     @app.set :public, nil
-    get "/#{F.basename(__FILE__)}"
+    get "/#{File.basename(__FILE__)}"
     assert not_found?
   end
 

data/test/test_test.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe "Sinatra::Test" do
+  it "support nested parameters" do
+    mock_app {
+      get '/' do
+        params[:post][:title]
+      end
+
+      post '/' do
+        params[:post][:content]
+      end
+    }
+
+    get '/', :post => { :title => 'My Post Title' }
+    assert_equal 'My Post Title', body
+
+    post '/', :post => { :content => 'Post Content' }
+    assert_equal 'Post Content', body
+  end
+end