rack 1.6.13 → 2.0.0.alpha

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_equal 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_equal 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_equal 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
@@ -225,64 +226,25 @@ begin
       req = Rack::MockRequest.new(pool)
 
       res0 = req.get("/")
-      session_id = Rack::Session::SessionId.new (cookie = res0["Set-Cookie"])[session_match, 1]
-      ses0 = pool.pool.get(session_id.private_id, true)
+      session_id = (cookie = res0["Set-Cookie"])[session_match, 1]
+      ses0 = pool.pool.get(session_id, true)
 
       req.get("/", "HTTP_COOKIE" => cookie)
-      ses1 = pool.pool.get(session_id.private_id, true)
+      ses1 = pool.pool.get(session_id, true)
 
-      ses1.should.not.equal ses0
-    end
-
-    it "can read the session with the legacy id" do
-      pool = Rack::Session::Memcache.new(incrementor)
-      req = Rack::MockRequest.new(pool)
-
-      res0 = req.get("/")
-      cookie = res0["Set-Cookie"]
-      session_id = Rack::Session::SessionId.new cookie[session_match, 1]
-      ses0 = pool.pool.get(session_id.private_id, true)
-      pool.pool.set(session_id.public_id, ses0, 0, true)
-      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
-    end
-
-    it "drops the session in the legacy id as well" 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("/")
-      cookie = res0["Set-Cookie"]
-      session_id = Rack::Session::SessionId.new cookie[session_match, 1]
-      ses0 = pool.pool.get(session_id.private_id, true)
-      pool.pool.set(session_id.public_id, ses0, 0, true)
-      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
+      ses1.wont_equal ses0
     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 +264,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 +281,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 +303,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'
@@ -5,7 +6,7 @@ require 'rack/session/pool'
 
 describe Rack::Session::Pool do
   session_key = Rack::Session::Pool::DEFAULT_OPTIONS[:key]
-  session_match = /#{session_key}=([0-9a-fA-F]+);/
+  session_match = /#{session_key}=[0-9a-fA-F]+;/
 
   incrementor = lambda do |env|
     env["rack.session"]["counter"] ||= 0
@@ -13,7 +14,7 @@ describe Rack::Session::Pool do
     Rack::Response.new(env["rack.session"].inspect).to_a
   end
 
-  get_session_id = Rack::Lint.new(lambda do |env|
+  session_id = Rack::Lint.new(lambda do |env|
     Rack::Response.new(env["rack.session"].inspect).to_a
   end)
 
@@ -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,52 +138,15 @@ 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
-  end
-
-  it "can read the session with the legacy id" do
-    pool = Rack::Session::Pool.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-
-    res0 = req.get("/")
-    cookie = res0["Set-Cookie"]
-    session_id = Rack::Session::SessionId.new cookie[session_match, 1]
-    ses0 = pool.pool[session_id.private_id]
-    pool.pool[session_id.public_id] = ses0
-    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
-  end
-
-  it "drops the session in the legacy id as well" 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("/")
-    cookie = res0["Set-Cookie"]
-    session_id = Rack::Session::SessionId.new cookie[session_match, 1]
-    ses0 = pool.pool[session_id.private_id]
-    pool.pool[session_id.public_id] = ses0
-    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
+    res1["Set-Cookie"].must_equal nil
+    res1.body.must_equal '{"counter"=>1}'
+    pool.pool.size.must_equal 1
   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 +155,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 +175,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)
+    app = Rack::Session::Pool.new(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