rack 0.9.1 → 1.0.0

data/test/spec_rack_session_pool.rb

@@ -6,51 +6,145 @@ require 'rack/response'
 require 'thread'
 
 context "Rack::Session::Pool" do
-  incrementor = lambda { |env|
+  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|
+    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 "creates a new cookie" do
     pool = Rack::Session::Pool.new(incrementor)
     res = Rack::MockRequest.new(pool).get("/")
-    res["Set-Cookie"].should.match("rack.session=")
+    res["Set-Cookie"].should.match session_match
     res.body.should.equal '{"counter"=>1}'
   end
 
   specify "determines session from a cookie" do
     pool = Rack::Session::Pool.new(incrementor)
-    res = Rack::MockRequest.new(pool).get("/")
-    cookie = res["Set-Cookie"]
-    res = Rack::MockRequest.new(pool).get("/", "HTTP_COOKIE" => cookie)
-    res.body.should.equal '{"counter"=>2}'
-    res = Rack::MockRequest.new(pool).get("/", "HTTP_COOKIE" => cookie)
-    res.body.should.equal '{"counter"=>3}'
+    req = Rack::MockRequest.new(pool)
+    cookie = req.get("/")["Set-Cookie"]
+    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
+  specify "survives nonexistant cookies" do
     pool = Rack::Session::Pool.new(incrementor)
     res = Rack::MockRequest.new(pool).
-      get("/", "HTTP_COOKIE" => "rack.session=blarghfasel")
+      get("/", "HTTP_COOKIE" => "#{session_key}=blarghfasel")
     res.body.should.equal '{"counter"=>1}'
   end
 
-  specify "maintains freshness" do
-    pool = Rack::Session::Pool.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(pool).get('/', "HTTP_COOKIE" => cookie)
-    res["Set-Cookie"].should.equal cookie
-    res.body.should.include '"counter"=>2'
-    sleep 4
-    res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
-    res["Set-Cookie"].should.not.equal cookie
-    res.body.should.include '"counter"=>1'
+  specify "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)
+
+    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 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
+  end
+
+  specify "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
+
+    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
+
+    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
+  end
+
+  specify "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
   end
 
+  # anyone know how to do this better?
   specify "multithread: should merge sessions" do
+    next unless $DEBUG
+    warn 'Running multithread tests for Session::Pool'
+    pool = Rack::Session::Pool.new(incrementor)
+    req = Rack::MockRequest.new(pool)
+
+    res = req.get('/')
+    res.body.should.equal '{"counter"=>1}'
+    cookie = res["Set-Cookie"]
+    sess_id = cookie[/#{pool.key}=([^,;]+)/,1]
+
     delta_incrementor = lambda do |env|
       # emulate disconjoinment of threading
       env['rack.session'] = env['rack.session'].dup
@@ -58,27 +152,21 @@ context "Rack::Session::Pool" do
       env['rack.session'][(Time.now.usec*rand).to_i] = true
       incrementor.call(env)
     end
-    pool = Rack::Session::Pool.new(incrementor)
-    res = Rack::MockRequest.new(pool).get('/')
-    res.body.should.equal '{"counter"=>1}'
-    cookie = res["Set-Cookie"]
-    sess_id = cookie[/#{pool.key}=([^,;]+)/,1]
-
-    pool = pool.context(delta_incrementor)
-    r = Array.new(rand(7).to_i+3).
-      map! do
-        Thread.new do
-          Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
-        end
-      end.
-      reverse!.
-      map!{|t| t.run.join.value }
-    session = pool.for.pool[sess_id] # for is needed by Utils::Context
-    session.size.should.be r.size+1 # counter
-    session['counter'].should.be 2 # meeeh
+    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
+
+    session = pool.pool[sess_id]
+    session.size.should.be tnum+1 # counter
+    session['counter'].should.be 2 # meeeh
   end
 end

data/test/spec_rack_static.rb

@@ -5,7 +5,7 @@ require 'rack/mock'
 
 class DummyApp
   def call(env)
-    [200, {}, "Hello World"]
+    [200, {}, ["Hello World"]]
   end
 end
 
@@ -34,4 +34,4 @@ context "Rack::Static" do
     res.body.should == "Hello World"
   end
 
-end
+end

data/test/spec_rack_thin.rb

@@ -10,9 +10,10 @@ context "Rack::Handler::Thin" do
   
   setup do
     @app = Rack::Lint.new(TestRequest.new)
+    @server = nil
     Thin::Logging.silent = true
     @thread = Thread.new do
-      Rack::Handler::Thin.run(@app, :Host => @host='0.0.0.0', :Port => @port=9201) do |server|
+      Rack::Handler::Thin.run(@app, :Host => @host='0.0.0.0', :Port => @port=9204) do |server|
         @server = server
       end
     end
@@ -31,7 +32,7 @@ context "Rack::Handler::Thin" do
     response["SERVER_SOFTWARE"].should =~ /thin/
     response["HTTP_VERSION"].should.equal "HTTP/1.1"
     response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
-    response["SERVER_PORT"].should.equal "9201"
+    response["SERVER_PORT"].should.equal "9204"
     response["SERVER_NAME"].should.equal "0.0.0.0"
   end
 

data/test/spec_rack_urlmap.rb

@@ -68,6 +68,12 @@ context "Rack::URLMap" do
                                 "X-Position" => "foo.org",
                                 "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
                               }, [""]]},
+                           "http://subdomain.foo.org/" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "subdomain.foo.org",
+                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
+                              }, [""]]},
                            "http://bar.org/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
@@ -94,6 +100,10 @@ context "Rack::URLMap" do
     res.should.be.ok
     res["X-Position"].should.equal "foo.org"
 
+    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "subdomain.foo.org", "SERVER_NAME" => "foo.org")
+    res.should.be.ok
+    res["X-Position"].should.equal "subdomain.foo.org"
+
     res = Rack::MockRequest.new(map).get("http://foo.org/")
     res.should.be.ok
     res["X-Position"].should.equal "default.org"

data/test/spec_rack_utils.rb

@@ -29,7 +29,83 @@ context "Rack::Utils" do
     Rack::Utils.parse_query("my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F").
       should.equal "my weird field" => "q1!2\"'w$5&7/z8)?"
   end
-  
+
+  specify "should parse nested query strings correctly" do
+    Rack::Utils.parse_nested_query("foo").
+      should.equal "foo" => nil
+    Rack::Utils.parse_nested_query("foo=").
+      should.equal "foo" => ""
+    Rack::Utils.parse_nested_query("foo=bar").
+      should.equal "foo" => "bar"
+
+    Rack::Utils.parse_nested_query("foo=bar&foo=quux").
+      should.equal "foo" => "quux"
+    Rack::Utils.parse_nested_query("foo&foo=").
+      should.equal "foo" => ""
+    Rack::Utils.parse_nested_query("foo=1&bar=2").
+      should.equal "foo" => "1", "bar" => "2"
+    Rack::Utils.parse_nested_query("&foo=1&&bar=2").
+      should.equal "foo" => "1", "bar" => "2"
+    Rack::Utils.parse_nested_query("foo&bar=").
+      should.equal "foo" => nil, "bar" => ""
+    Rack::Utils.parse_nested_query("foo=bar&baz=").
+      should.equal "foo" => "bar", "baz" => ""
+    Rack::Utils.parse_nested_query("my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F").
+      should.equal "my weird field" => "q1!2\"'w$5&7/z8)?"
+
+    Rack::Utils.parse_nested_query("foo[]").
+      should.equal "foo" => [nil]
+    Rack::Utils.parse_nested_query("foo[]=").
+      should.equal "foo" => [""]
+    Rack::Utils.parse_nested_query("foo[]=bar").
+      should.equal "foo" => ["bar"]
+
+    Rack::Utils.parse_nested_query("foo[]=1&foo[]=2").
+      should.equal "foo" => ["1", "2"]
+    Rack::Utils.parse_nested_query("foo=bar&baz[]=1&baz[]=2&baz[]=3").
+      should.equal "foo" => "bar", "baz" => ["1", "2", "3"]
+    Rack::Utils.parse_nested_query("foo[]=bar&baz[]=1&baz[]=2&baz[]=3").
+      should.equal "foo" => ["bar"], "baz" => ["1", "2", "3"]
+
+    Rack::Utils.parse_nested_query("x[y][z]=1").
+      should.equal "x" => {"y" => {"z" => "1"}}
+    Rack::Utils.parse_nested_query("x[y][z][]=1").
+      should.equal "x" => {"y" => {"z" => ["1"]}}
+    Rack::Utils.parse_nested_query("x[y][z]=1&x[y][z]=2").
+      should.equal "x" => {"y" => {"z" => "2"}}
+    Rack::Utils.parse_nested_query("x[y][z][]=1&x[y][z][]=2").
+      should.equal "x" => {"y" => {"z" => ["1", "2"]}}
+
+    Rack::Utils.parse_nested_query("x[y][][z]=1").
+      should.equal "x" => {"y" => [{"z" => "1"}]}
+    Rack::Utils.parse_nested_query("x[y][][z][]=1").
+      should.equal "x" => {"y" => [{"z" => ["1"]}]}
+    Rack::Utils.parse_nested_query("x[y][][z]=1&x[y][][w]=2").
+      should.equal "x" => {"y" => [{"z" => "1", "w" => "2"}]}
+
+    Rack::Utils.parse_nested_query("x[y][][v][w]=1").
+      should.equal "x" => {"y" => [{"v" => {"w" => "1"}}]}
+    Rack::Utils.parse_nested_query("x[y][][z]=1&x[y][][v][w]=2").
+      should.equal "x" => {"y" => [{"z" => "1", "v" => {"w" => "2"}}]}
+
+    Rack::Utils.parse_nested_query("x[y][][z]=1&x[y][][z]=2").
+      should.equal "x" => {"y" => [{"z" => "1"}, {"z" => "2"}]}
+    Rack::Utils.parse_nested_query("x[y][][z]=1&x[y][][w]=a&x[y][][z]=2&x[y][][w]=3").
+      should.equal "x" => {"y" => [{"z" => "1", "w" => "a"}, {"z" => "2", "w" => "3"}]}
+
+    lambda { Rack::Utils.parse_nested_query("x[y]=1&x[y]z=2") }.
+      should.raise(TypeError).
+      message.should.equal "expected Hash (got String) for param `y'"
+
+    lambda { Rack::Utils.parse_nested_query("x[y]=1&x[]=1") }.
+      should.raise(TypeError).
+      message.should.equal "expected Array (got Hash) for param `x'"
+
+    lambda { Rack::Utils.parse_nested_query("x[y]=1&x[y][][w]=2") }.
+      should.raise(TypeError).
+      message.should.equal "expected Array (got String) for param `y'"
+  end
+
   specify "should build query strings correctly" do
     Rack::Utils.build_query("foo" => "bar").should.equal "foo=bar"
     Rack::Utils.build_query("foo" => ["bar", "quux"]).
@@ -62,6 +138,10 @@ context "Rack::Utils" do
     helper.call(%w(foo bar identity), [["foo", 0], ["bar", 0]]).should.equal("identity")
     helper.call(%w(foo bar baz identity), [["*", 0], ["identity", 0.1]]).should.equal("identity")
   end
+
+  specify "should return the bytesize of String" do
+    Rack::Utils.bytesize("FOO\xE2\x82\xAC").should.equal 6
+  end
 end
 
 context "Rack::Utils::HeaderHash" do
@@ -95,75 +175,53 @@ context "Rack::Utils::HeaderHash" do
     h = Rack::Utils::HeaderHash.new("foo" => "bar")
     h.to_hash.should.be.instance_of Hash
   end
+
+  specify "should convert Array values to Strings when converting to Hash" do
+    h = Rack::Utils::HeaderHash.new("foo" => ["bar", "baz"])
+    h.to_hash.should.equal({ "foo" => "bar\nbaz" })
+  end
 end
 
 context "Rack::Utils::Context" do
-  test_app1 = Object.new
-  def test_app1.context app
-    Rack::Utils::Context.new self, app do |env|
-      app.call env
-    end
+  class ContextTest
+    attr_reader :app
+    def initialize app; @app=app; end
+    def call env; context env; end
+    def context env, app=@app; app.call(env); end
   end
-  test_app2 = Object.new
-  def test_app2.context env; end
-  test_app3 = Object.new
   test_target1 = proc{|e| e.to_s+' world' }
   test_target2 = proc{|e| e.to_i+2 }
   test_target3 = proc{|e| nil }
   test_target4 = proc{|e| [200,{'Content-Type'=>'text/plain', 'Content-Length'=>'0'},['']] }
-  test_target5 = Object.new
-
-  specify "should perform checks on both arguments" do
-    lambda { Rack::Utils::Context.new(nil, nil){} }.should.raise
-    lambda { Rack::Utils::Context.new(test_app1, nil){} }.should.raise
-    lambda { Rack::Utils::Context.new(nil, test_target1){} }.should.raise
-    lambda { Rack::Utils::Context.new(test_app1, test_target1){} }.should.not.raise
-    lambda { Rack::Utils::Context.new(test_app3, test_target1){} }.should.raise
-    lambda { Rack::Utils::Context.new(test_app1, test_target5){} }.should.raise
-    lambda { test_app1.context(nil){} }.should.raise
-    lambda { test_app1.context(test_target1){} }.should.not.raise
-    lambda { test_app1.context(test_target5){} }.should.raise
-  end
+  test_app = ContextTest.new test_target4
 
   specify "should set context correctly" do
-    c1 = Rack::Utils::Context.new(test_app1, test_target1){}
-    c1.for.should.equal test_app1
+    test_app.app.should.equal test_target4
+    c1 = Rack::Utils::Context.new(test_app, test_target1)
+    c1.for.should.equal test_app
     c1.app.should.equal test_target1
-    c2 = Rack::Utils::Context.new(test_app1, test_target2){}
-    c2.for.should.equal test_app1
+    c2 = Rack::Utils::Context.new(test_app, test_target2)
+    c2.for.should.equal test_app
     c2.app.should.equal test_target2
-    c3 = Rack::Utils::Context.new(test_app2, test_target3){}
-    c3.for.should.equal test_app2
-    c3.app.should.equal test_target3
-    c4 = Rack::Utils::Context.new(test_app2, test_target4){}
-    c4.for.should.equal test_app2
-    c4.app.should.equal test_target4
   end
 
   specify "should alter app on recontexting" do
-    c1 = Rack::Utils::Context.new(test_app1, test_target1){}
-    c1.for.should.equal test_app1
-    c1.app.should.equal test_target1
-    c2 = c1.context(test_target2)
-    c2.for.should.equal test_app1
-    c2.app.should.not.equal test_target1
+    c1 = Rack::Utils::Context.new(test_app, test_target1)
+    c2 = c1.recontext(test_target2)
+    c2.for.should.equal test_app
     c2.app.should.equal test_target2
-    c3 = c2.context(test_target3)
-    c3.for.should.equal test_app1
-    c3.app.should.not.equal test_target2
+    c3 = c2.recontext(test_target3)
+    c3.for.should.equal test_app
     c3.app.should.equal test_target3
-    c4 = c3.context(test_target4)
-    c4.for.should.equal test_app1
-    c4.app.should.not.equal test_target3
-    c4.app.should.equal test_target4
   end
 
   specify "should run different apps" do
-    c1 = test_app1.context(test_target1)
-    c2 = c1.context test_target2
-    c3 = c2.context test_target3
-    c4 = c3.context test_target4
+    c1 = Rack::Utils::Context.new test_app, test_target1
+    c2 = c1.recontext test_target2
+    c3 = c2.recontext test_target3
+    c4 = c3.recontext test_target4
     a4 = Rack::Lint.new c4
+    a5 = Rack::Lint.new test_app
     r1 = c1.call('hello')
     r1.should.equal 'hello world'
     r2 = c2.call(2)
@@ -172,5 +230,112 @@ context "Rack::Utils::Context" do
     r3.should.be.nil
     r4 = Rack::MockRequest.new(a4).get('/')
     r4.status.should.be 200
+    r5 = Rack::MockRequest.new(a5).get('/')
+    r5.status.should.be 200
+    r4.body.should.equal r5.body
+  end
+end
+
+context "Rack::Utils::Multipart" do
+  specify "should return nil if content type is not multipart" do
+    env = Rack::MockRequest.env_for("/",
+            "CONTENT_TYPE" => 'application/x-www-form-urlencoded')
+    Rack::Utils::Multipart.parse_multipart(env).should.equal nil
+  end
+
+  specify "should parse multipart upload with text file" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:text))
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["files"][:type].should.equal "text/plain"
+    params["files"][:filename].should.equal "file1.txt"
+    params["files"][:head].should.equal "Content-Disposition: form-data; " +
+      "name=\"files\"; filename=\"file1.txt\"\r\n" +
+      "Content-Type: text/plain\r\n"
+    params["files"][:name].should.equal "files"
+    params["files"][:tempfile].read.should.equal "contents"
+  end
+
+  specify "should parse multipart upload with nested parameters" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:nested))
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["foo"]["submit-name"].should.equal "Larry"
+    params["foo"]["files"][:type].should.equal "text/plain"
+    params["foo"]["files"][:filename].should.equal "file1.txt"
+    params["foo"]["files"][:head].should.equal "Content-Disposition: form-data; " +
+      "name=\"foo[files]\"; filename=\"file1.txt\"\r\n" +
+      "Content-Type: text/plain\r\n"
+    params["foo"]["files"][:name].should.equal "foo[files]"
+    params["foo"]["files"][:tempfile].read.should.equal "contents"
   end
+
+  specify "should parse multipart upload with binary file" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:binary))
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["files"][:type].should.equal "image/png"
+    params["files"][:filename].should.equal "rack-logo.png"
+    params["files"][:head].should.equal "Content-Disposition: form-data; " +
+      "name=\"files\"; filename=\"rack-logo.png\"\r\n" +
+      "Content-Type: image/png\r\n"
+    params["files"][:name].should.equal "files"
+    params["files"][:tempfile].read.length.should.equal 26473
+  end
+
+  specify "should parse multipart upload with empty file" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:empty))
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["files"][:type].should.equal "text/plain"
+    params["files"][:filename].should.equal "file1.txt"
+    params["files"][:head].should.equal "Content-Disposition: form-data; " +
+      "name=\"files\"; filename=\"file1.txt\"\r\n" +
+      "Content-Type: text/plain\r\n"
+    params["files"][:name].should.equal "files"
+    params["files"][:tempfile].read.should.equal ""
+  end
+
+  specify "should not include file params if no file was selected" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:none))
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["files"].should.equal nil
+    params.keys.should.not.include "files"
+  end
+
+  specify "should parse IE multipart upload and clean up filename" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:ie))
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["files"][:type].should.equal "text/plain"
+    params["files"][:filename].should.equal "file1.txt"
+    params["files"][:head].should.equal "Content-Disposition: form-data; " +
+      "name=\"files\"; " +
+      'filename="C:\Documents and Settings\Administrator\Desktop\file1.txt"' +
+      "\r\nContent-Type: text/plain\r\n"
+    params["files"][:name].should.equal "files"
+    params["files"][:tempfile].read.should.equal "contents"
+  end
+
+  specify "rewinds input after parsing upload" do
+    options = multipart_fixture(:text)
+    input = options[:input]
+    env = Rack::MockRequest.env_for("/", options)
+    params = Rack::Utils::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["files"][:filename].should.equal "file1.txt"
+    input.read.length.should.equal 197
+  end
+
+  private
+    def multipart_fixture(name)
+      file = File.join(File.dirname(__FILE__), "multipart", name.to_s)
+      data = File.open(file, 'rb') { |io| io.read }
+
+      type = "multipart/form-data; boundary=AaB03x"
+      length = data.respond_to?(:bytesize) ? data.bytesize : data.size
+
+      { "CONTENT_TYPE" => type,
+        "CONTENT_LENGTH" => length.to_s,
+        :input => StringIO.new(data) }
+    end
 end