adamwiggins-sinatra 0.8.9 → 0.10.1

data/compat/app_test.rb

@@ -1,300 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-context "Sinatra" do
-
-  setup do
-    Sinatra.application = nil
-  end
-
-  specify "should put all DSL methods on (main)" do
-    object = Object.new
-    Sinatra::Application::FORWARD_METHODS.each do |method|
-      object.private_methods.should.include(method)
-    end
-  end
-
-  specify "should handle result of nil" do
-    get '/' do
-      nil
-    end
-
-    get_it '/'
-    should.be.ok
-    body.should == ''
-  end
-
-  specify "handles events" do
-    get '/:name' do
-      'Hello ' + params["name"]
-    end
-
-    get_it '/Blake'
-
-    should.be.ok
-    body.should.equal 'Hello Blake'
-  end
-
-
-  specify "handles splats" do
-    get '/hi/*' do
-      params["splat"].kind_of?(Array).should.equal true
-      params["splat"].first
-    end
-
-    get_it '/hi/Blake'
-
-    should.be.ok
-    body.should.equal 'Blake'
-  end
-
-  specify "handles multiple splats" do
-    get '/say/*/to/*' do
-      params["splat"].join(' ')
-    end
-
-    get_it '/say/hello/to/world'
-
-    should.be.ok
-    body.should.equal 'hello world'
-  end
-
-  specify "allow empty splats" do
-    get '/say/*/to*/*' do
-      params["splat"].join(' ')
-    end
-
-    get_it '/say/hello/to/world'
-
-    should.be.ok
-    body.should.equal 'hello  world' # second splat is empty
-
-    get_it '/say/hello/tomy/world'
-
-    should.be.ok
-    body.should.equal 'hello my world'
-  end
-
-  specify "gives access to underlying response header Hash" do
-    get '/' do
-      header['X-Test'] = 'Is this thing on?'
-      headers 'X-Test2' => 'Foo', 'X-Test3' => 'Bar'
-      ''
-    end
-
-    get_it '/'
-    should.be.ok
-    headers.should.include 'X-Test'
-    headers['X-Test'].should.equal 'Is this thing on?'
-    headers.should.include 'X-Test3'
-    headers['X-Test3'].should.equal 'Bar'
-  end
-
-  specify "follows redirects" do
-    get '/' do
-      redirect '/blake'
-    end
-
-    get '/blake' do
-      'Mizerany'
-    end
-
-    get_it '/'
-    should.be.redirection
-    body.should.equal ''
-
-    follow!
-    should.be.ok
-    body.should.equal 'Mizerany'
-  end
-
-  specify "renders a body with a redirect" do
-    helpers do
-      def foo ; 'blah' ; end
-    end
-    get "/" do
-      redirect 'foo', :foo
-    end
-    get_it '/'
-    should.be.redirection
-    headers['Location'].should.equal 'foo'
-    body.should.equal 'blah'
-  end
-
-  specify "redirects permanently with 301 status code" do
-    get "/" do
-      redirect 'foo', 301
-    end
-    get_it '/'
-    should.be.redirection
-    headers['Location'].should.equal 'foo'
-    status.should.equal 301
-    body.should.be.empty
-  end
-
-  specify "stop sets content and ends event" do
-    get '/set_body' do
-      stop 'Hello!'
-      stop 'World!'
-      fail 'stop should have halted'
-    end
-
-    get_it '/set_body'
-
-    should.be.ok
-    body.should.equal 'Hello!'
-
-  end
-
-  # Deprecated. WTF was going on here? What's the 1 in [:foo, 1] do?
-  xspecify "should set status then call helper with a var" do
-    helpers do
-      def foo
-        'bah!'
-      end
-    end
-
-    get '/set_body' do
-      stop [404, [:foo, 1]]
-    end
-
-    get_it '/set_body'
-
-    should.be.not_found
-    body.should.equal 'bah!'
-
-  end
-
-  specify "should easily set response Content-Type" do
-    get '/foo.html' do
-      content_type 'text/html', :charset => 'utf-8'
-      "<h1>Hello, World</h1>"
-    end
-
-    get_it '/foo.html'
-    should.be.ok
-    headers['Content-Type'].should.equal 'text/html;charset=utf-8'
-    body.should.equal '<h1>Hello, World</h1>'
-
-    get '/foo_test.xml' do
-      content_type :xml
-      "<feed></feed>"
-    end
-
-    get_it '/foo_test.xml'
-    should.be.ok
-    headers['Content-Type'].should.equal 'application/xml'
-    body.should.equal '<feed></feed>'
-  end
-
-  specify "supports conditional GETs with last_modified" do
-    modified_at = Time.now
-    get '/maybe' do
-      last_modified modified_at
-      'response body, maybe'
-    end
-
-    get_it '/maybe'
-    should.be.ok
-    body.should.equal 'response body, maybe'
-
-    get_it '/maybe', :env => { 'HTTP_IF_MODIFIED_SINCE' => modified_at.httpdate }
-    status.should.equal 304
-    body.should.equal ''
-  end
-
-  specify "supports conditional GETs with entity_tag" do
-    get '/strong' do
-      entity_tag 'FOO'
-      'foo response'
-    end
-
-    get_it '/strong'
-    should.be.ok
-    body.should.equal 'foo response'
-
-    get_it '/strong', {},
-      'HTTP_IF_NONE_MATCH' => '"BAR"'
-    should.be.ok
-    body.should.equal 'foo response'
-
-    get_it '/strong', {},
-      'HTTP_IF_NONE_MATCH' => '"FOO"'
-    status.should.equal 304
-    body.should.equal ''
-
-    get_it '/strong', {},
-      'HTTP_IF_NONE_MATCH' => '"BAR", *'
-    status.should.equal 304
-    body.should.equal ''
-  end
-
-  specify "delegates HEAD requests to GET handlers" do
-    get '/invisible' do
-      "I am invisible to the world"
-    end
-
-    head_it '/invisible'
-    should.be.ok
-    body.should.not.equal "I am invisible to the world"
-    body.should.equal ''
-  end
-
-
-  specify "supports PUT" do
-    put '/' do
-      'puted'
-    end
-    put_it '/'
-    assert_equal 'puted', body
-  end
-
-  specify "rewrites POSTs with _method param to PUT" do
-    put '/' do
-      'puted'
-    end
-    post_it '/', :_method => 'PUT'
-    assert_equal 'puted', body
-  end
-
-  specify "rewrites POSTs with lowercase _method param to PUT" do
-    put '/' do
-      'puted'
-    end
-    post_it '/', :_method => 'put'
-    body.should.equal 'puted'
-  end
-
-  specify "does not rewrite GETs with _method param to PUT" do
-    get '/' do
-      'getted'
-    end
-    get_it '/', :_method => 'put'
-    should.be.ok
-    body.should.equal 'getted'
-  end
-
-  specify "ignores _method query string parameter on non-POST requests" do
-    post '/' do
-      'posted'
-    end
-    put '/' do
-      'booo'
-    end
-    post_it "/?_method=PUT"
-    should.be.ok
-    body.should.equal 'posted'
-  end
-
-  specify "does not read body if content type is not url encoded" do
-    post '/foo.xml' do
-      request.env['CONTENT_TYPE'].should.be == 'application/xml'
-      request.content_type.should.be == 'application/xml'
-      request.body.read
-    end
-
-    post_it '/foo.xml', '<foo></foo>', :content_type => 'application/xml'
-    @response.should.be.ok
-    @response.body.should.be == '<foo></foo>'
-  end
-
-end

data/compat/application_test.rb

@@ -1,334 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-require 'uri'
-
-class TesterWithEach
-  def each
-    yield 'foo'
-    yield 'bar'
-    yield 'baz'
-  end
-end
-
-context "Looking up a request" do
-
-  setup do
-    Sinatra.application = nil
-  end
-
-  # Deprecated. The lookup method is no longer used.
-  xspecify "returns what's at the end" do
-    block = Proc.new { 'Hello' }
-    get '/', &block
-
-    result = Sinatra.application.lookup(
-      Rack::Request.new(
-        'REQUEST_METHOD' => 'GET',
-        'PATH_INFO' => '/'
-      )
-    )
-
-    result.should.not.be.nil
-    result.block.should.be block
-  end
-
-  # Deprecated. The lookup method is no longer used.
-  xspecify "takes params in path" do
-    block = Proc.new { 'Hello' }
-    get '/:foo', &block
-
-    result = Sinatra.application.lookup(
-      Rack::Request.new(
-        'REQUEST_METHOD' => 'GET',
-        'PATH_INFO' => '/bar'
-      )
-    )
-
-    result.should.not.be.nil
-    result.block.should.be block
-    result.params.should.equal "foo" => 'bar'
-  end
-
-end
-
-context "An app returns" do
-
-  setup do
-    Sinatra.application = nil
-  end
-
-  specify "404 if no events found" do
-    request = Rack::MockRequest.new(@app)
-    get_it '/'
-    should.be.not_found
-    body.should.equal '<h1>Not Found</h1>'
-  end
-
-  specify "200 if success" do
-    get '/' do
-      'Hello World'
-    end
-    get_it '/'
-    should.be.ok
-    body.should.equal 'Hello World'
-  end
-
-  specify "an objects result from each if it has it" do
-
-    get '/' do
-      TesterWithEach.new
-    end
-
-    get_it '/'
-    should.be.ok
-    body.should.equal 'foobarbaz'
-
-  end
-
-  # Deprecated. The body method no longer halts.
-  xspecify "the body set if set before the last" do
-
-    get '/' do
-      body 'Blake'
-      'Mizerany'
-    end
-
-    get_it '/'
-    should.be.ok
-    body.should.equal 'Blake'
-
-  end
-
-  specify "404 if NotFound is raised" do
-
-    get '/' do
-      raise Sinatra::NotFound
-    end
-
-    get_it '/'
-    should.be.not_found
-
-  end
-
-end
-
-context "Application#configure blocks" do
-
-  setup do
-    Sinatra.application = nil
-  end
-
-  specify "run when no environment specified" do
-    ref = false
-    configure { ref = true }
-    ref.should.equal true
-  end
-
-  specify "run when matching environment specified" do
-    ref = false
-    configure(:test) { ref = true }
-    ref.should.equal true
-  end
-
-  specify "do not run when no matching environment specified" do
-    configure(:foo) { flunk "block should not have been executed" }
-    configure(:development, :production, :foo) { flunk "block should not have been executed" }
-  end
-
-  specify "accept multiple environments" do
-    ref = false
-    configure(:foo, :test, :bar) { ref = true }
-    ref.should.equal true
-  end
-
-end
-
-context "Default Application Configuration" do
-
-  # Sinatra::ServerError is no longer used
-  xspecify "includes 404 and 500 error handlers" do
-    Sinatra.application.errors.should.include(Sinatra::ServerError)
-    Sinatra.application.errors[Sinatra::ServerError].should.not.be.nil
-    Sinatra.application.errors.should.include(Sinatra::NotFound)
-    Sinatra.application.errors[Sinatra::NotFound].should.not.be.nil
-  end
-
-  # Deprecated. No such thing as a Static event anymore.
-  xspecify "includes Static event" do
-    assert Sinatra.application.events[:get].any? { |e| Sinatra::Static === e }
-  end
-
-end
-
-context "Events in an app" do
-
-  setup do
-    Sinatra.application = nil
-  end
-
-  specify "evaluate in a clean context" do
-    helpers do
-      def foo
-        'foo'
-      end
-    end
-
-    get '/foo' do
-      foo
-    end
-
-    get_it '/foo'
-    should.be.ok
-    body.should.equal 'foo'
-  end
-
-  specify "get access to request, response, and params" do
-    get '/:foo' do
-      params["foo"] + params["bar"]
-    end
-
-    get_it '/foo?bar=baz'
-    should.be.ok
-    body.should.equal 'foobaz'
-  end
-
-  specify "can filters by agent" do
-
-    get '/', :agent => /Windows/ do
-      request.env['HTTP_USER_AGENT']
-    end
-
-    get_it '/', :env => { :agent => 'Windows' }
-    should.be.ok
-    body.should.equal 'Windows'
-
-    get_it '/', :env => { :agent => 'Mac' }
-    should.not.be.ok
-
-  end
-
-  specify "can use regex to get parts of user-agent" do
-
-    get '/', :agent => /Windows (NT)/ do
-      params[:agent].first
-    end
-
-    get_it '/', :env => { :agent => 'Windows NT' }
-
-    body.should.equal 'NT'
-
-  end
-
-  specify "can deal with spaces in paths" do
-
-    path = '/path with spaces'
-
-    get path do
-      "Look ma, a path with spaces!"
-    end
-
-    get_it URI.encode(path)
-
-    body.should.equal "Look ma, a path with spaces!"
-  end
-
-  specify "route based on host" do
-
-    get '/' do
-      'asdf'
-    end
-
-    get_it '/'
-    assert ok?
-    assert_equal('asdf', body)
-
-    get '/foo', :host => 'foo.sinatrarb.com' do
-      'in foo!'
-    end
-
-    get '/foo', :host => 'bar.sinatrarb.com'  do
-      'in bar!'
-    end
-
-    get_it '/foo', {}, 'HTTP_HOST' => 'foo.sinatrarb.com'
-    assert ok?
-    assert_equal 'in foo!', body
-
-    get_it '/foo', {}, 'HTTP_HOST' => 'bar.sinatrarb.com'
-    assert ok?
-    assert_equal 'in bar!', body
-
-    get_it '/foo'
-    assert not_found?
-
-  end
-
-end
-
-
-context "Options in an app" do
-
-  setup do
-    Sinatra.application = nil
-    @app = Sinatra::application
-  end
-
-  specify "can be set singly on app" do
-    @app.set :foo, 1234
-    @app.options.foo.should.equal 1234
-  end
-
-  specify "can be set singly from top-level" do
-    set_option :foo, 1234
-    @app.options.foo.should.equal 1234
-  end
-
-  specify "can be set multiply on app" do
-    @app.options.foo.should.be.nil
-    @app.set :foo => 1234,
-      :bar => 'hello, world'
-    @app.options.foo.should.equal 1234
-    @app.options.bar.should.equal 'hello, world'
-  end
-
-  specify "can be set multiply from top-level" do
-    @app.options.foo.should.be.nil
-    set_options :foo => 1234,
-      :bar => 'hello, world'
-    @app.options.foo.should.equal 1234
-    @app.options.bar.should.equal 'hello, world'
-  end
-
-  specify "can be enabled on app" do
-    @app.options.foo.should.be.nil
-    @app.enable :sessions, :foo, :bar
-    @app.options.sessions.should.equal true
-    @app.options.foo.should.equal true
-    @app.options.bar.should.equal true
-  end
-
-  specify "can be enabled from top-level" do
-    @app.options.foo.should.be.nil
-    enable :sessions, :foo, :bar
-    @app.options.sessions.should.equal true
-    @app.options.foo.should.equal true
-    @app.options.bar.should.equal true
-  end
-
-  specify "can be disabled on app" do
-    @app.options.foo.should.be.nil
-    @app.disable :sessions, :foo, :bar
-    @app.options.sessions.should.equal false
-    @app.options.foo.should.equal false
-    @app.options.bar.should.equal false
-  end
-
-  specify "can be enabled from top-level" do
-    @app.options.foo.should.be.nil
-    disable :sessions, :foo, :bar
-    @app.options.sessions.should.equal false
-    @app.options.foo.should.equal false
-    @app.options.bar.should.equal false
-  end
-
-end