rack 1.6.13 → 2.2.3

data/test/spec_showexceptions.rb

@@ -1,98 +0,0 @@
-require 'rack/showexceptions'
-require 'rack/lint'
-require 'rack/mock'
-
-describe Rack::ShowExceptions do
-  def show_exceptions(app)
-    Rack::Lint.new Rack::ShowExceptions.new(app)
-  end
-  
-  it "catches exceptions" do
-    res = nil
-
-    req = Rack::MockRequest.new(
-      show_exceptions(
-        lambda{|env| raise RuntimeError }
-    ))
-
-    lambda{
-      res = req.get("/", "HTTP_ACCEPT" => "text/html")
-    }.should.not.raise
-
-    res.should.be.a.server_error
-    res.status.should.equal 500
-
-    res.should =~ /RuntimeError/
-    res.should =~ /ShowExceptions/
-  end
-
-  it "responds with HTML only to requests accepting HTML" do
-    res = nil
-
-    req = Rack::MockRequest.new(
-      show_exceptions(
-        lambda{|env| raise RuntimeError, "It was never supposed to work" }
-    ))
-
-    [
-      # Serve text/html when the client accepts text/html
-      ["text/html", ["/", {"HTTP_ACCEPT" => "text/html"}]],
-      ["text/html", ["/", {"HTTP_ACCEPT" => "*/*"}]],
-      # Serve text/plain when the client does not accept text/html
-      ["text/plain", ["/"]],
-      ["text/plain", ["/", {"HTTP_ACCEPT" => "application/json"}]]
-    ].each do |exmime, rargs|
-      lambda{
-        res = req.get(*rargs)
-      }.should.not.raise
-
-      res.should.be.a.server_error
-      res.status.should.equal 500
-
-      res.content_type.should.equal exmime
-
-      res.body.should.include "RuntimeError"
-      res.body.should.include "It was never supposed to work"
-
-      if exmime == "text/html"
-        res.body.should.include '</html>'
-      else
-        res.body.should.not.include '</html>'
-      end
-    end
-  end
-
-  it "handles exceptions without a backtrace" do
-    res = nil
-
-    req = Rack::MockRequest.new(
-      show_exceptions(
-        lambda{|env| raise RuntimeError, "", [] }
-      )
-    )
-
-    lambda{
-      res = req.get("/", "HTTP_ACCEPT" => "text/html")
-    }.should.not.raise
-
-    res.should.be.a.server_error
-    res.status.should.equal 500
-
-    res.should =~ /RuntimeError/
-    res.should =~ /ShowExceptions/
-    res.should =~ /unknown location/
-  end
-
-  it "knows to prefer plaintext for non-html" do
-    # We don't need an app for this
-    exc = Rack::ShowExceptions.new(nil)
-
-    [
-      [{ "HTTP_ACCEPT" => "text/plain" }, true],
-      [{ "HTTP_ACCEPT" => "text/foo" }, true],
-      [{ "HTTP_ACCEPT" => "text/html" }, false]
-    ].each do |env, expected|
-      expected.should.equal exc.prefers_plaintext?(env)
-    end
-  end
-end

data/test/spec_showstatus.rb

@@ -1,103 +0,0 @@
-require 'rack/showstatus'
-require 'rack/lint'
-require 'rack/mock'
-require 'rack/utils'
-
-describe Rack::ShowStatus do
-  def show_status(app)
-    Rack::Lint.new Rack::ShowStatus.new(app)
-  end
-  
-  should "provide a default status message" do
-    req = Rack::MockRequest.new(
-      show_status(lambda{|env|
-        [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
-    }))
-
-    res = req.get("/", :lint => true)
-    res.should.be.not_found
-    res.should.be.not.empty
-
-    res["Content-Type"].should.equal("text/html")
-    res.should =~ /404/
-    res.should =~ /Not Found/
-  end
-
-  should "let the app provide additional information" do
-    req = Rack::MockRequest.new(
-      show_status(
-        lambda{|env|
-          env["rack.showstatus.detail"] = "gone too meta."
-          [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
-    }))
-
-    res = req.get("/", :lint => true)
-    res.should.be.not_found
-    res.should.be.not.empty
-
-    res["Content-Type"].should.equal("text/html")
-    res.should =~ /404/
-    res.should =~ /Not Found/
-    res.should =~ /too meta/
-  end
-
-  should "escape error" do
-    detail = "<script>alert('hi \"')</script>"
-    req = Rack::MockRequest.new(
-      show_status(
-        lambda{|env|
-          env["rack.showstatus.detail"] = detail
-          [500, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
-    }))
-
-    res = req.get("/", :lint => true)
-    res.should.be.not.empty
-
-    res["Content-Type"].should.equal("text/html")
-    res.should =~ /500/
-    res.should.not.include detail
-    res.body.should.include Rack::Utils.escape_html(detail)
-  end
-
-  should "not replace existing messages" do
-    req = Rack::MockRequest.new(
-      show_status(
-        lambda{|env|
-          [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
-    }))
-
-    res = req.get("/", :lint => true)
-    res.should.be.not_found
-
-    res.body.should == "foo!"
-  end
-
-  should "pass on original headers" do
-    headers = {"WWW-Authenticate" => "Basic blah"}
-
-    req = Rack::MockRequest.new(
-      show_status(lambda{|env| [401, headers, []] }))
-    res = req.get("/", :lint => true)
-
-    res["WWW-Authenticate"].should.equal("Basic blah")
-  end
-
-  should "replace existing messages if there is detail" do
-    req = Rack::MockRequest.new(
-      show_status(
-        lambda{|env|
-          env["rack.showstatus.detail"] = "gone too meta."
-          [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
-    }))
-
-    res = req.get("/", :lint => true)
-    res.should.be.not_found
-    res.should.be.not.empty
-
-    res["Content-Type"].should.equal("text/html")
-    res["Content-Length"].should.not.equal("4")
-    res.should =~ /404/
-    res.should =~ /too meta/
-    res.body.should.not =~ /foo/
-  end
-end

data/test/spec_static.rb

@@ -1,145 +0,0 @@
-require 'rack/static'
-require 'rack/lint'
-require 'rack/mock'
-
-class DummyApp
-  def call(env)
-    [200, {"Content-Type" => "text/plain"}, ["Hello World"]]
-  end
-end
-
-describe Rack::Static do
-  def static(app, *args)
-    Rack::Lint.new Rack::Static.new(app, *args)
-  end
-
-  root = File.expand_path(File.dirname(__FILE__))
-
-  OPTIONS = {:urls => ["/cgi"], :root => root}
-  STATIC_OPTIONS = {:urls => [""], :root => "#{root}/static", :index => 'index.html'}
-  HASH_OPTIONS = {:urls => {"/cgi/sekret" => 'cgi/test'}, :root => root}
-
-  @request = Rack::MockRequest.new(static(DummyApp.new, OPTIONS))
-  @static_request = Rack::MockRequest.new(static(DummyApp.new, STATIC_OPTIONS))
-  @hash_request = Rack::MockRequest.new(static(DummyApp.new, HASH_OPTIONS))
-
-  it "serves files" do
-    res = @request.get("/cgi/test")
-    res.should.be.ok
-    res.body.should =~ /ruby/
-  end
-
-  it "404s if url root is known but it can't find the file" do
-    res = @request.get("/cgi/foo")
-    res.should.be.not_found
-  end
-
-  it "calls down the chain if url root is not known" do
-    res = @request.get("/something/else")
-    res.should.be.ok
-    res.body.should == "Hello World"
-  end
-
-  it "calls index file when requesting root in the given folder" do
-    res = @static_request.get("/")
-    res.should.be.ok
-    res.body.should =~ /index!/
-
-    res = @static_request.get("/other/")
-    res.should.be.not_found
-
-    res = @static_request.get("/another/")
-    res.should.be.ok
-    res.body.should =~ /another index!/
-  end
-
-  it "doesn't call index file if :index option was omitted" do
-    res = @request.get("/")
-    res.body.should == "Hello World"
-  end
-
-  it "serves hidden files" do
-    res = @hash_request.get("/cgi/sekret")
-    res.should.be.ok
-    res.body.should =~ /ruby/
-  end
-
-  it "calls down the chain if the URI is not specified" do
-    res = @hash_request.get("/something/else")
-    res.should.be.ok
-    res.body.should == "Hello World"
-  end
-
-  it "supports serving fixed cache-control (legacy option)" do
-    opts = OPTIONS.merge(:cache_control => 'public')
-    request = Rack::MockRequest.new(static(DummyApp.new, opts))
-    res = request.get("/cgi/test")
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public'
-  end
-
-  HEADER_OPTIONS = {:urls => ["/cgi"], :root => root, :header_rules => [
-    [:all, {'Cache-Control' => 'public, max-age=100'}],
-    [:fonts, {'Cache-Control' => 'public, max-age=200'}],
-    [%w(png jpg), {'Cache-Control' => 'public, max-age=300'}],
-    ['/cgi/assets/folder/', {'Cache-Control' => 'public, max-age=400'}],
-    ['cgi/assets/javascripts', {'Cache-Control' => 'public, max-age=500'}],
-    [/\.(css|erb)\z/, {'Cache-Control' => 'public, max-age=600'}]
-  ]}
-  @header_request = Rack::MockRequest.new(static(DummyApp.new, HEADER_OPTIONS))
-
-  it "supports header rule :all" do
-    # Headers for all files via :all shortcut
-    res = @header_request.get('/cgi/assets/index.html')
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public, max-age=100'
-  end
-
-  it "supports header rule :fonts" do
-    # Headers for web fonts via :fonts shortcut
-    res = @header_request.get('/cgi/assets/fonts/font.eot')
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public, max-age=200'
-  end
-
-  it "supports file extension header rules provided as an Array" do
-    # Headers for file extensions via array
-    res = @header_request.get('/cgi/assets/images/image.png')
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public, max-age=300'
-  end
-
-  it "supports folder rules provided as a String" do
-    # Headers for files in folder via string
-    res = @header_request.get('/cgi/assets/folder/test.js')
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public, max-age=400'
-  end
-
-  it "supports folder header rules provided as a String not starting with a slash" do
-    res = @header_request.get('/cgi/assets/javascripts/app.js')
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public, max-age=500'
-  end
-
-  it "supports flexible header rules provided as Regexp" do
-    # Flexible Headers via Regexp
-    res = @header_request.get('/cgi/assets/stylesheets/app.css')
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public, max-age=600'
-  end
-
-  it "prioritizes header rules over fixed cache-control setting (legacy option)" do
-    opts = OPTIONS.merge(
-      :cache_control => 'public, max-age=24',
-      :header_rules => [
-        [:all, {'Cache-Control' => 'public, max-age=42'}]
-      ])
-
-    request = Rack::MockRequest.new(static(DummyApp.new, opts))
-    res = request.get("/cgi/test")
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public, max-age=42'
-  end
-
-end

data/test/spec_tempfile_reaper.rb

@@ -1,63 +0,0 @@
-require 'rack/tempfile_reaper'
-require 'rack/lint'
-require 'rack/mock'
-
-describe Rack::TempfileReaper do
-  class MockTempfile
-    attr_reader :closed
-
-    def initialize
-      @closed = false
-    end
-
-    def close!
-      @closed = true
-    end
-  end
-
-  before do
-    @env = Rack::MockRequest.env_for
-  end
-
-  def call(app)
-    Rack::Lint.new(Rack::TempfileReaper.new(app)).call(@env)
-  end
-
-  should 'do nothing (i.e. not bomb out) without env[rack.tempfiles]' do
-    app = lambda { |_| [200, {}, ['Hello, World!']] }
-    response = call(app)
-    response[2].close
-    response[0].should.equal(200)
-  end
-
-  should 'close env[rack.tempfiles] when body is closed' do
-    tempfile1, tempfile2 = MockTempfile.new, MockTempfile.new
-    @env['rack.tempfiles'] = [ tempfile1, tempfile2 ]
-    app = lambda { |_| [200, {}, ['Hello, World!']] }
-    call(app)[2].close
-    tempfile1.closed.should.equal true
-    tempfile2.closed.should.equal true
-  end
-
-  should 'initialize env[rack.tempfiles] when not already present' do
-    tempfile = MockTempfile.new
-    app = lambda do |env|
-      env['rack.tempfiles'] << tempfile
-      [200, {}, ['Hello, World!']]
-    end
-    call(app)[2].close
-    tempfile.closed.should.equal true
-  end
-
-  should 'append env[rack.tempfiles] when already present' do
-    tempfile1, tempfile2 = MockTempfile.new, MockTempfile.new
-    @env['rack.tempfiles'] = [ tempfile1 ]
-    app = lambda do |env|
-      env['rack.tempfiles'] << tempfile2
-      [200, {}, ['Hello, World!']]
-    end
-    call(app)[2].close
-    tempfile1.closed.should.equal true
-    tempfile2.closed.should.equal true
-  end
-end

data/test/spec_thin.rb

@@ -1,91 +0,0 @@
-begin
-require 'rack/handler/thin'
-require File.expand_path('../testrequest', __FILE__)
-require 'timeout'
-
-describe Rack::Handler::Thin do
-  extend TestRequest::Helpers
-
-  @app = Rack::Lint.new(TestRequest.new)
-  @server = nil
-  Thin::Logging.silent = true
-
-  @thread = Thread.new do
-    Rack::Handler::Thin.run(@app, :Host => @host='127.0.0.1', :Port => @port=9204, :tag => "tag") do |server|
-      @server = server
-    end
-  end
-
-  Thread.pass until @server && @server.running?
-
-  should "respond" do
-    GET("/")
-    response.should.not.be.nil
-  end
-
-  should "be a Thin" do
-    GET("/")
-    status.should.equal 200
-    response["SERVER_SOFTWARE"].should =~ /thin/
-    response["HTTP_VERSION"].should.equal "HTTP/1.1"
-    response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
-    response["SERVER_PORT"].should.equal "9204"
-    response["SERVER_NAME"].should.equal "127.0.0.1"
-  end
-
-  should "have rack headers" do
-    GET("/")
-    response["rack.version"].should.equal [1,0]
-    response["rack.multithread"].should.equal false
-    response["rack.multiprocess"].should.equal false
-    response["rack.run_once"].should.equal false
-  end
-
-  should "have CGI headers on GET" do
-    GET("/")
-    response["REQUEST_METHOD"].should.equal "GET"
-    response["REQUEST_PATH"].should.equal "/"
-    response["PATH_INFO"].should.be.equal "/"
-    response["QUERY_STRING"].should.equal ""
-    response["test.postdata"].should.equal ""
-
-    GET("/test/foo?quux=1")
-    response["REQUEST_METHOD"].should.equal "GET"
-    response["REQUEST_PATH"].should.equal "/test/foo"
-    response["PATH_INFO"].should.equal "/test/foo"
-    response["QUERY_STRING"].should.equal "quux=1"
-  end
-
-  should "have CGI headers on POST" do
-    POST("/", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
-    status.should.equal 200
-    response["REQUEST_METHOD"].should.equal "POST"
-    response["REQUEST_PATH"].should.equal "/"
-    response["QUERY_STRING"].should.equal ""
-    response["HTTP_X_TEST_HEADER"].should.equal "42"
-    response["test.postdata"].should.equal "rack-form-data=23"
-  end
-
-  should "support HTTP auth" do
-    GET("/test", {:user => "ruth", :passwd => "secret"})
-    response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
-  end
-
-  should "set status" do
-    GET("/test?secret")
-    status.should.equal 403
-    response["rack.url_scheme"].should.equal "http"
-  end
-
-  should "set tag for server" do
-    @server.tag.should.equal 'tag'
-  end
-
-  @server.stop!
-  @thread.kill
-
-end
-
-rescue LoadError
-  $stderr.puts "Skipping Rack::Handler::Thin tests (Thin is required). `gem install thin` and try again."
-end