rack 1.6.13 → 2.0.0.alpha

data/test/spec_handler.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 require 'rack/handler'
 
 class Rack::Handler::Lobster; end
@@ -5,66 +6,50 @@ class RockLobster; end
 
 describe Rack::Handler do
   it "has registered default handlers" do
-    Rack::Handler.get('cgi').should.equal Rack::Handler::CGI
-    Rack::Handler.get('webrick').should.equal Rack::Handler::WEBrick
+    Rack::Handler.get('cgi').must_equal Rack::Handler::CGI
+    Rack::Handler.get('webrick').must_equal Rack::Handler::WEBrick
 
     begin
-      Rack::Handler.get('fastcgi').should.equal Rack::Handler::FastCGI
-    rescue LoadError
-    end
-
-    begin
-      Rack::Handler.get('mongrel').should.equal Rack::Handler::Mongrel
+      Rack::Handler.get('fastcgi').must_equal Rack::Handler::FastCGI
     rescue LoadError
     end
   end
 
-  should "raise LoadError if handler doesn't exist" do
+  it "raise LoadError if handler doesn't exist" do
     lambda {
       Rack::Handler.get('boom')
-    }.should.raise(LoadError)
-  end
+    }.must_raise(LoadError)
 
-  should "raise LoadError if handler isn't nested under Rack::Handler" do
-    # Feature-detect whether Ruby can do non-inherited const lookups.
-    # If it can't, then Rack::Handler may lookup non-handler toplevel
-    # constants, so the best we can do is no-op here and not test it.
-    begin
-      Rack::Handler._const_get('Object', false)
-    rescue NameError
-      lambda {
-        Rack::Handler.get('Object')
-      }.should.raise(LoadError)
-    end
+    lambda {
+      Rack::Handler.get('Object')
+    }.must_raise(LoadError)
   end
 
-  should "get unregistered, but already required, handler by name" do
-    Rack::Handler.get('Lobster').should.equal Rack::Handler::Lobster
+  it "get unregistered, but already required, handler by name" do
+    Rack::Handler.get('Lobster').must_equal Rack::Handler::Lobster
   end
 
-  should "register custom handler" do
+  it "register custom handler" do
     Rack::Handler.register('rock_lobster', 'RockLobster')
-    Rack::Handler.get('rock_lobster').should.equal RockLobster
+    Rack::Handler.get('rock_lobster').must_equal RockLobster
   end
 
-  should "not need registration for properly coded handlers even if not already required" do
+  it "not need registration for properly coded handlers even if not already required" do
     begin
       $LOAD_PATH.push File.expand_path('../unregistered_handler', __FILE__)
-      Rack::Handler.get('Unregistered').should.equal Rack::Handler::Unregistered
-      lambda {
-        Rack::Handler.get('UnRegistered')
-      }.should.raise LoadError
-      Rack::Handler.get('UnregisteredLongOne').should.equal Rack::Handler::UnregisteredLongOne
+      Rack::Handler.get('Unregistered').must_equal Rack::Handler::Unregistered
+      lambda { Rack::Handler.get('UnRegistered') }.must_raise LoadError
+      Rack::Handler.get('UnregisteredLongOne').must_equal Rack::Handler::UnregisteredLongOne
     ensure
       $LOAD_PATH.delete File.expand_path('../unregistered_handler', __FILE__)
     end
   end
 
-  should "allow autoloaded handlers to be registered properly while being loaded" do
+  it "allow autoloaded handlers to be registered properly while being loaded" do
     path = File.expand_path('../registering_handler', __FILE__)
     begin
       $LOAD_PATH.push path
-      Rack::Handler.get('registering_myself').should.equal Rack::Handler::RegisteringMyself
+      Rack::Handler.get('registering_myself').must_equal Rack::Handler::RegisteringMyself
     ensure
       $LOAD_PATH.delete path
     end

data/test/spec_head.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 require 'rack/head'
 require 'rack/lint'
 require 'rack/mock'
@@ -15,31 +16,31 @@ describe Rack::Head do
     return response, body
   end
 
-  should "pass GET, POST, PUT, DELETE, OPTIONS, TRACE requests" do
+  it "pass GET, POST, PUT, DELETE, OPTIONS, TRACE requests" do
     %w[GET POST PUT DELETE OPTIONS TRACE].each do |type|
       resp, _ = test_response("REQUEST_METHOD" => type)
 
-      resp[0].should.equal(200)
-      resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"})
-      resp[2].to_enum.to_a.should.equal(["foo"])
+      resp[0].must_equal 200
+      resp[1].must_equal "Content-type" => "test/plain", "Content-length" => "3"
+      resp[2].to_enum.to_a.must_equal ["foo"]
     end
   end
 
-  should "remove body from HEAD requests" do
+  it "remove body from HEAD requests" do
     resp, _ = test_response("REQUEST_METHOD" => "HEAD")
 
-    resp[0].should.equal(200)
-    resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"})
-    resp[2].to_enum.to_a.should.equal([])
+    resp[0].must_equal 200
+    resp[1].must_equal "Content-type" => "test/plain", "Content-length" => "3"
+    resp[2].to_enum.to_a.must_equal []
   end
 
-  should "close the body when it is removed" do
+  it "close the body when it is removed" do
     resp, body = test_response("REQUEST_METHOD" => "HEAD")
-    resp[0].should.equal(200)
-    resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"})
-    resp[2].to_enum.to_a.should.equal([])
-    body.should.not.be.closed
+    resp[0].must_equal 200
+    resp[1].must_equal "Content-type" => "test/plain", "Content-length" => "3"
+    resp[2].to_enum.to_a.must_equal []
+    body.wont_be :closed?
     resp[2].close
-    body.should.be.closed
+    body.must_be :closed?
   end
 end

data/test/spec_lint.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 require 'stringio'
 require 'tempfile'
 require 'rack/lint'
@@ -8,129 +9,127 @@ describe Rack::Lint do
     Rack::MockRequest.env_for("/", *args)
   end
 
-  should "pass valid request" do
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]]
-                     }).call(env({}))
-    }.should.not.raise
+  it "pass valid request" do
+    Rack::Lint.new(lambda { |env|
+                     [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]]
+                   }).call(env({})).first.must_equal 200
   end
 
-  should "notice fatal errors" do
-    lambda { Rack::Lint.new(nil).call }.should.raise(Rack::Lint::LintError).
-      message.should.match(/No env given/)
+  it "notice fatal errors" do
+    lambda { Rack::Lint.new(nil).call }.must_raise(Rack::Lint::LintError).
+      message.must_match(/No env given/)
   end
 
-  should "notice environment errors" do
-    lambda { Rack::Lint.new(nil).call 5 }.should.raise(Rack::Lint::LintError).
-      message.should.match(/not a Hash/)
+  it "notice environment errors" do
+    lambda { Rack::Lint.new(nil).call 5 }.must_raise(Rack::Lint::LintError).
+      message.must_match(/not a Hash/)
 
     lambda {
       e = env
       e.delete("REQUEST_METHOD")
       Rack::Lint.new(nil).call(e)
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/missing required key REQUEST_METHOD/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/missing required key REQUEST_METHOD/)
 
     lambda {
       e = env
       e.delete("SERVER_NAME")
       Rack::Lint.new(nil).call(e)
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/missing required key SERVER_NAME/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/missing required key SERVER_NAME/)
 
 
     lambda {
       Rack::Lint.new(nil).call(env("HTTP_CONTENT_TYPE" => "text/plain"))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/contains HTTP_CONTENT_TYPE/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/contains HTTP_CONTENT_TYPE/)
 
     lambda {
       Rack::Lint.new(nil).call(env("HTTP_CONTENT_LENGTH" => "42"))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/contains HTTP_CONTENT_LENGTH/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/contains HTTP_CONTENT_LENGTH/)
 
     lambda {
       Rack::Lint.new(nil).call(env("FOO" => Object.new))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/non-string value/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/non-string value/)
 
     lambda {
       Rack::Lint.new(nil).call(env("rack.version" => "0.2"))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/must be an Array/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/must be an Array/)
 
     lambda {
       Rack::Lint.new(nil).call(env("rack.url_scheme" => "gopher"))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/url_scheme unknown/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/url_scheme unknown/)
 
     lambda {
       Rack::Lint.new(nil).call(env("rack.session" => []))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.equal("session [] must respond to store and []=")
+    }.must_raise(Rack::Lint::LintError).
+      message.must_equal "session [] must respond to store and []="
 
     lambda {
       Rack::Lint.new(nil).call(env("rack.logger" => []))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.equal("logger [] must respond to info")
+    }.must_raise(Rack::Lint::LintError).
+      message.must_equal "logger [] must respond to info"
 
     lambda {
       Rack::Lint.new(nil).call(env("rack.multipart.buffer_size" => 0))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.equal("rack.multipart.buffer_size must be an Integer > 0 if specified")
+    }.must_raise(Rack::Lint::LintError).
+      message.must_equal "rack.multipart.buffer_size must be an Integer > 0 if specified"
 
     lambda {
       Rack::Lint.new(nil).call(env("rack.multipart.tempfile_factory" => Tempfile))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.equal("rack.multipart.tempfile_factory must respond to #call")
+    }.must_raise(Rack::Lint::LintError).
+      message.must_equal "rack.multipart.tempfile_factory must respond to #call"
 
     lambda {
       Rack::Lint.new(lambda { |env|
         env['rack.multipart.tempfile_factory'].call("testfile", "text/plain")
       }).call(env("rack.multipart.tempfile_factory" => lambda { |filename, content_type| Object.new }))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.equal("rack.multipart.tempfile_factory return value must respond to #<<")
+    }.must_raise(Rack::Lint::LintError).
+      message.must_equal "rack.multipart.tempfile_factory return value must respond to #<<"
 
     lambda {
       Rack::Lint.new(nil).call(env("REQUEST_METHOD" => "FUCKUP?"))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/REQUEST_METHOD/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/REQUEST_METHOD/)
 
     lambda {
       Rack::Lint.new(nil).call(env("SCRIPT_NAME" => "howdy"))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/must start with/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/must start with/)
 
     lambda {
       Rack::Lint.new(nil).call(env("PATH_INFO" => "../foo"))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/must start with/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/must start with/)
 
     lambda {
       Rack::Lint.new(nil).call(env("CONTENT_LENGTH" => "xcii"))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/Invalid CONTENT_LENGTH/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/Invalid CONTENT_LENGTH/)
 
     lambda {
       e = env
       e.delete("PATH_INFO")
       e.delete("SCRIPT_NAME")
       Rack::Lint.new(nil).call(e)
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/One of .* must be set/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/One of .* must be set/)
 
     lambda {
       Rack::Lint.new(nil).call(env("SCRIPT_NAME" => "/"))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/cannot be .* make it ''/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/cannot be .* make it ''/)
   end
 
-  should "notice input errors" do
+  it "notice input errors" do
     lambda {
       Rack::Lint.new(nil).call(env("rack.input" => ""))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/does not respond to #gets/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/does not respond to #gets/)
 
     lambda {
       input = Object.new
@@ -138,8 +137,8 @@ describe Rack::Lint do
         false
       end
       Rack::Lint.new(nil).call(env("rack.input" => input))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/is not opened in binary mode/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/is not opened in binary mode/)
 
     lambda {
       input = Object.new
@@ -151,54 +150,54 @@ describe Rack::Lint do
         result
       end
       Rack::Lint.new(nil).call(env("rack.input" => input))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/does not have ASCII-8BIT as its external encoding/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/does not have ASCII-8BIT as its external encoding/)
   end
 
-  should "notice error errors" do
+  it "notice error errors" do
     lambda {
       Rack::Lint.new(nil).call(env("rack.errors" => ""))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/does not respond to #puts/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/does not respond to #puts/)
   end
 
-  should "notice status errors" do
+  it "notice status errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        ["cc", {}, ""]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/must be >=100 seen as integer/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/must be >=100 seen as integer/)
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        [42, {}, ""]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/must be >=100 seen as integer/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/must be >=100 seen as integer/)
   end
 
-  should "notice header errors" do
+  it "notice header errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, Object.new, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.equal("headers object should respond to #each, but doesn't (got Object as headers)")
+    }.must_raise(Rack::Lint::LintError).
+      message.must_equal "headers object should respond to #each, but doesn't (got Object as headers)"
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {true=>false}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.equal("header key must be a string, was TrueClass")
+    }.must_raise(Rack::Lint::LintError).
+      message.must_equal "header key must be a string, was TrueClass"
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Status" => "404"}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/must not contain Status/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/must not contain Status/)
 
     # From RFC 7230:<F24><F25>
     # Most HTTP header field values are defined using common syntax
@@ -206,9 +205,9 @@ describe Rack::Lint do
     # whitespace or specific delimiting characters.  Delimiters are chosen
     # from the set of US-ASCII visual characters not allowed in a token
     # (DQUOTE and "(),/:;<=>?@[\]{}").
-    # 
+    #
     #   token          = 1*tchar
-    # 
+    #
     #   tchar          = "!" / "#" / "$" / "%" / "&" / "'" / "*"
     #                 / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
     #                 / DIGIT / ALPHA
@@ -219,157 +218,151 @@ describe Rack::Lint do
         Rack::Lint.new(lambda { |env|
           [200, {invalid_header => "text/plain"}, []]
         }).call(env({}))
-      }.should.raise(Rack::Lint::LintError, "on invalid header: #{invalid_header}").
-      message.should.equal("invalid header name: #{invalid_header}")
+      }.must_raise(Rack::Lint::LintError, "on invalid header: #{invalid_header}").
+      message.must_equal("invalid header name: #{invalid_header}")
     end
     valid_headers = 0.upto(127).map(&:chr) - invalid_headers
     valid_headers.each do |valid_header|
-      lambda {
-        Rack::Lint.new(lambda { |env|
-          [200, {valid_header => "text/plain"}, []]
-        }).call(env({}))
-      }.should.not.raise(Rack::Lint::LintError, "on valid header: #{valid_header}")
+      Rack::Lint.new(lambda { |env|
+                       [200, {valid_header => "text/plain"}, []]
+                     }).call(env({})).first.must_equal 200
     end
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Foo" => Object.new}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.equal("a header value must be a String, but the value of 'Foo' is a Object")
+    }.must_raise(Rack::Lint::LintError).
+      message.must_equal "a header value must be a String, but the value of 'Foo' is a Object"
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Foo" => [1, 2, 3]}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.equal("a header value must be a String, but the value of 'Foo' is a Array")
+    }.must_raise(Rack::Lint::LintError).
+      message.must_equal "a header value must be a String, but the value of 'Foo' is a Array"
 
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Foo-Bar" => "text\000plain"}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/invalid header/)
-
-    # line ends (010) should be allowed in header values.
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       [200, {"Foo-Bar" => "one\ntwo\nthree", "Content-Length" => "0", "Content-Type" => "text/plain" }, []]
-                     }).call(env({}))
-    }.should.not.raise(Rack::Lint::LintError)
-
-    # non-Hash header responses should be allowed
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       [200, [%w(Content-Type text/plain), %w(Content-Length 0)], []]
-                     }).call(env({}))
-    }.should.not.raise(TypeError)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/invalid header/)
+
+    # line ends (010).must_be :allowed in header values.?
+    Rack::Lint.new(lambda { |env|
+                     [200, {"Foo-Bar" => "one\ntwo\nthree", "Content-Length" => "0", "Content-Type" => "text/plain" }, []]
+                   }).call(env({})).first.must_equal 200
+
+    # non-Hash header responses.must_be :allowed?
+    Rack::Lint.new(lambda { |env|
+                     [200, [%w(Content-Type text/plain), %w(Content-Length 0)], []]
+                   }).call(env({})).first.must_equal 200
   end
 
-  should "notice content-type errors" do
+  it "notice content-type errors" do
     # lambda {
     #   Rack::Lint.new(lambda { |env|
     #                    [200, {"Content-length" => "0"}, []]
     #                  }).call(env({}))
-    # }.should.raise(Rack::Lint::LintError).
-    #   message.should.match(/No Content-Type/)
+    # }.must_raise(Rack::Lint::LintError).
+    #   message.must_match(/No Content-Type/)
 
     [100, 101, 204, 205, 304].each do |status|
       lambda {
         Rack::Lint.new(lambda { |env|
                          [status, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                        }).call(env({}))
-      }.should.raise(Rack::Lint::LintError).
-        message.should.match(/Content-Type header found/)
+      }.must_raise(Rack::Lint::LintError).
+        message.must_match(/Content-Type header found/)
     end
   end
 
-  should "notice content-length errors" do
+  it "notice content-length errors" do
     [100, 101, 204, 205, 304].each do |status|
       lambda {
         Rack::Lint.new(lambda { |env|
                          [status, {"Content-length" => "0"}, []]
                        }).call(env({}))
-      }.should.raise(Rack::Lint::LintError).
-        message.should.match(/Content-Length header found/)
+      }.must_raise(Rack::Lint::LintError).
+        message.must_match(/Content-Length header found/)
     end
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Content-type" => "text/plain", "Content-Length" => "1"}, []]
                      }).call(env({}))[2].each { }
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/Content-Length header was 1, but should be 0/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/Content-Length header was 1, but should be 0/)
   end
 
-  should "notice body errors" do
+  it "notice body errors" do
     lambda {
       body = Rack::Lint.new(lambda { |env|
                                [200, {"Content-type" => "text/plain","Content-length" => "3"}, [1,2,3]]
                              }).call(env({}))[2]
       body.each { |part| }
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/yielded non-string/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/yielded non-string/)
   end
 
-  should "notice input handling errors" do
+  it "notice input handling errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].gets("\r\n")
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/gets called with arguments/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/gets called with arguments/)
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].read(1, 2, 3)
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/read called with too many arguments/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/read called with too many arguments/)
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].read("foo")
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/read called with non-integer and non-nil length/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/read called with non-integer and non-nil length/)
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].read(-1)
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/read called with a negative length/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/read called with a negative length/)
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].read(nil, nil)
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/read called with non-String buffer/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/read called with non-String buffer/)
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].read(nil, 1)
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/read called with non-String buffer/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/read called with non-String buffer/)
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].rewind(0)
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/rewind called with arguments/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/rewind called with arguments/)
 
     weirdio = Object.new
     class << weirdio
@@ -413,40 +406,40 @@ describe Rack::Lint do
                        env["rack.input"].gets
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env("rack.input" => weirdio))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/gets didn't return a String/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/gets didn't return a String/)
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].each { |x| }
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env("rack.input" => weirdio))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/each didn't yield a String/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/each didn't yield a String/)
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].read
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env("rack.input" => weirdio))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/read didn't return nil or a String/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/read didn't return nil or a String/)
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].read
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env("rack.input" => eof_weirdio))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/read\(nil\) returned nil on EOF/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/read\(nil\) returned nil on EOF/)
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].rewind
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env("rack.input" => weirdio))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/rewind raised Errno::ESPIPE/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/rewind raised Errno::ESPIPE/)
 
 
     lambda {
@@ -454,97 +447,69 @@ describe Rack::Lint do
                        env["rack.input"].close
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/close must not be called/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/close must not be called/)
   end
 
-  should "notice error handling errors" do
+  it "notice error handling errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.errors"].write(42)
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/write not called with a String/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/write not called with a String/)
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.errors"].close
                        [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/close must not be called/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/close must not be called/)
   end
 
-  should "notice HEAD errors" do
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       [200, {"Content-type" => "test/plain", "Content-length" => "3"}, []]
-                     }).call(env({"REQUEST_METHOD" => "HEAD"}))
-    }.should.not.raise
+  it "notice HEAD errors" do
+    Rack::Lint.new(lambda { |env|
+                     [200, {"Content-type" => "test/plain", "Content-length" => "3"}, []]
+                   }).call(env({"REQUEST_METHOD" => "HEAD"})).first.must_equal 200
 
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]]
                      }).call(env({"REQUEST_METHOD" => "HEAD"}))[2].each { }
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/body was given for HEAD/)
+    }.must_raise(Rack::Lint::LintError).
+      message.must_match(/body was given for HEAD/)
   end
 
-  should "pass valid read calls" do
+  def assert_lint(*args)
     hello_str = "hello world"
-    hello_str.force_encoding("ASCII-8BIT") if hello_str.respond_to? :force_encoding
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       env["rack.input"].read
-                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
-                     }).call(env({"rack.input" => StringIO.new(hello_str)}))
-    }.should.not.raise(Rack::Lint::LintError)
-
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       env["rack.input"].read(0)
-                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
-                     }).call(env({"rack.input" => StringIO.new(hello_str)}))
-    }.should.not.raise(Rack::Lint::LintError)
-
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       env["rack.input"].read(1)
-                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
-                     }).call(env({"rack.input" => StringIO.new(hello_str)}))
-    }.should.not.raise(Rack::Lint::LintError)
-
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       env["rack.input"].read(nil)
-                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
-                     }).call(env({"rack.input" => StringIO.new(hello_str)}))
-    }.should.not.raise(Rack::Lint::LintError)
+    hello_str.force_encoding(Encoding::ASCII_8BIT)
 
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       env["rack.input"].read(nil, '')
-                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
-                     }).call(env({"rack.input" => StringIO.new(hello_str)}))
-    }.should.not.raise(Rack::Lint::LintError)
+    Rack::Lint.new(lambda { |env|
+                     env["rack.input"].send(:read, *args)
+                     [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                   }).call(env({"rack.input" => StringIO.new(hello_str)})).
+      first.must_equal 201
+  end
 
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       env["rack.input"].read(1, '')
-                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
-                     }).call(env({"rack.input" => StringIO.new(hello_str)}))
-    }.should.not.raise(Rack::Lint::LintError)
+  it "pass valid read calls" do
+    assert_lint
+    assert_lint 0
+    assert_lint 1
+    assert_lint nil
+    assert_lint nil, ''
+    assert_lint 1, ''
   end
 end
 
 describe "Rack::Lint::InputWrapper" do
-  should "delegate :rewind to underlying IO object" do
+  it "delegate :rewind to underlying IO object" do
     io = StringIO.new("123")
     wrapper = Rack::Lint::InputWrapper.new(io)
-    wrapper.read.should.equal "123"
-    wrapper.read.should.equal ""
+    wrapper.read.must_equal "123"
+    wrapper.read.must_equal ""
     wrapper.rewind
-    wrapper.read.should.equal "123"
+    wrapper.read.must_equal "123"
   end
 end