rack 1.1.6 → 1.2.0

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

@@ -1,12 +1,9 @@
-require 'test/spec'
-
 begin
   require 'rack/session/memcache'
   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|
@@ -27,30 +24,36 @@ begin
       incrementor.call(env)
     end
 
-    specify "faults on no connection" do
+    it "faults on no connection" do
       if RUBY_VERSION < "1.9"
-        lambda do
-          Rack::Session::Memcache.new incrementor, :memcache_server => 'nosuchserver'
-        end.should.raise
+        lambda{
+          Rack::Session::Memcache.new(incrementor, :memcache_server => 'nosuchserver')
+        }.should.raise
       else
-        lambda do
-          Rack::Session::Memcache.new incrementor, :memcache_server => 'nosuchserver'
-        end.should.raise ArgumentError
+        lambda{
+          Rack::Session::Memcache.new(incrementor, :memcache_server => 'nosuchserver')
+        }.should.raise ArgumentError
       end
     end
 
-    specify "connect to existing server" do
-      test_pool = MemCache.new incrementor, :namespace => 'test:rack:session'
+    it "connects to existing server" do
+      test_pool = MemCache.new(incrementor, :namespace => 'test:rack:session')
+      test_pool.namespace.should.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'
     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 +64,7 @@ begin
         body.should.equal '{"counter"=>3}'
     end
 
-    specify "survives nonexistant cookies" do
+    it "survives nonexistant cookies" do
       bad_cookie = "rack.session=blarghfasel"
       pool = Rack::Session::Memcache.new(incrementor)
       res = Rack::MockRequest.new(pool).
@@ -71,7 +74,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,7 +89,7 @@ begin
       res.body.should.include '"counter"=>1'
     end
 
-    specify "deletes cookies with :drop option" do
+    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)
@@ -109,7 +112,7 @@ begin
       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)
@@ -134,7 +137,7 @@ begin
       res3.body.should.equal '{"counter"=>4}'
     end
 
-    specify "omits cookie with :defer option" do
+    it "omits cookie with :defer option" do
       pool = Rack::Session::Memcache.new(incrementor)
       req = Rack::MockRequest.new(pool)
       defer = Rack::Utils::Context.new(pool, defer_session)
@@ -157,7 +160,7 @@ begin
       res3.body.should.equal '{"counter"=>4}'
     end
 
-    specify "deep hashes are correctly updated" do
+    it "updates deep hashes correctly" do
       store = nil
       hash_check = proc do |env|
         session = env['rack.session']
@@ -183,8 +186,11 @@ begin
     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,8 +221,8 @@ 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|

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

@@ -1,39 +1,40 @@
-require 'test/spec'
-
-require 'rack/session/pool'
-require 'rack/mock'
-require 'rack/response'
 require 'thread'
+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|
+
+  drop_session = lambda do |env|
     env['rack.session.options'][:drop] = true
     incrementor.call(env)
   end
-  renew_session = proc do |env|
+
+  renew_session = lambda do |env|
     env['rack.session.options'][:renew] = true
     incrementor.call(env)
   end
-  defer_session = proc do |env|
+
+  defer_session = lambda do |env|
     env['rack.session.options'][:defer] = true
     incrementor.call(env)
   end
 
-  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,14 +44,14 @@ 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 "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)
@@ -59,25 +60,25 @@ context "Rack::Session::Pool" do
     res0 = req.get("/")
     session = (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.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.body.should.equal '{"counter"=>3}'
-    pool.pool.size.should.be 0
+    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)
@@ -86,27 +87,27 @@ context "Rack::Session::Pool" do
     res0 = req.get("/")
     session = (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.body.should.equal '{"counter"=>2}'
-    pool.pool.size.should.be 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
+    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
+    pool.pool.size.should.equal 1
   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)
@@ -115,27 +116,31 @@ context "Rack::Session::Pool" do
     res0 = req.get("/")
     session = (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.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.body.should.equal '{"counter"=>3}'
-    pool.pool.size.should.be 1
+    pool.pool.size.should.equal 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
+    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)
@@ -166,7 +171,7 @@ context "Rack::Session::Pool" do
     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
 end

data/spec/spec_showexceptions.rb

@@ -0,0 +1,23 @@
+require 'rack/showexceptions'
+require 'rack/mock'
+
+describe Rack::ShowExceptions do
+  it "catches exceptions" do
+    res = nil
+
+    req = Rack::MockRequest.new(
+      Rack::ShowExceptions.new(
+        lambda{|env| raise RuntimeError }
+    ))
+
+    lambda{
+      res = req.get("/")
+    }.should.not.raise
+
+    res.should.be.a.server_error
+    res.status.should.equal 500
+
+    res.should =~ /RuntimeError/
+    res.should =~ /ShowExceptions/
+  end
+end

data/spec/spec_showstatus.rb

@@ -0,0 +1,79 @@
+require 'rack/showstatus'
+require 'rack/mock'
+
+describe Rack::ShowStatus do
+  should "provide a default status message" do
+    req = Rack::MockRequest.new(
+      Rack::ShowStatus.new(lambda{|env|
+        [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
+    }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+    res.should.be.not.empty
+
+    res["Content-Type"].should.equal("text/html")
+    res.should =~ /404/
+    res.should =~ /Not Found/
+  end
+
+  should "let the app provide additional information" do
+    req = Rack::MockRequest.new(
+      Rack::ShowStatus.new(
+        lambda{|env|
+          env["rack.showstatus.detail"] = "gone too meta."
+          [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
+    }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+    res.should.be.not.empty
+
+    res["Content-Type"].should.equal("text/html")
+    res.should =~ /404/
+    res.should =~ /Not Found/
+    res.should =~ /too meta/
+  end
+
+  should "not replace existing messages" do
+    req = Rack::MockRequest.new(
+      Rack::ShowStatus.new(
+        lambda{|env|
+          [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
+    }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+
+    res.body.should == "foo!"
+  end
+
+  should "pass on original headers" do
+    headers = {"WWW-Authenticate" => "Basic blah"}
+
+    req = Rack::MockRequest.new(
+      Rack::ShowStatus.new(lambda{|env| [401, headers, []] }))
+    res = req.get("/", :lint => true)
+
+    res["WWW-Authenticate"].should.equal("Basic blah")
+  end
+
+  should "replace existing messages if there is detail" do
+    req = Rack::MockRequest.new(
+      Rack::ShowStatus.new(
+        lambda{|env|
+          env["rack.showstatus.detail"] = "gone too meta."
+          [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
+    }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+    res.should.be.not.empty
+
+    res["Content-Type"].should.equal("text/html")
+    res["Content-Length"].should.not.equal("4")
+    res.should =~ /404/
+    res.should =~ /too meta/
+    res.body.should.not =~ /foo/
+  end
+end

data/{test/spec_rack_static.rb → spec/spec_static.rb}

@@ -1,5 +1,3 @@
-require 'test/spec'
-
 require 'rack/static'
 require 'rack/mock'
 
@@ -9,26 +7,24 @@ class DummyApp
   end
 end
 
-context "Rack::Static" do
+describe Rack::Static do
   root = File.expand_path(File.dirname(__FILE__))
   OPTIONS = {:urls => ["/cgi"], :root => root}
 
-  setup do
-    @request = Rack::MockRequest.new(Rack::Static.new(DummyApp.new, OPTIONS))
-  end
+  @request = Rack::MockRequest.new(Rack::Static.new(DummyApp.new, OPTIONS))
 
-  specify "serves files" do
+  it "serves files" do
     res = @request.get("/cgi/test")
     res.should.be.ok
     res.body.should =~ /ruby/
   end
 
-  specify "404s if url root is known but it can't find the file" do
+  it "404s if url root is known but it can't find the file" do
     res = @request.get("/cgi/foo")
     res.should.be.not_found
   end
 
-  specify "calls down the chain if url root is not known" do
+  it "calls down the chain if url root is not known" do
     res = @request.get("/something/else")
     res.should.be.ok
     res.body.should == "Hello World"