rack 1.6.11 → 2.2.0

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

data/test/spec_urlmap.rb

@@ -1,236 +0,0 @@
-require 'rack/urlmap'
-require 'rack/mock'
-
-describe Rack::URLMap do
-  it "dispatches paths correctly" do
-    app = lambda { |env|
-      [200, {
-        'X-ScriptName' => env['SCRIPT_NAME'],
-        'X-PathInfo' => env['PATH_INFO'],
-        'Content-Type' => 'text/plain'
-      }, [""]]
-    }
-    map = Rack::Lint.new(Rack::URLMap.new({
-      'http://foo.org/bar' => app,
-      '/foo' => app,
-      '/foo/bar' => app
-    }))
-
-    res = Rack::MockRequest.new(map).get("/")
-    res.should.be.not_found
-
-    res = Rack::MockRequest.new(map).get("/qux")
-    res.should.be.not_found
-
-    res = Rack::MockRequest.new(map).get("/foo")
-    res.should.be.ok
-    res["X-ScriptName"].should.equal "/foo"
-    res["X-PathInfo"].should.equal ""
-
-    res = Rack::MockRequest.new(map).get("/foo/")
-    res.should.be.ok
-    res["X-ScriptName"].should.equal "/foo"
-    res["X-PathInfo"].should.equal "/"
-
-    res = Rack::MockRequest.new(map).get("/foo/bar")
-    res.should.be.ok
-    res["X-ScriptName"].should.equal "/foo/bar"
-    res["X-PathInfo"].should.equal ""
-
-    res = Rack::MockRequest.new(map).get("/foo/bar/")
-    res.should.be.ok
-    res["X-ScriptName"].should.equal "/foo/bar"
-    res["X-PathInfo"].should.equal "/"
-
-    res = Rack::MockRequest.new(map).get("/foo///bar//quux")
-    res.status.should.equal 200
-    res.should.be.ok
-    res["X-ScriptName"].should.equal "/foo/bar"
-    res["X-PathInfo"].should.equal "//quux"
-
-    res = Rack::MockRequest.new(map).get("/foo/quux", "SCRIPT_NAME" => "/bleh")
-    res.should.be.ok
-    res["X-ScriptName"].should.equal "/bleh/foo"
-    res["X-PathInfo"].should.equal "/quux"
-
-    res = Rack::MockRequest.new(map).get("/bar", 'HTTP_HOST' => 'foo.org')
-    res.should.be.ok
-    res["X-ScriptName"].should.equal "/bar"
-    res["X-PathInfo"].should.be.empty
-
-    res = Rack::MockRequest.new(map).get("/bar/", 'HTTP_HOST' => 'foo.org')
-    res.should.be.ok
-    res["X-ScriptName"].should.equal "/bar"
-    res["X-PathInfo"].should.equal '/'
-  end
-
-
-  it "dispatches hosts correctly" do
-    map = Rack::Lint.new(Rack::URLMap.new("http://foo.org/" => lambda { |env|
-                             [200,
-                              { "Content-Type" => "text/plain",
-                                "X-Position" => "foo.org",
-                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
-                              }, [""]]},
-                           "http://subdomain.foo.org/" => lambda { |env|
-                             [200,
-                              { "Content-Type" => "text/plain",
-                                "X-Position" => "subdomain.foo.org",
-                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
-                              }, [""]]},
-                           "http://bar.org/" => lambda { |env|
-                             [200,
-                              { "Content-Type" => "text/plain",
-                                "X-Position" => "bar.org",
-                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
-                              }, [""]]},
-                           "/" => lambda { |env|
-                             [200,
-                              { "Content-Type" => "text/plain",
-                                "X-Position" => "default.org",
-                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
-                              }, [""]]}
-                           ))
-
-    res = Rack::MockRequest.new(map).get("/")
-    res.should.be.ok
-    res["X-Position"].should.equal "default.org"
-
-    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "bar.org")
-    res.should.be.ok
-    res["X-Position"].should.equal "bar.org"
-
-    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "foo.org")
-    res.should.be.ok
-    res["X-Position"].should.equal "foo.org"
-
-    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "subdomain.foo.org", "SERVER_NAME" => "foo.org")
-    res.should.be.ok
-    res["X-Position"].should.equal "subdomain.foo.org"
-
-    res = Rack::MockRequest.new(map).get("http://foo.org/")
-    res.should.be.ok
-    res["X-Position"].should.equal "foo.org"
-
-    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "example.org")
-    res.should.be.ok
-    res["X-Position"].should.equal "default.org"
-
-    res = Rack::MockRequest.new(map).get("/",
-                                         "HTTP_HOST" => "example.org:9292",
-                                         "SERVER_PORT" => "9292")
-    res.should.be.ok
-    res["X-Position"].should.equal "default.org"
-  end
-
-  should "be nestable" do
-    map = Rack::Lint.new(Rack::URLMap.new("/foo" =>
-      Rack::URLMap.new("/bar" =>
-        Rack::URLMap.new("/quux" =>  lambda { |env|
-                           [200,
-                            { "Content-Type" => "text/plain",
-                              "X-Position" => "/foo/bar/quux",
-                              "X-PathInfo" => env["PATH_INFO"],
-                              "X-ScriptName" => env["SCRIPT_NAME"],
-                            }, [""]]}
-                         ))))
-
-    res = Rack::MockRequest.new(map).get("/foo/bar")
-    res.should.be.not_found
-
-    res = Rack::MockRequest.new(map).get("/foo/bar/quux")
-    res.should.be.ok
-    res["X-Position"].should.equal "/foo/bar/quux"
-    res["X-PathInfo"].should.equal ""
-    res["X-ScriptName"].should.equal "/foo/bar/quux"
-  end
-
-  should "route root apps correctly" do
-    map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
-                             [200,
-                              { "Content-Type" => "text/plain",
-                                "X-Position" => "root",
-                                "X-PathInfo" => env["PATH_INFO"],
-                                "X-ScriptName" => env["SCRIPT_NAME"]
-                              }, [""]]},
-                           "/foo" => lambda { |env|
-                             [200,
-                              { "Content-Type" => "text/plain",
-                                "X-Position" => "foo",
-                                "X-PathInfo" => env["PATH_INFO"],
-                                "X-ScriptName" => env["SCRIPT_NAME"]
-                              }, [""]]}
-                           ))
-
-    res = Rack::MockRequest.new(map).get("/foo/bar")
-    res.should.be.ok
-    res["X-Position"].should.equal "foo"
-    res["X-PathInfo"].should.equal "/bar"
-    res["X-ScriptName"].should.equal "/foo"
-
-    res = Rack::MockRequest.new(map).get("/foo")
-    res.should.be.ok
-    res["X-Position"].should.equal "foo"
-    res["X-PathInfo"].should.equal ""
-    res["X-ScriptName"].should.equal "/foo"
-
-    res = Rack::MockRequest.new(map).get("/bar")
-    res.should.be.ok
-    res["X-Position"].should.equal "root"
-    res["X-PathInfo"].should.equal "/bar"
-    res["X-ScriptName"].should.equal ""
-
-    res = Rack::MockRequest.new(map).get("")
-    res.should.be.ok
-    res["X-Position"].should.equal "root"
-    res["X-PathInfo"].should.equal "/"
-    res["X-ScriptName"].should.equal ""
-  end
-
-  should "not squeeze slashes" do
-    map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
-                             [200,
-                              { "Content-Type" => "text/plain",
-                                "X-Position" => "root",
-                                "X-PathInfo" => env["PATH_INFO"],
-                                "X-ScriptName" => env["SCRIPT_NAME"]
-                              }, [""]]},
-                           "/foo" => lambda { |env|
-                             [200,
-                              { "Content-Type" => "text/plain",
-                                "X-Position" => "foo",
-                                "X-PathInfo" => env["PATH_INFO"],
-                                "X-ScriptName" => env["SCRIPT_NAME"]
-                              }, [""]]}
-                           ))
-
-    res = Rack::MockRequest.new(map).get("/http://example.org/bar")
-    res.should.be.ok
-    res["X-Position"].should.equal "root"
-    res["X-PathInfo"].should.equal "/http://example.org/bar"
-    res["X-ScriptName"].should.equal ""
-  end
-
-  should "not be case sensitive with hosts" do
-    map = Rack::Lint.new(Rack::URLMap.new("http://example.org/" => lambda { |env|
-                             [200,
-                              { "Content-Type" => "text/plain",
-                                "X-Position" => "root",
-                                "X-PathInfo" => env["PATH_INFO"],
-                                "X-ScriptName" => env["SCRIPT_NAME"]
-                              }, [""]]}
-                           ))
-
-    res = Rack::MockRequest.new(map).get("http://example.org/")
-    res.should.be.ok
-    res["X-Position"].should.equal "root"
-    res["X-PathInfo"].should.equal "/"
-    res["X-ScriptName"].should.equal ""
-
-    res = Rack::MockRequest.new(map).get("http://EXAMPLE.ORG/")
-    res.should.be.ok
-    res["X-Position"].should.equal "root"
-    res["X-PathInfo"].should.equal "/"
-    res["X-ScriptName"].should.equal ""
-  end
-end