sinatra 0.9.0.5 → 0.9.1

data/test/routing_test.rb

@@ -1,5 +1,10 @@
 require File.dirname(__FILE__) + '/helper'
 
+# Helper method for easy route pattern matching testing
+def route_def(pattern)
+  mock_app { get(pattern) { } }
+end
+
 describe "Routing" do
   %w[get put post delete].each do |verb|
     it "defines #{verb.upcase} request handlers with #{verb}" do
@@ -39,6 +44,27 @@ describe "Routing" do
     assert_equal 404, status
   end
 
+  it 'takes multiple definitions of a route' do
+    mock_app {
+      user_agent(/Foo/)
+      get '/foo' do
+        'foo'
+      end
+
+      get '/foo' do
+        'not foo'
+      end
+    }
+
+    get '/foo', {}, 'HTTP_USER_AGENT' => 'Foo'
+    assert ok?
+    assert_equal 'foo', body
+
+    get '/foo'
+    assert ok?
+    assert_equal 'not foo', body
+  end
+
   it "exposes params with indifferent hash" do
     mock_app {
       get '/:foo' do
@@ -134,6 +160,64 @@ describe "Routing" do
     assert ok?
   end
 
+  it "matches a dot ('.') as part of a named param" do
+    mock_app {
+      get '/:foo/:bar' do
+        params[:foo]
+      end
+    }
+
+    get '/user@example.com/name'
+    assert_equal 200, response.status
+    assert_equal 'user@example.com', body
+  end
+
+  it "matches a literal dot ('.') outside of named params" do
+    mock_app {
+      get '/:file.:ext' do
+        assert_equal 'pony', params[:file]
+        assert_equal 'jpg', params[:ext]
+        'right on'
+      end
+    }
+
+    get '/pony.jpg'
+    assert_equal 200, response.status
+    assert_equal 'right on', body
+  end
+
+  it "literally matches . in paths" do
+    route_def '/test.bar'
+
+    get '/test.bar'
+    assert ok?
+    get 'test0bar'
+    assert not_found?
+  end
+
+  it "literally matches $ in paths" do
+    route_def '/test$/'
+
+    get '/test$/'
+    assert ok?
+  end
+
+  it "literally matches + in paths" do
+    route_def '/te+st/'
+
+    get '/te%2Bst/'
+    assert ok?
+    get '/teeeeeeest/'
+    assert not_found?
+  end
+
+  it "literally matches () in paths" do
+    route_def '/test(bar)/'
+
+    get '/test(bar)/'
+    assert ok?
+  end
+
   it "supports basic nested params" do
     mock_app {
       get '/hi' do
@@ -186,7 +270,7 @@ describe "Routing" do
         'looks good'
       end
     }
-    get "/foo?#{param_string(input)}"
+    get "/foo?#{build_query(input)}"
     assert ok?
     assert_equal 'looks good', body
   end
@@ -206,7 +290,7 @@ describe "Routing" do
     assert_equal 'looks good', body
   end
 
-  it "supports paths that include spaces" do
+  it "matches paths that include spaces encoded with %20" do
     mock_app {
       get '/path with spaces' do
         'looks good'
@@ -218,6 +302,18 @@ describe "Routing" do
     assert_equal 'looks good', body
   end
 
+  it "matches paths that include spaces encoded with +" do
+    mock_app {
+      get '/path with spaces' do
+        'looks good'
+      end
+    }
+
+    get '/path+with+spaces'
+    assert ok?
+    assert_equal 'looks good', body
+  end
+
   it "URL decodes named parameters and splats" do
     mock_app {
       get '/:foo/*' do
@@ -256,6 +352,11 @@ describe "Routing" do
     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){} }
+  end
+
   it "returns response immediately on halt" do
     mock_app {
       get '/' do
@@ -442,4 +543,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
 
@@ -64,19 +62,4 @@ describe 'Static' do
     get "/foobarbaz.txt"
     assert not_found?
   end
-
-  it 'serves files when .. path traverses within public directory' do
-    get "/data/../#{File.basename(__FILE__)}"
-    assert ok?
-    assert_equal File.read(__FILE__), body
-  end
-
-  it '404s when .. path traverses outside of public directory' do
-    mock_app {
-      set :static, true
-      set :public, File.dirname(__FILE__) + '/data'
-    }
-    get "/../#{File.basename(__FILE__)}"
-    assert not_found?
-  end
 end

data/test/test_test.rb

@@ -0,0 +1,144 @@
+require 'yaml'
+require File.dirname(__FILE__) + '/helper'
+
+describe 'Sinatra::Test' do
+  def request
+    YAML.load(body)
+  end
+
+  def request_body
+    request['test.body']
+  end
+
+  def request_params
+    YAML.load(request['test.params'])
+  end
+
+  before do
+    mock_app {
+      %w[get head post put delete].each { |verb|
+        send(verb, '/') do
+          redirect '/redirected' if params[:redirect]
+          env.update('test.body'   => request.body.read)
+          env.update('test.params' => params.to_yaml)
+          env.to_yaml
+        end
+      }
+
+      get '/redirected' do
+        "you've been redirected"
+      end
+    }
+  end
+
+  it 'allows GET/HEAD/POST/PUT/DELETE' do
+    get '/'
+    assert_equal('GET', request['REQUEST_METHOD'])
+
+    post '/'
+    assert_equal('POST', request['REQUEST_METHOD'])
+
+    put '/'
+    assert_equal('PUT', request['REQUEST_METHOD'])
+
+    delete '/'
+    assert_equal('DELETE', request['REQUEST_METHOD'])
+
+    head '/'
+    assert_equal('596', response.headers['Content-Length'])
+    assert_equal('', response.body)
+  end
+
+  it 'allows to specify a body' do
+    post '/', '42'
+    assert_equal '42', request_body
+  end
+
+  it 'allows to specify params' do
+    get '/', :foo => 'bar'
+    assert_equal 'bar', request_params['foo']
+  end
+
+  it 'supports nested params' do
+    get '/', :foo => { :x => 'y', :chunky => 'bacon' }
+    assert_equal "y", request_params['foo']['x']
+    assert_equal "bacon", request_params['foo']['chunky']
+  end
+
+  it 'provides easy access to response status and body' do
+    get '/'
+    assert_equal 200, status
+    assert body =~ /^---/
+  end
+
+  it 'delegates methods to @response' do
+    get '/'
+    assert ok?
+  end
+
+  it 'follows redirect' do
+    get '/', :redirect => true
+    follow!
+    assert_equal "you've been redirected", body
+  end
+
+  it 'provides sugar for common HTTP headers' do
+    get '/', :env => { :accept => 'text/plain' }
+    assert_equal 'text/plain', request['HTTP_ACCEPT']
+
+    get '/', :env => { :agent => 'TATFT' }
+    assert_equal 'TATFT', request['HTTP_USER_AGENT']
+
+    get '/', :env => { :host => '1.2.3.4' }
+    assert_equal '1.2.3.4', request['HTTP_HOST']
+
+    get '/', :env => { :session => 'foo' }
+    assert_equal 'foo', request['rack.session']
+
+    get '/', :env => { :cookies => 'foo' }
+    assert_equal 'foo', request['HTTP_COOKIE']
+
+    get '/', :env => { :content_type => 'text/plain' }
+    assert_equal 'text/plain', request['CONTENT_TYPE']
+  end
+
+  it 'allow to test session easily' do
+    app = mock_app(Sinatra::Default) {
+      get '/' do
+        session['foo'] = 'bar'
+        200
+      end
+
+      post '/' do
+        assert_equal 'bar', session['foo']
+        session['foo'] || "blah"
+      end
+    }
+
+    browser = Sinatra::TestHarness.new(app)
+    browser.get '/'
+    browser.post '/', {}, :session => { 'foo' => 'bar' }
+    assert_equal 'bar', browser.response.body
+  end
+
+  it 'yields the request object to the block before invoking the application' do
+    called = false
+    get '/' do |req|
+      called = true
+      assert req.kind_of?(Rack::MockRequest)
+    end
+    assert called
+  end
+
+  it 'sets the environment to :test on include' do
+    Sinatra::Default.set(:environment, :production)
+    Class.new { include Sinatra::Test }
+    assert_equal :test, Sinatra::Default.environment
+  end
+
+  def test_TestHarness
+    session  = Sinatra::TestHarness.new(@app)
+    response = session.get('/')
+    assert_equal 200, response.status
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sinatra
 version: !ruby/object:Gem::Version 
-  version: 0.9.0.5
+  version: 0.9.1
 platform: ruby
 authors: 
 - Blake Mizerany
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-09 00:00:00 -07:00
+date: 2009-03-02 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,6 +21,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version 
         version: 0.9.1
+    - - <
+      - !ruby/object:Gem::Version 
+        version: "1.0"
     version: 
 description: Classy web-development dressed in a DSL
 email: sinatrarb@googlegroups.com
@@ -88,6 +91,7 @@ files:
 - 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
@@ -97,12 +101,15 @@ files:
 - 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
@@ -147,6 +154,7 @@ test_files:
 - test/base_test.rb
 - test/builder_test.rb
 - test/erb_test.rb
+- test/extensions_test.rb
 - test/filter_test.rb
 - test/haml_test.rb
 - test/helpers_test.rb
@@ -155,9 +163,12 @@ test_files:
 - 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