rack 1.6.13 → 2.0.9

data/test/spec_session_memcache.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 begin
   require 'rack/session/memcache'
   require 'rack/lint'
@@ -34,26 +35,26 @@ begin
     Rack::Session::Memcache.new(incrementor)
 
     it "faults on no connection" do
-      lambda{
+      lambda {
         Rack::Session::Memcache.new(incrementor, :memcache_server => 'nosuchserver')
-      }.should.raise
+      }.must_raise(RuntimeError).message.must_equal 'No memcache servers'
     end
 
     it "connects to existing server" do
       test_pool = MemCache.new(incrementor, :namespace => 'test:rack:session')
-      test_pool.namespace.should.equal 'test:rack:session'
+      test_pool.namespace.must_equal 'test:rack:session'
     end
 
     it "passes options to MemCache" do
       pool = Rack::Session::Memcache.new(incrementor, :namespace => 'test:rack:session')
-      pool.pool.namespace.should.equal 'test:rack:session'
+      pool.pool.namespace.must_equal 'test:rack:session'
     end
 
     it "creates a new cookie" do
       pool = Rack::Session::Memcache.new(incrementor)
       res = Rack::MockRequest.new(pool).get("/")
-      res["Set-Cookie"].should.include("#{session_key}=")
-      res.body.should.equal '{"counter"=>1}'
+      res["Set-Cookie"].must_include "#{session_key}="
+      res.body.must_equal '{"counter"=>1}'
     end
 
     it "determines session from a cookie" do
@@ -62,9 +63,9 @@ begin
       res = req.get("/")
       cookie = res["Set-Cookie"]
       req.get("/", "HTTP_COOKIE" => cookie).
-        body.should.equal '{"counter"=>2}'
+        body.must_equal '{"counter"=>2}'
       req.get("/", "HTTP_COOKIE" => cookie).
-        body.should.equal '{"counter"=>3}'
+        body.must_equal '{"counter"=>3}'
     end
 
     it "determines session only from a cookie by default" do
@@ -73,9 +74,9 @@ begin
       res = req.get("/")
       sid = res["Set-Cookie"][session_match, 1]
       req.get("/?rack.session=#{sid}").
-        body.should.equal '{"counter"=>1}'
+        body.must_equal '{"counter"=>1}'
       req.get("/?rack.session=#{sid}").
-        body.should.equal '{"counter"=>1}'
+        body.must_equal '{"counter"=>1}'
     end
 
     it "determines session from params" do
@@ -84,9 +85,9 @@ begin
       res = req.get("/")
       sid = res["Set-Cookie"][session_match, 1]
       req.get("/?rack.session=#{sid}").
-        body.should.equal '{"counter"=>2}'
+        body.must_equal '{"counter"=>2}'
       req.get("/?rack.session=#{sid}").
-        body.should.equal '{"counter"=>3}'
+        body.must_equal '{"counter"=>3}'
     end
 
     it "survives nonexistant cookies" do
@@ -94,24 +95,24 @@ begin
       pool = Rack::Session::Memcache.new(incrementor)
       res = Rack::MockRequest.new(pool).
         get("/", "HTTP_COOKIE" => bad_cookie)
-      res.body.should.equal '{"counter"=>1}'
+      res.body.must_equal '{"counter"=>1}'
       cookie = res["Set-Cookie"][session_match]
-      cookie.should.not.match(/#{bad_cookie}/)
+      cookie.wont_match(/#{bad_cookie}/)
     end
 
     it "maintains freshness" do
       pool = Rack::Session::Memcache.new(incrementor, :expire_after => 3)
       res = Rack::MockRequest.new(pool).get('/')
-      res.body.should.include '"counter"=>1'
+      res.body.must_include '"counter"=>1'
       cookie = res["Set-Cookie"]
       res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
-      res["Set-Cookie"].should.equal cookie
-      res.body.should.include '"counter"=>2'
+      res["Set-Cookie"].must_equal cookie
+      res.body.must_include '"counter"=>2'
       puts 'Sleeping to expire session' if $DEBUG
       sleep 4
       res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
-      res["Set-Cookie"].should.not.equal cookie
-      res.body.should.include '"counter"=>1'
+      res["Set-Cookie"].wont_equal cookie
+      res.body.must_include '"counter"=>1'
     end
 
     it "does not send the same session id if it did not change" do
@@ -120,15 +121,15 @@ begin
 
       res0 = req.get("/")
       cookie = res0["Set-Cookie"][session_match]
-      res0.body.should.equal '{"counter"=>1}'
+      res0.body.must_equal '{"counter"=>1}'
 
       res1 = req.get("/", "HTTP_COOKIE" => cookie)
-      res1["Set-Cookie"].should.be.nil
-      res1.body.should.equal '{"counter"=>2}'
+      res1["Set-Cookie"].must_be_nil
+      res1.body.must_equal '{"counter"=>2}'
 
       res2 = req.get("/", "HTTP_COOKIE" => cookie)
-      res2["Set-Cookie"].should.be.nil
-      res2.body.should.equal '{"counter"=>3}'
+      res2["Set-Cookie"].must_be_nil
+      res2.body.must_equal '{"counter"=>3}'
     end
 
     it "deletes cookies with :drop option" do
@@ -139,15 +140,15 @@ begin
 
       res1 = req.get("/")
       session = (cookie = res1["Set-Cookie"])[session_match]
-      res1.body.should.equal '{"counter"=>1}'
+      res1.body.must_equal '{"counter"=>1}'
 
       res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
-      res2["Set-Cookie"].should.equal nil
-      res2.body.should.equal '{"counter"=>2}'
+      res2["Set-Cookie"].must_be_nil
+      res2.body.must_equal '{"counter"=>2}'
 
       res3 = req.get("/", "HTTP_COOKIE" => cookie)
-      res3["Set-Cookie"][session_match].should.not.equal session
-      res3.body.should.equal '{"counter"=>1}'
+      res3["Set-Cookie"][session_match].wont_equal session
+      res3.body.must_equal '{"counter"=>1}'
     end
 
     it "provides new session id with :renew option" do
@@ -158,20 +159,20 @@ begin
 
       res1 = req.get("/")
       session = (cookie = res1["Set-Cookie"])[session_match]
-      res1.body.should.equal '{"counter"=>1}'
+      res1.body.must_equal '{"counter"=>1}'
 
       res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
       new_cookie = res2["Set-Cookie"]
       new_session = new_cookie[session_match]
-      new_session.should.not.equal session
-      res2.body.should.equal '{"counter"=>2}'
+      new_session.wont_equal session
+      res2.body.must_equal '{"counter"=>2}'
 
       res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
-      res3.body.should.equal '{"counter"=>3}'
+      res3.body.must_equal '{"counter"=>3}'
 
       # Old cookie was deleted
       res4 = req.get("/", "HTTP_COOKIE" => cookie)
-      res4.body.should.equal '{"counter"=>1}'
+      res4.body.must_equal '{"counter"=>1}'
     end
 
     it "omits cookie with :defer option but still updates the state" do
@@ -182,14 +183,14 @@ begin
       creq = Rack::MockRequest.new(count)
 
       res0 = dreq.get("/")
-      res0["Set-Cookie"].should.equal nil
-      res0.body.should.equal '{"counter"=>1}'
+      res0["Set-Cookie"].must_be_nil
+      res0.body.must_equal '{"counter"=>1}'
 
       res0 = creq.get("/")
       res1 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
-      res1.body.should.equal '{"counter"=>2}'
+      res1.body.must_equal '{"counter"=>2}'
       res2 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
-      res2.body.should.equal '{"counter"=>3}'
+      res2.body.must_equal '{"counter"=>3}'
     end
 
     it "omits cookie and state update with :skip option" do
@@ -200,14 +201,14 @@ begin
       creq = Rack::MockRequest.new(count)
 
       res0 = sreq.get("/")
-      res0["Set-Cookie"].should.equal nil
-      res0.body.should.equal '{"counter"=>1}'
+      res0["Set-Cookie"].must_be_nil
+      res0.body.must_equal '{"counter"=>1}'
 
       res0 = creq.get("/")
       res1 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
-      res1.body.should.equal '{"counter"=>2}'
+      res1.body.must_equal '{"counter"=>2}'
       res2 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
-      res2.body.should.equal '{"counter"=>2}'
+      res2.body.must_equal '{"counter"=>2}'
     end
 
     it "updates deep hashes correctly" do
@@ -231,7 +232,7 @@ begin
       req.get("/", "HTTP_COOKIE" => cookie)
       ses1 = pool.pool.get(session_id.private_id, true)
 
-      ses1.should.not.equal ses0
+      ses1.wont_equal ses0
     end
 
     it "can read the session with the legacy id" do
@@ -246,9 +247,9 @@ begin
       pool.pool.delete(session_id.private_id)
 
       res1 = req.get("/", "HTTP_COOKIE" => cookie)
-      res1["Set-Cookie"].should.be.nil
-      res1.body.should.equal '{"counter"=>2}'
-      pool.pool.get(session_id.private_id, true).should.not.be.nil
+      res1["Set-Cookie"].must_be_nil
+      res1.body.must_equal '{"counter"=>2}'
+      pool.pool.get(session_id.private_id, true).wont_be_nil
     end
 
     it "drops the session in the legacy id as well" do
@@ -265,24 +266,22 @@ begin
       pool.pool.delete(session_id.private_id)
 
       res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
-      res2["Set-Cookie"].should.be.nil
-      res2.body.should.equal '{"counter"=>2}'
-      pool.pool.get(session_id.private_id, true).should.be.nil
-      pool.pool.get(session_id.public_id, true).should.be.nil
+      res2["Set-Cookie"].must_be_nil
+      res2.body.must_equal '{"counter"=>2}'
+      pool.pool.get(session_id.private_id, true).must_be_nil
+      pool.pool.get(session_id.public_id, true).must_be_nil
     end
 
     # anyone know how to do this better?
     it "cleanly merges sessions when multithreaded" do
-      unless $DEBUG
-        1.should.equal 1 # fake assertion to appease the mighty bacon
-        next
-      end
+      skip unless $DEBUG
+
       warn 'Running multithread test for Session::Memcache'
       pool = Rack::Session::Memcache.new(incrementor)
       req = Rack::MockRequest.new(pool)
 
       res = req.get('/')
-      res.body.should.equal '{"counter"=>1}'
+      res.body.must_equal '{"counter"=>1}'
       cookie = res["Set-Cookie"]
       session_id = cookie[session_match, 1]
 
@@ -302,13 +301,13 @@ begin
         end
       end.reverse.map{|t| t.run.join.value }
       r.each do |request|
-        request['Set-Cookie'].should.equal cookie
-        request.body.should.include '"counter"=>2'
+        request['Set-Cookie'].must_equal cookie
+        request.body.must_include '"counter"=>2'
       end
 
       session = pool.pool.get(session_id)
-      session.size.should.equal tnum+1 # counter
-      session['counter'].should.equal 2 # meeeh
+      session.size.must_equal tnum+1 # counter
+      session['counter'].must_equal 2 # meeeh
 
       tnum = rand(7).to_i+5
       r = Array.new(tnum) do
@@ -319,13 +318,13 @@ begin
         end
       end.reverse.map{|t| t.run.join.value }
       r.each do |request|
-        request['Set-Cookie'].should.equal cookie
-        request.body.should.include '"counter"=>3'
+        request['Set-Cookie'].must_equal cookie
+        request.body.must_include '"counter"=>3'
       end
 
       session = pool.pool.get(session_id)
-      session.size.should.be tnum+1
-      session['counter'].should.be 3
+      session.size.must_equal tnum+1
+      session['counter'].must_equal 3
 
       drop_counter = proc do |env|
         env['rack.session'].delete 'counter'
@@ -341,14 +340,14 @@ begin
         end
       end.reverse.map{|t| t.run.join.value }
       r.each do |request|
-        request['Set-Cookie'].should.equal cookie
-        request.body.should.include '"foo"=>"bar"'
+        request['Set-Cookie'].must_equal cookie
+        request.body.must_include '"foo"=>"bar"'
       end
 
       session = pool.pool.get(session_id)
-      session.size.should.be r.size+1
-      session['counter'].should.be.nil?
-      session['foo'].should.equal 'bar'
+      session.size.must_equal r.size+1
+      session['counter'].must_be_nil?
+      session['foo'].must_equal 'bar'
     end
   end
 rescue RuntimeError

data/test/spec_session_pool.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 require 'thread'
 require 'rack/lint'
 require 'rack/mock'
@@ -35,14 +36,14 @@ describe Rack::Session::Pool do
     env['rack.session.options'][:defer] = true
     incrementor.call(env)
   end)
-  
+
   incrementor = Rack::Lint.new(incrementor)
 
   it "creates a new cookie" do
     pool = Rack::Session::Pool.new(incrementor)
     res = Rack::MockRequest.new(pool).get("/")
-    res["Set-Cookie"].should.match session_match
-    res.body.should.equal '{"counter"=>1}'
+    res["Set-Cookie"].must_match(session_match)
+    res.body.must_equal '{"counter"=>1}'
   end
 
   it "determines session from a cookie" do
@@ -50,16 +51,16 @@ describe Rack::Session::Pool do
     req = Rack::MockRequest.new(pool)
     cookie = req.get("/")["Set-Cookie"]
     req.get("/", "HTTP_COOKIE" => cookie).
-      body.should.equal '{"counter"=>2}'
+      body.must_equal '{"counter"=>2}'
     req.get("/", "HTTP_COOKIE" => cookie).
-      body.should.equal '{"counter"=>3}'
+      body.must_equal '{"counter"=>3}'
   end
 
   it "survives nonexistant cookies" do
     pool = Rack::Session::Pool.new(incrementor)
     res = Rack::MockRequest.new(pool).
       get("/", "HTTP_COOKIE" => "#{session_key}=blarghfasel")
-    res.body.should.equal '{"counter"=>1}'
+    res.body.must_equal '{"counter"=>1}'
   end
 
   it "does not send the same session id if it did not change" do
@@ -68,18 +69,18 @@ describe Rack::Session::Pool do
 
     res0 = req.get("/")
     cookie = res0["Set-Cookie"][session_match]
-    res0.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.equal 1
+    res0.body.must_equal '{"counter"=>1}'
+    pool.pool.size.must_equal 1
 
     res1 = req.get("/", "HTTP_COOKIE" => cookie)
-    res1["Set-Cookie"].should.be.nil
-    res1.body.should.equal '{"counter"=>2}'
-    pool.pool.size.should.equal 1
+    res1["Set-Cookie"].must_be_nil
+    res1.body.must_equal '{"counter"=>2}'
+    pool.pool.size.must_equal 1
 
     res2 = req.get("/", "HTTP_COOKIE" => cookie)
-    res2["Set-Cookie"].should.be.nil
-    res2.body.should.equal '{"counter"=>3}'
-    pool.pool.size.should.equal 1
+    res2["Set-Cookie"].must_be_nil
+    res2.body.must_equal '{"counter"=>3}'
+    pool.pool.size.must_equal 1
   end
 
   it "deletes cookies with :drop option" do
@@ -90,18 +91,18 @@ describe Rack::Session::Pool do
 
     res1 = req.get("/")
     session = (cookie = res1["Set-Cookie"])[session_match]
-    res1.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.equal 1
+    res1.body.must_equal '{"counter"=>1}'
+    pool.pool.size.must_equal 1
 
     res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
-    res2["Set-Cookie"].should.be.nil
-    res2.body.should.equal '{"counter"=>2}'
-    pool.pool.size.should.equal 0
+    res2["Set-Cookie"].must_be_nil
+    res2.body.must_equal '{"counter"=>2}'
+    pool.pool.size.must_equal 0
 
     res3 = req.get("/", "HTTP_COOKIE" => cookie)
-    res3["Set-Cookie"][session_match].should.not.equal session
-    res3.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.equal 1
+    res3["Set-Cookie"][session_match].wont_equal session
+    res3.body.must_equal '{"counter"=>1}'
+    pool.pool.size.must_equal 1
   end
 
   it "provides new session id with :renew option" do
@@ -112,23 +113,23 @@ describe Rack::Session::Pool do
 
     res1 = req.get("/")
     session = (cookie = res1["Set-Cookie"])[session_match]
-    res1.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.equal 1
+    res1.body.must_equal '{"counter"=>1}'
+    pool.pool.size.must_equal 1
 
     res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
     new_cookie = res2["Set-Cookie"]
     new_session = new_cookie[session_match]
-    new_session.should.not.equal session
-    res2.body.should.equal '{"counter"=>2}'
-    pool.pool.size.should.equal 1
+    new_session.wont_equal session
+    res2.body.must_equal '{"counter"=>2}'
+    pool.pool.size.must_equal 1
 
     res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
-    res3.body.should.equal '{"counter"=>3}'
-    pool.pool.size.should.equal 1
+    res3.body.must_equal '{"counter"=>3}'
+    pool.pool.size.must_equal 1
 
     res4 = req.get("/", "HTTP_COOKIE" => cookie)
-    res4.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.equal 2
+    res4.body.must_equal '{"counter"=>1}'
+    pool.pool.size.must_equal 2
   end
 
   it "omits cookie with :defer option" do
@@ -137,9 +138,9 @@ describe Rack::Session::Pool do
     dreq = Rack::MockRequest.new(defer)
 
     res1 = dreq.get("/")
-    res1["Set-Cookie"].should.equal nil
-    res1.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.equal 1
+    res1["Set-Cookie"].must_be_nil
+    res1.body.must_equal '{"counter"=>1}'
+    pool.pool.size.must_equal 1
   end
 
   it "can read the session with the legacy id" do
@@ -154,9 +155,9 @@ describe Rack::Session::Pool do
     pool.pool.delete(session_id.private_id)
 
     res1 = req.get("/", "HTTP_COOKIE" => cookie)
-    res1["Set-Cookie"].should.be.nil
-    res1.body.should.equal '{"counter"=>2}'
-    pool.pool[session_id.private_id].should.not.be.nil
+    res1["Set-Cookie"].must_be_nil
+    res1.body.must_equal '{"counter"=>2}'
+    pool.pool[session_id.private_id].wont_be_nil
   end
 
   it "drops the session in the legacy id as well" do
@@ -173,16 +174,16 @@ describe Rack::Session::Pool do
     pool.pool.delete(session_id.private_id)
 
     res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
-    res2["Set-Cookie"].should.be.nil
-    res2.body.should.equal '{"counter"=>2}'
-    pool.pool[session_id.private_id].should.be.nil
-    pool.pool[session_id.public_id].should.be.nil
+    res2["Set-Cookie"].must_be_nil
+    res2.body.must_equal '{"counter"=>2}'
+    pool.pool[session_id.private_id].must_be_nil
+    pool.pool[session_id.public_id].must_be_nil
   end
 
   # anyone know how to do this better?
   it "should merge sessions when multithreaded" do
     unless $DEBUG
-      1.should.equal 1
+      1.must_equal 1
       next
     end
 
@@ -191,7 +192,7 @@ describe Rack::Session::Pool do
     req = Rack::MockRequest.new(pool)
 
     res = req.get('/')
-    res.body.should.equal '{"counter"=>1}'
+    res.body.must_equal '{"counter"=>1}'
     cookie = res["Set-Cookie"]
     sess_id = cookie[/#{pool.key}=([^,;]+)/,1]
 
@@ -211,36 +212,36 @@ describe Rack::Session::Pool do
       end
     end.reverse.map{|t| t.run.join.value }
     r.each do |resp|
-      resp['Set-Cookie'].should.equal cookie
-      resp.body.should.include '"counter"=>2'
+      resp['Set-Cookie'].must_equal cookie
+      resp.body.must_include '"counter"=>2'
     end
 
     session = pool.pool[sess_id]
-    session.size.should.equal tnum+1 # counter
-    session['counter'].should.equal 2 # meeeh
+    session.size.must_equal tnum+1 # counter
+    session['counter'].must_equal 2 # meeeh
   end
 
   it "does not return a cookie if cookie was not read/written" do
     app = Rack::Session::Pool.new(nothing)
     res = Rack::MockRequest.new(app).get("/")
-    res["Set-Cookie"].should.be.nil
+    res["Set-Cookie"].must_be_nil
   end
 
   it "does not return a cookie if cookie was not written (only read)" do
     app = Rack::Session::Pool.new(get_session_id)
     res = Rack::MockRequest.new(app).get("/")
-    res["Set-Cookie"].should.be.nil
+    res["Set-Cookie"].must_be_nil
   end
 
   it "returns even if not read/written if :expire_after is set" do
     app = Rack::Session::Pool.new(nothing, :expire_after => 3600)
     res = Rack::MockRequest.new(app).get("/", 'rack.session' => {'not' => 'empty'})
-    res["Set-Cookie"].should.not.be.nil
+    res["Set-Cookie"].wont_be :nil?
   end
 
   it "returns no cookie if no data was written and no session was created previously, even if :expire_after is set" do
     app = Rack::Session::Pool.new(nothing, :expire_after => 3600)
     res = Rack::MockRequest.new(app).get("/")
-    res["Set-Cookie"].should.be.nil
+    res["Set-Cookie"].must_be_nil
   end
 end

data/test/{spec_showexceptions.rb → spec_show_exceptions.rb}

@@ -1,4 +1,5 @@
-require 'rack/showexceptions'
+require 'minitest/autorun'
+require 'rack/show_exceptions'
 require 'rack/lint'
 require 'rack/mock'
 
@@ -6,7 +7,7 @@ describe Rack::ShowExceptions do
   def show_exceptions(app)
     Rack::Lint.new Rack::ShowExceptions.new(app)
   end
-  
+
   it "catches exceptions" do
     res = nil
 
@@ -15,15 +16,13 @@ describe Rack::ShowExceptions do
         lambda{|env| raise RuntimeError }
     ))
 
-    lambda{
-      res = req.get("/", "HTTP_ACCEPT" => "text/html")
-    }.should.not.raise
+    res = req.get("/", "HTTP_ACCEPT" => "text/html")
 
-    res.should.be.a.server_error
-    res.status.should.equal 500
+    res.must_be :server_error?
+    res.status.must_equal 500
 
-    res.should =~ /RuntimeError/
-    res.should =~ /ShowExceptions/
+    assert_match(res, /RuntimeError/)
+    assert_match(res, /ShowExceptions/)
   end
 
   it "responds with HTML only to requests accepting HTML" do
@@ -42,22 +41,20 @@ describe Rack::ShowExceptions do
       ["text/plain", ["/"]],
       ["text/plain", ["/", {"HTTP_ACCEPT" => "application/json"}]]
     ].each do |exmime, rargs|
-      lambda{
-        res = req.get(*rargs)
-      }.should.not.raise
+      res = req.get(*rargs)
 
-      res.should.be.a.server_error
-      res.status.should.equal 500
+      res.must_be :server_error?
+      res.status.must_equal 500
 
-      res.content_type.should.equal exmime
+      res.content_type.must_equal exmime
 
-      res.body.should.include "RuntimeError"
-      res.body.should.include "It was never supposed to work"
+      res.body.must_include "RuntimeError"
+      res.body.must_include "It was never supposed to work"
 
       if exmime == "text/html"
-        res.body.should.include '</html>'
+        res.body.must_include '</html>'
       else
-        res.body.should.not.include '</html>'
+        res.body.wont_include '</html>'
       end
     end
   end
@@ -71,16 +68,14 @@ describe Rack::ShowExceptions do
       )
     )
 
-    lambda{
-      res = req.get("/", "HTTP_ACCEPT" => "text/html")
-    }.should.not.raise
+    res = req.get("/", "HTTP_ACCEPT" => "text/html")
 
-    res.should.be.a.server_error
-    res.status.should.equal 500
+    res.must_be :server_error?
+    res.status.must_equal 500
 
-    res.should =~ /RuntimeError/
-    res.should =~ /ShowExceptions/
-    res.should =~ /unknown location/
+    assert_match(res, /RuntimeError/)
+    assert_match(res, /ShowExceptions/)
+    assert_match(res, /unknown location/)
   end
 
   it "knows to prefer plaintext for non-html" do
@@ -92,7 +87,7 @@ describe Rack::ShowExceptions do
       [{ "HTTP_ACCEPT" => "text/foo" }, true],
       [{ "HTTP_ACCEPT" => "text/html" }, false]
     ].each do |env, expected|
-      expected.should.equal exc.prefers_plaintext?(env)
+      assert_equal(expected, exc.prefers_plaintext?(env))
     end
   end
 end