rack 1.4.7 → 1.5.0.beta.1

data/test/spec_nulllogger.rb

@@ -1,23 +1,20 @@
-require 'enumerator'
 require 'rack/lint'
 require 'rack/mock'
 require 'rack/nulllogger'
 
 describe Rack::NullLogger do
-  ::Enumerator = ::Enumerable::Enumerator unless Object.const_defined?(:Enumerator)
-  
   should "act as a noop logger" do
     app = lambda { |env|
       env['rack.logger'].warn "b00m"
       [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]]
     }
-    
+
     logger = Rack::Lint.new(Rack::NullLogger.new(app))
-    
+
     res = logger.call(Rack::MockRequest.env_for)
     res[0..1].should.equal [
       200, {'Content-Type' => 'text/plain'}
     ]
-    Enumerator.new(res[2]).to_a.should.equal ["Hello, World!"]
+    res[2].to_enum.to_a.should.equal ["Hello, World!"]
   end
 end

data/test/spec_request.rb

@@ -2,7 +2,6 @@ require 'stringio'
 require 'cgi'
 require 'rack/request'
 require 'rack/mock'
-require 'securerandom'
 
 describe Rack::Request do
   should "wrap the rack variables" do
@@ -412,6 +411,103 @@ describe Rack::Request do
     req.cookies.should.equal 'foo' => 'bar'
   end
 
+  should "not modify the params hash in place" do
+    e = Rack::MockRequest.env_for("")
+    req1 = Rack::Request.new(e)
+    req1.params.should.equal({})
+    req1.params['foo'] = 'bar'
+    req1.params.should.equal 'foo' => 'bar'
+    req2 = Rack::Request.new(e)
+    req2.params.should.equal({})
+  end
+
+  should "modify params hash if param is in GET" do
+    e = Rack::MockRequest.env_for("?foo=duh")
+    req1 = Rack::Request.new(e)
+    req1.params.should.equal 'foo' => 'duh'
+    req1.update_param 'foo', 'bar'
+    req1.params.should.equal 'foo' => 'bar'
+    req2 = Rack::Request.new(e)
+    req2.params.should.equal 'foo' => 'bar'
+  end
+
+  should "modify params hash if param is in POST" do
+    e = Rack::MockRequest.env_for("", "REQUEST_METHOD" => 'POST', :input => 'foo=duh')
+    req1 = Rack::Request.new(e)
+    req1.params.should.equal 'foo' => 'duh'
+    req1.update_param 'foo', 'bar'
+    req1.params.should.equal 'foo' => 'bar'
+    req2 = Rack::Request.new(e)
+    req2.params.should.equal 'foo' => 'bar'
+  end
+
+  should "modify params hash, even if param didn't exist before" do
+    e = Rack::MockRequest.env_for("")
+    req1 = Rack::Request.new(e)
+    req1.params.should.equal({})
+    req1.update_param 'foo', 'bar'
+    req1.params.should.equal 'foo' => 'bar'
+    req2 = Rack::Request.new(e)
+    req2.params.should.equal 'foo' => 'bar'
+  end
+
+  should "modify params hash by changing only GET" do
+    e = Rack::MockRequest.env_for("?foo=duhget")
+    req = Rack::Request.new(e)
+    req.GET.should.equal 'foo' => 'duhget'
+    req.POST.should.equal({})
+    req.update_param 'foo', 'bar'
+    req.GET.should.equal 'foo' => 'bar'
+    req.POST.should.equal({})
+  end
+
+  should "modify params hash by changing only POST" do
+    e = Rack::MockRequest.env_for("", "REQUEST_METHOD" => 'POST', :input => "foo=duhpost")
+    req = Rack::Request.new(e)
+    req.GET.should.equal({})
+    req.POST.should.equal 'foo' => 'duhpost'
+    req.update_param 'foo', 'bar'
+    req.GET.should.equal({})
+    req.POST.should.equal 'foo' => 'bar'
+  end
+
+  should "modify params hash, even if param is defined in both POST and GET" do
+    e = Rack::MockRequest.env_for("?foo=duhget", "REQUEST_METHOD" => 'POST', :input => "foo=duhpost")
+    req1 = Rack::Request.new(e)
+    req1.GET.should.equal 'foo' => 'duhget'
+    req1.POST.should.equal 'foo' => 'duhpost'
+    req1.params.should.equal 'foo' => 'duhpost'
+    req1.update_param 'foo', 'bar'
+    req1.GET.should.equal 'foo' => 'bar'
+    req1.POST.should.equal 'foo' => 'bar'
+    req1.params.should.equal 'foo' => 'bar'
+    req2 = Rack::Request.new(e)
+    req2.GET.should.equal 'foo' => 'bar'
+    req2.POST.should.equal 'foo' => 'bar'
+    req2.params.should.equal 'foo' => 'bar'
+    req2.params.should.equal 'foo' => 'bar'
+  end
+
+  should "allow deleting from params hash if param is in GET" do
+    e = Rack::MockRequest.env_for("?foo=bar")
+    req1 = Rack::Request.new(e)
+    req1.params.should.equal 'foo' => 'bar'
+    req1.delete_param('foo').should.equal 'bar'
+    req1.params.should.equal({})
+    req2 = Rack::Request.new(e)
+    req2.params.should.equal({})
+  end
+
+  should "allow deleting from params hash if param is in POST" do
+    e = Rack::MockRequest.env_for("", "REQUEST_METHOD" => 'POST', :input => 'foo=bar')
+    req1 = Rack::Request.new(e)
+    req1.params.should.equal 'foo' => 'bar'
+    req1.delete_param('foo').should.equal 'bar'
+    req1.params.should.equal({})
+    req2 = Rack::Request.new(e)
+    req2.params.should.equal({})
+  end
+
   should "pass through non-uri escaped cookies as-is" do
     req = Rack::Request.new Rack::MockRequest.env_for("", "HTTP_COOKIE" => "foo=%")
     req.cookies["foo"].should == "%"
@@ -473,7 +569,10 @@ describe Rack::Request do
       should.equal "http://example.org:8080/"
     Rack::Request.new(Rack::MockRequest.env_for("https://example.org/")).url.
       should.equal "https://example.org/"
-
+    Rack::Request.new(Rack::MockRequest.env_for("coffee://example.org/")).url.
+      should.equal "coffee://example.org/"
+    Rack::Request.new(Rack::MockRequest.env_for("coffee://example.org:443/")).url.
+      should.equal "coffee://example.org:443/"
     Rack::Request.new(Rack::MockRequest.env_for("https://example.com:8080/foo?foo")).url.
       should.equal "https://example.com:8080/foo?foo"
   end
@@ -614,22 +713,6 @@ EOF
     f[:tempfile].size.should.equal 76
   end
 
-  should "MultipartLimitError when request has too many multipart parts if limit set" do
-    begin
-      data = 10000.times.map { "--AaB03x\r\nContent-Type: text/plain\r\nContent-Disposition: attachment; name=#{SecureRandom.hex(10)}; filename=#{SecureRandom.hex(10)}\r\n\r\ncontents\r\n" }.join("\r\n")
-      data += "--AaB03x--\r"
-
-      options = {
-        "CONTENT_TYPE" => "multipart/form-data; boundary=AaB03x",
-        "CONTENT_LENGTH" => data.length.to_s,
-        :input => StringIO.new(data)
-      }
-
-      request = Rack::Request.new Rack::MockRequest.env_for("/", options)
-      lambda { request.POST }.should.raise(Rack::Multipart::MultipartLimitError)
-    end
-  end
-
   should "parse big multipart form data" do
     input = <<EOF
 --AaB03x\r
@@ -909,6 +992,17 @@ EOF
 
     res = mock.get '/', 'HTTP_X_FORWARDED_FOR' => '8.8.8.8, fe80::202:b3ff:fe1e:8329'
     res.body.should.equal 'fe80::202:b3ff:fe1e:8329'
+
+    # Unix Sockets
+    res = mock.get '/',
+      'REMOTE_ADDR' => 'unix',
+      'HTTP_X_FORWARDED_FOR' => '3.4.5.6'
+    res.body.should.equal '3.4.5.6'
+
+    res = mock.get '/',
+      'REMOTE_ADDR' => 'unix:/tmp/foo',
+      'HTTP_X_FORWARDED_FOR' => '3.4.5.6'
+    res.body.should.equal '3.4.5.6'
   end
 
   class MyRequest < Rack::Request

data/test/spec_response.rb

@@ -6,7 +6,7 @@ describe Rack::Response do
     response = Rack::Response.new
     status, header, body = response.finish
     status.should.equal 200
-    header.should.equal "Content-Type" => "text/html"
+    header.should.equal({})
     body.each { |part|
       part.should.equal ""
     }
@@ -14,7 +14,7 @@ describe Rack::Response do
     response = Rack::Response.new
     status, header, body = *response
     status.should.equal 200
-    header.should.equal "Content-Type" => "text/html"
+    header.should.equal({})
     body.each { |part|
       part.should.equal ""
     }
@@ -37,7 +37,7 @@ describe Rack::Response do
 
   it "can set and read headers" do
     response = Rack::Response.new
-    response["Content-Type"].should.equal "text/html"
+    response["Content-Type"].should.equal nil
     response["Content-Type"] = "text/plain"
     response["Content-Type"].should.equal "text/plain"
   end
@@ -92,7 +92,7 @@ describe Rack::Response do
     response.delete_cookie "foo"
     response["Set-Cookie"].should.equal [
       "foo2=bar2",
-      "foo=; expires=Thu, 01-Jan-1970 00:00:00 GMT"
+      "foo=; max-age=0; expires=Thu, 01-Jan-1970 00:00:00 GMT"
     ].join("\n")
   end
 
@@ -102,10 +102,10 @@ describe Rack::Response do
     response.set_cookie "foo", {:value => "bar", :domain => ".example.com"}
     response["Set-Cookie"].should.equal ["foo=bar; domain=sample.example.com", "foo=bar; domain=.example.com"].join("\n")
     response.delete_cookie "foo", :domain => ".example.com"
-    response["Set-Cookie"].should.equal ["foo=bar; domain=sample.example.com", "foo=; domain=.example.com; expires=Thu, 01-Jan-1970 00:00:00 GMT"].join("\n")
+    response["Set-Cookie"].should.equal ["foo=bar; domain=sample.example.com", "foo=; domain=.example.com; max-age=0; expires=Thu, 01-Jan-1970 00:00:00 GMT"].join("\n")
     response.delete_cookie "foo", :domain => "sample.example.com"
-    response["Set-Cookie"].should.equal ["foo=; domain=.example.com; expires=Thu, 01-Jan-1970 00:00:00 GMT",
-                                         "foo=; domain=sample.example.com; expires=Thu, 01-Jan-1970 00:00:00 GMT"].join("\n")
+    response["Set-Cookie"].should.equal ["foo=; domain=.example.com; max-age=0; expires=Thu, 01-Jan-1970 00:00:00 GMT",
+                                         "foo=; domain=sample.example.com; max-age=0; expires=Thu, 01-Jan-1970 00:00:00 GMT"].join("\n")
   end
 
   it "can delete cookies with the same name with different paths" do
@@ -117,7 +117,7 @@ describe Rack::Response do
 
     response.delete_cookie "foo", :path => "/path"
     response["Set-Cookie"].should.equal ["foo=bar; path=/",
-                                         "foo=; path=/path; expires=Thu, 01-Jan-1970 00:00:00 GMT"].join("\n")
+                                         "foo=; path=/path; max-age=0; expires=Thu, 01-Jan-1970 00:00:00 GMT"].join("\n")
   end
 
   it "can do redirects" do

data/test/spec_sendfile.rb

@@ -2,7 +2,6 @@ require 'fileutils'
 require 'rack/lint'
 require 'rack/sendfile'
 require 'rack/mock'
-require 'tmpdir'
 
 describe Rack::File do
   should "respond to #to_path" do
@@ -12,9 +11,9 @@ end
 
 describe Rack::Sendfile do
   def sendfile_body
-    FileUtils.touch File.join(Dir.tmpdir,  "rack_sendfile")
+    FileUtils.touch "/tmp/rack_sendfile"
     res = ['Hello World']
-    def res.to_path ; File.join(Dir.tmpdir,  "rack_sendfile") ; end
+    def res.to_path ; "/tmp/rack_sendfile" ; end
     res
   end
 
@@ -22,14 +21,20 @@ describe Rack::Sendfile do
     lambda { |env| [200, {'Content-Type' => 'text/plain'}, body] }
   end
 
-  def sendfile_app(body=sendfile_body)
-    Rack::Lint.new Rack::Sendfile.new(simple_app(body))
+  def sendfile_app(body, mappings = [])
+    Rack::Lint.new Rack::Sendfile.new(simple_app(body), nil, mappings)
   end
 
-  @request = Rack::MockRequest.new(sendfile_app)
+  def request(headers={}, body=sendfile_body, mappings=[])
+    yield Rack::MockRequest.new(sendfile_app(body, mappings)).get('/', headers)
+  end
 
-  def request(headers={})
-    yield @request.get('/', headers)
+  def open_file(path)
+    Class.new(File) do
+      unless method_defined?(:to_path)
+        alias :to_path :path
+      end
+    end.open(path, 'w+')
   end
 
   it "does nothing when no X-Sendfile-Type header present" do
@@ -45,7 +50,7 @@ describe Rack::Sendfile do
       response.should.be.ok
       response.body.should.be.empty
       response.headers['Content-Length'].should.equal '0'
-      response.headers['X-Sendfile'].should.equal File.join(Dir.tmpdir,  "rack_sendfile")
+      response.headers['X-Sendfile'].should.equal '/tmp/rack_sendfile'
     end
   end
 
@@ -54,14 +59,14 @@ describe Rack::Sendfile do
       response.should.be.ok
       response.body.should.be.empty
       response.headers['Content-Length'].should.equal '0'
-      response.headers['X-Lighttpd-Send-File'].should.equal File.join(Dir.tmpdir,  "rack_sendfile")
+      response.headers['X-Lighttpd-Send-File'].should.equal '/tmp/rack_sendfile'
     end
   end
 
   it "sets X-Accel-Redirect response header and discards body" do
     headers = {
       'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect',
-      'HTTP_X_ACCEL_MAPPING' => "#{Dir.tmpdir}/=/foo/bar/"
+      'HTTP_X_ACCEL_MAPPING' => '/tmp/=/foo/bar/'
     }
     request headers do |response|
       response.should.be.ok
@@ -81,10 +86,44 @@ describe Rack::Sendfile do
   end
 
   it 'does nothing when body does not respond to #to_path' do
-    @request = Rack::MockRequest.new(sendfile_app(['Not a file...']))
-    request 'HTTP_X_SENDFILE_TYPE' => 'X-Sendfile' do |response|
+    request({'HTTP_X_SENDFILE_TYPE' => 'X-Sendfile'}, ['Not a file...']) do |response|
       response.body.should.equal 'Not a file...'
       response.headers.should.not.include 'X-Sendfile'
     end
   end
+
+  it "sets X-Accel-Redirect response header and discards body when initialized with multiple mappings" do
+    begin
+      dir1 = Dir.mktmpdir
+      dir2 = Dir.mktmpdir
+
+      first_body = open_file(File.join(dir1, 'rack_sendfile'))
+      first_body.puts 'hello world'
+
+      second_body = open_file(File.join(dir2, 'rack_sendfile'))
+      second_body.puts 'goodbye world'
+
+      mappings = [
+        ["#{dir1}/", '/foo/bar/'],
+        ["#{dir2}/", '/wibble/']
+      ]
+
+      request({'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect'}, first_body, mappings) do |response|
+        response.should.be.ok
+        response.body.should.be.empty
+        response.headers['Content-Length'].should.equal '0'
+        response.headers['X-Accel-Redirect'].should.equal '/foo/bar/rack_sendfile'
+      end
+
+      request({'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect'}, second_body, mappings) do |response|
+        response.should.be.ok
+        response.body.should.be.empty
+        response.headers['Content-Length'].should.equal '0'
+        response.headers['X-Accel-Redirect'].should.equal '/wibble/rack_sendfile'
+      end
+    ensure
+      FileUtils.remove_entry_secure dir1
+      FileUtils.remove_entry_secure dir2
+    end
+  end
 end

data/test/spec_server.rb

@@ -22,6 +22,12 @@ describe Rack::Server do
     server.app.should == "FOO"
   end
 
+  should "prefer to use :builder when it is passed in" do
+    server = Rack::Server.new(:builder => "run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['success']] }")
+    server.app.class.should == Proc
+    Rack::MockRequest.new(server.app).get("/").body.to_s.should.equal 'success'
+  end
+
   should "not include Rack::Lint in deployment or none environments" do
     server = Rack::Server.new(:app => 'foo')
     server.middleware['deployment'].flatten.should.not.include(Rack::Lint)

data/test/spec_session_abstract_id.rb

@@ -40,4 +40,14 @@ describe Rack::Session::Abstract::ID do
     end
   end
 
-end
+  should "allow to use another securerandom provider" do
+    secure_random = Class.new do
+      def hex(*args)
+        'fake_hex'
+      end
+    end
+    id = Rack::Session::Abstract::ID.new nil, :secure_random => secure_random.new
+    id.send(:generate_sid).should.eql 'fake_hex'
+  end
+
+end

data/test/spec_session_cookie.rb

@@ -121,234 +121,221 @@ describe Rack::Session::Cookie do
       def encode(str); @calls << :encode; str; end
       def decode(str); @calls << :decode; str; end
     }.new
-    cookie = Rack::Session::Cookie.new(incrementor, :coder => identity)
-    res = Rack::MockRequest.new(cookie).get("/")
-    res["Set-Cookie"].should.include("rack.session=")
-    res.body.should.equal '{"counter"=>1}'
+    response = response_for(:app => [incrementor, { :coder => identity }])
+
+    response["Set-Cookie"].should.include("rack.session=")
+    response.body.should.equal '{"counter"=>1}'
     identity.calls.should.equal [:decode, :encode]
   end
 
   it "creates a new cookie" do
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).get("/")
-    res["Set-Cookie"].should.include("rack.session=")
-    res.body.should.equal '{"counter"=>1}'
+    response = response_for(:app => incrementor)
+    response["Set-Cookie"].should.include("rack.session=")
+    response.body.should.equal '{"counter"=>1}'
   end
 
   it "loads from a cookie" do
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).get("/")
-    cookie = res["Set-Cookie"]
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).
-      get("/", "HTTP_COOKIE" => cookie)
-    res.body.should.equal '{"counter"=>2}'
-    cookie = res["Set-Cookie"]
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).
-      get("/", "HTTP_COOKIE" => cookie)
-    res.body.should.equal '{"counter"=>3}'
-  end
+    response = response_for(:app => incrementor)
 
-  renewer = lambda do |env|
-    env["rack.session.options"][:renew] = true
-    Rack::Response.new("Nothing").to_a
-  end
+    response = response_for(:app => incrementor, :cookie => response)
+    response.body.should.equal '{"counter"=>2}'
 
-  only_session_id = lambda do |env|
-    Rack::Response.new(env["rack.session"]["session_id"].to_s).to_a
+    response = response_for(:app => incrementor, :cookie => response)
+    response.body.should.equal '{"counter"=>3}'
   end
 
   it "renew session id" do
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).get("/")
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(only_session_id)).
-      get("/", "HTTP_COOKIE" => res["Set-Cookie"])
+    response = response_for(:app => incrementor)
+    cookie   = response['Set-Cookie']
+    response = response_for(:app => only_session_id, :cookie => cookie)
+    cookie   = response['Set-Cookie'] if response['Set-Cookie']
 
-    res.body.should.not.equal ""
-    old_session_id = res.body
+    response.body.should.not.equal ""
+    old_session_id = response.body
 
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(renewer)).
-      get("/", "HTTP_COOKIE" => res["Set-Cookie"])
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(only_session_id)).
-      get("/", "HTTP_COOKIE" => res["Set-Cookie"])
+    response = response_for(:app => renewer, :cookie => cookie)
+    cookie   = response['Set-Cookie'] if response['Set-Cookie']
+    response = response_for(:app => only_session_id, :cookie => cookie)
 
-    res.body.should.not.equal ""
-    res.body.should.not.equal old_session_id
+    response.body.should.not.equal ""
+    response.body.should.not.equal old_session_id
   end
 
-  it "survives broken cookies" do
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).
-      get("/", "HTTP_COOKIE" => "rack.session=blarghfasel")
-    res.body.should.equal '{"counter"=>1}'
+  it "destroys session" do
+    response = response_for(:app => incrementor)
+    response = response_for(:app => only_session_id, :cookie => response)
+
+    response.body.should.not.equal ""
+    old_session_id = response.body
 
-    app = Rack::Session::Cookie.new(incrementor, :secret => 'test')
-    res = Rack::MockRequest.new(app).get("/", "HTTP_COOKIE" => "rack.session=")
-    res.body.should.equal '{"counter"=>1}'
+    response = response_for(:app => destroy_session, :cookie => response)
+    response = response_for(:app => only_session_id, :cookie => response)
+
+    response.body.should.not.equal ""
+    response.body.should.not.equal old_session_id
   end
 
-  bigcookie = lambda do |env|
-    env["rack.session"]["cookie"] = "big" * 3000
-    Rack::Response.new(env["rack.session"].inspect).to_a
+  it "survives broken cookies" do
+    response = response_for(
+      :app => incrementor,
+      :cookie => "rack.session=blarghfasel"
+    )
+    response.body.should.equal '{"counter"=>1}'
+
+    response = response_for(
+      :app => [incrementor, { :secret => "test" }],
+      :cookie => "rack.session="
+    )
+    response.body.should.equal '{"counter"=>1}'
   end
 
   it "barks on too big cookies" do
     lambda{
-      Rack::MockRequest.new(Rack::Session::Cookie.new(bigcookie)).
-        get("/", :fatal => true)
+      response_for(:app => bigcookie, :request => { :fatal => true })
     }.should.raise(Rack::MockRequest::FatalWarning)
   end
 
   it "loads from a cookie with integrity hash" do
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).get("/")
-    cookie = res["Set-Cookie"]
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).
-      get("/", "HTTP_COOKIE" => cookie)
-    res.body.should.equal '{"counter"=>2}'
-    cookie = res["Set-Cookie"]
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).
-      get("/", "HTTP_COOKIE" => cookie)
-    res.body.should.equal '{"counter"=>3}'
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'other')).
-      get("/", "HTTP_COOKIE" => cookie)
-    res.body.should.equal '{"counter"=>1}'
+    app = [incrementor, { :secret => "test" }]
+
+    response = response_for(:app => app)
+    response = response_for(:app => app, :cookie => response)
+    response.body.should.equal '{"counter"=>2}'
+
+    response = response_for(:app => app, :cookie => response)
+    response.body.should.equal '{"counter"=>3}'
+
+    app = [incrementor, { :secret => "other" }]
+
+    response = response_for(:app => app, :cookie => response)
+    response.body.should.equal '{"counter"=>1}'
   end
 
   it "loads from a cookie wih accept-only integrity hash for graceful key rotation" do
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).get("/")
-    cookie = res["Set-Cookie"]
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test2', :old_secret => 'test')).
-      get("/", "HTTP_COOKIE" => cookie)
-    res.body.should.equal '{"counter"=>2}'
-    cookie = res["Set-Cookie"]
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test3', :old_secret => 'test2')).
-      get("/", "HTTP_COOKIE" => cookie)
-    res.body.should.equal '{"counter"=>3}'
+    response = response_for(:app => [incrementor, { :secret => "test" }])
+
+    app = [incrementor, { :secret => "test2", :old_secret => "test" }]
+    response = response_for(:app => app, :cookie => response)
+    response.body.should.equal '{"counter"=>2}'
+
+    app = [incrementor, { :secret => "test3", :old_secret => "test2" }]
+    response = response_for(:app => app, :cookie => response)
+    response.body.should.equal '{"counter"=>3}'
   end
 
   it "ignores tampered with session cookies" do
-    app = Rack::Session::Cookie.new(incrementor, :secret => 'test')
-    response1 = Rack::MockRequest.new(app).get("/")
-    response1.body.should.equal '{"counter"=>1}'
-    response1 = Rack::MockRequest.new(app).get("/", "HTTP_COOKIE" => response1["Set-Cookie"])
-    response1.body.should.equal '{"counter"=>2}'
+    app = [incrementor, { :secret => "test" }]
+    response = response_for(:app => app)
+    response.body.should.equal '{"counter"=>1}'
+
+    response = response_for(:app => app, :cookie => response)
+    response.body.should.equal '{"counter"=>2}'
 
-    _, digest = response1["Set-Cookie"].split("--")
+    _, digest = response["Set-Cookie"].split("--")
     tampered_with_cookie = "hackerman-was-here" + "--" + digest
-    response2 = Rack::MockRequest.new(app).get("/", "HTTP_COOKIE" =>
-                                               tampered_with_cookie)
 
-    # Tampered cookie was ignored. Counter is back to 1.
-    response2.body.should.equal '{"counter"=>1}'
+    response = response_for(:app => app, :cookie => tampered_with_cookie)
+    response.body.should.equal '{"counter"=>1}'
   end
 
   it "supports either of secret or old_secret" do
-    app = Rack::Session::Cookie.new(incrementor, :secret => 'test')
-    res = Rack::MockRequest.new(app).get("/")
-    res.body.should.equal '{"counter"=>1}'
-    res = Rack::MockRequest.new(app).get("/", "HTTP_COOKIE" => res["Set-Cookie"])
-    res.body.should.equal '{"counter"=>2}'
-    app = Rack::Session::Cookie.new(incrementor, :old_secret => 'test')
-    res = Rack::MockRequest.new(app).get("/")
-    res.body.should.equal '{"counter"=>1}'
-    res = Rack::MockRequest.new(app).get("/", "HTTP_COOKIE" => res["Set-Cookie"])
-    res.body.should.equal '{"counter"=>2}'
-  end
-
-  describe "1.9 bugs relating to inspecting yet-to-be-loaded from cookie data: Rack::Session::Abstract::SessionHash" do
-
-    it "can handle Rack::Lint middleware" do
-      app = Rack::Session::Cookie.new(incrementor)
-      res = Rack::MockRequest.new(app).get("/")
-
-      app = Rack::Session::Cookie.new(Rack::Lint.new(session_id))
-      res = Rack::MockRequest.new(app).get("/", "HTTP_COOKIE" => res["Set-Cookie"])
-      res.body.should.not.be.nil
-    end
+    app = [incrementor, { :secret => "test" }]
+    response = response_for(:app => app)
+    response.body.should.equal '{"counter"=>1}'
 
-    it "can handle a middleware that inspects the env" do
-      class TestEnvInspector
-        def initialize(app)
-          @app = app
-        end
-        def call(env)
-          env.inspect
-          @app.call(env)
-        end
-      end
+    response = response_for(:app => app, :cookie => response)
+    response.body.should.equal '{"counter"=>2}'
 
-      app = Rack::Session::Cookie.new(incrementor)
-      res = Rack::MockRequest.new(app).get("/")
+    app = [incrementor, { :old_secret => "test" }]
+    response = response_for(:app => app)
+    response.body.should.equal '{"counter"=>1}'
+
+    response = response_for(:app => app, :cookie => response)
+    response.body.should.equal '{"counter"=>2}'
+  end
+
+  it "can handle Rack::Lint middleware" do
+    response = response_for(:app => incrementor)
+
+    lint = Rack::Lint.new(session_id)
+    response = response_for(:app => lint, :cookie => response)
+    response.body.should.not.be.nil
+  end
 
-      app = Rack::Session::Cookie.new(TestEnvInspector.new(session_id))
-      res = Rack::MockRequest.new(app).get("/", "HTTP_COOKIE" => res["Set-Cookie"])
-      res.body.should.not.be.nil
+  it "can handle middleware that inspects the env" do
+    class TestEnvInspector
+      def initialize(app)
+        @app = app
+      end
+      def call(env)
+        env.inspect
+        @app.call(env)
+      end
     end
 
+    response = response_for(:app => incrementor)
+
+    inspector = TestEnvInspector.new(session_id)
+    response = response_for(:app => inspector, :cookie => response)
+    response.body.should.not.be.nil
   end
 
   it "returns the session id in the session hash" do
-    app = Rack::Session::Cookie.new(incrementor)
-    res = Rack::MockRequest.new(app).get("/")
-    res.body.should.equal '{"counter"=>1}'
+    response = response_for(:app => incrementor)
+    response.body.should.equal '{"counter"=>1}'
 
-    app = Rack::Session::Cookie.new(session_id)
-    res = Rack::MockRequest.new(app).get("/", "HTTP_COOKIE" => res["Set-Cookie"])
-    res.body.should.match(/"session_id"=>/)
-    res.body.should.match(/"counter"=>1/)
+    response = response_for(:app => session_id, :cookie => response)
+    response.body.should.match(/"session_id"=>/)
+    response.body.should.match(/"counter"=>1/)
   end
 
   it "does not return a cookie if set to secure but not using ssl" do
-    app = Rack::Session::Cookie.new(incrementor, :secure => true)
-    res = Rack::MockRequest.new(app).get("/")
-    res["Set-Cookie"].should.be.nil
+    app = [incrementor, { :secure => true }]
 
-    res = Rack::MockRequest.new(app).get("/", "HTTPS" => "on")
-    res["Set-Cookie"].should.not.be.nil
-    res["Set-Cookie"].should.match(/secure/)
+    response = response_for(:app => app)
+    response["Set-Cookie"].should.be.nil
+
+    response = response_for(:app => app, :request => { "HTTPS" => "on" })
+    response["Set-Cookie"].should.not.be.nil
+    response["Set-Cookie"].should.match(/secure/)
   end
 
   it "does not return a cookie if cookie was not read/written" do
-    app = Rack::Session::Cookie.new(nothing)
-    res = Rack::MockRequest.new(app).get("/")
-    res["Set-Cookie"].should.be.nil
+    response = response_for(:app => nothing)
+    response["Set-Cookie"].should.be.nil
   end
 
   it "does not return a cookie if cookie was not written (only read)" do
-    app = Rack::Session::Cookie.new(session_id)
-    res = Rack::MockRequest.new(app).get("/")
-    res["Set-Cookie"].should.be.nil
+    response = response_for(:app => session_id)
+    response["Set-Cookie"].should.be.nil
   end
 
   it "returns even if not read/written if :expire_after is set" do
-    app = Rack::Session::Cookie.new(nothing, :expire_after => 3600)
-    res = Rack::MockRequest.new(app).get("/", 'rack.session' => {'not' => 'empty'})
-    res["Set-Cookie"].should.not.be.nil
+    app = [nothing, { :expire_after => 3600 }]
+    request = { "rack.session" => { "not" => "empty" }}
+    response = response_for(:app => app, :request => request)
+    response["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::Cookie.new(nothing, :expire_after => 3600)
-    res = Rack::MockRequest.new(app).get("/")
-    res["Set-Cookie"].should.be.nil
+    app = [nothing, { :expire_after => 3600 }]
+    response = response_for(:app => app)
+    response["Set-Cookie"].should.be.nil
   end
 
   it "exposes :secret in env['rack.session.option']" do
-    app = Rack::Session::Cookie.new(session_option[:secret], :secret => "foo")
-    res = Rack::MockRequest.new(app).get("/")
-    res.body.should == '"foo"'
+    response = response_for(:app => [session_option[:secret], { :secret => "foo" }])
+    response.body.should == '"foo"'
   end
 
   it "exposes :coder in env['rack.session.option']" do
-    app = Rack::Session::Cookie.new(session_option[:coder])
-    res = Rack::MockRequest.new(app).get("/")
-    res.body.should.match(/Base64::Marshal/)
+    response = response_for(:app => session_option[:coder])
+    response.body.should.match(/Base64::Marshal/)
   end
 
   it "allows passing in a hash with session data from middleware in front" do
-    app = Rack::Session::Cookie.new(session_id)
-    res = Rack::MockRequest.new(app).get("/", 'rack.session' => {:foo => 'bar'})
-    res.body.should.match(/foo/)
-  end
-
-  it "allows modifying session data with session data from middleware in front" do
     request = { 'rack.session' => { :foo => 'bar' }}
-    response = response_for(:app => incrementor, :request => request)
-    response.body.should.match(/counter/)
+    response = response_for(:app => session_id, :request => request)
     response.body.should.match(/foo/)
   end