rack 0.9.1 → 1.0.0

data/test/spec_rack_lock.rb

@@ -0,0 +1,38 @@
+require 'test/spec'
+
+require 'rack/mock'
+require 'rack/lock'
+
+context "Rack::Lock" do
+  class Lock
+    attr_reader :synchronized
+
+    def initialize
+      @synchronized = false
+    end
+
+    def synchronize
+      @synchronized = true
+      yield
+    end
+  end
+
+  specify "should call synchronize on lock" do
+    lock = Lock.new
+    env = Rack::MockRequest.env_for("/")
+    app = Rack::Lock.new(lambda { |env| }, lock)
+    lock.synchronized.should.equal false
+    app.call(env)
+    lock.synchronized.should.equal true
+  end
+
+  specify "should set multithread flag to false" do
+    app = Rack::Lock.new(lambda { |env| env['rack.multithread'] })
+    app.call(Rack::MockRequest.env_for("/")).should.equal false
+  end
+
+  specify "should reset original multithread flag when exiting lock" do
+    app = Rack::Lock.new(lambda { |env| env })
+    app.call(Rack::MockRequest.env_for("/"))['rack.multithread'].should.equal true
+  end
+end

data/test/spec_rack_mock.rb

@@ -64,6 +64,11 @@ context "Rack::MockRequest" do
       should.equal "OPTIONS"
   end
 
+  specify "should set content length" do
+    env = Rack::MockRequest.env_for("/", :input => "foo")
+    env["CONTENT_LENGTH"].should.equal "3"
+  end
+
   specify "should allow posting" do
     res = Rack::MockRequest.new(app).get("", :input => "foo")
     env = YAML.load(res.body)
@@ -125,7 +130,7 @@ context "Rack::MockResponse" do
     res.original_headers["Content-Type"].should.equal "text/yaml"
     res["Content-Type"].should.equal "text/yaml"
     res.content_type.should.equal "text/yaml"
-    res.content_length.should.be 381  # needs change often.
+    res.content_length.should.be 464  # needs change often.
     res.location.should.be.nil
   end
 

data/test/spec_rack_request.rb

@@ -25,7 +25,7 @@ context "Rack::Request" do
     req.host.should.equal "example.com"
     req.port.should.equal 8080
 
-    req.content_length.should.be.nil
+    req.content_length.should.equal "0"
     req.content_type.should.be.nil
   end
 
@@ -93,14 +93,10 @@ context "Rack::Request" do
     input.read.should.equal "foo=bar&quux=bla"
   end
 
-  specify "does not rewind unwindable CGI input" do
-    input = StringIO.new("foo=bar&quux=bla")
-    input.instance_eval "undef :rewind"
+  specify "cleans up Safari's ajax POST body" do
     req = Rack::Request.new \
-      Rack::MockRequest.env_for("/",
-        "CONTENT_TYPE" => 'application/x-www-form-urlencoded;foo=bar',
-        :input => input)
-    req.params.should.equal "foo" => "bar", "quux" => "bla"
+      Rack::MockRequest.env_for("/", :input => "foo=bar&quux=bla\0")
+    req.POST.should.equal "foo" => "bar", "quux" => "bla"
   end
 
   specify "can get value by key from params with #[]" do
@@ -354,6 +350,33 @@ EOF
     lambda { req.POST }.should.raise(EOFError)
   end
 
+  specify "shouldn't try to interpret binary as utf8" do
+    begin
+      original_kcode = $KCODE
+      $KCODE='UTF8'
+
+      input = <<EOF
+--AaB03x\r
+content-disposition: form-data; name="fileupload"; filename="junk.a"\r
+content-type: application/octet-stream\r
+\r
+#{[0x36,0xCF,0x0A,0xF8].pack('c*')}\r
+--AaB03x--\r
+EOF
+
+      req = Rack::Request.new Rack::MockRequest.env_for("/",
+                        "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x",
+                        "CONTENT_LENGTH" => input.size,
+                        :input => input)
+
+      lambda{req.POST}.should.not.raise(EOFError)
+      req.POST["fileupload"][:tempfile].size.should.equal 4
+    ensure
+      $KCODE = original_kcode
+    end
+  end
+
+
   specify "should work around buggy 1.8.* Tempfile equality" do
     input = <<EOF
 --AaB03x\r
@@ -380,7 +403,7 @@ EOF
     app = lambda { |env|
       content = Rack::Request.new(env).POST["file"].inspect
       size = content.respond_to?(:bytesize) ? content.bytesize : content.size
-      [200, {"Content-Type" => "text/html", "Content-Length" => size.to_s}, content]
+      [200, {"Content-Type" => "text/html", "Content-Length" => size.to_s}, [content]]
     }
 
     input = <<EOF
@@ -429,18 +452,64 @@ EOF
 
     mock = Rack::MockRequest.new(Rack::Lint.new(app))
     res = mock.get '/', 'REMOTE_ADDR' => '123.123.123.123'
-    res.body.should == '123.123.123.123'
+    res.body.should.equal '123.123.123.123'
 
     res = mock.get '/',
       'REMOTE_ADDR' => '123.123.123.123',
       'HTTP_X_FORWARDED_FOR' => '234.234.234.234'
 
-    res.body.should == '234.234.234.234'
+    res.body.should.equal '234.234.234.234'
 
     res = mock.get '/',
       'REMOTE_ADDR' => '123.123.123.123',
       'HTTP_X_FORWARDED_FOR' => '234.234.234.234,212.212.212.212'
 
-    res.body.should == '212.212.212.212'
+    res.body.should.equal '212.212.212.212'
+  end
+
+  specify "memoizes itself to reduce the cost of repetitive initialization" do
+    env = Rack::MockRequest.env_for("http://example.com:8080/")
+    env['rack.request'].should.be.nil
+
+    req1 = Rack::Request.new(env)
+    env['rack.request'].should.not.be.nil
+    req1.should.equal env['rack.request']
+
+    rack_request_object_id = env['rack.request'].object_id
+
+    req2 = Rack::Request.new(env)
+    env['rack.request'].should.not.be.nil
+    rack_request_object_id.should.be.equal env['rack.request'].object_id
+    req2.should.equal env['rack.request']
+  end
+
+  class MyRequest < Rack::Request
+    def params
+      {:foo => "bar"}
+    end
+  end
+
+  specify "should allow subclass request to be instantiated after parent request" do
+    env = Rack::MockRequest.env_for("/?foo=bar")
+
+    req1 = Rack::Request.new(env)
+    req1.GET.should.equal "foo" => "bar"
+    req1.params.should.equal "foo" => "bar"
+
+    req2 = MyRequest.new(env)
+    req2.GET.should.equal "foo" => "bar"
+    req2.params.should.equal :foo => "bar"
+  end
+
+  specify "should allow parent request to be instantiated after subclass request" do
+    env = Rack::MockRequest.env_for("/?foo=bar")
+
+    req1 = MyRequest.new(env)
+    req1.GET.should.equal "foo" => "bar"
+    req1.params.should.equal :foo => "bar"
+
+    req2 = Rack::Request.new(env)
+    req2.GET.should.equal "foo" => "bar"
+    req2.params.should.equal "foo" => "bar"
   end
 end

data/test/spec_rack_response.rb

@@ -8,7 +8,7 @@ context "Rack::Response" do
     response = Rack::Response.new
     status, header, body = response.finish
     status.should.equal 200
-    header.should.equal "Content-Type" => "text/html", "Content-Length" => "0"
+    header.should.equal "Content-Type" => "text/html"
     body.each { |part|
       part.should.equal ""
     }
@@ -16,7 +16,7 @@ context "Rack::Response" do
     response = Rack::Response.new
     status, header, body = *response
     status.should.equal 200
-    header.should.equal "Content-Type" => "text/html", "Content-Length" => "0"
+    header.should.equal "Content-Type" => "text/html"
     body.each { |part|
       part.should.equal ""
     }
@@ -69,6 +69,12 @@ context "Rack::Response" do
     response["Set-Cookie"].should.equal "foo=bar; secure"
   end
 
+  specify "can set http only cookies" do
+    response = Rack::Response.new
+    response.set_cookie "foo", {:value => "bar", :httponly => true}
+    response["Set-Cookie"].should.equal "foo=bar; HttpOnly"
+  end
+
   specify "can delete cookies" do
     response = Rack::Response.new
     response.set_cookie "foo", "bar"
@@ -78,6 +84,21 @@ context "Rack::Response" do
                                   "foo=; expires=Thu, 01-Jan-1970 00:00:00 GMT"]
   end
 
+  specify "can do redirects" do
+    response = Rack::Response.new
+    response.redirect "/foo"
+    status, header, body = response.finish
+
+    status.should.equal 302
+    header["Location"].should.equal "/foo"
+
+    response = Rack::Response.new
+    response.redirect "/foo", 307
+    status, header, body = response.finish
+
+    status.should.equal 307
+  end
+
   specify "has a useful constructor" do
     r = Rack::Response.new("foo")
     status, header, body = r.finish
@@ -171,4 +192,27 @@ context "Rack::Response" do
     res.location.should.be.nil
   end
 
+  specify "does not add or change Content-Length when #finish()ing" do
+    res = Rack::Response.new
+    res.status = 200
+    res.finish
+    res.headers["Content-Length"].should.be.nil
+
+    res = Rack::Response.new
+    res.status = 200
+    res.headers["Content-Length"] = "10"
+    res.finish
+    res.headers["Content-Length"].should.equal "10"
+  end
+
+  specify "updates Content-Length when body appended to using #write" do
+    res = Rack::Response.new
+    res.status = 200
+    res.headers["Content-Length"].should.be.nil
+    res.write "Hi"
+    res.headers["Content-Length"].should.equal "2"
+    res.write " there"
+    res.headers["Content-Length"].should.equal "8"
+  end
+
 end

data/test/spec_rack_rewindable_input.rb

@@ -0,0 +1,118 @@
+require 'test/spec'
+require 'stringio'
+require 'rack/rewindable_input'
+
+shared_context "a rewindable IO object" do
+  setup do
+    @rio = Rack::RewindableInput.new(@io)
+  end
+  
+  teardown do
+    @rio.close
+  end
+  
+  specify "should be able to handle to read()" do
+    @rio.read.should.equal "hello world"
+  end
+  
+  specify "should be able to handle to read(nil)" do
+    @rio.read(nil).should.equal "hello world"
+  end
+  
+  specify "should be able to handle to read(length)" do
+    @rio.read(1).should.equal "h"
+  end
+  
+  specify "should be able to handle to read(length, buffer)" do
+    buffer = ""
+    result = @rio.read(1, buffer)
+    result.should.equal "h"
+    result.object_id.should.equal buffer.object_id
+  end
+  
+  specify "should be able to handle to read(nil, buffer)" do
+    buffer = ""
+    result = @rio.read(nil, buffer)
+    result.should.equal "hello world"
+    result.object_id.should.equal buffer.object_id
+  end
+  
+  specify "should rewind to the beginning when #rewind is called" do
+    @rio.read(1)
+    @rio.rewind
+    @rio.read.should.equal "hello world"
+  end
+  
+  specify "should be able to handle gets" do
+    @rio.gets.should == "hello world"
+  end
+  
+  specify "should be able to handle each" do
+    array = []
+    @rio.each do |data|
+      array << data
+    end
+    array.should.equal(["hello world"])
+  end
+  
+  specify "should not buffer into a Tempfile if no data has been read yet" do
+    @rio.instance_variable_get(:@rewindable_io).should.be.nil
+  end
+  
+  specify "should buffer into a Tempfile when data has been consumed for the first time" do
+    @rio.read(1)
+    tempfile = @rio.instance_variable_get(:@rewindable_io)
+    tempfile.should.not.be.nil
+    @rio.read(1)
+    tempfile2 = @rio.instance_variable_get(:@rewindable_io)
+    tempfile2.should.equal tempfile
+  end
+  
+  specify "should close the underlying tempfile upon calling #close" do
+    @rio.read(1)
+    tempfile = @rio.instance_variable_get(:@rewindable_io)
+    @rio.close
+    tempfile.should.be.closed
+  end
+  
+  specify "should be possibel to call #close when no data has been buffered yet" do
+    @rio.close
+  end
+  
+  specify "should be possible to call #close multiple times" do
+    @rio.close
+    @rio.close
+  end
+end
+
+context "Rack::RewindableInput" do
+  context "given an IO object that is already rewindable" do
+    setup do
+      @io = StringIO.new("hello world")
+    end
+    
+    it_should_behave_like "a rewindable IO object"
+  end
+  
+  context "given an IO object that is not rewindable" do
+    setup do
+      @io = StringIO.new("hello world")
+      @io.instance_eval do
+        undef :rewind
+      end
+    end
+    
+    it_should_behave_like "a rewindable IO object"
+  end
+  
+  context "given an IO object whose rewind method raises Errno::ESPIPE" do
+    setup do
+      @io = StringIO.new("hello world")
+      def @io.rewind
+        raise Errno::ESPIPE, "You can't rewind this!"
+      end
+    end
+    
+    it_should_behave_like "a rewindable IO object"
+  end
+end

data/test/spec_rack_session_memcache.rb

@@ -7,18 +7,28 @@ begin
   require 'thread'
 
   context "Rack::Session::Memcache" do
-    incrementor = lambda { |env|
+    session_key = Rack::Session::Memcache::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
-    }
-
-    # Keep this first.
-    specify "startup" do
-      $pid = fork {
-        exec "memcached"
-      }
-      sleep 1
+    end
+    drop_session = proc do |env|
+      env['rack.session.options'][:drop] = true
+      incrementor.call(env)
+    end
+    renew_session = proc do |env|
+      env['rack.session.options'][:renew] = true
+      incrementor.call(env)
+    end
+    defer_session = proc do |env|
+      env['rack.session.options'][:defer] = true
+      incrementor.call(env)
+    end
+
+    specify "MemCache can connect to existing server" do
+      test_pool = MemCache.new :namespace => 'test:rack:session'
     end
 
     specify "faults on no connection" do
@@ -28,104 +38,202 @@ begin
     end
 
     specify "creates a new cookie" do
-      cache = Rack::Session::Memcache.new(incrementor)
-      res = Rack::MockRequest.new(cache).get("/")
-      res["Set-Cookie"].should.match("rack.session=")
+      pool = Rack::Session::Memcache.new(incrementor)
+      res = Rack::MockRequest.new(pool).get("/")
+      res["Set-Cookie"].should.match("#{session_key}=")
       res.body.should.equal '{"counter"=>1}'
     end
 
     specify "determines session from a cookie" do
-      cache = Rack::Session::Memcache.new(incrementor)
-      res = Rack::MockRequest.new(cache).get("/")
+      pool = Rack::Session::Memcache.new(incrementor)
+      req = Rack::MockRequest.new(pool)
+      res = req.get("/")
       cookie = res["Set-Cookie"]
-      res = Rack::MockRequest.new(cache).get("/", "HTTP_COOKIE" => cookie)
-      res.body.should.equal '{"counter"=>2}'
-      res = Rack::MockRequest.new(cache).get("/", "HTTP_COOKIE" => cookie)
-      res.body.should.equal '{"counter"=>3}'
+      req.get("/", "HTTP_COOKIE" => cookie).
+        body.should.equal '{"counter"=>2}'
+      req.get("/", "HTTP_COOKIE" => cookie).
+        body.should.equal '{"counter"=>3}'
     end
 
-    specify "survives broken cookies" do
-      cache = Rack::Session::Memcache.new(incrementor)
-      res = Rack::MockRequest.new(cache).
-        get("/", "HTTP_COOKIE" => "rack.session=blarghfasel")
+    specify "survives nonexistant cookies" do
+      bad_cookie = "rack.session=blarghfasel"
+      pool = Rack::Session::Memcache.new(incrementor)
+      res = Rack::MockRequest.new(pool).
+        get("/", "HTTP_COOKIE" => bad_cookie)
       res.body.should.equal '{"counter"=>1}'
+      cookie = res["Set-Cookie"][session_match]
+      cookie.should.not.match(/#{bad_cookie}/)
     end
 
     specify "maintains freshness" do
-      cache = Rack::Session::Memcache.new(incrementor, :expire_after => 3)
-      res = Rack::MockRequest.new(cache).get('/')
+      pool = Rack::Session::Memcache.new(incrementor, :expire_after => 3)
+      res = Rack::MockRequest.new(pool).get('/')
       res.body.should.include '"counter"=>1'
       cookie = res["Set-Cookie"]
-      res = Rack::MockRequest.new(cache).get('/', "HTTP_COOKIE" => cookie)
+      res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
       res["Set-Cookie"].should.equal cookie
       res.body.should.include '"counter"=>2'
       puts 'Sleeping to expire session' if $DEBUG
       sleep 4
-      res = Rack::MockRequest.new(cache).get('/', "HTTP_COOKIE" => cookie)
+      res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
       res["Set-Cookie"].should.not.equal cookie
       res.body.should.include '"counter"=>1'
     end
 
+    specify "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)
+
+      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}'
+
+      res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
+      res2["Set-Cookie"].should.equal nil
+      res2.body.should.equal '{"counter"=>3}'
+
+      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
+      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}'
+
+      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}'
+
+      res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
+      res3["Set-Cookie"][session_match].should.equal new_session
+      res3.body.should.equal '{"counter"=>4}'
+    end
+
+    specify "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)
+      dreq = Rack::MockRequest.new(defer)
+
+      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}'
+
+      res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
+      res2["Set-Cookie"].should.equal nil
+      res2.body.should.equal '{"counter"=>3}'
+
+      res3 = req.get("/", "HTTP_COOKIE" => cookie)
+      res3["Set-Cookie"][session_match].should.equal session
+      res3.body.should.equal '{"counter"=>4}'
+    end
+
+    # anyone know how to do this better?
     specify "multithread: should cleanly merge sessions" do
-      cache = Rack::Session::Memcache.new(incrementor)
-      drop_counter = Rack::Session::Memcache.new(proc do |env|
-        env['rack.session'].delete 'counter'
-        env['rack.session']['foo'] = 'bar'
-        [200, {'Content-Type'=>'text/plain'}, env['rack.session'].inspect]
-      end)
+      next unless $DEBUG
+      warn 'Running multithread test for Session::Memcache'
+      pool = Rack::Session::Memcache.new(incrementor)
+      req = Rack::MockRequest.new(pool)
 
-      res = Rack::MockRequest.new(cache).get('/')
+      res = req.get('/')
       res.body.should.equal '{"counter"=>1}'
       cookie = res["Set-Cookie"]
-      sess_id = cookie[/#{cache.key}=([^,;]+)/, 1]
+      sess_id = cookie[/#{pool.key}=([^,;]+)/,1]
+
+      delta_incrementor = lambda do |env|
+        # emulate disconjoinment of threading
+        env['rack.session'] = env['rack.session'].dup
+        Thread.stop
+        env['rack.session'][(Time.now.usec*rand).to_i] = true
+        incrementor.call(env)
+      end
+      tses = Rack::Utils::Context.new pool, delta_incrementor
+      treq = Rack::MockRequest.new(tses)
+      tnum = rand(7).to_i+5
+      r = Array.new(tnum) do
+        Thread.new(treq) do |run|
+          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'
+      end
 
-      res = Rack::MockRequest.new(cache).get('/', "HTTP_COOKIE" => cookie)
-      res.body.should.equal '{"counter"=>2}'
+      session = pool.pool.get(sess_id)
+      session.size.should.be tnum+1 # counter
+      session['counter'].should.be 2 # meeeh
 
-      r = Array.new(rand(7).to_i+2) do |i|
-        app = proc do |env|
+      tnum = rand(7).to_i+5
+      r = Array.new(tnum) do |i|
+        delta_time = proc do |env|
           env['rack.session'][i]  = Time.now
-          sleep 2
+          Thread.stop
           env['rack.session']     = env['rack.session'].dup
           env['rack.session'][i] -= Time.now
           incrementor.call(env)
         end
-        Thread.new(cache.context(app)) do |run|
-          Rack::MockRequest.new(run).
-            get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+        app = Rack::Utils::Context.new pool, time_delta
+        req = Rack::MockRequest.new app
+        Thread.new(req) do |run|
+          run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
         end
-      end
-
-      r.reverse!
-
-      r.map! do |t|
-        p t if $DEBUG
-        t.join.value
-      end
-
+      end.reverse.map{|t| t.run.join.value }
       r.each do |res|
         res['Set-Cookie'].should.equal cookie
         res.body.should.include '"counter"=>3'
       end
 
-      session = cache.pool[sess_id]
-      session.size.should.be r.size+1
+      session = pool.pool.get(sess_id)
+      session.size.should.be tnum+1
       session['counter'].should.be 3
 
-      res = Rack::MockRequest.new(drop_counter).get('/', "HTTP_COOKIE" => cookie)
-      res.body.should.include '"foo"=>"bar"'
+      drop_counter = proc do |env|
+        env['rack.session'].delete 'counter'
+        env['rack.session']['foo'] = 'bar'
+        [200, {'Content-Type'=>'text/plain'}, env['rack.session'].inspect]
+      end
+      tses = Rack::Utils::Context.new pool, drop_counter
+      treq = Rack::MockRequest.new(tses)
+      tnum = rand(7).to_i+5
+      r = Array.new(tnum) do
+        Thread.new(treq) do |run|
+          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 '"foo"=>"bar"'
+      end
 
-      session = cache.pool[sess_id]
+      session = pool.pool.get(sess_id)
       session.size.should.be r.size+1
       session['counter'].should.be.nil?
       session['foo'].should.equal 'bar'
     end
-
-    # Keep this last.
-    specify "shutdown" do
-      Process.kill 15, $pid
-      Process.wait($pid).should.equal $pid
-    end
   end
 rescue LoadError
   $stderr.puts "Skipping Rack::Session::Memcache tests (Memcache is required). `gem install memcache-client` and try again."