rack 1.6.13 → 2.0.0.alpha

data/test/spec_thin.rb

@@ -1,89 +1,94 @@
+require 'minitest/autorun'
 begin
 require 'rack/handler/thin'
 require File.expand_path('../testrequest', __FILE__)
 require 'timeout'
 
 describe Rack::Handler::Thin do
-  extend TestRequest::Helpers
+  include TestRequest::Helpers
 
-  @app = Rack::Lint.new(TestRequest.new)
-  @server = nil
-  Thin::Logging.silent = true
+  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
+    @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
 
-  Thread.pass until @server && @server.running?
 
-  should "respond" do
+  it "respond" do
     GET("/")
-    response.should.not.be.nil
+    response.wont_be :nil?
   end
 
-  should "be a Thin" do
+  it "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"
+    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
 
-  should "have rack headers" do
+  it "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
+    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
 
-  should "have CGI headers on GET" do
+  it "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 ""
+    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"].should.equal "GET"
-    response["REQUEST_PATH"].should.equal "/test/foo"
-    response["PATH_INFO"].should.equal "/test/foo"
-    response["QUERY_STRING"].should.equal "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
 
-  should "have CGI headers on POST" do
+  it "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"
+    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
 
-  should "support HTTP auth" do
+  it "support HTTP auth" do
     GET("/test", {:user => "ruth", :passwd => "secret"})
-    response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
+    response["HTTP_AUTHORIZATION"].must_equal "Basic cnV0aDpzZWNyZXQ="
   end
 
-  should "set status" do
+  it "set status" do
     GET("/test?secret")
-    status.should.equal 403
-    response["rack.url_scheme"].should.equal "http"
+    status.must_equal 403
+    response["rack.url_scheme"].must_equal "http"
   end
 
-  should "set tag for server" do
-    @server.tag.should.equal 'tag'
+  it "set tag for server" do
+    @server.tag.must_equal 'tag'
   end
-
-  @server.stop!
-  @thread.kill
-
 end
 
 rescue LoadError

data/test/spec_urlmap.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 require 'rack/urlmap'
 require 'rack/mock'
 
@@ -17,51 +18,51 @@ describe Rack::URLMap do
     }))
 
     res = Rack::MockRequest.new(map).get("/")
-    res.should.be.not_found
+    res.must_be :not_found?
 
     res = Rack::MockRequest.new(map).get("/qux")
-    res.should.be.not_found
+    res.must_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.must_be :ok?
+    res["X-ScriptName"].must_equal "/foo"
+    res["X-PathInfo"].must_equal ""
 
     res = Rack::MockRequest.new(map).get("/foo/")
-    res.should.be.ok
-    res["X-ScriptName"].should.equal "/foo"
-    res["X-PathInfo"].should.equal "/"
+    res.must_be :ok?
+    res["X-ScriptName"].must_equal "/foo"
+    res["X-PathInfo"].must_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.must_be :ok?
+    res["X-ScriptName"].must_equal "/foo/bar"
+    res["X-PathInfo"].must_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.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.should.equal 200
-    res.should.be.ok
-    res["X-ScriptName"].should.equal "/foo/bar"
-    res["X-PathInfo"].should.equal "//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.should.be.ok
-    res["X-ScriptName"].should.equal "/bleh/foo"
-    res["X-PathInfo"].should.equal "/quux"
+    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.should.be.ok
-    res["X-ScriptName"].should.equal "/bar"
-    res["X-PathInfo"].should.be.empty
+    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.should.be.ok
-    res["X-ScriptName"].should.equal "/bar"
-    res["X-PathInfo"].should.equal '/'
+    res.must_be :ok?
+    res["X-ScriptName"].must_equal "/bar"
+    res["X-PathInfo"].must_equal '/'
   end
 
 
@@ -93,37 +94,37 @@ describe Rack::URLMap do
                            ))
 
     res = Rack::MockRequest.new(map).get("/")
-    res.should.be.ok
-    res["X-Position"].should.equal "default.org"
+    res.must_be :ok?
+    res["X-Position"].must_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.must_be :ok?
+    res["X-Position"].must_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.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.should.be.ok
-    res["X-Position"].should.equal "subdomain.foo.org"
+    res.must_be :ok?
+    res["X-Position"].must_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.must_be :ok?
+    res["X-Position"].must_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.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.should.be.ok
-    res["X-Position"].should.equal "default.org"
+    res.must_be :ok?
+    res["X-Position"].must_equal "default.org"
   end
 
-  should "be nestable" do
+  it "be nestable" do
     map = Rack::Lint.new(Rack::URLMap.new("/foo" =>
       Rack::URLMap.new("/bar" =>
         Rack::URLMap.new("/quux" =>  lambda { |env|
@@ -136,16 +137,16 @@ describe Rack::URLMap do
                          ))))
 
     res = Rack::MockRequest.new(map).get("/foo/bar")
-    res.should.be.not_found
+    res.must_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"
+    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
 
-  should "route root apps correctly" do
+  it "route root apps correctly" do
     map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
@@ -163,31 +164,31 @@ describe Rack::URLMap do
                            ))
 
     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.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.should.be.ok
-    res["X-Position"].should.equal "foo"
-    res["X-PathInfo"].should.equal ""
-    res["X-ScriptName"].should.equal "/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.should.be.ok
-    res["X-Position"].should.equal "root"
-    res["X-PathInfo"].should.equal "/bar"
-    res["X-ScriptName"].should.equal ""
+    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.should.be.ok
-    res["X-Position"].should.equal "root"
-    res["X-PathInfo"].should.equal "/"
-    res["X-ScriptName"].should.equal ""
+    res.must_be :ok?
+    res["X-Position"].must_equal "root"
+    res["X-PathInfo"].must_equal "/"
+    res["X-ScriptName"].must_equal ""
   end
 
-  should "not squeeze slashes" do
+  it "not squeeze slashes" do
     map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
@@ -205,13 +206,13 @@ describe Rack::URLMap do
                            ))
 
     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 ""
+    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
 
-  should "not be case sensitive with hosts" do
+  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",
@@ -222,15 +223,15 @@ describe Rack::URLMap do
                            ))
 
     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.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.should.be.ok
-    res["X-Position"].should.equal "root"
-    res["X-PathInfo"].should.equal "/"
-    res["X-ScriptName"].should.equal ""
+    res.must_be :ok?
+    res["X-Position"].must_equal "root"
+    res["X-PathInfo"].must_equal "/"
+    res["X-ScriptName"].must_equal ""
   end
 end

data/test/spec_utils.rb

@@ -1,288 +1,312 @@
 # -*- encoding: utf-8 -*-
+require 'minitest/autorun'
 require 'rack/utils'
 require 'rack/mock'
 require 'timeout'
 
 describe Rack::Utils do
 
-  # A helper method which checks
-  # if certain query parameters 
-  # are equal.
-  def equal_query_to(query)
-    parts = query.split('&')
-    lambda{|other| (parts & other.split('&')) == parts }
+  def assert_sets exp, act
+    exp = Set.new exp.split '&'
+    act = Set.new act.split '&'
+
+    assert_equal exp, act
+  end
+
+  def assert_query exp, act
+    assert_sets exp, Rack::Utils.build_query(act)
   end
 
-  def kcodeu
-    one8 = RUBY_VERSION.to_f < 1.9
-    default_kcode, $KCODE = $KCODE, 'U' if one8
-    yield
-  ensure
-    $KCODE = default_kcode if one8
+  def assert_nested_query exp, act
+    assert_sets exp, Rack::Utils.build_nested_query(act)
+  end
+
+  it 'can be mixed in and used' do
+    instance = Class.new {
+      include Rack::Utils
+
+      public :parse_nested_query
+      public :parse_query
+    }.new
+
+    assert_equal({ "foo" => "bar" }, instance.parse_nested_query("foo=bar"))
+    assert_equal({ "foo" => "bar" }, instance.parse_query("foo=bar"))
   end
 
-  should "round trip binary data" do
+  it "round trip binary data" do
     r = [218, 0].pack 'CC'
-    if defined?(::Encoding)
       z = Rack::Utils.unescape(Rack::Utils.escape(r), Encoding::BINARY)
-    else
-      z = Rack::Utils.unescape(Rack::Utils.escape(r))
-    end
-    r.should.equal z
+    r.must_equal z
   end
 
-  should "escape correctly" do
-    Rack::Utils.escape("fo<o>bar").should.equal "fo%3Co%3Ebar"
-    Rack::Utils.escape("a space").should.equal "a+space"
+  it "escape correctly" do
+    Rack::Utils.escape("fo<o>bar").must_equal "fo%3Co%3Ebar"
+    Rack::Utils.escape("a space").must_equal "a+space"
     Rack::Utils.escape("q1!2\"'w$5&7/z8)?\\").
-      should.equal "q1%212%22%27w%245%267%2Fz8%29%3F%5C"
+      must_equal "q1%212%22%27w%245%267%2Fz8%29%3F%5C"
   end
 
-  should "escape correctly for multibyte characters" do
+  it "escape correctly for multibyte characters" do
     matz_name = "\xE3\x81\xBE\xE3\x81\xA4\xE3\x82\x82\xE3\x81\xA8".unpack("a*")[0] # Matsumoto
-    matz_name.force_encoding("UTF-8") if matz_name.respond_to? :force_encoding
-    Rack::Utils.escape(matz_name).should.equal '%E3%81%BE%E3%81%A4%E3%82%82%E3%81%A8'
+    matz_name.force_encoding(Encoding::UTF_8)
+    Rack::Utils.escape(matz_name).must_equal '%E3%81%BE%E3%81%A4%E3%82%82%E3%81%A8'
     matz_name_sep = "\xE3\x81\xBE\xE3\x81\xA4 \xE3\x82\x82\xE3\x81\xA8".unpack("a*")[0] # Matsu moto
     matz_name_sep.force_encoding("UTF-8") if matz_name_sep.respond_to? :force_encoding
-    Rack::Utils.escape(matz_name_sep).should.equal '%E3%81%BE%E3%81%A4+%E3%82%82%E3%81%A8'
-  end
-
-  if RUBY_VERSION[/^\d+\.\d+/] == '1.8'
-    should "escape correctly for multibyte characters if $KCODE is set to 'U'" do
-      kcodeu do
-        matz_name = "\xE3\x81\xBE\xE3\x81\xA4\xE3\x82\x82\xE3\x81\xA8".unpack("a*")[0] # Matsumoto
-        matz_name.force_encoding("UTF-8") if matz_name.respond_to? :force_encoding
-        Rack::Utils.escape(matz_name).should.equal '%E3%81%BE%E3%81%A4%E3%82%82%E3%81%A8'
-        matz_name_sep = "\xE3\x81\xBE\xE3\x81\xA4 \xE3\x82\x82\xE3\x81\xA8".unpack("a*")[0] # Matsu moto
-        matz_name_sep.force_encoding("UTF-8") if matz_name_sep.respond_to? :force_encoding
-        Rack::Utils.escape(matz_name_sep).should.equal '%E3%81%BE%E3%81%A4+%E3%82%82%E3%81%A8'
-      end
-    end
+    Rack::Utils.escape(matz_name_sep).must_equal '%E3%81%BE%E3%81%A4+%E3%82%82%E3%81%A8'
+  end
 
-    should "unescape multibyte characters correctly if $KCODE is set to 'U'" do
-      kcodeu do
-        Rack::Utils.unescape('%E3%81%BE%E3%81%A4+%E3%82%82%E3%81%A8').should.equal(
-          "\xE3\x81\xBE\xE3\x81\xA4 \xE3\x82\x82\xE3\x81\xA8".unpack("a*")[0])
-      end
-    end
+  it "escape objects that responds to to_s" do
+    Rack::Utils.escape(:id).must_equal "id"
   end
 
-  should "escape objects that responds to to_s" do
-    kcodeu do
-      Rack::Utils.escape(:id).should.equal "id"
-    end
+  it "escape non-UTF8 strings" do
+    Rack::Utils.escape("ø".encode("ISO-8859-1")).must_equal "%F8"
   end
 
-  if "".respond_to?(:encode)
-    should "escape non-UTF8 strings" do
-      Rack::Utils.escape("ø".encode("ISO-8859-1")).should.equal "%F8"
+  it "not hang on escaping long strings that end in % (http://redmine.ruby-lang.org/issues/5149)" do
+    Timeout.timeout(1) do
+      lambda {
+        URI.decode_www_form_component "A string that causes catastrophic backtracking as it gets longer %"
+      }.must_raise ArgumentError
     end
   end
-  
-  should "not hang on escaping long strings that end in % (http://redmine.ruby-lang.org/issues/5149)" do
-    lambda {
-      timeout(1) do
-        lambda {
-          URI.decode_www_form_component "A string that causes catastrophic backtracking as it gets longer %"
-        }.should.raise(ArgumentError)
-      end
-    }.should.not.raise(Timeout::Error)
-  end
 
-  should "escape path spaces with %20" do
-    Rack::Utils.escape_path("foo bar").should.equal  "foo%20bar"
+  it "escape path spaces with %20" do
+    Rack::Utils.escape_path("foo bar").must_equal  "foo%20bar"
   end
 
-  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"
+  it "unescape correctly" do
+    Rack::Utils.unescape("fo%3Co%3Ebar").must_equal "fo<o>bar"
+    Rack::Utils.unescape("a+space").must_equal "a space"
+    Rack::Utils.unescape("a%20space").must_equal "a space"
     Rack::Utils.unescape("q1%212%22%27w%245%267%2Fz8%29%3F%5C").
-      should.equal "q1!2\"'w$5&7/z8)?\\"
+      must_equal "q1!2\"'w$5&7/z8)?\\"
   end
 
-  should "parse query strings correctly" do
+  it "parse query strings correctly" do
     Rack::Utils.parse_query("foo=bar").
-      should.equal "foo" => "bar"
+      must_equal "foo" => "bar"
     Rack::Utils.parse_query("foo=\"bar\"").
-      should.equal "foo" => "\"bar\""
+      must_equal "foo" => "\"bar\""
     Rack::Utils.parse_query("foo=bar&foo=quux").
-      should.equal "foo" => ["bar", "quux"]
+      must_equal "foo" => ["bar", "quux"]
     Rack::Utils.parse_query("foo=1&bar=2").
-      should.equal "foo" => "1", "bar" => "2"
+      must_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"
-    Rack::Utils.parse_query("=").should.equal "" => ""
-    Rack::Utils.parse_query("=value").should.equal "" => "value"
-    Rack::Utils.parse_query("key=").should.equal "key" => ""
-    Rack::Utils.parse_query("&key&").should.equal "key" => nil
-    Rack::Utils.parse_query(";key;", ";,").should.equal "key" => nil
-    Rack::Utils.parse_query(",key,", ";,").should.equal "key" => nil
-    Rack::Utils.parse_query(";foo=bar,;", ";,").should.equal "foo" => "bar"
-    Rack::Utils.parse_query(",foo=bar;,", ";,").should.equal "foo" => "bar"
-  end
-
-  should "not create infinite loops with cycle structures" do
+      must_equal "my weird field" => "q1!2\"'w$5&7/z8)?"
+    Rack::Utils.parse_query("foo%3Dbaz=bar").must_equal "foo=baz" => "bar"
+    Rack::Utils.parse_query("=").must_equal "" => ""
+    Rack::Utils.parse_query("=value").must_equal "" => "value"
+    Rack::Utils.parse_query("key=").must_equal "key" => ""
+    Rack::Utils.parse_query("&key&").must_equal "key" => nil
+    Rack::Utils.parse_query(";key;", ";,").must_equal "key" => nil
+    Rack::Utils.parse_query(",key,", ";,").must_equal "key" => nil
+    Rack::Utils.parse_query(";foo=bar,;", ";,").must_equal "foo" => "bar"
+    Rack::Utils.parse_query(",foo=bar;,", ";,").must_equal "foo" => "bar"
+  end
+
+  it "not create infinite loops with cycle structures" do
     ex = { "foo" => nil }
     ex["foo"] = ex
 
-    params = Rack::Utils::KeySpaceConstrainedParams.new
+    params = Rack::Utils::KeySpaceConstrainedParams.new(65536)
     params['foo'] = params
-    lambda {
-      params.to_params_hash.to_s.should.equal ex.to_s
-    }.should.not.raise
+    params.to_params_hash.to_s.must_equal ex.to_s
+  end
+
+  it "parse nil as an empty query string" do
+    Rack::Utils.parse_nested_query(nil).must_equal({})
   end
 
-  should "raise an exception if the params are too deep" do
+  it "raise an exception if the params are too deep" do
     len = Rack::Utils.param_depth_limit
 
     lambda {
       Rack::Utils.parse_nested_query("foo#{"[a]" * len}=bar")
-    }.should.raise(RangeError)
+    }.must_raise(RangeError)
 
-    lambda {
-      Rack::Utils.parse_nested_query("foo#{"[a]" * (len - 1)}=bar")
-    }.should.not.raise
+    Rack::Utils.parse_nested_query("foo#{"[a]" * (len - 1)}=bar")
   end
 
-  should "parse nested query strings correctly" do
+  it "parse nested query strings correctly" do
     Rack::Utils.parse_nested_query("foo").
-      should.equal "foo" => nil
+      must_equal "foo" => nil
     Rack::Utils.parse_nested_query("foo=").
-      should.equal "foo" => ""
+      must_equal "foo" => ""
     Rack::Utils.parse_nested_query("foo=bar").
-      should.equal "foo" => "bar"
+      must_equal "foo" => "bar"
     Rack::Utils.parse_nested_query("foo=\"bar\"").
-      should.equal "foo" => "\"bar\""
+      must_equal "foo" => "\"bar\""
 
     Rack::Utils.parse_nested_query("foo=bar&foo=quux").
-      should.equal "foo" => "quux"
+      must_equal "foo" => "quux"
     Rack::Utils.parse_nested_query("foo&foo=").
-      should.equal "foo" => ""
+      must_equal "foo" => ""
     Rack::Utils.parse_nested_query("foo=1&bar=2").
-      should.equal "foo" => "1", "bar" => "2"
+      must_equal "foo" => "1", "bar" => "2"
     Rack::Utils.parse_nested_query("&foo=1&&bar=2").
-      should.equal "foo" => "1", "bar" => "2"
+      must_equal "foo" => "1", "bar" => "2"
     Rack::Utils.parse_nested_query("foo&bar=").
-      should.equal "foo" => nil, "bar" => ""
+      must_equal "foo" => nil, "bar" => ""
     Rack::Utils.parse_nested_query("foo=bar&baz=").
-      should.equal "foo" => "bar", "baz" => ""
+      must_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)?"
+      must_equal "my weird field" => "q1!2\"'w$5&7/z8)?"
 
     Rack::Utils.parse_nested_query("a=b&pid%3D1234=1023").
-      should.equal "pid=1234" => "1023", "a" => "b"
+      must_equal "pid=1234" => "1023", "a" => "b"
 
     Rack::Utils.parse_nested_query("foo[]").
-      should.equal "foo" => [nil]
+      must_equal "foo" => [nil]
     Rack::Utils.parse_nested_query("foo[]=").
-      should.equal "foo" => [""]
+      must_equal "foo" => [""]
     Rack::Utils.parse_nested_query("foo[]=bar").
-      should.equal "foo" => ["bar"]
+      must_equal "foo" => ["bar"]
     Rack::Utils.parse_nested_query("foo[]=bar&foo").
-      should.equal "foo" => nil
+      must_equal "foo" => nil
     Rack::Utils.parse_nested_query("foo[]=bar&foo[").
-      should.equal "foo" => ["bar"], "foo[" => nil
+      must_equal "foo" => ["bar"], "foo[" => nil
     Rack::Utils.parse_nested_query("foo[]=bar&foo[=baz").
-      should.equal "foo" => ["bar"], "foo[" => "baz"
+      must_equal "foo" => ["bar"], "foo[" => "baz"
     Rack::Utils.parse_nested_query("foo[]=bar&foo[]").
-      should.equal "foo" => ["bar", nil]
+      must_equal "foo" => ["bar", nil]
     Rack::Utils.parse_nested_query("foo[]=bar&foo[]=").
-      should.equal "foo" => ["bar", ""]
+      must_equal "foo" => ["bar", ""]
 
     Rack::Utils.parse_nested_query("foo[]=1&foo[]=2").
-      should.equal "foo" => ["1", "2"]
+      must_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"]
+      must_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"]
+      must_equal "foo" => ["bar"], "baz" => ["1", "2", "3"]
 
     Rack::Utils.parse_nested_query("x[y][z]=1").
-      should.equal "x" => {"y" => {"z" => "1"}}
+      must_equal "x" => {"y" => {"z" => "1"}}
     Rack::Utils.parse_nested_query("x[y][z][]=1").
-      should.equal "x" => {"y" => {"z" => ["1"]}}
+      must_equal "x" => {"y" => {"z" => ["1"]}}
     Rack::Utils.parse_nested_query("x[y][z]=1&x[y][z]=2").
-      should.equal "x" => {"y" => {"z" => "2"}}
+      must_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"]}}
+      must_equal "x" => {"y" => {"z" => ["1", "2"]}}
 
     Rack::Utils.parse_nested_query("x[y][][z]=1").
-      should.equal "x" => {"y" => [{"z" => "1"}]}
+      must_equal "x" => {"y" => [{"z" => "1"}]}
     Rack::Utils.parse_nested_query("x[y][][z][]=1").
-      should.equal "x" => {"y" => [{"z" => ["1"]}]}
+      must_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"}]}
+      must_equal "x" => {"y" => [{"z" => "1", "w" => "2"}]}
 
     Rack::Utils.parse_nested_query("x[y][][v][w]=1").
-      should.equal "x" => {"y" => [{"v" => {"w" => "1"}}]}
+      must_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"}}]}
+      must_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"}]}
+      must_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"}]}
+      must_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(Rack::Utils::ParameterTypeError).
-      message.should.equal "expected Hash (got String) for param `y'"
+      must_raise(Rack::Utils::ParameterTypeError).
+      message.must_equal "expected Hash (got String) for param `y'"
 
     lambda { Rack::Utils.parse_nested_query("x[y]=1&x[]=1") }.
-      should.raise(Rack::Utils::ParameterTypeError).
-      message.should.match(/expected Array \(got [^)]*\) for param `x'/)
+      must_raise(Rack::Utils::ParameterTypeError).
+      message.must_match(/expected Array \(got [^)]*\) for param `x'/)
 
     lambda { Rack::Utils.parse_nested_query("x[y]=1&x[y][][w]=2") }.
-      should.raise(Rack::Utils::ParameterTypeError).
-      message.should.equal "expected Array (got String) for param `y'"
-
-    if RUBY_VERSION.to_f > 1.9
-      lambda { Rack::Utils.parse_nested_query("foo%81E=1") }.
-        should.raise(Rack::Utils::InvalidParameterError).
-        message.should.equal "invalid byte sequence in UTF-8"
+      must_raise(Rack::Utils::ParameterTypeError).
+      message.must_equal "expected Array (got String) for param `y'"
+
+    lambda { Rack::Utils.parse_nested_query("foo%81E=1") }.
+      must_raise(Rack::Utils::InvalidParameterError).
+      message.must_equal "invalid byte sequence in UTF-8"
+  end
+
+  it "allow setting the params hash class to use for parsing query strings" do
+    begin
+      default_parser = Rack::Utils.default_query_parser
+      param_parser_class = Class.new(Rack::QueryParser::Params) do
+        def initialize(*)
+          super
+          @params = Hash.new{|h,k| h[k.to_s] if k.is_a?(Symbol)}
+        end
+      end
+      Rack::Utils.default_query_parser = Rack::QueryParser.new(param_parser_class, 65536, 100)
+      Rack::Utils.parse_query(",foo=bar;,", ";,")[:foo].must_equal "bar"
+      Rack::Utils.parse_nested_query("x[y][][z]=1&x[y][][w]=2")[:x][:y][0][:z].must_equal "1"
+    ensure
+      Rack::Utils.default_query_parser = default_parser
     end
   end
 
-  should "build query strings correctly" do
-    Rack::Utils.build_query("foo" => "bar").should.be equal_query_to("foo=bar")
-    Rack::Utils.build_query("foo" => ["bar", "quux"]).
-      should.be equal_query_to("foo=bar&foo=quux")
-    Rack::Utils.build_query("foo" => "1", "bar" => "2").
-      should.be equal_query_to("foo=1&bar=2")
-    Rack::Utils.build_query("my weird field" => "q1!2\"'w$5&7/z8)?").
-      should.be equal_query_to("my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F")
-  end
-
-  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.be equal_query_to("foo=1&bar=2")
-    Rack::Utils.build_nested_query("foo" => 1, "bar" => 2).
-      should.be equal_query_to("foo=1&bar=2")
-    Rack::Utils.build_nested_query("my weird field" => "q1!2\"'w$5&7/z8)?").
-      should.be equal_query_to("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"
-    Rack::Utils.build_nested_query('foo' => []).
-      should.equal ''
-    Rack::Utils.build_nested_query('foo' => {}).
-      should.equal ''
-    Rack::Utils.build_nested_query('foo' => 'bar', 'baz' => []).
-      should.equal 'foo=bar'
-    Rack::Utils.build_nested_query('foo' => 'bar', 'baz' => {}).
-      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.
+  it "build query strings correctly" do
+    assert_query "foo=bar", "foo" => "bar"
+    assert_query "foo=bar&foo=quux", "foo" => ["bar", "quux"]
+    assert_query "foo=1&bar=2", "foo" => "1", "bar" => "2"
+    assert_query("my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F",
+                 "my weird field" => "q1!2\"'w$5&7/z8)?")
+  end
+
+  it "build nested query strings correctly" do
+    Rack::Utils.build_nested_query("foo" => nil).must_equal "foo"
+    Rack::Utils.build_nested_query("foo" => "").must_equal "foo="
+    Rack::Utils.build_nested_query("foo" => "bar").must_equal "foo=bar"
+
+    assert_nested_query("foo=1&bar=2",
+                        "foo" => "1", "bar" => "2")
+    assert_nested_query("foo=1&bar=2",
+                        "foo" => 1, "bar" => 2)
+    assert_nested_query("my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F",
+                        "my weird field" => "q1!2\"'w$5&7/z8)?")
+
+    Rack::Utils.build_nested_query("foo" => [nil]).must_equal "foo[]"
+    Rack::Utils.build_nested_query("foo" => [""]).must_equal "foo[]="
+    Rack::Utils.build_nested_query("foo" => ["bar"]).must_equal "foo[]=bar"
+    Rack::Utils.build_nested_query('foo' => []).must_equal ''
+    Rack::Utils.build_nested_query('foo' => {}).must_equal ''
+    Rack::Utils.build_nested_query('foo' => 'bar', 'baz' => []).must_equal 'foo=bar'
+    Rack::Utils.build_nested_query('foo' => 'bar', 'baz' => {}).must_equal 'foo=bar'
+
+    Rack::Utils.build_nested_query('foo' => nil, 'bar' => '').
+      must_equal 'foo&bar='
+    Rack::Utils.build_nested_query('foo' => 'bar', 'baz' => '').
+      must_equal 'foo=bar&baz='
+    Rack::Utils.build_nested_query('foo' => ['1', '2']).
+      must_equal 'foo[]=1&foo[]=2'
+    Rack::Utils.build_nested_query('foo' => 'bar', 'baz' => ['1', '2', '3']).
+      must_equal 'foo=bar&baz[]=1&baz[]=2&baz[]=3'
+    Rack::Utils.build_nested_query('foo' => ['bar'], 'baz' => ['1', '2', '3']).
+      must_equal 'foo[]=bar&baz[]=1&baz[]=2&baz[]=3'
+    Rack::Utils.build_nested_query('foo' => ['bar'], 'baz' => ['1', '2', '3']).
+      must_equal 'foo[]=bar&baz[]=1&baz[]=2&baz[]=3'
+    Rack::Utils.build_nested_query('x' => { 'y' => { 'z' => '1' } }).
+      must_equal 'x[y][z]=1'
+    Rack::Utils.build_nested_query('x' => { 'y' => { 'z' => ['1'] } }).
+      must_equal 'x[y][z][]=1'
+    Rack::Utils.build_nested_query('x' => { 'y' => { 'z' => ['1', '2'] } }).
+      must_equal 'x[y][z][]=1&x[y][z][]=2'
+    Rack::Utils.build_nested_query('x' => { 'y' => [{ 'z' => '1' }] }).
+      must_equal 'x[y][][z]=1'
+    Rack::Utils.build_nested_query('x' => { 'y' => [{ 'z' => ['1'] }] }).
+      must_equal 'x[y][][z][]=1'
+    Rack::Utils.build_nested_query('x' => { 'y' => [{ 'z' => '1', 'w' => '2' }] }).
+      must_equal 'x[y][][z]=1&x[y][][w]=2'
+    Rack::Utils.build_nested_query('x' => { 'y' => [{ 'v' => { 'w' => '1' } }] }).
+      must_equal 'x[y][][v][w]=1'
+    Rack::Utils.build_nested_query('x' => { 'y' => [{ 'z' => '1', 'v' => { 'w' => '2' } }] }).
+      must_equal 'x[y][][z]=1&x[y][][v][w]=2'
+    Rack::Utils.build_nested_query('x' => { 'y' => [{ 'z' => '1' }, { 'z' => '2' }] }).
+      must_equal 'x[y][][z]=1&x[y][][z]=2'
+    Rack::Utils.build_nested_query('x' => { 'y' => [{ 'z' => '1', 'w' => 'a' }, { 'z' => '2', 'w' => '3' }] }).
+      must_equal 'x[y][][z]=1&x[y][][w]=a&x[y][][z]=2&x[y][][w]=3'
+
+    lambda { Rack::Utils.build_nested_query("foo=bar") }.
+      must_raise(ArgumentError).
+      message.must_equal "value must be a Hash"
+  end
+
+  should 'perform the inverse function of #parse_nested_query' do
     [{"foo" => nil, "bar" => ""},
       {"foo" => "bar", "baz" => ""},
       {"foo" => ["1", "2"]},
@@ -302,293 +326,341 @@ describe Rack::Utils do
       {"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
+      Rack::Utils.parse_nested_query(qs).must_equal params
     }
 
     lambda { Rack::Utils.build_nested_query("foo=bar") }.
-      should.raise(ArgumentError).
-      message.should.equal "value must be a Hash"
+      must_raise(ArgumentError).
+      message.must_equal "value must be a Hash"
   end
 
-  should "parse query strings that have a non-existent value" do
+  it "parse query strings that have a non-existent value" do
     key = "post/2011/08/27/Deux-%22rat%C3%A9s%22-de-l-Universit"
-    Rack::Utils.parse_query(key).should.equal Rack::Utils.unescape(key) => nil
+    Rack::Utils.parse_query(key).must_equal Rack::Utils.unescape(key) => nil
   end
 
-  should "build query strings without = with non-existent values" do
+  it "build query strings without = with non-existent values" do
     key = "post/2011/08/27/Deux-%22rat%C3%A9s%22-de-l-Universit"
     key = Rack::Utils.unescape(key)
-    Rack::Utils.build_query(key => nil).should.equal Rack::Utils.escape(key)
+    Rack::Utils.build_query(key => nil).must_equal Rack::Utils.escape(key)
   end
 
-  should "parse q-values" do
+  it "parse q-values" do
     # XXX handle accept-extension
-    Rack::Utils.q_values("foo;q=0.5,bar,baz;q=0.9").should.equal [
+    Rack::Utils.q_values("foo;q=0.5,bar,baz;q=0.9").must_equal [
       [ 'foo', 0.5 ],
       [ 'bar', 1.0 ],
       [ 'baz', 0.9 ]
     ]
   end
 
-  should "select best quality match" do
-    Rack::Utils.best_q_match("text/html", %w[text/html]).should.equal "text/html"
+  it "select best quality match" do
+    Rack::Utils.best_q_match("text/html", %w[text/html]).must_equal "text/html"
 
     # More specific matches are preferred
-    Rack::Utils.best_q_match("text/*;q=0.5,text/html;q=1.0", %w[text/html]).should.equal "text/html"
+    Rack::Utils.best_q_match("text/*;q=0.5,text/html;q=1.0", %w[text/html]).must_equal "text/html"
 
     # Higher quality matches are preferred
-    Rack::Utils.best_q_match("text/*;q=0.5,text/plain;q=1.0", %w[text/plain text/html]).should.equal "text/plain"
+    Rack::Utils.best_q_match("text/*;q=0.5,text/plain;q=1.0", %w[text/plain text/html]).must_equal "text/plain"
 
     # Respect requested content type
-    Rack::Utils.best_q_match("application/json", %w[application/vnd.lotus-1-2-3 application/json]).should.equal "application/json"
+    Rack::Utils.best_q_match("application/json", %w[application/vnd.lotus-1-2-3 application/json]).must_equal "application/json"
 
     # All else equal, the available mimes are preferred in order
-    Rack::Utils.best_q_match("text/*", %w[text/html text/plain]).should.equal "text/html"
-    Rack::Utils.best_q_match("text/plain,text/html", %w[text/html text/plain]).should.equal "text/html"
+    Rack::Utils.best_q_match("text/*", %w[text/html text/plain]).must_equal "text/html"
+    Rack::Utils.best_q_match("text/plain,text/html", %w[text/html text/plain]).must_equal "text/html"
 
     # When there are no matches, return nil:
-    Rack::Utils.best_q_match("application/json", %w[text/html text/plain]).should.equal nil
+    Rack::Utils.best_q_match("application/json", %w[text/html text/plain]).must_equal nil
   end
 
-  should "escape html entities [&><'\"/]" do
-    Rack::Utils.escape_html("foo").should.equal "foo"
-    Rack::Utils.escape_html("f&o").should.equal "f&amp;o"
-    Rack::Utils.escape_html("f<o").should.equal "f&lt;o"
-    Rack::Utils.escape_html("f>o").should.equal "f&gt;o"
-    Rack::Utils.escape_html("f'o").should.equal "f&#x27;o"
-    Rack::Utils.escape_html('f"o').should.equal "f&quot;o"
-    Rack::Utils.escape_html("f/o").should.equal "f&#x2F;o"
-    Rack::Utils.escape_html("<foo></foo>").should.equal "&lt;foo&gt;&lt;&#x2F;foo&gt;"
+  it "escape html entities [&><'\"/]" do
+    Rack::Utils.escape_html("foo").must_equal "foo"
+    Rack::Utils.escape_html("f&o").must_equal "f&amp;o"
+    Rack::Utils.escape_html("f<o").must_equal "f&lt;o"
+    Rack::Utils.escape_html("f>o").must_equal "f&gt;o"
+    Rack::Utils.escape_html("f'o").must_equal "f&#x27;o"
+    Rack::Utils.escape_html('f"o').must_equal "f&quot;o"
+    Rack::Utils.escape_html("f/o").must_equal "f&#x2F;o"
+    Rack::Utils.escape_html("<foo></foo>").must_equal "&lt;foo&gt;&lt;&#x2F;foo&gt;"
   end
 
-  should "escape html entities even on MRI when it's bugged" do
+  it "escape html entities even on MRI when it's bugged" do
     test_escape = lambda do
-      kcodeu do
-        Rack::Utils.escape_html("\300<").should.equal "\300&lt;"
-      end
+      Rack::Utils.escape_html("\300<").must_equal "\300&lt;"
     end
 
-    if RUBY_VERSION.to_f < 1.9
-      test_escape.call
-    else
-      test_escape.should.raise(ArgumentError)
-    end
+    test_escape.must_raise ArgumentError
   end
 
-  if "".respond_to?(:encode)
-    should "escape html entities in unicode strings" do
+  it "escape html entities in unicode strings" do
       # the following will cause warnings if the regex is poorly encoded:
-      Rack::Utils.escape_html("☃").should.equal "☃"
-    end
+    Rack::Utils.escape_html("☃").must_equal "☃"
   end
 
-  should "figure out which encodings are acceptable" do
+  it "figure out which encodings are acceptable" do
     helper = lambda do |a, b|
       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(), [["x", 1]]).must_equal nil
+    helper.call(%w(identity), [["identity", 0.0]]).must_equal nil
+    helper.call(%w(identity), [["*", 0.0]]).must_equal nil
 
-    helper.call(%w(identity), [["compress", 1.0], ["gzip", 1.0]]).should.equal("identity")
+    helper.call(%w(identity), [["compress", 1.0], ["gzip", 1.0]]).must_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(compress gzip identity), [["compress", 1.0], ["gzip", 1.0]]).must_equal "compress"
+    helper.call(%w(compress gzip identity), [["compress", 0.5], ["gzip", 1.0]]).must_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), []).must_equal "identity"
+    helper.call(%w(foo bar identity), [["*", 1.0]]).must_equal "foo"
+    helper.call(%w(foo bar identity), [["*", 1.0], ["foo", 0.9]]).must_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")
+    helper.call(%w(foo bar identity), [["foo", 0], ["bar", 0]]).must_equal "identity"
+    helper.call(%w(foo bar baz identity), [["*", 0], ["identity", 0.1]]).must_equal "identity"
   end
 
-  should "return the bytesize of String" do
-    Rack::Utils.bytesize("FOO\xE2\x82\xAC").should.equal 6
+  it "should perform constant time string comparison" do
+    Rack::Utils.secure_compare('a', 'a').must_equal true
+    Rack::Utils.secure_compare('a', 'b').must_equal false
   end
 
-  should "should perform constant time string comparison" do
-    Rack::Utils.secure_compare('a', 'a').should.equal true
-    Rack::Utils.secure_compare('a', 'b').should.equal false
+  it "return status code for integer" do
+    Rack::Utils.status_code(200).must_equal 200
   end
 
-  should "return status code for integer" do
-    Rack::Utils.status_code(200).should.equal 200
+  it "return status code for string" do
+    Rack::Utils.status_code("200").must_equal 200
   end
 
-  should "return status code for string" do
-    Rack::Utils.status_code("200").should.equal 200
+  it "return status code for symbol" do
+    Rack::Utils.status_code(:ok).must_equal 200
   end
 
-  should "return status code for symbol" do
-    Rack::Utils.status_code(:ok).should.equal 200
+  it "return rfc2822 format from rfc2822 helper" do
+    Rack::Utils.rfc2822(Time.at(0).gmtime).must_equal "Thu, 01 Jan 1970 00:00:00 -0000"
   end
 
-  should "return rfc2822 format from rfc2822 helper" do
-    Rack::Utils.rfc2822(Time.at(0).gmtime).should == "Thu, 01 Jan 1970 00:00:00 -0000"
+  it "return rfc2109 format from rfc2109 helper" do
+    Rack::Utils.rfc2109(Time.at(0).gmtime).must_equal "Thu, 01-Jan-1970 00:00:00 GMT"
   end
 
-  should "return rfc2109 format from rfc2109 helper" do
-    Rack::Utils.rfc2109(Time.at(0).gmtime).should == "Thu, 01-Jan-1970 00:00:00 GMT"
+  it "clean directory traversal" do
+    Rack::Utils.clean_path_info("/cgi/../cgi/test").must_equal "/cgi/test"
+    Rack::Utils.clean_path_info(".").must_be_empty
+    Rack::Utils.clean_path_info("test/..").must_be_empty
   end
 
-  should "clean directory traversal" do
-    Rack::Utils.clean_path_info("/cgi/../cgi/test").should.equal "/cgi/test"
-    Rack::Utils.clean_path_info(".").should.empty
-    Rack::Utils.clean_path_info("test/..").should.empty
+  it "clean unsafe directory traversal to safe path" do
+    Rack::Utils.clean_path_info("/../README.rdoc").must_equal "/README.rdoc"
+    Rack::Utils.clean_path_info("../test/spec_utils.rb").must_equal "test/spec_utils.rb"
   end
 
-  should "clean unsafe directory traversal to safe path" do
-    Rack::Utils.clean_path_info("/../README.rdoc").should.equal "/README.rdoc"
-    Rack::Utils.clean_path_info("../test/spec_utils.rb").should.equal "test/spec_utils.rb"
+  it "not clean directory traversal with encoded periods" do
+    Rack::Utils.clean_path_info("/%2E%2E/README").must_equal "/%2E%2E/README"
+  end
+
+  it "clean slash only paths" do
+    Rack::Utils.clean_path_info("/").must_equal "/"
+  end
+end
+
+describe Rack::Utils, "cookies" do
+  it "parses cookies" do
+    env = Rack::MockRequest.env_for("", "HTTP_COOKIE" => "zoo=m")
+    Rack::Utils.parse_cookies(env).must_equal({"zoo" => "m"})
+
+    env = Rack::MockRequest.env_for("", "HTTP_COOKIE" => "foo=%")
+    Rack::Utils.parse_cookies(env).must_equal({"foo" => "%"})
+
+    env = Rack::MockRequest.env_for("", "HTTP_COOKIE" => "foo=bar;foo=car")
+    Rack::Utils.parse_cookies(env).must_equal({"foo" => "bar"})
+
+    env = Rack::MockRequest.env_for("", "HTTP_COOKIE" => "foo=bar;quux=h&m")
+    Rack::Utils.parse_cookies(env).must_equal({"foo" => "bar", "quux" => "h&m"})
+
+    env = Rack::MockRequest.env_for("", "HTTP_COOKIE" => "foo=bar").freeze
+    Rack::Utils.parse_cookies(env).must_equal({"foo" => "bar"})
   end
 
-  should "not clean directory traversal with encoded periods" do
-    Rack::Utils.clean_path_info("/%2E%2E/README").should.equal "/%2E%2E/README"
+  it "adds new cookies to nil header" do
+    Rack::Utils.add_cookie_to_header(nil, 'name', 'value').must_equal 'name=value'
   end
 
-  should "clean slash only paths" do
-    Rack::Utils.clean_path_info("/").should.equal "/"
+  it "adds new cookies to blank header" do
+    header = ''
+    Rack::Utils.add_cookie_to_header(header, 'name', 'value').must_equal 'name=value'
+    header.must_equal ''
+  end
+
+  it "adds new cookies to string header" do
+    header = 'existing-cookie'
+    Rack::Utils.add_cookie_to_header(header, 'name', 'value').must_equal "existing-cookie\nname=value"
+    header.must_equal 'existing-cookie'
+  end
+
+  it "adds new cookies to array header" do
+    header = %w[ existing-cookie ]
+    Rack::Utils.add_cookie_to_header(header, 'name', 'value').must_equal "existing-cookie\nname=value"
+    header.must_equal %w[ existing-cookie ]
+  end
+
+  it "adds new cookies to an unrecognized header" do
+    lambda {
+      Rack::Utils.add_cookie_to_header(Object.new, 'name', 'value')
+    }.must_raise ArgumentError
   end
 end
 
 describe Rack::Utils, "byte_range" do
-  should "ignore missing or syntactically invalid byte ranges" do
-    Rack::Utils.byte_ranges({},500).should.equal nil
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "foobar"},500).should.equal nil
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "furlongs=123-456"},500).should.equal nil
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes="},500).should.equal nil
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=-"},500).should.equal nil
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=123,456"},500).should.equal nil
+  it "ignore missing or syntactically invalid byte ranges" do
+    Rack::Utils.byte_ranges({},500).must_equal nil
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "foobar"},500).must_equal nil
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "furlongs=123-456"},500).must_equal nil
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes="},500).must_equal nil
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=-"},500).must_equal nil
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=123,456"},500).must_equal nil
     # A range of non-positive length is syntactically invalid and ignored:
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=456-123"},500).should.equal nil
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=456-455"},500).should.equal nil
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=456-123"},500).must_equal nil
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=456-455"},500).must_equal nil
   end
 
-  should "parse simple byte ranges" do
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=123-456"},500).should.equal [(123..456)]
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=123-"},500).should.equal [(123..499)]
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=-100"},500).should.equal [(400..499)]
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=0-0"},500).should.equal [(0..0)]
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=499-499"},500).should.equal [(499..499)]
+  it "parse simple byte ranges" do
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=123-456"},500).must_equal [(123..456)]
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=123-"},500).must_equal [(123..499)]
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=-100"},500).must_equal [(400..499)]
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=0-0"},500).must_equal [(0..0)]
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=499-499"},500).must_equal [(499..499)]
   end
 
-  should "parse several byte ranges" do
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=500-600,601-999"},1000).should.equal [(500..600),(601..999)]
+  it "parse several byte ranges" do
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=500-600,601-999"},1000).must_equal [(500..600),(601..999)]
   end
 
-  should "truncate byte ranges" do
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=123-999"},500).should.equal [(123..499)]
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=600-999"},500).should.equal []
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=-999"},500).should.equal [(0..499)]
+  it "truncate byte ranges" do
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=123-999"},500).must_equal [(123..499)]
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=600-999"},500).must_equal []
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=-999"},500).must_equal [(0..499)]
   end
 
-  should "ignore unsatisfiable byte ranges" do
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=500-501"},500).should.equal []
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=500-"},500).should.equal []
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=999-"},500).should.equal []
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=-0"},500).should.equal []
+  it "ignore unsatisfiable byte ranges" do
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=500-501"},500).must_equal []
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=500-"},500).must_equal []
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=999-"},500).must_equal []
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=-0"},500).must_equal []
   end
 
-  should "handle byte ranges of empty files" do
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=123-456"},0).should.equal []
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=0-"},0).should.equal []
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=-100"},0).should.equal []
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=0-0"},0).should.equal []
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=-0"},0).should.equal []
+  it "handle byte ranges of empty files" do
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=123-456"},0).must_equal []
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=0-"},0).must_equal []
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=-100"},0).must_equal []
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=0-0"},0).must_equal []
+    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=-0"},0).must_equal []
   end
 end
 
 describe Rack::Utils::HeaderHash do
-  should "retain header case" do
+  it "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!'
+    h.to_hash.must_equal "Content-MD5" => "d5ff4e2a0 ...", "ETag" => 'Boo!'
   end
 
-  should "check existence of keys case insensitively" do
+  it "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'
+    h.must_include 'content-md5'
+    h.wont_include 'ETag'
+  end
+
+  it "create deep HeaderHash copy on dup" do
+    h1 = Rack::Utils::HeaderHash.new("Content-MD5" => "d5ff4e2a0 ...")
+    h2 = h1.dup
+
+    h1.must_include 'content-md5'
+    h2.must_include 'content-md5'
+
+    h2.delete("Content-MD5")
+
+    h2.wont_include 'content-md5'
+    h1.must_include 'content-md5'
   end
 
-  should "merge case-insensitively" do
+  it "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'
+    merged.must_equal "Etag"=>'WORLD', "Content-Length"=>'321', "Foo"=>'BAR'
   end
 
-  should "overwrite case insensitively and assume the new key's case" do
+  it "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"
+    h["FOO-BAR"].must_equal "bizzle"
+    h.length.must_equal 1
+    h.to_hash.must_equal "foo-bar" => "bizzle"
   end
 
-  should "be converted to real Hash" do
+  it "be converted to real Hash" do
     h = Rack::Utils::HeaderHash.new("foo" => "bar")
-    h.to_hash.should.be.instance_of Hash
+    h.to_hash.must_be_instance_of Hash
   end
 
-  should "convert Array values to Strings when converting to Hash" do
+  it "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" })
+    h.to_hash.must_equal({ "foo" => "bar\nbaz" })
   end
 
-  should "replace hashes correctly" do
+  it "replace hashes correctly" do
     h = Rack::Utils::HeaderHash.new("Foo-Bar" => "baz")
     j = {"foo" => "bar"}
     h.replace(j)
-    h["foo"].should.equal "bar"
+    h["foo"].must_equal "bar"
   end
 
-  should "be able to delete the given key case-sensitively" do
+  it "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
+    h["foo"].must_be_nil
+    h["FOO"].must_be_nil
   end
 
-  should "be able to delete the given key case-insensitively" do
+  it "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
+    h["foo"].must_be_nil
+    h["FOO"].must_be_nil
   end
 
-  should "return the deleted value when #delete is called on an existing key" do
+  it "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")
+    h.delete("Foo").must_equal "bar"
   end
 
-  should "return nil when #delete is called on a non-existant key" do
+  it "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
+    h.delete("Hello").must_be_nil
   end
 
-  should "avoid unnecessary object creation if possible" do
+  it "avoid unnecessary object creation if possible" do
     a = Rack::Utils::HeaderHash.new("foo" => "bar")
     b = Rack::Utils::HeaderHash.new(a)
-    b.object_id.should.equal(a.object_id)
-    b.should.equal(a)
+    b.object_id.must_equal a.object_id
+    b.must_equal a
   end
 
-  should "convert Array values to Strings when responding to #each" do
+  it "convert Array values to Strings when responding to #each" do
     h = Rack::Utils::HeaderHash.new("foo" => ["bar", "baz"])
     h.each do |k,v|
-      k.should.equal("foo")
-      v.should.equal("bar\nbaz")
+      k.must_equal "foo"
+      v.must_equal "bar\nbaz"
     end
   end
 
-  should "not create headers out of thin air" do
+  it "not create headers out of thin air" do
     h = Rack::Utils::HeaderHash.new
     h['foo']
-    h['foo'].should.be.nil
-    h.should.not.include 'foo'
+    h['foo'].must_be_nil
+    h.wont_include 'foo'
   end
 end
 
@@ -605,27 +677,27 @@ describe Rack::Utils::Context do
   test_target4 = proc{|e| [200,{'Content-Type'=>'text/plain', 'Content-Length'=>'0'},['']] }
   test_app = ContextTest.new test_target4
 
-  should "set context correctly" do
-    test_app.app.should.equal test_target4
+  it "set context correctly" do
+    test_app.app.must_equal test_target4
     c1 = Rack::Utils::Context.new(test_app, test_target1)
-    c1.for.should.equal test_app
-    c1.app.should.equal test_target1
+    c1.for.must_equal test_app
+    c1.app.must_equal test_target1
     c2 = Rack::Utils::Context.new(test_app, test_target2)
-    c2.for.should.equal test_app
-    c2.app.should.equal test_target2
+    c2.for.must_equal test_app
+    c2.app.must_equal test_target2
   end
 
-  should "alter app on recontexting" do
+  it "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
+    c2.for.must_equal test_app
+    c2.app.must_equal test_target2
     c3 = c2.recontext(test_target3)
-    c3.for.should.equal test_app
-    c3.app.should.equal test_target3
+    c3.for.must_equal test_app
+    c3.app.must_equal test_target3
   end
 
-  should "run different apps" do
+  it "run different apps" do
     c1 = Rack::Utils::Context.new test_app, test_target1
     c2 = c1.recontext test_target2
     c3 = c2.recontext test_target3
@@ -633,15 +705,15 @@ describe Rack::Utils::Context do
     a4 = Rack::Lint.new c4
     a5 = Rack::Lint.new test_app
     r1 = c1.call('hello')
-    r1.should.equal 'hello world'
+    r1.must_equal 'hello world'
     r2 = c2.call(2)
-    r2.should.equal 4
+    r2.must_equal 4
     r3 = c3.call(:misc_symbol)
-    r3.should.be.nil
+    r3.must_be_nil
     r4 = Rack::MockRequest.new(a4).get('/')
-    r4.status.should.equal 200
+    r4.status.must_equal 200
     r5 = Rack::MockRequest.new(a5).get('/')
-    r5.status.should.equal 200
-    r4.body.should.equal r5.body
+    r5.status.must_equal 200
+    r4.body.must_equal r5.body
   end
 end