qoobaa-rack 1.0.0.1

data/test/spec_rack_utils.rb

@@ -0,0 +1,467 @@
+require 'test/spec'
+
+require 'rack/utils'
+require 'rack/lint'
+require 'rack/mock'
+
+context "Rack::Utils" do
+  specify "should escape correctly" do
+    Rack::Utils.escape("fo<o>bar").should.equal "fo%3Co%3Ebar"
+    Rack::Utils.escape("a space").should.equal "a+space"
+    Rack::Utils.escape("q1!2\"'w$5&7/z8)?\\").
+      should.equal "q1%212%22%27w%245%267%2Fz8%29%3F%5C"
+  end
+
+  specify "should unescape correctly" do
+    Rack::Utils.unescape("fo%3Co%3Ebar").should.equal "fo<o>bar"
+    Rack::Utils.unescape("a+space").should.equal "a space"
+    Rack::Utils.unescape("a%20space").should.equal "a space"
+    Rack::Utils.unescape("q1%212%22%27w%245%267%2Fz8%29%3F%5C").
+      should.equal "q1!2\"'w$5&7/z8)?\\"
+  end
+
+  specify "should parse query strings correctly" do
+    Rack::Utils.parse_query("foo=bar").should.equal "foo" => "bar"
+    Rack::Utils.parse_query("foo=bar&foo=quux").
+      should.equal "foo" => ["bar", "quux"]
+    Rack::Utils.parse_query("foo=1&bar=2").
+      should.equal "foo" => "1", "bar" => "2"
+    Rack::Utils.parse_query("my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F").
+      should.equal "my weird field" => "q1!2\"'w$5&7/z8)?"
+    Rack::Utils.parse_query("foo%3Dbaz=bar").should.equal "foo=baz" => "bar"
+  end
+
+  specify "should parse nested query strings correctly" do
+    Rack::Utils.parse_nested_query("foo").
+      should.equal "foo" => nil
+    Rack::Utils.parse_nested_query("foo=").
+      should.equal "foo" => ""
+    Rack::Utils.parse_nested_query("foo=bar").
+      should.equal "foo" => "bar"
+
+    Rack::Utils.parse_nested_query("foo=bar&foo=quux").
+      should.equal "foo" => "quux"
+    Rack::Utils.parse_nested_query("foo&foo=").
+      should.equal "foo" => ""
+    Rack::Utils.parse_nested_query("foo=1&bar=2").
+      should.equal "foo" => "1", "bar" => "2"
+    Rack::Utils.parse_nested_query("&foo=1&&bar=2").
+      should.equal "foo" => "1", "bar" => "2"
+    Rack::Utils.parse_nested_query("foo&bar=").
+      should.equal "foo" => nil, "bar" => ""
+    Rack::Utils.parse_nested_query("foo=bar&baz=").
+      should.equal "foo" => "bar", "baz" => ""
+    Rack::Utils.parse_nested_query("my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F").
+      should.equal "my weird field" => "q1!2\"'w$5&7/z8)?"
+
+    Rack::Utils.parse_nested_query("foo[]").
+      should.equal "foo" => [nil]
+    Rack::Utils.parse_nested_query("foo[]=").
+      should.equal "foo" => [""]
+    Rack::Utils.parse_nested_query("foo[]=bar").
+      should.equal "foo" => ["bar"]
+
+    Rack::Utils.parse_nested_query("foo[]=1&foo[]=2").
+      should.equal "foo" => ["1", "2"]
+    Rack::Utils.parse_nested_query("foo=bar&baz[]=1&baz[]=2&baz[]=3").
+      should.equal "foo" => "bar", "baz" => ["1", "2", "3"]
+    Rack::Utils.parse_nested_query("foo[]=bar&baz[]=1&baz[]=2&baz[]=3").
+      should.equal "foo" => ["bar"], "baz" => ["1", "2", "3"]
+
+    Rack::Utils.parse_nested_query("x[y][z]=1").
+      should.equal "x" => {"y" => {"z" => "1"}}
+    Rack::Utils.parse_nested_query("x[y][z][]=1").
+      should.equal "x" => {"y" => {"z" => ["1"]}}
+    Rack::Utils.parse_nested_query("x[y][z]=1&x[y][z]=2").
+      should.equal "x" => {"y" => {"z" => "2"}}
+    Rack::Utils.parse_nested_query("x[y][z][]=1&x[y][z][]=2").
+      should.equal "x" => {"y" => {"z" => ["1", "2"]}}
+
+    Rack::Utils.parse_nested_query("x[y][][z]=1").
+      should.equal "x" => {"y" => [{"z" => "1"}]}
+    Rack::Utils.parse_nested_query("x[y][][z][]=1").
+      should.equal "x" => {"y" => [{"z" => ["1"]}]}
+    Rack::Utils.parse_nested_query("x[y][][z]=1&x[y][][w]=2").
+      should.equal "x" => {"y" => [{"z" => "1", "w" => "2"}]}
+
+    Rack::Utils.parse_nested_query("x[y][][v][w]=1").
+      should.equal "x" => {"y" => [{"v" => {"w" => "1"}}]}
+    Rack::Utils.parse_nested_query("x[y][][z]=1&x[y][][v][w]=2").
+      should.equal "x" => {"y" => [{"z" => "1", "v" => {"w" => "2"}}]}
+
+    Rack::Utils.parse_nested_query("x[y][][z]=1&x[y][][z]=2").
+      should.equal "x" => {"y" => [{"z" => "1"}, {"z" => "2"}]}
+    Rack::Utils.parse_nested_query("x[y][][z]=1&x[y][][w]=a&x[y][][z]=2&x[y][][w]=3").
+      should.equal "x" => {"y" => [{"z" => "1", "w" => "a"}, {"z" => "2", "w" => "3"}]}
+
+    lambda { Rack::Utils.parse_nested_query("x[y]=1&x[y]z=2") }.
+      should.raise(TypeError).
+      message.should.equal "expected Hash (got String) for param `y'"
+
+    lambda { Rack::Utils.parse_nested_query("x[y]=1&x[]=1") }.
+      should.raise(TypeError).
+      message.should.equal "expected Array (got Hash) for param `x'"
+
+    lambda { Rack::Utils.parse_nested_query("x[y]=1&x[y][][w]=2") }.
+      should.raise(TypeError).
+      message.should.equal "expected Array (got String) for param `y'"
+  end
+
+  specify "should build query strings correctly" do
+    Rack::Utils.build_query("foo" => "bar").should.equal "foo=bar"
+    Rack::Utils.build_query("foo" => ["bar", "quux"]).
+      should.equal "foo=bar&foo=quux"
+    Rack::Utils.build_query("foo" => "1", "bar" => "2").
+      should.equal "foo=1&bar=2"
+    Rack::Utils.build_query("my weird field" => "q1!2\"'w$5&7/z8)?").
+      should.equal "my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F"
+  end
+
+  specify "should build nested query strings correctly" do
+    Rack::Utils.build_nested_query("foo" => nil).should.equal "foo"
+    Rack::Utils.build_nested_query("foo" => "").should.equal "foo="
+    Rack::Utils.build_nested_query("foo" => "bar").should.equal "foo=bar"
+
+    Rack::Utils.build_nested_query("foo" => "1", "bar" => "2").
+      should.equal "foo=1&bar=2"
+    Rack::Utils.build_nested_query("my weird field" => "q1!2\"'w$5&7/z8)?").
+      should.equal "my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F"
+
+    Rack::Utils.build_nested_query("foo" => [nil]).
+      should.equal "foo[]"
+    Rack::Utils.build_nested_query("foo" => [""]).
+      should.equal "foo[]="
+    Rack::Utils.build_nested_query("foo" => ["bar"]).
+      should.equal "foo[]=bar"
+
+    # The ordering of the output query string is unpredictable with 1.8's
+    # unordered hash. Test that build_nested_query performs the inverse
+    # function of parse_nested_query.
+    [{"foo" => nil, "bar" => ""},
+     {"foo" => "bar", "baz" => ""},
+     {"foo" => ["1", "2"]},
+     {"foo" => "bar", "baz" => ["1", "2", "3"]},
+     {"foo" => ["bar"], "baz" => ["1", "2", "3"]},
+     {"foo" => ["1", "2"]},
+     {"foo" => "bar", "baz" => ["1", "2", "3"]},
+     {"x" => {"y" => {"z" => "1"}}},
+     {"x" => {"y" => {"z" => ["1"]}}},
+     {"x" => {"y" => {"z" => ["1", "2"]}}},
+     {"x" => {"y" => [{"z" => "1"}]}},
+     {"x" => {"y" => [{"z" => ["1"]}]}},
+     {"x" => {"y" => [{"z" => "1", "w" => "2"}]}},
+     {"x" => {"y" => [{"v" => {"w" => "1"}}]}},
+     {"x" => {"y" => [{"z" => "1", "v" => {"w" => "2"}}]}},
+     {"x" => {"y" => [{"z" => "1"}, {"z" => "2"}]}},
+     {"x" => {"y" => [{"z" => "1", "w" => "a"}, {"z" => "2", "w" => "3"}]}}
+    ].each { |params|
+      qs = Rack::Utils.build_nested_query(params)
+      Rack::Utils.parse_nested_query(qs).should.equal params
+    }
+
+    lambda { Rack::Utils.build_nested_query("foo=bar") }.
+      should.raise(ArgumentError).
+      message.should.equal "value must be a Hash"
+  end
+
+  specify "should figure out which encodings are acceptable" do
+    helper = lambda do |a, b|
+      request = Rack::Request.new(Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => a))
+      Rack::Utils.select_best_encoding(a, b)
+    end
+
+    helper.call(%w(), [["x", 1]]).should.equal(nil)
+    helper.call(%w(identity), [["identity", 0.0]]).should.equal(nil)
+    helper.call(%w(identity), [["*", 0.0]]).should.equal(nil)
+
+    helper.call(%w(identity), [["compress", 1.0], ["gzip", 1.0]]).should.equal("identity")
+
+    helper.call(%w(compress gzip identity), [["compress", 1.0], ["gzip", 1.0]]).should.equal("compress")
+    helper.call(%w(compress gzip identity), [["compress", 0.5], ["gzip", 1.0]]).should.equal("gzip")
+
+    helper.call(%w(foo bar identity), []).should.equal("identity")
+    helper.call(%w(foo bar identity), [["*", 1.0]]).should.equal("foo")
+    helper.call(%w(foo bar identity), [["*", 1.0], ["foo", 0.9]]).should.equal("bar")
+
+    helper.call(%w(foo bar identity), [["foo", 0], ["bar", 0]]).should.equal("identity")
+    helper.call(%w(foo bar baz identity), [["*", 0], ["identity", 0.1]]).should.equal("identity")
+  end
+
+  specify "should return the bytesize of String" do
+    Rack::Utils.bytesize("FOO\xE2\x82\xAC").should.equal 6
+  end
+end
+
+context "Rack::Utils::HeaderHash" do
+  specify "should retain header case" do
+    h = Rack::Utils::HeaderHash.new("Content-MD5" => "d5ff4e2a0 ...")
+    h['ETag'] = 'Boo!'
+    h.to_hash.should.equal "Content-MD5" => "d5ff4e2a0 ...", "ETag" => 'Boo!'
+  end
+
+  specify "should check existence of keys case insensitively" do
+    h = Rack::Utils::HeaderHash.new("Content-MD5" => "d5ff4e2a0 ...")
+    h.should.include 'content-md5'
+    h.should.not.include 'ETag'
+  end
+
+  specify "should merge case-insensitively" do
+    h = Rack::Utils::HeaderHash.new("ETag" => 'HELLO', "content-length" => '123')
+    merged = h.merge("Etag" => 'WORLD', 'Content-Length' => '321', "Foo" => 'BAR')
+    merged.should.equal "Etag"=>'WORLD', "Content-Length"=>'321', "Foo"=>'BAR'
+  end
+
+  specify "should overwrite case insensitively and assume the new key's case" do
+    h = Rack::Utils::HeaderHash.new("Foo-Bar" => "baz")
+    h["foo-bar"] = "bizzle"
+    h["FOO-BAR"].should.equal "bizzle"
+    h.length.should.equal 1
+    h.to_hash.should.equal "foo-bar" => "bizzle"
+  end
+
+  specify "should be converted to real Hash" do
+    h = Rack::Utils::HeaderHash.new("foo" => "bar")
+    h.to_hash.should.be.instance_of Hash
+  end
+
+  specify "should convert Array values to Strings when converting to Hash" do
+    h = Rack::Utils::HeaderHash.new("foo" => ["bar", "baz"])
+    h.to_hash.should.equal({ "foo" => "bar\nbaz" })
+  end
+
+  specify "should replace hashes correctly" do
+    h = Rack::Utils::HeaderHash.new("Foo-Bar" => "baz")
+    j = {"foo" => "bar"}
+    h.replace(j)
+    h["foo"].should.equal "bar"
+  end
+  
+  specify "should be able to delete the given key case-sensitively" do
+    h = Rack::Utils::HeaderHash.new("foo" => "bar")
+    h.delete("foo")
+    h["foo"].should.be.nil
+    h["FOO"].should.be.nil
+  end
+  
+  specify "should be able to delete the given key case-insensitively" do
+    h = Rack::Utils::HeaderHash.new("foo" => "bar")
+    h.delete("FOO")
+    h["foo"].should.be.nil
+    h["FOO"].should.be.nil
+  end
+  
+  specify "should return the deleted value when #delete is called on an existing key" do
+    h = Rack::Utils::HeaderHash.new("foo" => "bar")
+    h.delete("Foo").should.equal("bar")
+  end
+  
+  specify "should return nil when #delete is called on a non-existant key" do
+    h = Rack::Utils::HeaderHash.new("foo" => "bar")
+    h.delete("Hello").should.be.nil
+  end
+end
+
+context "Rack::Utils::Context" do
+  class ContextTest
+    attr_reader :app
+    def initialize app; @app=app; end
+    def call env; context env; end
+    def context env, app=@app; app.call(env); end
+  end
+  test_target1 = proc{|e| e.to_s+' world' }
+  test_target2 = proc{|e| e.to_i+2 }
+  test_target3 = proc{|e| nil }
+  test_target4 = proc{|e| [200,{'Content-Type'=>'text/plain', 'Content-Length'=>'0'},['']] }
+  test_app = ContextTest.new test_target4
+
+  specify "should set context correctly" do
+    test_app.app.should.equal test_target4
+    c1 = Rack::Utils::Context.new(test_app, test_target1)
+    c1.for.should.equal test_app
+    c1.app.should.equal test_target1
+    c2 = Rack::Utils::Context.new(test_app, test_target2)
+    c2.for.should.equal test_app
+    c2.app.should.equal test_target2
+  end
+
+  specify "should alter app on recontexting" do
+    c1 = Rack::Utils::Context.new(test_app, test_target1)
+    c2 = c1.recontext(test_target2)
+    c2.for.should.equal test_app
+    c2.app.should.equal test_target2
+    c3 = c2.recontext(test_target3)
+    c3.for.should.equal test_app
+    c3.app.should.equal test_target3
+  end
+
+  specify "should run different apps" do
+    c1 = Rack::Utils::Context.new test_app, test_target1
+    c2 = c1.recontext test_target2
+    c3 = c2.recontext test_target3
+    c4 = c3.recontext test_target4
+    a4 = Rack::Lint.new c4
+    a5 = Rack::Lint.new test_app
+    r1 = c1.call('hello')
+    r1.should.equal 'hello world'
+    r2 = c2.call(2)
+    r2.should.equal 4
+    r3 = c3.call(:misc_symbol)
+    r3.should.be.nil
+    r4 = Rack::MockRequest.new(a4).get('/')
+    r4.status.should.be 200
+    r5 = Rack::MockRequest.new(a5).get('/')
+    r5.status.should.be 200
+    r4.body.should.equal r5.body
+  end
+end
+
+context "Rack::Utils::Multipart" do
+  specify "should return nil if content type is not multipart" do
+    env = Rack::MockRequest.env_for("/",
+            "CONTENT_TYPE" => 'application/x-www-form-urlencoded')
+    Rack::Utils::Multipart.parse_multipart(env).should.equal nil
+  end
+
+  specify "should parse multipart upload with text file" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:text))
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["files"][:type].should.equal "text/plain"
+    params["files"][:filename].should.equal "file1.txt"
+    params["files"][:head].should.equal "Content-Disposition: form-data; " +
+      "name=\"files\"; filename=\"file1.txt\"\r\n" +
+      "Content-Type: text/plain\r\n"
+    params["files"][:name].should.equal "files"
+    params["files"][:tempfile].read.should.equal "contents"
+  end
+
+  specify "should parse multipart upload with nested parameters" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:nested))
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["foo"]["submit-name"].should.equal "Larry"
+    params["foo"]["files"][:type].should.equal "text/plain"
+    params["foo"]["files"][:filename].should.equal "file1.txt"
+    params["foo"]["files"][:head].should.equal "Content-Disposition: form-data; " +
+      "name=\"foo[files]\"; filename=\"file1.txt\"\r\n" +
+      "Content-Type: text/plain\r\n"
+    params["foo"]["files"][:name].should.equal "foo[files]"
+    params["foo"]["files"][:tempfile].read.should.equal "contents"
+  end
+
+  specify "should parse multipart upload with binary file" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:binary))
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["files"][:type].should.equal "image/png"
+    params["files"][:filename].should.equal "rack-logo.png"
+    params["files"][:head].should.equal "Content-Disposition: form-data; " +
+      "name=\"files\"; filename=\"rack-logo.png\"\r\n" +
+      "Content-Type: image/png\r\n"
+    params["files"][:name].should.equal "files"
+    params["files"][:tempfile].read.length.should.equal 26473
+  end
+
+  specify "should parse multipart upload with empty file" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:empty))
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["files"][:type].should.equal "text/plain"
+    params["files"][:filename].should.equal "file1.txt"
+    params["files"][:head].should.equal "Content-Disposition: form-data; " +
+      "name=\"files\"; filename=\"file1.txt\"\r\n" +
+      "Content-Type: text/plain\r\n"
+    params["files"][:name].should.equal "files"
+    params["files"][:tempfile].read.should.equal ""
+  end
+
+  specify "should not include file params if no file was selected" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:none))
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["files"].should.equal nil
+    params.keys.should.not.include "files"
+  end
+
+  specify "should parse IE multipart upload and clean up filename" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:ie))
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["files"][:type].should.equal "text/plain"
+    params["files"][:filename].should.equal "file1.txt"
+    params["files"][:head].should.equal "Content-Disposition: form-data; " +
+      "name=\"files\"; " +
+      'filename="C:\Documents and Settings\Administrator\Desktop\file1.txt"' +
+      "\r\nContent-Type: text/plain\r\n"
+    params["files"][:name].should.equal "files"
+    params["files"][:tempfile].read.should.equal "contents"
+  end
+
+  specify "rewinds input after parsing upload" do
+    options = multipart_fixture(:text)
+    input = options[:input]
+    env = Rack::MockRequest.env_for("/", options)
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["files"][:filename].should.equal "file1.txt"
+    input.read.length.should.equal 197
+  end
+
+  specify "builds multipart body" do
+    files = Rack::Utils::Multipart::UploadedFile.new(multipart_file("file1.txt"))
+    data  = Rack::Utils::Multipart.build_multipart("submit-name" => "Larry", "files" => files)
+
+    options = {
+      "CONTENT_TYPE" => "multipart/form-data; boundary=AaB03x",
+      "CONTENT_LENGTH" => data.length.to_s,
+      :input => StringIO.new(data)
+    }
+    env = Rack::MockRequest.env_for("/", options)
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["files"][:filename].should.equal "file1.txt"
+    params["files"][:tempfile].read.should.equal "contents"
+  end
+
+  specify "builds nested multipart body" do
+    files = Rack::Utils::Multipart::UploadedFile.new(multipart_file("file1.txt"))
+    data  = Rack::Utils::Multipart.build_multipart("people" => [{"submit-name" => "Larry", "files" => files}])
+
+    options = {
+      "CONTENT_TYPE" => "multipart/form-data; boundary=AaB03x",
+      "CONTENT_LENGTH" => data.length.to_s,
+      :input => StringIO.new(data)
+    }
+    env = Rack::MockRequest.env_for("/", options)
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["people"][0]["submit-name"].should.equal "Larry"
+    params["people"][0]["files"][:filename].should.equal "file1.txt"
+    params["people"][0]["files"][:tempfile].read.should.equal "contents"
+  end
+
+  specify "should return nil if no UploadedFiles were used" do
+    data = Rack::Utils::Multipart.build_multipart("people" => [{"submit-name" => "Larry", "files" => "contents"}])
+    data.should.equal nil
+  end
+
+  specify "should raise ArgumentError if params is not a Hash" do
+    lambda { Rack::Utils::Multipart.build_multipart("foo=bar") }.
+      should.raise(ArgumentError).
+      message.should.equal "value must be a Hash"
+  end
+
+  private
+    def multipart_fixture(name)
+      file = multipart_file(name)
+      data = File.open(file, 'rb') { |io| io.read }
+
+      type = "multipart/form-data; boundary=AaB03x"
+      length = data.respond_to?(:bytesize) ? data.bytesize : data.size
+
+      { "CONTENT_TYPE" => type,
+        "CONTENT_LENGTH" => length.to_s,
+        :input => StringIO.new(data) }
+    end
+
+    def multipart_file(name)
+      File.join(File.dirname(__FILE__), "multipart", name.to_s)
+    end
+end

data/test/spec_rack_webrick.rb

@@ -0,0 +1,130 @@
+require 'test/spec'
+
+require 'rack/handler/webrick'
+require 'rack/lint'
+require 'rack/response'
+require 'testrequest'
+
+Thread.abort_on_exception = true
+
+context "Rack::Handler::WEBrick" do
+  include TestRequest::Helpers
+  
+  setup do
+    @server = WEBrick::HTTPServer.new(:Host => @host='0.0.0.0',
+                                      :Port => @port=9202,
+                                      :Logger => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN),
+                                      :AccessLog => [])
+    @server.mount "/test", Rack::Handler::WEBrick,
+      Rack::Lint.new(TestRequest.new)
+    Thread.new { @server.start }
+    trap(:INT) { @server.shutdown }
+  end
+
+  specify "should respond" do
+    lambda {
+      GET("/test")
+    }.should.not.raise
+  end
+
+  specify "should be a WEBrick" do
+    GET("/test")
+    status.should.be 200
+    response["SERVER_SOFTWARE"].should =~ /WEBrick/
+    response["HTTP_VERSION"].should.equal "HTTP/1.1"
+    response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
+    response["SERVER_PORT"].should.equal "9202"
+    response["SERVER_NAME"].should.equal "0.0.0.0"
+  end
+
+  specify "should have rack headers" do
+    GET("/test")
+    response["rack.version"].should.equal [1,0]
+    response["rack.multithread"].should.be true
+    response["rack.multiprocess"].should.be false
+    response["rack.run_once"].should.be false
+  end
+
+  specify "should have CGI headers on GET" do
+    GET("/test")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["SCRIPT_NAME"].should.equal "/test"
+    response["REQUEST_PATH"].should.equal "/"
+    response["PATH_INFO"].should.be.nil
+    response["QUERY_STRING"].should.equal ""
+    response["test.postdata"].should.equal ""
+
+    GET("/test/foo?quux=1")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["SCRIPT_NAME"].should.equal "/test"
+    response["REQUEST_PATH"].should.equal "/"
+    response["PATH_INFO"].should.equal "/foo"
+    response["QUERY_STRING"].should.equal "quux=1"
+    
+    GET("/test/foo%25encoding?quux=1")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["SCRIPT_NAME"].should.equal "/test"
+    response["REQUEST_PATH"].should.equal "/"
+    response["PATH_INFO"].should.equal "/foo%25encoding"
+    response["QUERY_STRING"].should.equal "quux=1"
+  end
+
+  specify "should have CGI headers on POST" do
+    POST("/test", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
+    status.should.equal 200
+    response["REQUEST_METHOD"].should.equal "POST"
+    response["SCRIPT_NAME"].should.equal "/test"
+    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
+
+  specify "should support HTTP auth" do
+    GET("/test", {:user => "ruth", :passwd => "secret"})
+    response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
+  end
+
+  specify "should set status" do
+    GET("/test?secret")
+    status.should.equal 403
+    response["rack.url_scheme"].should.equal "http"
+  end
+
+  specify "should correctly set cookies" do
+    @server.mount "/cookie-test", Rack::Handler::WEBrick,
+    Rack::Lint.new(lambda { |req|
+                     res = Rack::Response.new
+                     res.set_cookie "one", "1"
+                     res.set_cookie "two", "2"
+                     res.finish
+                   })
+
+    Net::HTTP.start(@host, @port) { |http|
+      res = http.get("/cookie-test")
+      res.code.to_i.should.equal 200
+      res.get_fields("set-cookie").should.equal ["one=1", "two=2"]
+    }
+  end
+
+  specify "should provide a .run" do
+    block_ran = false
+    catch(:done) {
+      Rack::Handler::WEBrick.run(lambda {},
+                                 {:Port => 9210,
+                                   :Logger => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN),
+                                   :AccessLog => []}) { |server|
+        block_ran = true
+        server.should.be.kind_of WEBrick::HTTPServer
+        @s = server
+        throw :done
+      }
+    }
+    block_ran.should.be true
+    @s.shutdown
+  end
+
+  teardown do
+    @server.shutdown
+  end
+end

data/test/testrequest.rb

@@ -0,0 +1,57 @@
+require 'yaml'
+require 'net/http'
+
+class TestRequest
+  def call(env)
+    status = env["QUERY_STRING"] =~ /secret/ ? 403 : 200
+    env["test.postdata"] = env["rack.input"].read
+    body = env.to_yaml
+    size = body.respond_to?(:bytesize) ? body.bytesize : body.size
+    [status, {"Content-Type" => "text/yaml", "Content-Length" => size.to_s}, [body]]
+  end
+
+  module Helpers
+    attr_reader :status, :response
+
+    def GET(path, header={})
+      Net::HTTP.start(@host, @port) { |http|
+        user = header.delete(:user)
+        passwd = header.delete(:passwd)
+
+        get = Net::HTTP::Get.new(path, header)
+        get.basic_auth user, passwd  if user && passwd
+        http.request(get) { |response|
+          @status = response.code.to_i
+          @response = YAML.load(response.body)
+        }
+      }
+    end
+
+    def POST(path, formdata={}, header={})
+      Net::HTTP.start(@host, @port) { |http|
+        user = header.delete(:user)
+        passwd = header.delete(:passwd)
+
+        post = Net::HTTP::Post.new(path, header)
+        post.form_data = formdata
+        post.basic_auth user, passwd  if user && passwd
+        http.request(post) { |response|
+          @status = response.code.to_i
+          @response = YAML.load(response.body)
+        }
+      }
+    end
+  end
+end
+
+class StreamingRequest
+  def self.call(env)
+    [200, {"Content-Type" => "text/plain"}, new]
+  end
+
+  def each
+    yield "hello there!\n"
+    sleep 5
+    yield "that is all.\n"
+  end
+end

data/test/unregistered_handler/rack/handler/unregistered.rb

@@ -0,0 +1,7 @@
+module Rack
+  module Handler
+    # this class doesn't do anything, we're just seeing if we get it.
+    class Unregistered
+    end
+  end
+end

data/test/unregistered_handler/rack/handler/unregistered_long_one.rb

@@ -0,0 +1,7 @@
+module Rack
+  module Handler
+    # this class doesn't do anything, we're just seeing if we get it.
+    class UnregisteredLongOne
+    end
+  end
+end