sprokovuln 0.2.0

data/vendor/ruby/gems/rack-2.0.5/test/spec_show_status.rb

@@ -0,0 +1,104 @@
+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/vendor/ruby/gems/rack-2.0.5/test/spec_static.rb

@@ -0,0 +1,184 @@
+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/vendor/ruby/gems/rack-2.0.5/test/spec_tempfile_reaper.rb

@@ -0,0 +1,64 @@
+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/vendor/ruby/gems/rack-2.0.5/test/spec_thin.rb

@@ -0,0 +1,96 @@
+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/vendor/ruby/gems/rack-2.0.5/test/spec_urlmap.rb

@@ -0,0 +1,237 @@
+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