sinatra 1.4.8 → 2.0.0

data/test/rabl_test.rb

@@ -1,89 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-begin
-require 'rabl'
-require 'ostruct'
-require 'json'
-require 'active_support/core_ext/hash/conversions'
-
-class RablTest < Minitest::Test
-  def rabl_app(&block)
-    mock_app {
-      set :views, File.dirname(__FILE__) + '/views'
-      get '/', &block
-    }
-    get '/'
-  end
-
-  it 'renders inline rabl strings' do
-    rabl_app do
-      @foo = OpenStruct.new(:baz => 'w00t')
-      rabl %q{
-        object @foo
-        attributes :baz
-      }
-    end
-    assert ok?
-    assert_equal '{"openstruct":{"baz":"w00t"}}', body
-  end
-  it 'renders .rabl files in views path' do
-    rabl_app do
-      @foo = OpenStruct.new(:bar => 'baz')
-      rabl :hello
-    end
-    assert ok?
-    assert_equal '{"openstruct":{"bar":"baz"}}', body
-  end
-
-  it "renders with file layouts" do
-    rabl_app {
-      @foo = OpenStruct.new(:bar => 'baz')
-      rabl :hello, :layout => :layout2
-    }
-    assert ok?
-    assert_equal '{"qux":{"openstruct":{"bar":"baz"}}}', body
-  end
-
-  it "raises error if template not found" do
-    mock_app {
-      get('/') { rabl :no_such_template }
-    }
-    assert_raises(Errno::ENOENT) { get('/') }
-  end
-
-  it "passes rabl options to the rabl engine" do
-    mock_app do
-      get('/') do
-        @foo = OpenStruct.new(:bar => 'baz')
-        rabl %q{
-          object @foo
-          attributes :bar
-        }, :format => 'xml'
-      end
-    end
-    get '/'
-    assert ok?
-    assert_body '<?xml version="1.0" encoding="UTF-8"?><openstruct><bar>baz</bar></openstruct>'
-  end
-
-  it "passes default rabl options to the rabl engine" do
-    mock_app do
-      set :rabl, :format => 'xml'
-      get('/') do
-        @foo = OpenStruct.new(:bar => 'baz')
-        rabl %q{
-          object @foo
-          attributes :bar
-        }
-      end
-    end
-    get '/'
-    assert ok?
-    assert_body '<?xml version="1.0" encoding="UTF-8"?><openstruct><bar>baz</bar></openstruct>'
-  end
-
-end
-
-rescue LoadError
-  warn "#{$!.to_s}: skipping rabl tests"
-end

data/test/rack_test.rb

@@ -1,45 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'rack'
-
-class RackTest < Minitest::Test
-  setup do
-    @foo = Sinatra.new { get('/foo') { 'foo' }}
-    @bar = Sinatra.new { get('/bar') { 'bar' }}
-  end
-
-  def build(*middleware)
-    endpoint = middleware.pop
-    @app = Rack::Builder.app do
-      middleware.each { |m| use m }
-      run endpoint
-    end
-  end
-
-  def check(*middleware)
-    build(*middleware)
-    assert get('/foo').ok?
-    assert_body 'foo'
-    assert get('/bar').ok?
-    assert_body 'bar'
-  end
-
-  it 'works as middleware in front of Rack::Lock, with lock enabled' do
-    @foo.enable :lock
-    check(@foo, Rack::Lock, @bar)
-  end
-
-  it 'works as middleware behind Rack::Lock, with lock enabled' do
-    @foo.enable :lock
-    check(Rack::Lock, @foo, @bar)
-  end
-
-  it 'works as middleware in front of Rack::Lock, with lock disabled' do
-    @foo.disable :lock
-    check(@foo, Rack::Lock, @bar)
-  end
-
-  it 'works as middleware behind Rack::Lock, with lock disabled' do
-    @foo.disable :lock
-    check(Rack::Lock, @foo, @bar)
-  end
-end

data/test/radius_test.rb

@@ -1,59 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-begin
-require 'radius'
-
-class RadiusTest < Minitest::Test
-  def radius_app(&block)
-    mock_app do
-      set :views, File.dirname(__FILE__) + '/views'
-      get('/', &block)
-    end
-    get '/'
-  end
-
-  it 'renders inline radius strings' do
-    radius_app { radius '<h1>Hiya</h1>' }
-    assert ok?
-    assert_equal "<h1>Hiya</h1>", body
-  end
-
-  it 'renders .radius files in views path' do
-    radius_app { radius :hello }
-    assert ok?
-    assert_equal "<h1>Hello From Radius</h1>\n", body
-  end
-
-  it "renders with inline layouts" do
-    mock_app do
-      layout { "<h1>THIS. IS. <r:yield /></h1>" }
-      get('/') { radius '<EM>SPARTA</EM>' }
-    end
-    get '/'
-    assert ok?
-    assert_equal "<h1>THIS. IS. <EM>SPARTA</EM></h1>", body
-  end
-
-  it "renders with file layouts" do
-    radius_app { radius 'Hello World', :layout => :layout2 }
-    assert ok?
-    assert_equal "<h1>Radius Layout!</h1>\n<p>Hello World</p>\n", body
-  end
-
-  it "raises error if template not found" do
-    mock_app { get('/') { radius :no_such_template } }
-    assert_raises(Errno::ENOENT) { get('/') }
-  end
-
-  it "allows passing locals" do
-    radius_app {
-      radius '<r:value />', :locals => { :value => 'foo' }
-    }
-    assert ok?
-    assert_equal 'foo', body
-  end
-end
-
-rescue LoadError
-  warn "#{$!.to_s}: skipping radius tests"
-end

data/test/rdoc_test.rb

@@ -1,66 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-begin
-require 'rdoc'
-require 'rdoc/markup/to_html'
-
-class RdocTest < Minitest::Test
-  def rdoc_app(&block)
-    mock_app do
-      set :views, File.dirname(__FILE__) + '/views'
-      get('/', &block)
-    end
-    get '/'
-  end
-
-  it 'renders inline rdoc strings' do
-    rdoc_app { rdoc '= Hiya' }
-    assert ok?
-    assert_body(/<h1[^>]*>Hiya(<span><a href=\"#label-Hiya\">&para;<\/a> <a href=\"#(documentation|top)\">&uarr;<\/a><\/span>)?<\/h1>/)
-  end
-
-  it 'renders .rdoc files in views path' do
-    rdoc_app { rdoc :hello }
-    assert ok?
-    assert_body(/<h1[^>]*>Hello From RDoc(<span><a href=\"#label-Hello\+From\+RDoc\">&para;<\/a> <a href=\"#(documentation|top)\">&uarr;<\/a><\/span>)?<\/h1>/)
-  end
-
-  it "raises error if template not found" do
-    mock_app { get('/') { rdoc :no_such_template } }
-    assert_raises(Errno::ENOENT) { get('/') }
-  end
-
-  it "renders with inline layouts" do
-    mock_app do
-      layout { 'THIS. IS. #{yield.upcase}!' }
-      get('/') { rdoc 'Sparta', :layout_engine => :str }
-    end
-    get '/'
-    assert ok?
-    assert_like 'THIS. IS. <P>SPARTA</P>!', body
-  end
-
-  it "renders with file layouts" do
-    rdoc_app {
-      rdoc '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><%= rdoc :inner %></outer>" }
-      get('/') { erb :outer }
-    end
-
-    get '/'
-    assert ok?
-    assert_like '<outer><p>hi</p></outer>', body
-  end
-end
-
-rescue LoadError
-  warn "#{$!.to_s}: skipping rdoc tests"
-end

data/test/readme_test.rb

@@ -1,130 +0,0 @@
-# Tests to check if all the README examples work.
-require File.expand_path('../helper', __FILE__)
-
-class ReadmeTest < Minitest::Test
-  example do
-    mock_app { get('/') { 'Hello world!' } }
-    get '/'
-    assert_body 'Hello world!'
-  end
-
-  section "Routes" do
-    example do
-      mock_app do
-        get('/') { ".. show something .." }
-
-        post('/') { ".. create something .." }
-
-        put('/') { ".. replace something .." }
-
-        patch('/') { ".. modify something .." }
-
-        delete('/') { ".. annihilate something .." }
-
-        options('/') { ".. appease something .." }
-
-        link('/') { ".. affiliate something .." }
-
-        unlink('/') { ".. separate something .." }
-      end
-
-      get '/'
-      assert_body '.. show something ..'
-
-      post '/'
-      assert_body '.. create something ..'
-
-      put '/'
-      assert_body '.. replace something ..'
-
-      patch '/'
-      assert_body '.. modify something ..'
-
-      delete '/'
-      assert_body '.. annihilate something ..'
-
-      options '/'
-      assert_body '.. appease something ..'
-
-      link '/'
-      assert_body '.. affiliate something ..'
-
-      unlink '/'
-      assert_body '.. separate something ..'
-    end
-
-    example do
-      mock_app do
-        get('/hello/:name') do
-          # matches "GET /hello/foo" and "GET /hello/bar"
-          # params[:name] is 'foo' or 'bar'
-          "Hello #{params[:name]}!"
-        end
-      end
-
-      get '/hello/foo'
-      assert_body 'Hello foo!'
-
-      get '/hello/bar'
-      assert_body 'Hello bar!'
-    end
-
-    example do
-      mock_app { get('/hello/:name') { |n| "Hello #{n}!" } }
-
-      get '/hello/foo'
-      assert_body 'Hello foo!'
-
-      get '/hello/bar'
-      assert_body 'Hello bar!'
-    end
-
-    example do
-      mock_app do
-        get('/say/*/to/*') do
-          # matches /say/hello/to/world
-          params[:splat].inspect # => ["hello", "world"]
-        end
-
-        get('/download/*.*') do
-          # matches /download/path/to/file.xml
-          params[:splat].inspect # => ["path/to/file", "xml"]
-        end
-      end
-
-      get "/say/hello/to/world"
-      assert_body '["hello", "world"]'
-
-      get "/download/path/to/file.xml"
-      assert_body '["path/to/file", "xml"]'
-    end
-
-    example do
-      mock_app do
-        get(%r{/hello/([\w]+)}) {
-          "Hello, #{params[:captures].first}!"
-        }
-      end
-
-      get '/hello/foo'
-      assert_body 'Hello, foo!'
-
-      get '/hello/bar'
-      assert_body 'Hello, bar!'
-    end
-
-    example do
-      mock_app do
-        get( %r{/hello/([\w]+)}) { |c|
-          "Hello, #{c}!"
-        }
-      end
-
-      get '/hello/foo'
-      assert_body 'Hello, foo!'
-
-      get '/hello/bar'
-      assert_body 'Hello, bar!'
-    end
-  end
-end

data/test/request_test.rb

@@ -1,100 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'stringio'
-
-class RequestTest < Minitest::Test
-  it 'responds to #user_agent' do
-    request = Sinatra::Request.new({'HTTP_USER_AGENT' => 'Test'})
-    assert request.respond_to?(:user_agent)
-    assert_equal 'Test', request.user_agent
-  end
-
-  it 'parses POST params when Content-Type is form-dataish' do
-    request = Sinatra::Request.new(
-      'REQUEST_METHOD' => 'PUT',
-      'CONTENT_TYPE' => 'application/x-www-form-urlencoded',
-      'rack.input' => StringIO.new('foo=bar')
-    )
-    assert_equal 'bar', request.params['foo']
-  end
-
-  it 'is secure when the url scheme is https' do
-    request = Sinatra::Request.new('rack.url_scheme' => 'https')
-    assert request.secure?
-  end
-
-  it 'is not secure when the url scheme is http' do
-    request = Sinatra::Request.new('rack.url_scheme' => 'http')
-    assert !request.secure?
-  end
-
-  it 'respects X-Forwarded-Proto header for proxied SSL' do
-    request = Sinatra::Request.new('HTTP_X_FORWARDED_PROTO' => 'https')
-    assert request.secure?
-  end
-
-  it 'is possible to marshal params' do
-    request = Sinatra::Request.new(
-      'REQUEST_METHOD' => 'PUT',
-      'CONTENT_TYPE' => 'application/x-www-form-urlencoded',
-      'rack.input' => StringIO.new('foo=bar')
-    )
-    Sinatra::Base.new!.send(:indifferent_hash).replace(request.params)
-    dumped = Marshal.dump(request.params)
-    assert_equal 'bar', Marshal.load(dumped)['foo']
-  end
-
-  it "exposes the preferred type's parameters" do
-    request = Sinatra::Request.new(
-      'HTTP_ACCEPT' => 'image/jpeg; compress=0.25'
-    )
-    assert_equal({ 'compress' => '0.25' }, request.preferred_type.params)
-  end
-
-  it "makes accept types behave like strings" do
-    request = Sinatra::Request.new('HTTP_ACCEPT' => 'image/jpeg; compress=0.25')
-    assert                     request.accept?('image/jpeg')
-    assert_equal 'image/jpeg', request.preferred_type.to_s
-    assert_equal 'image/jpeg; compress=0.25', request.preferred_type.to_s(true)
-    assert_equal 'image/jpeg', request.preferred_type.to_str
-    assert_equal 'image',      request.preferred_type.split('/').first
-
-    String.instance_methods.each do |method|
-      next unless "".respond_to? method
-      assert request.preferred_type.respond_to?(method), "responds to #{method}"
-    end
-  end
-
-  it "accepts types when wildcards are requested" do
-    request = Sinatra::Request.new('HTTP_ACCEPT' => 'image/*')
-    assert request.accept?('image/jpeg')
-  end
-
-  it "properly decodes MIME type parameters" do
-    request = Sinatra::Request.new(
-      'HTTP_ACCEPT' => 'image/jpeg;unquoted=0.25;quoted="0.25";chartest="\";,\x"'
-    )
-    expected = { 'unquoted' => '0.25', 'quoted' => '0.25', 'chartest' => '";,x' }
-    assert_equal(expected, request.preferred_type.params)
-  end
-
-  it 'accepts */* when HTTP_ACCEPT is not present in the request' do
-    request = Sinatra::Request.new Hash.new
-    assert_equal 1, request.accept.size
-    assert request.accept?('text/html')
-    assert_equal '*/*', request.preferred_type.to_s
-    assert_equal '*/*', request.preferred_type.to_s(true)
-  end
-
-  it 'accepts */* when HTTP_ACCEPT is blank in the request' do
-    request = Sinatra::Request.new 'HTTP_ACCEPT' => ''
-    assert_equal 1, request.accept.size
-    assert request.accept?('text/html')
-    assert_equal '*/*', request.preferred_type.to_s
-    assert_equal '*/*', request.preferred_type.to_s(true)
-  end
-
-  it 'will not accept types not specified in HTTP_ACCEPT when HTTP_ACCEPT is provided' do
-    request = Sinatra::Request.new 'HTTP_ACCEPT' => 'application/json'
-    assert !request.accept?('text/html')
-  end
-end

data/test/response_test.rb

@@ -1,63 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path('../helper', __FILE__)
-
-class ResponseTest < Minitest::Test
-  setup { @response = Sinatra::Response.new }
-
-  def assert_same_body(a, b)
-    assert_equal a.to_enum(:each).to_a, b.to_enum(:each).to_a
-  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.join
-  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!', '✈']
-    _, headers, body = @response.finish
-    assert_equal '14', headers['Content-Length']
-    assert_same_body @response.body, body
-  end
-
-  it 'does not call #to_ary or #inject on the body' do
-    object = Object.new
-    def object.inject(*) fail 'called' end
-    def object.to_ary(*) fail 'called' end
-    def object.each(*) end
-    @response.body = object
-    assert @response.finish
-  end
-
-  it 'does not nest a Sinatra::Response' do
-    @response.body = Sinatra::Response.new ["foo"]
-    assert_same_body @response.body, ["foo"]
-  end
-
-  it 'does not nest a Rack::Response' do
-    @response.body = Rack::Response.new ["foo"]
-    assert_same_body @response.body, ["foo"]
-  end
-end

data/test/result_test.rb

@@ -1,76 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class ResultTest < Minitest::Test
-  it "sets response.body when result is a String" do
-    mock_app { get('/') { 'Hello World' } }
-
-    get '/'
-    assert ok?
-    assert_equal 'Hello World', body
-  end
-
-  it "sets response.body when result is an Array of Strings" do
-    mock_app { get('/') { ['Hello', 'World'] } }
-
-    get '/'
-    assert ok?
-    assert_equal 'HelloWorld', body
-  end
-
-  it "sets response.body when result responds to #each" do
-    mock_app do
-      get('/') do
-        res = lambda { 'Hello World' }
-        def res.each ; yield call ; end
-        return res
-      end
-    end
-
-    get '/'
-    assert ok?
-    assert_equal 'Hello World', body
-  end
-
-  it "sets response.body to [] when result is nil" do
-    mock_app { get( '/') { nil } }
-
-    get '/'
-    assert ok?
-    assert_equal '', body
-  end
-
-  it "sets status, headers, and body when result is a Rack response tuple" do
-    mock_app {
-      get('/') { [203, {'Content-Type' => 'foo/bar'}, 'Hello World'] }
-    }
-
-    get '/'
-    assert_equal 203, status
-    assert_equal 'foo/bar', response['Content-Type']
-    assert_equal 'Hello World', body
-  end
-
-  it "sets status and body when result is a two-tuple" do
-    mock_app { get('/') { [409, 'formula of'] } }
-
-    get '/'
-    assert_equal 409, status
-    assert_equal 'formula of', body
-  end
-
-  it "raises a ArgumentError when result is a non two or three tuple Array" do
-    mock_app {
-      get('/') { [409, 'formula of', 'something else', 'even more'] }
-    }
-
-    assert_raises(ArgumentError) { get '/' }
-  end
-
-  it "sets status when result is a Fixnum status code" do
-    mock_app { get('/') { 205 } }
-
-    get '/'
-    assert_equal 205, status
-    assert_equal '', body
-  end
-end

data/test/route_added_hook_test.rb

@@ -1,59 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-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 < Minitest::Test
-  setup do
-    RouteAddedTest.routes.clear
-    RouteAddedTest.procs.clear
-  end
-
-  it "should be notified of an added route" do
-    mock_app(Class.new(Sinatra::Base)) do
-      register RouteAddedTest
-      get('/') {}
-    end
-
-    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)) do
-      register RouteAddedTest
-      register RouteAddedTest
-      get('/') {}
-    end
-
-    assert_equal [["GET", "/"], ["HEAD", "/"]],
-      RouteAddedTest.routes
-  end
-
-  it "should pass route blocks as an argument" do
-    mock_app(Class.new(Sinatra::Base)) do
-      register RouteAddedTest
-      get('/') {}
-    end
-
-    assert_kind_of Proc, RouteAddedTest.procs.first
-  end
-end