rack 1.1.6 → 1.6.9

data/test/{spec_rack_session_memcache.rb → spec_session_memcache.rb}

@@ -1,12 +1,10 @@
-require 'test/spec'
-
 begin
   require 'rack/session/memcache'
+  require 'rack/lint'
   require 'rack/mock'
-  require 'rack/response'
   require 'thread'
 
-  context "Rack::Session::Memcache" do
+  describe Rack::Session::Memcache do
     session_key = Rack::Session::Memcache::DEFAULT_OPTIONS[:key]
     session_match = /#{session_key}=([0-9a-fA-F]+);/
     incrementor = lambda do |env|
@@ -14,43 +12,51 @@ begin
       env["rack.session"]["counter"] += 1
       Rack::Response.new(env["rack.session"].inspect).to_a
     end
-    drop_session = proc do |env|
+    drop_session = Rack::Lint.new(proc do |env|
       env['rack.session.options'][:drop] = true
       incrementor.call(env)
-    end
-    renew_session = proc do |env|
+    end)
+    renew_session = Rack::Lint.new(proc do |env|
       env['rack.session.options'][:renew] = true
       incrementor.call(env)
-    end
-    defer_session = proc do |env|
+    end)
+    defer_session = Rack::Lint.new(proc do |env|
       env['rack.session.options'][:defer] = true
       incrementor.call(env)
+    end)
+    skip_session = Rack::Lint.new(proc do |env|
+      env['rack.session.options'][:skip] = true
+      incrementor.call(env)
+    end)
+    incrementor = Rack::Lint.new(incrementor)
+
+    # test memcache connection
+    Rack::Session::Memcache.new(incrementor)
+
+    it "faults on no connection" do
+      lambda{
+        Rack::Session::Memcache.new(incrementor, :memcache_server => 'nosuchserver')
+      }.should.raise
     end
 
-    specify "faults on no connection" do
-      if RUBY_VERSION < "1.9"
-        lambda do
-          Rack::Session::Memcache.new incrementor, :memcache_server => 'nosuchserver'
-        end.should.raise
-      else
-        lambda do
-          Rack::Session::Memcache.new incrementor, :memcache_server => 'nosuchserver'
-        end.should.raise ArgumentError
-      end
+    it "connects to existing server" do
+      test_pool = MemCache.new(incrementor, :namespace => 'test:rack:session')
+      test_pool.namespace.should.equal 'test:rack:session'
     end
 
-    specify "connect to existing server" do
-      test_pool = MemCache.new incrementor, :namespace => 'test:rack:session'
+    it "passes options to MemCache" do
+      pool = Rack::Session::Memcache.new(incrementor, :namespace => 'test:rack:session')
+      pool.pool.namespace.should.equal 'test:rack:session'
     end
 
-    specify "creates a new cookie" do
+    it "creates a new cookie" do
       pool = Rack::Session::Memcache.new(incrementor)
       res = Rack::MockRequest.new(pool).get("/")
-      res["Set-Cookie"].should.match("#{session_key}=")
+      res["Set-Cookie"].should.include("#{session_key}=")
       res.body.should.equal '{"counter"=>1}'
     end
 
-    specify "determines session from a cookie" do
+    it "determines session from a cookie" do
       pool = Rack::Session::Memcache.new(incrementor)
       req = Rack::MockRequest.new(pool)
       res = req.get("/")
@@ -61,7 +67,29 @@ begin
         body.should.equal '{"counter"=>3}'
     end
 
-    specify "survives nonexistant cookies" do
+    it "determines session only from a cookie by default" do
+      pool = Rack::Session::Memcache.new(incrementor)
+      req = Rack::MockRequest.new(pool)
+      res = req.get("/")
+      sid = res["Set-Cookie"][session_match, 1]
+      req.get("/?rack.session=#{sid}").
+        body.should.equal '{"counter"=>1}'
+      req.get("/?rack.session=#{sid}").
+        body.should.equal '{"counter"=>1}'
+    end
+
+    it "determines session from params" do
+      pool = Rack::Session::Memcache.new(incrementor, :cookie_only => false)
+      req = Rack::MockRequest.new(pool)
+      res = req.get("/")
+      sid = res["Set-Cookie"][session_match, 1]
+      req.get("/?rack.session=#{sid}").
+        body.should.equal '{"counter"=>2}'
+      req.get("/?rack.session=#{sid}").
+        body.should.equal '{"counter"=>3}'
+    end
+
+    it "survives nonexistant cookies" do
       bad_cookie = "rack.session=blarghfasel"
       pool = Rack::Session::Memcache.new(incrementor)
       res = Rack::MockRequest.new(pool).
@@ -71,7 +99,7 @@ begin
       cookie.should.not.match(/#{bad_cookie}/)
     end
 
-    specify "maintains freshness" do
+    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'
@@ -86,79 +114,103 @@ begin
       res.body.should.include '"counter"=>1'
     end
 
-    specify "deletes cookies with :drop option" do
+    it "does not send the same session id if it did not change" do
       pool = Rack::Session::Memcache.new(incrementor)
       req = Rack::MockRequest.new(pool)
-      drop = Rack::Utils::Context.new(pool, drop_session)
-      dreq = Rack::MockRequest.new(drop)
 
       res0 = req.get("/")
-      session = (cookie = res0["Set-Cookie"])[session_match]
+      cookie = res0["Set-Cookie"][session_match]
       res0.body.should.equal '{"counter"=>1}'
 
       res1 = req.get("/", "HTTP_COOKIE" => cookie)
-      res1["Set-Cookie"][session_match].should.equal session
+      res1["Set-Cookie"].should.be.nil
       res1.body.should.equal '{"counter"=>2}'
 
+      res2 = req.get("/", "HTTP_COOKIE" => cookie)
+      res2["Set-Cookie"].should.be.nil
+      res2.body.should.equal '{"counter"=>3}'
+    end
+
+    it "deletes cookies with :drop option" do
+      pool = Rack::Session::Memcache.new(incrementor)
+      req = Rack::MockRequest.new(pool)
+      drop = Rack::Utils::Context.new(pool, drop_session)
+      dreq = Rack::MockRequest.new(drop)
+
+      res1 = req.get("/")
+      session = (cookie = res1["Set-Cookie"])[session_match]
+      res1.body.should.equal '{"counter"=>1}'
+
       res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
       res2["Set-Cookie"].should.equal nil
-      res2.body.should.equal '{"counter"=>3}'
+      res2.body.should.equal '{"counter"=>2}'
 
       res3 = req.get("/", "HTTP_COOKIE" => cookie)
       res3["Set-Cookie"][session_match].should.not.equal session
       res3.body.should.equal '{"counter"=>1}'
     end
 
-    specify "provides new session id with :renew option" do
+    it "provides new session id with :renew option" do
       pool = Rack::Session::Memcache.new(incrementor)
       req = Rack::MockRequest.new(pool)
       renew = Rack::Utils::Context.new(pool, renew_session)
       rreq = Rack::MockRequest.new(renew)
 
-      res0 = req.get("/")
-      session = (cookie = res0["Set-Cookie"])[session_match]
-      res0.body.should.equal '{"counter"=>1}'
-
-      res1 = req.get("/", "HTTP_COOKIE" => cookie)
-      res1["Set-Cookie"][session_match].should.equal session
-      res1.body.should.equal '{"counter"=>2}'
+      res1 = req.get("/")
+      session = (cookie = res1["Set-Cookie"])[session_match]
+      res1.body.should.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"=>3}'
+      res2.body.should.equal '{"counter"=>2}'
 
       res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
-      res3["Set-Cookie"][session_match].should.equal new_session
-      res3.body.should.equal '{"counter"=>4}'
+      res3.body.should.equal '{"counter"=>3}'
+
+      # Old cookie was deleted
+      res4 = req.get("/", "HTTP_COOKIE" => cookie)
+      res4.body.should.equal '{"counter"=>1}'
     end
 
-    specify "omits cookie with :defer option" do
+    it "omits cookie with :defer option but still updates the state" do
       pool = Rack::Session::Memcache.new(incrementor)
-      req = Rack::MockRequest.new(pool)
+      count = Rack::Utils::Context.new(pool, incrementor)
       defer = Rack::Utils::Context.new(pool, defer_session)
       dreq = Rack::MockRequest.new(defer)
+      creq = Rack::MockRequest.new(count)
 
-      res0 = req.get("/")
-      session = (cookie = res0["Set-Cookie"])[session_match]
+      res0 = dreq.get("/")
+      res0["Set-Cookie"].should.equal nil
       res0.body.should.equal '{"counter"=>1}'
 
-      res1 = req.get("/", "HTTP_COOKIE" => cookie)
-      res1["Set-Cookie"][session_match].should.equal session
+      res0 = creq.get("/")
+      res1 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
       res1.body.should.equal '{"counter"=>2}'
-
-      res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
-      res2["Set-Cookie"].should.equal nil
+      res2 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
       res2.body.should.equal '{"counter"=>3}'
+    end
 
-      res3 = req.get("/", "HTTP_COOKIE" => cookie)
-      res3["Set-Cookie"][session_match].should.equal session
-      res3.body.should.equal '{"counter"=>4}'
+    it "omits cookie and state update with :skip option" do
+      pool = Rack::Session::Memcache.new(incrementor)
+      count = Rack::Utils::Context.new(pool, incrementor)
+      skip = Rack::Utils::Context.new(pool, skip_session)
+      sreq = Rack::MockRequest.new(skip)
+      creq = Rack::MockRequest.new(count)
+
+      res0 = sreq.get("/")
+      res0["Set-Cookie"].should.equal nil
+      res0.body.should.equal '{"counter"=>1}'
+
+      res0 = creq.get("/")
+      res1 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
+      res1.body.should.equal '{"counter"=>2}'
+      res2 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
+      res2.body.should.equal '{"counter"=>2}'
     end
 
-    specify "deep hashes are correctly updated" do
-      store = nil
+    it "updates deep hashes correctly" do
       hash_check = proc do |env|
         session = env['rack.session']
         unless session.include? 'test'
@@ -167,7 +219,7 @@ begin
         else
           session[:f][:g][:h] = :j
         end
-        [200, {}, session.inspect]
+        [200, {}, [session.inspect]]
       end
       pool = Rack::Session::Memcache.new(hash_check)
       req = Rack::MockRequest.new(pool)
@@ -176,15 +228,18 @@ begin
       session_id = (cookie = res0["Set-Cookie"])[session_match, 1]
       ses0 = pool.pool.get(session_id, true)
 
-      res1 = req.get("/", "HTTP_COOKIE" => cookie)
+      req.get("/", "HTTP_COOKIE" => cookie)
       ses1 = pool.pool.get(session_id, true)
 
       ses1.should.not.equal ses0
     end
 
     # anyone know how to do this better?
-    specify "multithread: should cleanly merge sessions" do
-      next unless $DEBUG
+    it "cleanly merges sessions when multithreaded" do
+      unless $DEBUG
+        1.should.equal 1 # fake assertion to appease the mighty bacon
+        next
+      end
       warn 'Running multithread test for Session::Memcache'
       pool = Rack::Session::Memcache.new(incrementor)
       req = Rack::MockRequest.new(pool)
@@ -215,18 +270,11 @@ begin
       end
 
       session = pool.pool.get(session_id)
-      session.size.should.be tnum+1 # counter
-      session['counter'].should.be 2 # meeeh
+      session.size.should.equal tnum+1 # counter
+      session['counter'].should.equal 2 # meeeh
 
       tnum = rand(7).to_i+5
-      r = Array.new(tnum) do |i|
-        delta_time = proc do |env|
-          env['rack.session'][i]  = Time.now
-          Thread.stop
-          env['rack.session']     = env['rack.session'].dup
-          env['rack.session'][i] -= Time.now
-          incrementor.call(env)
-        end
+      r = Array.new(tnum) do
         app = Rack::Utils::Context.new pool, time_delta
         req = Rack::MockRequest.new app
         Thread.new(req) do |run|

data/test/{spec_rack_session_pool.rb → spec_session_pool.rb}

@@ -1,39 +1,51 @@
-require 'test/spec'
-
-require 'rack/session/pool'
-require 'rack/mock'
-require 'rack/response'
 require 'thread'
+require 'rack/lint'
+require 'rack/mock'
+require 'rack/session/pool'
 
-context "Rack::Session::Pool" do
+describe Rack::Session::Pool do
   session_key = Rack::Session::Pool::DEFAULT_OPTIONS[:key]
   session_match = /#{session_key}=[0-9a-fA-F]+;/
+
   incrementor = lambda do |env|
     env["rack.session"]["counter"] ||= 0
     env["rack.session"]["counter"] += 1
     Rack::Response.new(env["rack.session"].inspect).to_a
   end
-  drop_session = proc do |env|
+
+  session_id = Rack::Lint.new(lambda do |env|
+    Rack::Response.new(env["rack.session"].inspect).to_a
+  end)
+
+  nothing = Rack::Lint.new(lambda do |env|
+    Rack::Response.new("Nothing").to_a
+  end)
+
+  drop_session = Rack::Lint.new(lambda do |env|
     env['rack.session.options'][:drop] = true
     incrementor.call(env)
-  end
-  renew_session = proc do |env|
+  end)
+
+  renew_session = Rack::Lint.new(lambda do |env|
     env['rack.session.options'][:renew] = true
     incrementor.call(env)
-  end
-  defer_session = proc do |env|
+  end)
+
+  defer_session = Rack::Lint.new(lambda do |env|
     env['rack.session.options'][:defer] = true
     incrementor.call(env)
-  end
+  end)
+  
+  incrementor = Rack::Lint.new(incrementor)
 
-  specify "creates a new cookie" do
+  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}'
   end
 
-  specify "determines session from a cookie" do
+  it "determines session from a cookie" do
     pool = Rack::Session::Pool.new(incrementor)
     req = Rack::MockRequest.new(pool)
     cookie = req.get("/")["Set-Cookie"]
@@ -43,99 +55,100 @@ context "Rack::Session::Pool" do
       body.should.equal '{"counter"=>3}'
   end
 
-  specify "survives nonexistant cookies" do
+  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}'
   end
 
-  specify "deletes cookies with :drop option" do
+  it "does not send the same session id if it did not change" do
     pool = Rack::Session::Pool.new(incrementor)
     req = Rack::MockRequest.new(pool)
-    drop = Rack::Utils::Context.new(pool, drop_session)
-    dreq = Rack::MockRequest.new(drop)
 
     res0 = req.get("/")
-    session = (cookie = res0["Set-Cookie"])[session_match]
+    cookie = res0["Set-Cookie"][session_match]
     res0.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.be 1
+    pool.pool.size.should.equal 1
 
     res1 = req.get("/", "HTTP_COOKIE" => cookie)
-    res1["Set-Cookie"][session_match].should.equal session
+    res1["Set-Cookie"].should.be.nil
     res1.body.should.equal '{"counter"=>2}'
-    pool.pool.size.should.be 1
+    pool.pool.size.should.equal 1
 
-    res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
-    res2["Set-Cookie"].should.equal nil
+    res2 = req.get("/", "HTTP_COOKIE" => cookie)
+    res2["Set-Cookie"].should.be.nil
     res2.body.should.equal '{"counter"=>3}'
-    pool.pool.size.should.be 0
+    pool.pool.size.should.equal 1
+  end
+
+  it "deletes cookies with :drop option" do
+    pool = Rack::Session::Pool.new(incrementor)
+    req = Rack::MockRequest.new(pool)
+    drop = Rack::Utils::Context.new(pool, drop_session)
+    dreq = Rack::MockRequest.new(drop)
+
+    res1 = req.get("/")
+    session = (cookie = res1["Set-Cookie"])[session_match]
+    res1.body.should.equal '{"counter"=>1}'
+    pool.pool.size.should.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
 
     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.be 1
+    pool.pool.size.should.equal 1
   end
 
-  specify "provides new session id with :renew option" do
+  it "provides new session id with :renew option" do
     pool = Rack::Session::Pool.new(incrementor)
     req = Rack::MockRequest.new(pool)
     renew = Rack::Utils::Context.new(pool, renew_session)
     rreq = Rack::MockRequest.new(renew)
 
-    res0 = req.get("/")
-    session = (cookie = res0["Set-Cookie"])[session_match]
-    res0.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.be 1
-
-    res1 = req.get("/", "HTTP_COOKIE" => cookie)
-    res1["Set-Cookie"][session_match].should.equal session
-    res1.body.should.equal '{"counter"=>2}'
-    pool.pool.size.should.be 1
+    res1 = req.get("/")
+    session = (cookie = res1["Set-Cookie"])[session_match]
+    res1.body.should.equal '{"counter"=>1}'
+    pool.pool.size.should.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"=>3}'
-    pool.pool.size.should.be 1
+    res2.body.should.equal '{"counter"=>2}'
+    pool.pool.size.should.equal 1
 
     res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
-    res3["Set-Cookie"][session_match].should.equal new_session
-    res3.body.should.equal '{"counter"=>4}'
-    pool.pool.size.should.be 1
+    res3.body.should.equal '{"counter"=>3}'
+    pool.pool.size.should.equal 1
+
+    res4 = req.get("/", "HTTP_COOKIE" => cookie)
+    res4.body.should.equal '{"counter"=>1}'
+    pool.pool.size.should.equal 2
   end
 
-  specify "omits cookie with :defer option" do
+  it "omits cookie with :defer option" do
     pool = Rack::Session::Pool.new(incrementor)
-    req = Rack::MockRequest.new(pool)
     defer = Rack::Utils::Context.new(pool, defer_session)
     dreq = Rack::MockRequest.new(defer)
 
-    res0 = req.get("/")
-    session = (cookie = res0["Set-Cookie"])[session_match]
-    res0.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.be 1
-
-    res1 = req.get("/", "HTTP_COOKIE" => cookie)
-    res1["Set-Cookie"][session_match].should.equal session
-    res1.body.should.equal '{"counter"=>2}'
-    pool.pool.size.should.be 1
-
-    res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
-    res2["Set-Cookie"].should.equal nil
-    res2.body.should.equal '{"counter"=>3}'
-    pool.pool.size.should.be 1
-
-    res3 = req.get("/", "HTTP_COOKIE" => cookie)
-    res3["Set-Cookie"][session_match].should.equal session
-    res3.body.should.equal '{"counter"=>4}'
-    pool.pool.size.should.be 1
+    res1 = dreq.get("/")
+    res1["Set-Cookie"].should.equal nil
+    res1.body.should.equal '{"counter"=>1}'
+    pool.pool.size.should.equal 1
   end
 
   # anyone know how to do this better?
-  specify "multithread: should merge sessions" do
-    next unless $DEBUG
+  it "should merge sessions when multithreaded" do
+    unless $DEBUG
+      1.should.equal 1
+      next
+    end
+
     warn 'Running multithread tests for Session::Pool'
     pool = Rack::Session::Pool.new(incrementor)
     req = Rack::MockRequest.new(pool)
@@ -160,13 +173,37 @@ context "Rack::Session::Pool" do
         run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
       end
     end.reverse.map{|t| t.run.join.value }
-    r.each do |res|
-      res['Set-Cookie'].should.equal cookie
-      res.body.should.include '"counter"=>2'
+    r.each do |resp|
+      resp['Set-Cookie'].should.equal cookie
+      resp.body.should.include '"counter"=>2'
     end
 
     session = pool.pool[sess_id]
-    session.size.should.be tnum+1 # counter
-    session['counter'].should.be 2 # meeeh
+    session.size.should.equal tnum+1 # counter
+    session['counter'].should.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
+  end
+
+  it "does not return a cookie if cookie was not written (only read)" do
+    app = Rack::Session::Pool.new(session_id)
+    res = Rack::MockRequest.new(app).get("/")
+    res["Set-Cookie"].should.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
+  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
   end
 end

data/test/spec_showexceptions.rb

@@ -0,0 +1,85 @@
+require 'rack/showexceptions'
+require 'rack/lint'
+require 'rack/mock'
+
+describe Rack::ShowExceptions do
+  def show_exceptions(app)
+    Rack::Lint.new Rack::ShowExceptions.new(app)
+  end
+  
+  it "catches exceptions" do
+    res = nil
+
+    req = Rack::MockRequest.new(
+      show_exceptions(
+        lambda{|env| raise RuntimeError }
+    ))
+
+    lambda{
+      res = req.get("/", "HTTP_ACCEPT" => "text/html")
+    }.should.not.raise
+
+    res.should.be.a.server_error
+    res.status.should.equal 500
+
+    res.should =~ /RuntimeError/
+    res.should =~ /ShowExceptions/
+  end
+
+  it "responds with HTML only to requests accepting HTML" do
+    res = nil
+
+    req = Rack::MockRequest.new(
+      show_exceptions(
+        lambda{|env| raise RuntimeError, "It was never supposed to work" }
+    ))
+
+    [
+      # Serve text/html when the client accepts text/html
+      ["text/html", ["/", {"HTTP_ACCEPT" => "text/html"}]],
+      ["text/html", ["/", {"HTTP_ACCEPT" => "*/*"}]],
+      # Serve text/plain when the client does not accept text/html
+      ["text/plain", ["/"]],
+      ["text/plain", ["/", {"HTTP_ACCEPT" => "application/json"}]]
+    ].each do |exmime, rargs|
+      lambda{
+        res = req.get(*rargs)
+      }.should.not.raise
+
+      res.should.be.a.server_error
+      res.status.should.equal 500
+
+      res.content_type.should.equal exmime
+
+      res.body.should.include "RuntimeError"
+      res.body.should.include "It was never supposed to work"
+
+      if exmime == "text/html"
+        res.body.should.include '</html>'
+      else
+        res.body.should.not.include '</html>'
+      end
+    end
+  end
+
+  it "handles exceptions without a backtrace" do
+    res = nil
+
+    req = Rack::MockRequest.new(
+      show_exceptions(
+        lambda{|env| raise RuntimeError, "", [] }
+      )
+    )
+
+    lambda{
+      res = req.get("/", "HTTP_ACCEPT" => "text/html")
+    }.should.not.raise
+
+    res.should.be.a.server_error
+    res.status.should.equal 500
+
+    res.should =~ /RuntimeError/
+    res.should =~ /ShowExceptions/
+    res.should =~ /unknown location/
+  end
+end