rack 2.0.3 → 2.2.4

data/test/spec_show_status.rb

@@ -1,104 +0,0 @@
-require 'minitest/autorun'
-require 'rack/show_status'
-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
-
-  it "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.must_be :not_found?
-    res.wont_be_empty
-
-    res["Content-Type"].must_equal "text/html"
-    assert_match(res, /404/)
-    assert_match(res, /Not Found/)
-  end
-
-  it "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.must_be :not_found?
-    res.wont_be_empty
-
-    res["Content-Type"].must_equal "text/html"
-    assert_match(res, /404/)
-    assert_match(res, /Not Found/)
-    assert_match(res, /too meta/)
-  end
-
-  it "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.wont_be_empty
-
-    res["Content-Type"].must_equal "text/html"
-    assert_match(res, /500/)
-    res.wont_include detail
-    res.body.must_include Rack::Utils.escape_html(detail)
-  end
-
-  it "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.must_be :not_found?
-
-    res.body.must_equal "foo!"
-  end
-
-  it "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"].must_equal "Basic blah"
-  end
-
-  it "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.must_be :not_found?
-    res.wont_be_empty
-
-    res["Content-Type"].must_equal "text/html"
-    res["Content-Length"].wont_equal "4"
-    assert_match(res, /404/)
-    assert_match(res, /too meta/)
-    res.body.wont_match(/foo/)
-  end
-end

data/test/spec_static.rb

@@ -1,184 +0,0 @@
-require 'minitest/autorun'
-require 'rack/static'
-require 'rack/lint'
-require 'rack/mock'
-require 'zlib'
-require 'stringio'
-
-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}
-  HASH_ROOT_OPTIONS = {:urls => {"/" => "static/foo.html"}, :root => root}
-  GZIP_OPTIONS = {:urls => ["/cgi"], :root => root, :gzip=>true}
-
-  before do
-  @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))
-  @hash_root_request = Rack::MockRequest.new(static(DummyApp.new, HASH_ROOT_OPTIONS))
-  @gzip_request = Rack::MockRequest.new(static(DummyApp.new, GZIP_OPTIONS))
-  @header_request = Rack::MockRequest.new(static(DummyApp.new, HEADER_OPTIONS))
-  end
-
-  it "serves files" do
-    res = @request.get("/cgi/test")
-    res.must_be :ok?
-    res.body.must_match(/ruby/)
-  end
-
-  it "404s if url root is known but it can't find the file" do
-    res = @request.get("/cgi/foo")
-    res.must_be :not_found?
-  end
-
-  it "calls down the chain if url root is not known" do
-    res = @request.get("/something/else")
-    res.must_be :ok?
-    res.body.must_equal "Hello World"
-  end
-
-  it "calls index file when requesting root in the given folder" do
-    res = @static_request.get("/")
-    res.must_be :ok?
-    res.body.must_match(/index!/)
-
-    res = @static_request.get("/other/")
-    res.must_be :not_found?
-
-    res = @static_request.get("/another/")
-    res.must_be :ok?
-    res.body.must_match(/another index!/)
-  end
-
-  it "doesn't call index file if :index option was omitted" do
-    res = @request.get("/")
-    res.body.must_equal "Hello World"
-  end
-
-  it "serves hidden files" do
-    res = @hash_request.get("/cgi/sekret")
-    res.must_be :ok?
-    res.body.must_match(/ruby/)
-  end
-
-  it "calls down the chain if the URI is not specified" do
-    res = @hash_request.get("/something/else")
-    res.must_be :ok?
-    res.body.must_equal "Hello World"
-  end
-
-  it "allows the root URI to be configured via hash options" do
-    res = @hash_root_request.get("/")
-    res.must_be :ok?
-    res.body.must_match(/foo.html!/)
-  end
-
-  it "serves gzipped files if client accepts gzip encoding and gzip files are present" do
-    res = @gzip_request.get("/cgi/test", 'HTTP_ACCEPT_ENCODING'=>'deflate, gzip')
-    res.must_be :ok?
-    res.headers['Content-Encoding'].must_equal 'gzip'
-    res.headers['Content-Type'].must_equal 'text/plain'
-    Zlib::GzipReader.wrap(StringIO.new(res.body), &:read).must_match(/ruby/)
-  end
-
-  it "serves regular files if client accepts gzip encoding and gzip files are not present" do
-    res = @gzip_request.get("/cgi/rackup_stub.rb", 'HTTP_ACCEPT_ENCODING'=>'deflate, gzip')
-    res.must_be :ok?
-    res.headers['Content-Encoding'].must_be_nil
-    res.headers['Content-Type'].must_equal 'text/x-script.ruby'
-    res.body.must_match(/ruby/)
-  end
-
-  it "serves regular files if client does not accept gzip encoding" do
-    res = @gzip_request.get("/cgi/test")
-    res.must_be :ok?
-    res.headers['Content-Encoding'].must_be_nil
-    res.headers['Content-Type'].must_equal 'text/plain'
-    res.body.must_match(/ruby/)
-  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.must_be :ok?
-    res.headers['Cache-Control'].must_equal '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'}]
-  ]}
-
-  it "supports header rule :all" do
-    # Headers for all files via :all shortcut
-    res = @header_request.get('/cgi/assets/index.html')
-    res.must_be :ok?
-    res.headers['Cache-Control'].must_equal '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.must_be :ok?
-    res.headers['Cache-Control'].must_equal '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.must_be :ok?
-    res.headers['Cache-Control'].must_equal '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.must_be :ok?
-    res.headers['Cache-Control'].must_equal '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.must_be :ok?
-    res.headers['Cache-Control'].must_equal '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.must_be :ok?
-    res.headers['Cache-Control'].must_equal '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.must_be :ok?
-    res.headers['Cache-Control'].must_equal 'public, max-age=42'
-  end
-
-end

data/test/spec_tempfile_reaper.rb

@@ -1,64 +0,0 @@
-require 'minitest/autorun'
-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
-
-  it '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].must_equal 200
-  end
-
-  it '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.must_equal true
-    tempfile2.closed.must_equal true
-  end
-
-  it '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.must_equal true
-  end
-
-  it '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.must_equal true
-    tempfile2.closed.must_equal true
-  end
-end

data/test/spec_thin.rb

@@ -1,96 +0,0 @@
-require 'minitest/autorun'
-begin
-require 'rack/handler/thin'
-require File.expand_path('../testrequest', __FILE__)
-require 'timeout'
-
-describe Rack::Handler::Thin do
-  include TestRequest::Helpers
-
-  before do
-    @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?
-  end
-
-  after do
-    @server.stop!
-    @thread.join
-  end
-
-
-  it "respond" do
-    GET("/")
-    response.wont_be :nil?
-  end
-
-  it "be a Thin" do
-    GET("/")
-    status.must_equal 200
-    response["SERVER_SOFTWARE"].must_match(/thin/)
-    response["HTTP_VERSION"].must_equal "HTTP/1.1"
-    response["SERVER_PROTOCOL"].must_equal "HTTP/1.1"
-    response["SERVER_PORT"].must_equal "9204"
-    response["SERVER_NAME"].must_equal "127.0.0.1"
-  end
-
-  it "have rack headers" do
-    GET("/")
-    response["rack.version"].must_equal [1,0]
-    response["rack.multithread"].must_equal false
-    response["rack.multiprocess"].must_equal false
-    response["rack.run_once"].must_equal false
-  end
-
-  it "have CGI headers on GET" do
-    GET("/")
-    response["REQUEST_METHOD"].must_equal "GET"
-    response["REQUEST_PATH"].must_equal "/"
-    response["PATH_INFO"].must_equal "/"
-    response["QUERY_STRING"].must_equal ""
-    response["test.postdata"].must_equal ""
-
-    GET("/test/foo?quux=1")
-    response["REQUEST_METHOD"].must_equal "GET"
-    response["REQUEST_PATH"].must_equal "/test/foo"
-    response["PATH_INFO"].must_equal "/test/foo"
-    response["QUERY_STRING"].must_equal "quux=1"
-  end
-
-  it "have CGI headers on POST" do
-    POST("/", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
-    status.must_equal 200
-    response["REQUEST_METHOD"].must_equal "POST"
-    response["REQUEST_PATH"].must_equal "/"
-    response["QUERY_STRING"].must_equal ""
-    response["HTTP_X_TEST_HEADER"].must_equal "42"
-    response["test.postdata"].must_equal "rack-form-data=23"
-  end
-
-  it "support HTTP auth" do
-    GET("/test", {:user => "ruth", :passwd => "secret"})
-    response["HTTP_AUTHORIZATION"].must_equal "Basic cnV0aDpzZWNyZXQ="
-  end
-
-  it "set status" do
-    GET("/test?secret")
-    status.must_equal 403
-    response["rack.url_scheme"].must_equal "http"
-  end
-
-  it "set tag for server" do
-    @server.tag.must_equal 'tag'
-  end
-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,237 +0,0 @@
-require 'minitest/autorun'
-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.must_be :not_found?
-
-    res = Rack::MockRequest.new(map).get("/qux")
-    res.must_be :not_found?
-
-    res = Rack::MockRequest.new(map).get("/foo")
-    res.must_be :ok?
-    res["X-ScriptName"].must_equal "/foo"
-    res["X-PathInfo"].must_equal ""
-
-    res = Rack::MockRequest.new(map).get("/foo/")
-    res.must_be :ok?
-    res["X-ScriptName"].must_equal "/foo"
-    res["X-PathInfo"].must_equal "/"
-
-    res = Rack::MockRequest.new(map).get("/foo/bar")
-    res.must_be :ok?
-    res["X-ScriptName"].must_equal "/foo/bar"
-    res["X-PathInfo"].must_equal ""
-
-    res = Rack::MockRequest.new(map).get("/foo/bar/")
-    res.must_be :ok?
-    res["X-ScriptName"].must_equal "/foo/bar"
-    res["X-PathInfo"].must_equal "/"
-
-    res = Rack::MockRequest.new(map).get("/foo///bar//quux")
-    res.status.must_equal 200
-    res.must_be :ok?
-    res["X-ScriptName"].must_equal "/foo/bar"
-    res["X-PathInfo"].must_equal "//quux"
-
-    res = Rack::MockRequest.new(map).get("/foo/quux", "SCRIPT_NAME" => "/bleh")
-    res.must_be :ok?
-    res["X-ScriptName"].must_equal "/bleh/foo"
-    res["X-PathInfo"].must_equal "/quux"
-
-    res = Rack::MockRequest.new(map).get("/bar", 'HTTP_HOST' => 'foo.org')
-    res.must_be :ok?
-    res["X-ScriptName"].must_equal "/bar"
-    res["X-PathInfo"].must_be :empty?
-
-    res = Rack::MockRequest.new(map).get("/bar/", 'HTTP_HOST' => 'foo.org')
-    res.must_be :ok?
-    res["X-ScriptName"].must_equal "/bar"
-    res["X-PathInfo"].must_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.must_be :ok?
-    res["X-Position"].must_equal "default.org"
-
-    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "bar.org")
-    res.must_be :ok?
-    res["X-Position"].must_equal "bar.org"
-
-    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "foo.org")
-    res.must_be :ok?
-    res["X-Position"].must_equal "foo.org"
-
-    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "subdomain.foo.org", "SERVER_NAME" => "foo.org")
-    res.must_be :ok?
-    res["X-Position"].must_equal "subdomain.foo.org"
-
-    res = Rack::MockRequest.new(map).get("http://foo.org/")
-    res.must_be :ok?
-    res["X-Position"].must_equal "foo.org"
-
-    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "example.org")
-    res.must_be :ok?
-    res["X-Position"].must_equal "default.org"
-
-    res = Rack::MockRequest.new(map).get("/",
-                                         "HTTP_HOST" => "example.org:9292",
-                                         "SERVER_PORT" => "9292")
-    res.must_be :ok?
-    res["X-Position"].must_equal "default.org"
-  end
-
-  it "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.must_be :not_found?
-
-    res = Rack::MockRequest.new(map).get("/foo/bar/quux")
-    res.must_be :ok?
-    res["X-Position"].must_equal "/foo/bar/quux"
-    res["X-PathInfo"].must_equal ""
-    res["X-ScriptName"].must_equal "/foo/bar/quux"
-  end
-
-  it "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.must_be :ok?
-    res["X-Position"].must_equal "foo"
-    res["X-PathInfo"].must_equal "/bar"
-    res["X-ScriptName"].must_equal "/foo"
-
-    res = Rack::MockRequest.new(map).get("/foo")
-    res.must_be :ok?
-    res["X-Position"].must_equal "foo"
-    res["X-PathInfo"].must_equal ""
-    res["X-ScriptName"].must_equal "/foo"
-
-    res = Rack::MockRequest.new(map).get("/bar")
-    res.must_be :ok?
-    res["X-Position"].must_equal "root"
-    res["X-PathInfo"].must_equal "/bar"
-    res["X-ScriptName"].must_equal ""
-
-    res = Rack::MockRequest.new(map).get("")
-    res.must_be :ok?
-    res["X-Position"].must_equal "root"
-    res["X-PathInfo"].must_equal "/"
-    res["X-ScriptName"].must_equal ""
-  end
-
-  it "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.must_be :ok?
-    res["X-Position"].must_equal "root"
-    res["X-PathInfo"].must_equal "/http://example.org/bar"
-    res["X-ScriptName"].must_equal ""
-  end
-
-  it "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.must_be :ok?
-    res["X-Position"].must_equal "root"
-    res["X-PathInfo"].must_equal "/"
-    res["X-ScriptName"].must_equal ""
-
-    res = Rack::MockRequest.new(map).get("http://EXAMPLE.ORG/")
-    res.must_be :ok?
-    res["X-Position"].must_equal "root"
-    res["X-PathInfo"].must_equal "/"
-    res["X-ScriptName"].must_equal ""
-  end
-end