rack 1.6.12 → 2.0.3

data/test/spec_etag.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 require 'rack/etag'
 require 'rack/lint'
 require 'rack/mock'
@@ -7,101 +8,101 @@ describe Rack::ETag do
   def etag(app, *args)
     Rack::Lint.new Rack::ETag.new(app, *args)
   end
-  
+
   def request
     Rack::MockRequest.env_for
   end
-  
+
   def sendfile_body
     res = ['Hello World']
     def res.to_path ; "/tmp/hello.txt" ; end
     res
   end
 
-  should "set ETag if none is set if status is 200" do
+  it "set ETag if none is set if status is 200" do
     app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
     response = etag(app).call(request)
-    response[1]['ETag'].should.equal "W/\"65a8e27d8879283831b664bd8b7f0ad4\""
+    response[1]['ETag'].must_equal "W/\"dffd6021bb2bd5b0af676290809ec3a5\""
   end
 
-  should "set ETag if none is set if status is 201" do
+  it "set ETag if none is set if status is 201" do
     app = lambda { |env| [201, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
     response = etag(app).call(request)
-    response[1]['ETag'].should.equal "W/\"65a8e27d8879283831b664bd8b7f0ad4\""
+    response[1]['ETag'].must_equal "W/\"dffd6021bb2bd5b0af676290809ec3a5\""
   end
 
-  should "set Cache-Control to 'max-age=0, private, must-revalidate' (default) if none is set" do
+  it "set Cache-Control to 'max-age=0, private, must-revalidate' (default) if none is set" do
     app = lambda { |env| [201, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
     response = etag(app).call(request)
-    response[1]['Cache-Control'].should.equal 'max-age=0, private, must-revalidate'
+    response[1]['Cache-Control'].must_equal 'max-age=0, private, must-revalidate'
   end
 
-  should "set Cache-Control to chosen one if none is set" do
+  it "set Cache-Control to chosen one if none is set" do
     app = lambda { |env| [201, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
     response = etag(app, nil, 'public').call(request)
-    response[1]['Cache-Control'].should.equal 'public'
+    response[1]['Cache-Control'].must_equal 'public'
   end
 
-  should "set a given Cache-Control even if digest could not be calculated" do
+  it "set a given Cache-Control even if digest could not be calculated" do
     app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, []] }
     response = etag(app, 'no-cache').call(request)
-    response[1]['Cache-Control'].should.equal 'no-cache'
+    response[1]['Cache-Control'].must_equal 'no-cache'
   end
 
-  should "not set Cache-Control if it is already set" do
+  it "not set Cache-Control if it is already set" do
     app = lambda { |env| [201, {'Content-Type' => 'text/plain', 'Cache-Control' => 'public'}, ["Hello, World!"]] }
     response = etag(app).call(request)
-    response[1]['Cache-Control'].should.equal 'public'
+    response[1]['Cache-Control'].must_equal 'public'
   end
 
-  should "not set Cache-Control if directive isn't present" do
+  it "not set Cache-Control if directive isn't present" do
     app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
     response = etag(app, nil, nil).call(request)
-    response[1]['Cache-Control'].should.equal nil
+    response[1]['Cache-Control'].must_be_nil
   end
 
-  should "not change ETag if it is already set" do
+  it "not change ETag if it is already set" do
     app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'ETag' => '"abc"'}, ["Hello, World!"]] }
     response = etag(app).call(request)
-    response[1]['ETag'].should.equal "\"abc\""
+    response[1]['ETag'].must_equal "\"abc\""
   end
 
-  should "not set ETag if body is empty" do
+  it "not set ETag if body is empty" do
     app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'Last-Modified' => Time.now.httpdate}, []] }
     response = etag(app).call(request)
-    response[1]['ETag'].should.be.nil
+    response[1]['ETag'].must_be_nil
   end
 
-  should "not set ETag if Last-Modified is set" do
+  it "not set ETag if Last-Modified is set" do
     app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'Last-Modified' => Time.now.httpdate}, ["Hello, World!"]] }
     response = etag(app).call(request)
-    response[1]['ETag'].should.be.nil
+    response[1]['ETag'].must_be_nil
   end
 
-  should "not set ETag if a sendfile_body is given" do
+  it "not set ETag if a sendfile_body is given" do
     app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, sendfile_body] }
     response = etag(app).call(request)
-    response[1]['ETag'].should.be.nil
+    response[1]['ETag'].must_be_nil
   end
 
-  should "not set ETag if a status is not 200 or 201" do
+  it "not set ETag if a status is not 200 or 201" do
     app = lambda { |env| [401, {'Content-Type' => 'text/plain'}, ['Access denied.']] }
     response = etag(app).call(request)
-    response[1]['ETag'].should.be.nil
+    response[1]['ETag'].must_be_nil
   end
 
-  should "not set ETag if no-cache is given" do
+  it "not set ETag if no-cache is given" do
     app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'Cache-Control' => 'no-cache, must-revalidate'}, ['Hello, World!']] }
     response = etag(app).call(request)
-    response[1]['ETag'].should.be.nil
+    response[1]['ETag'].must_be_nil
   end
 
-  should "close the original body" do
+  it "close the original body" do
     body = StringIO.new
     app = lambda { |env| [200, {}, body] }
     response = etag(app).call(request)
-    body.should.not.be.closed
+    body.wont_be :closed?
     response[2].close
-    body.should.be.closed
+    body.must_be :closed?
   end
 end

data/test/spec_events.rb

@@ -0,0 +1,133 @@
+require 'helper'
+require 'rack/events'
+
+module Rack
+  class TestEvents < Rack::TestCase
+    class EventMiddleware
+      attr_reader :events
+
+      def initialize events
+        @events = events
+      end
+
+      def on_start req, res
+        events << [self, __method__]
+      end
+
+      def on_commit req, res
+        events << [self, __method__]
+      end
+
+      def on_send req, res
+        events << [self, __method__]
+      end
+
+      def on_finish req, res
+        events << [self, __method__]
+      end
+
+      def on_error req, res, e
+        events << [self, __method__]
+      end
+    end
+
+    def test_events_fire
+      events = []
+      ret = [200, {}, []]
+      app = lambda { |env| events << [app, :call]; ret }
+      se = EventMiddleware.new events
+      e = Events.new app, [se]
+      triple = e.call({})
+      response_body = []
+      triple[2].each { |x| response_body << x }
+      triple[2].close
+      triple[2] = response_body
+      assert_equal ret, triple
+      assert_equal [[se, :on_start],
+                    [app, :call],
+                    [se, :on_commit],
+                    [se, :on_send],
+                    [se, :on_finish],
+      ], events
+    end
+
+    def test_send_and_finish_are_not_run_until_body_is_sent
+      events = []
+      ret = [200, {}, []]
+      app = lambda { |env| events << [app, :call]; ret }
+      se = EventMiddleware.new events
+      e = Events.new app, [se]
+      triple = e.call({})
+      assert_equal [[se, :on_start],
+                    [app, :call],
+                    [se, :on_commit],
+      ], events
+    end
+
+    def test_send_is_called_on_each
+      events = []
+      ret = [200, {}, []]
+      app = lambda { |env| events << [app, :call]; ret }
+      se = EventMiddleware.new events
+      e = Events.new app, [se]
+      triple = e.call({})
+      triple[2].each { |x| }
+      assert_equal [[se, :on_start],
+                    [app, :call],
+                    [se, :on_commit],
+                    [se, :on_send],
+      ], events
+    end
+
+    def test_finish_is_called_on_close
+      events = []
+      ret = [200, {}, []]
+      app = lambda { |env| events << [app, :call]; ret }
+      se = EventMiddleware.new events
+      e = Events.new app, [se]
+      triple = e.call({})
+      triple[2].each { |x| }
+      triple[2].close
+      assert_equal [[se, :on_start],
+                    [app, :call],
+                    [se, :on_commit],
+                    [se, :on_send],
+                    [se, :on_finish],
+      ], events
+    end
+
+    def test_finish_is_called_in_reverse_order
+      events = []
+      ret = [200, {}, []]
+      app = lambda { |env| events << [app, :call]; ret }
+      se1 = EventMiddleware.new events
+      se2 = EventMiddleware.new events
+      se3 = EventMiddleware.new events
+
+      e = Events.new app, [se1, se2, se3]
+      triple = e.call({})
+      triple[2].each { |x| }
+      triple[2].close
+
+      groups = events.group_by { |x| x.last }
+      assert_equal groups[:on_start].map(&:first), groups[:on_finish].map(&:first).reverse
+      assert_equal groups[:on_commit].map(&:first), groups[:on_finish].map(&:first)
+      assert_equal groups[:on_send].map(&:first), groups[:on_finish].map(&:first)
+    end
+
+    def test_finish_is_called_if_there_is_an_exception
+      events = []
+      ret = [200, {}, []]
+      app = lambda { |env| raise }
+      se = EventMiddleware.new events
+      e = Events.new app, [se]
+      assert_raises(RuntimeError) do
+        e.call({})
+      end
+      assert_equal [[se, :on_start],
+                    [se, :on_error],
+                    [se, :on_finish],
+      ], events
+    end
+  end
+end

data/test/spec_fastcgi.rb

@@ -1,107 +1,85 @@
-begin
+require 'helper'
+
+if defined? LIGHTTPD_PID
+
 require File.expand_path('../testrequest', __FILE__)
 require 'rack/handler/fastcgi'
 
 describe Rack::Handler::FastCGI do
-  extend TestRequest::Helpers
+  include TestRequest::Helpers
 
-  @host = '127.0.0.1'
-  @port = 9203
-
-  if `which lighttpd` && !$?.success?
-    raise "lighttpd not found"
+  before do
+    @host = '127.0.0.1'
+    @port = 9203
   end
 
-  # Keep this first.
-  $pid = fork {
-    ENV['RACK_ENV'] = 'deployment'
-    ENV['RUBYLIB'] = [
-      File.expand_path('../../lib', __FILE__),
-      ENV['RUBYLIB'],
-    ].compact.join(':')
-
-    Dir.chdir(File.expand_path("../cgi", __FILE__)) do
-      exec "lighttpd -D -f lighttpd.conf"
-    end
-  }
-
-  should "respond" do
+  it "respond" do
     sleep 1
     GET("/test")
-    response.should.not.be.nil
+    response.wont_be :nil?
   end
 
-  should "respond via rackup server" do
+  it "respond via rackup server" do
     GET("/sample_rackup.ru")
-    status.should.equal 200
+    status.must_equal 200
   end
 
-  should "be a lighttpd" do
+  it "be a lighttpd" do
     GET("/test.fcgi")
-    status.should.equal 200
-    response["SERVER_SOFTWARE"].should =~ /lighttpd/
-    response["HTTP_VERSION"].should.equal "HTTP/1.1"
-    response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
-    response["SERVER_PORT"].should.equal @port.to_s
-    response["SERVER_NAME"].should.equal @host
+    status.must_equal 200
+    response["SERVER_SOFTWARE"].must_match(/lighttpd/)
+    response["HTTP_VERSION"].must_equal "HTTP/1.1"
+    response["SERVER_PROTOCOL"].must_equal "HTTP/1.1"
+    response["SERVER_PORT"].must_equal @port.to_s
+    response["SERVER_NAME"].must_equal @host
   end
 
-  should "have rack headers" do
+  it "have rack headers" do
     GET("/test.fcgi")
-    response["rack.version"].should.equal [1,3]
-    response["rack.multithread"].should.be.false
-    response["rack.multiprocess"].should.be.true
-    response["rack.run_once"].should.be.false
+    response["rack.version"].must_equal [1,3]
+    assert_equal false, response["rack.multithread"]
+    assert_equal true, response["rack.multiprocess"]
+    assert_equal false, response["rack.run_once"]
   end
 
-  should "have CGI headers on GET" do
+  it "have CGI headers on GET" do
     GET("/test.fcgi")
-    response["REQUEST_METHOD"].should.equal "GET"
-    response["SCRIPT_NAME"].should.equal "/test.fcgi"
-    response["REQUEST_PATH"].should.equal "/"
-    response["PATH_INFO"].should.equal ""
-    response["QUERY_STRING"].should.equal ""
-    response["test.postdata"].should.equal ""
+    response["REQUEST_METHOD"].must_equal "GET"
+    response["SCRIPT_NAME"].must_equal "/test.fcgi"
+    response["REQUEST_PATH"].must_equal "/"
+    response["PATH_INFO"].must_equal ""
+    response["QUERY_STRING"].must_equal ""
+    response["test.postdata"].must_equal ""
 
     GET("/test.fcgi/foo?quux=1")
-    response["REQUEST_METHOD"].should.equal "GET"
-    response["SCRIPT_NAME"].should.equal "/test.fcgi"
-    response["REQUEST_PATH"].should.equal "/"
-    response["PATH_INFO"].should.equal "/foo"
-    response["QUERY_STRING"].should.equal "quux=1"
+    response["REQUEST_METHOD"].must_equal "GET"
+    response["SCRIPT_NAME"].must_equal "/test.fcgi"
+    response["REQUEST_PATH"].must_equal "/"
+    response["PATH_INFO"].must_equal "/foo"
+    response["QUERY_STRING"].must_equal "quux=1"
   end
 
-  should "have CGI headers on POST" do
+  it "have CGI headers on POST" do
     POST("/test.fcgi", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
-    status.should.equal 200
-    response["REQUEST_METHOD"].should.equal "POST"
-    response["SCRIPT_NAME"].should.equal "/test.fcgi"
-    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["SCRIPT_NAME"].must_equal "/test.fcgi"
+    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.fcgi", {: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.fcgi?secret")
-    status.should.equal 403
-    response["rack.url_scheme"].should.equal "http"
-  end
-
-  # Keep this last.
-  should "shutdown" do
-    Process.kill 15, $pid
-    Process.wait($pid).should.equal $pid
+    status.must_equal 403
+    response["rack.url_scheme"].must_equal "http"
   end
 end
 
-rescue RuntimeError
-  $stderr.puts "Skipping Rack::Handler::FastCGI tests (lighttpd is required). Install lighttpd and try again."
-rescue LoadError
-  $stderr.puts "Skipping Rack::Handler::FastCGI tests (FCGI is required). `gem install fcgi` and try again."
-end
+end # if defined? LIGHTTPD_PID

data/test/spec_file.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 require 'rack/file'
 require 'rack/lint'
 require 'rack/mock'
@@ -9,213 +10,255 @@ describe Rack::File do
     Rack::Lint.new Rack::File.new(*args)
   end
 
-  should "serve files" do
+  it 'serves files with + in the file name' do
+    Dir.mktmpdir do |dir|
+      File.write File.join(dir, "you+me.txt"), "hello world"
+      app = file(dir)
+      env = Rack::MockRequest.env_for("/you+me.txt")
+      status,_,body = app.call env
+
+      assert_equal 200, status
+
+      str = ''
+      body.each { |x| str << x }
+      assert_match "hello world", str
+    end
+  end
+
+  it "serve files" do
     res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/test")
 
-    res.should.be.ok
-    res.should =~ /ruby/
+    res.must_be :ok?
+    assert_match(res, /ruby/)
   end
 
-  should "set Last-Modified header" do
+  it "set Last-Modified header" do
     res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/test")
 
     path = File.join(DOCROOT, "/cgi/test")
 
-    res.should.be.ok
-    res["Last-Modified"].should.equal File.mtime(path).httpdate
+    res.must_be :ok?
+    res["Last-Modified"].must_equal File.mtime(path).httpdate
   end
 
-  should "return 304 if file isn't modified since last serve" do
+  it "return 304 if file isn't modified since last serve" do
     path = File.join(DOCROOT, "/cgi/test")
     res = Rack::MockRequest.new(file(DOCROOT)).
       get("/cgi/test", 'HTTP_IF_MODIFIED_SINCE' => File.mtime(path).httpdate)
 
-    res.status.should.equal 304
-    res.body.should.be.empty
+    res.status.must_equal 304
+    res.body.must_be :empty?
   end
 
-  should "return the file if it's modified since last serve" do
+  it "return the file if it's modified since last serve" do
     path = File.join(DOCROOT, "/cgi/test")
     res = Rack::MockRequest.new(file(DOCROOT)).
       get("/cgi/test", 'HTTP_IF_MODIFIED_SINCE' => (File.mtime(path) - 100).httpdate)
 
-    res.should.be.ok
+    res.must_be :ok?
   end
 
-  should "serve files with URL encoded filenames" do
+  it "serve files with URL encoded filenames" do
     res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/%74%65%73%74") # "/cgi/test"
 
-    res.should.be.ok
-    res.should =~ /ruby/
+    res.must_be :ok?
+    # res.must_match(/ruby/)    # nope
+    # (/ruby/).must_match res   # This is wierd, but an oddity of minitest
+    # assert_match(/ruby/, res) # nope
+    assert_match(res, /ruby/)
+  end
+
+  it "serve uri with URL encoded null byte (%00) in filenames" do
+    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/test%00")
+    res.must_be :bad_request?
   end
 
-  should "allow safe directory traversal" do
+  it "allow safe directory traversal" do
     req = Rack::MockRequest.new(file(DOCROOT))
 
     res = req.get('/cgi/../cgi/test')
-    res.should.be.successful
+    res.must_be :successful?
 
     res = req.get('.')
-    res.should.be.not_found
+    res.must_be :not_found?
 
     res = req.get("test/..")
-    res.should.be.not_found
+    res.must_be :not_found?
   end
 
-  should "not allow unsafe directory traversal" do
+  it "not allow unsafe directory traversal" do
     req = Rack::MockRequest.new(file(DOCROOT))
 
     res = req.get("/../README.rdoc")
-    res.should.be.client_error
+    res.must_be :client_error?
 
     res = req.get("../test/spec_file.rb")
-    res.should.be.client_error
+    res.must_be :client_error?
 
     res = req.get("../README.rdoc")
-    res.should.be.client_error
+    res.must_be :client_error?
 
-    res.should.be.not_found
+    res.must_be :not_found?
   end
 
-  should "allow files with .. in their name" do
+  it "allow files with .. in their name" do
     req = Rack::MockRequest.new(file(DOCROOT))
     res = req.get("/cgi/..test")
-    res.should.be.not_found
+    res.must_be :not_found?
 
     res = req.get("/cgi/test..")
-    res.should.be.not_found
+    res.must_be :not_found?
 
     res = req.get("/cgi../test..")
-    res.should.be.not_found
+    res.must_be :not_found?
   end
 
-  should "not allow unsafe directory traversal with encoded periods" do
+  it "not allow unsafe directory traversal with encoded periods" do
     res = Rack::MockRequest.new(file(DOCROOT)).get("/%2E%2E/README")
 
-    res.should.be.client_error?
-    res.should.be.not_found
+    res.must_be :client_error?
+    res.must_be :not_found?
   end
 
-  should "allow safe directory traversal with encoded periods" do
+  it "allow safe directory traversal with encoded periods" do
     res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/%2E%2E/cgi/test")
 
-    res.should.be.successful
+    res.must_be :successful?
   end
 
-  should "404 if it can't find the file" do
+  it "404 if it can't find the file" do
     res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/blubb")
 
-    res.should.be.not_found
+    res.must_be :not_found?
   end
 
-  should "detect SystemCallErrors" do
+  it "detect SystemCallErrors" do
     res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi")
 
-    res.should.be.not_found
+    res.must_be :not_found?
   end
 
-  should "return bodies that respond to #to_path" do
+  it "return bodies that respond to #to_path" do
     env = Rack::MockRequest.env_for("/cgi/test")
     status, _, body = Rack::File.new(DOCROOT).call(env)
 
     path = File.join(DOCROOT, "/cgi/test")
 
-    status.should.equal 200
-    body.should.respond_to :to_path
-    body.to_path.should.equal path
+    status.must_equal 200
+    body.must_respond_to :to_path
+    body.to_path.must_equal path
   end
 
-  should "return correct byte range in body" do
+  it "return correct byte range in body" do
     env = Rack::MockRequest.env_for("/cgi/test")
     env["HTTP_RANGE"] = "bytes=22-33"
     res = Rack::MockResponse.new(*file(DOCROOT).call(env))
 
-    res.status.should.equal 206
-    res["Content-Length"].should.equal "12"
-    res["Content-Range"].should.equal "bytes 22-33/193"
-    res.body.should.equal "-*- ruby -*-"
+    res.status.must_equal 206
+    res["Content-Length"].must_equal "12"
+    res["Content-Range"].must_equal "bytes 22-33/193"
+    res.body.must_equal "-*- ruby -*-"
   end
 
-  should "return error for unsatisfiable byte range" do
+  it "return error for unsatisfiable byte range" do
     env = Rack::MockRequest.env_for("/cgi/test")
     env["HTTP_RANGE"] = "bytes=1234-5678"
     res = Rack::MockResponse.new(*file(DOCROOT).call(env))
 
-    res.status.should.equal 416
-    res["Content-Range"].should.equal "bytes */193"
+    res.status.must_equal 416
+    res["Content-Range"].must_equal "bytes */193"
   end
 
-  should "support custom http headers" do
+  it "support custom http headers" do
     env = Rack::MockRequest.env_for("/cgi/test")
     status, heads, _ = file(DOCROOT, 'Cache-Control' => 'public, max-age=38',
      'Access-Control-Allow-Origin' => '*').call(env)
 
-    status.should.equal 200
-    heads['Cache-Control'].should.equal 'public, max-age=38'
-    heads['Access-Control-Allow-Origin'].should.equal '*'
+    status.must_equal 200
+    heads['Cache-Control'].must_equal 'public, max-age=38'
+    heads['Access-Control-Allow-Origin'].must_equal '*'
   end
 
-  should "support not add custom http headers if none are supplied" do
+  it "support not add custom http headers if none are supplied" do
     env = Rack::MockRequest.env_for("/cgi/test")
     status, heads, _ = file(DOCROOT).call(env)
 
-    status.should.equal 200
-    heads['Cache-Control'].should.equal nil
-    heads['Access-Control-Allow-Origin'].should.equal nil
+    status.must_equal 200
+    heads['Cache-Control'].must_be_nil
+    heads['Access-Control-Allow-Origin'].must_be_nil
   end
 
-  should "only support GET, HEAD, and OPTIONS requests" do
+  it "only support GET, HEAD, and OPTIONS requests" do
     req = Rack::MockRequest.new(file(DOCROOT))
 
     forbidden = %w[post put patch delete]
     forbidden.each do |method|
       res = req.send(method, "/cgi/test")
-      res.should.be.client_error
-      res.should.be.method_not_allowed
-      res.headers['Allow'].split(/, */).sort.should == %w(GET HEAD OPTIONS)
+      res.must_be :client_error?
+      res.must_be :method_not_allowed?
+      res.headers['Allow'].split(/, */).sort.must_equal %w(GET HEAD OPTIONS)
     end
 
     allowed = %w[get head options]
     allowed.each do |method|
       res = req.send(method, "/cgi/test")
-      res.should.be.successful
+      res.must_be :successful?
     end
   end
 
-  should "set Allow correctly for OPTIONS requests" do
+  it "set Allow correctly for OPTIONS requests" do
     req = Rack::MockRequest.new(file(DOCROOT))
     res = req.options('/cgi/test')
-    res.should.be.successful
-    res.headers['Allow'].should.not.equal nil
-    res.headers['Allow'].split(/, */).sort.should == %w(GET HEAD OPTIONS)
+    res.must_be :successful?
+    res.headers['Allow'].wont_equal nil
+    res.headers['Allow'].split(/, */).sort.must_equal %w(GET HEAD OPTIONS)
   end
 
-  should "set Content-Length correctly for HEAD requests" do
+  it "set Content-Length correctly for HEAD requests" do
     req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT)))
     res = req.head "/cgi/test"
-    res.should.be.successful
-    res['Content-Length'].should.equal "193"
+    res.must_be :successful?
+    res['Content-Length'].must_equal "193"
   end
 
-  should "default to a mime type of text/plain" do
+  it "default to a mime type of text/plain" do
     req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT)))
     res = req.get "/cgi/test"
-    res.should.be.successful
-    res['Content-Type'].should.equal "text/plain"
+    res.must_be :successful?
+    res['Content-Type'].must_equal "text/plain"
   end
 
-  should "allow the default mime type to be set" do
+  it "allow the default mime type to be set" do
     req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT, nil, 'application/octet-stream')))
     res = req.get "/cgi/test"
-    res.should.be.successful
-    res['Content-Type'].should.equal "application/octet-stream"
+    res.must_be :successful?
+    res['Content-Type'].must_equal "application/octet-stream"
   end
 
-  should "not set Content-Type if the mime type is not set" do
+  it "not set Content-Type if the mime type is not set" do
     req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT, nil, nil)))
     res = req.get "/cgi/test"
-    res.should.be.successful
-    res['Content-Type'].should.equal nil
+    res.must_be :successful?
+    res['Content-Type'].must_be_nil
+  end
+
+  it "return error when file not found for head request" do
+    res = Rack::MockRequest.new(file(DOCROOT)).head("/cgi/missing")
+    res.must_be :not_found?
+    res.body.must_be :empty?
+  end
+
+  class MyFile < Rack::File
+    def response_body
+      "hello world"
+    end
+  end
+
+  it "behaves gracefully if response_body is present" do
+    file = Rack::Lint.new MyFile.new(DOCROOT)
+    res  = Rack::MockRequest.new(file).get("/cgi/test")
+
+    res.must_be :ok?
   end
 
 end