rack 1.2.8 → 1.3.0.beta

data/test/spec_fastcgi.rb

@@ -1,3 +1,4 @@
+begin
 require File.expand_path('../testrequest', __FILE__)
 require 'rack/handler/fastcgi'
 
@@ -7,6 +8,10 @@ describe Rack::Handler::FastCGI do
   @host = '0.0.0.0'
   @port = 9203
 
+  if `which lighttpd` && !$?.success?
+    raise "lighttpd not found"
+  end
+
   # Keep this first.
   $pid = fork {
     ENV['RACK_ENV'] = 'deployment'
@@ -94,3 +99,9 @@ describe Rack::Handler::FastCGI do
     Process.wait($pid).should.equal $pid
   end
 end
+
+rescue RuntimeError
+  $stderr.puts "Skipping Rack::Handler::FastCGI tests (lighttpd is required). Install lighttpd and try again."
+rescue LoadError
+  $stderr.puts "Skipping Rack::Handler::FastCGI tests (FCGI is required). `gem install fcgi` and try again."
+end

data/test/spec_file.rb

@@ -31,12 +31,32 @@ describe Rack::File do
   end
 
   should "not allow directory traversal" do
-    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
-      get("/cgi/../test")
+    req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT)))
+    res = req.get("/cgi/../test")
+    res.should.be.forbidden
+
+    res = req.get("../test")
+    res.should.be.forbidden
 
+    res = req.get("..")
+    res.should.be.forbidden
+
+    res = req.get("test/..")
     res.should.be.forbidden
   end
 
+  should "allow files with .. in their name" do
+    req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT)))
+    res = req.get("/cgi/..test")
+    res.should.be.not_found
+
+    res = req.get("/cgi/test..")
+    res.should.be.not_found
+
+    res = req.get("/cgi../test..")
+    res.should.be.not_found
+  end
+
   should "not allow directory traversal with encoded periods" do
     res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
       get("/%2E%2E/README")
@@ -60,7 +80,7 @@ describe Rack::File do
 
   should "return bodies that respond to #to_path" do
     env = Rack::MockRequest.env_for("/cgi/test")
-    status, headers, body = Rack::File.new(DOCROOT).call(env)
+    status, _, body = Rack::File.new(DOCROOT).call(env)
 
     path = File.join(DOCROOT, "/cgi/test")
 
@@ -68,4 +88,35 @@ describe Rack::File do
     body.should.respond_to :to_path
     body.to_path.should.equal path
   end
+
+  should "return correct byte range in body" do
+    env = Rack::MockRequest.env_for("/cgi/test")
+    env["HTTP_RANGE"] = "bytes=22-33"
+    res = Rack::MockResponse.new(*Rack::File.new(DOCROOT).call(env))
+
+    res.status.should.equal 206
+    res["Content-Length"].should.equal "12"
+    res["Content-Range"].should.equal "bytes 22-33/193"
+    res.body.should.equal "-*- ruby -*-"
+  end
+
+  should "return error for unsatisfiable byte range" do
+    env = Rack::MockRequest.env_for("/cgi/test")
+    env["HTTP_RANGE"] = "bytes=1234-5678"
+    res = Rack::MockResponse.new(*Rack::File.new(DOCROOT).call(env))
+
+    res.status.should.equal 416
+    res["Content-Range"].should.equal "bytes */193"
+  end
+
+  should "support cache control options" do
+    env = Rack::MockRequest.env_for("/cgi/test")
+    status, heads, _ = Rack::File.new(DOCROOT, 'public, max-age=38').call(env)
+
+    path = File.join(DOCROOT, "/cgi/test")
+
+    status.should.equal 200
+    heads['Cache-Control'].should.equal 'public, max-age=38'
+  end
+
 end

data/test/spec_handler.rb

@@ -6,15 +6,23 @@ class RockLobster; end
 describe Rack::Handler do
   it "has registered default handlers" do
     Rack::Handler.get('cgi').should.equal Rack::Handler::CGI
-    Rack::Handler.get('fastcgi').should.equal Rack::Handler::FastCGI
-    Rack::Handler.get('mongrel').should.equal Rack::Handler::Mongrel
     Rack::Handler.get('webrick').should.equal Rack::Handler::WEBrick
+
+    begin
+      Rack::Handler.get('fastcgi').should.equal Rack::Handler::FastCGI
+    rescue LoadError
+    end
+
+    begin
+      Rack::Handler.get('mongrel').should.equal Rack::Handler::Mongrel
+    rescue LoadError
+    end
   end
 
-  should "raise NameError if handler doesn't exist" do
+  should "raise LoadError if handler doesn't exist" do
     lambda {
       Rack::Handler.get('boom')
-    }.should.raise(NameError)
+    }.should.raise(LoadError)
   end
 
   should "get unregistered, but already required, handler by name" do
@@ -32,10 +40,20 @@ describe Rack::Handler do
       Rack::Handler.get('Unregistered').should.equal Rack::Handler::Unregistered
       lambda {
         Rack::Handler.get('UnRegistered')
-      }.should.raise(NameError)
+      }.should.raise LoadError
       Rack::Handler.get('UnregisteredLongOne').should.equal Rack::Handler::UnregisteredLongOne
     ensure
       $LOAD_PATH.delete File.expand_path('../unregistered_handler', __FILE__)
     end
   end
+
+  should "allow autoloaded handlers to be registered properly while being loaded" do
+    path = File.expand_path('../registering_handler', __FILE__)
+    begin
+      $LOAD_PATH.push path
+      Rack::Handler.get('registering_myself').should.equal Rack::Handler::RegisteringMyself
+    ensure
+      $LOAD_PATH.delete path
+    end
+  end
 end

data/test/spec_lint.rb

@@ -271,9 +271,9 @@ describe Rack::Lint do
 
   should "notice body errors" do
     lambda {
-      status, header, body = Rack::Lint.new(lambda { |env|
+      body = Rack::Lint.new(lambda { |env|
                                [200, {"Content-type" => "text/plain","Content-length" => "3"}, [1,2,3]]
-                             }).call(env({}))
+                             }).call(env({}))[2]
       body.each { |part| }
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/yielded non-string/)

data/test/spec_lock.rb

@@ -12,25 +12,131 @@ class Lock
     @synchronized = true
     yield
   end
+
+  def lock
+    @synchronized = true
+  end
+
+  def unlock
+    @synchronized = false
+  end
 end
 
 describe Rack::Lock do
+  describe 'Proxy' do
+    should 'delegate each' do
+      lock     = Lock.new
+      env      = Rack::MockRequest.env_for("/")
+      response = Class.new {
+        attr_accessor :close_called
+        def initialize; @close_called = false; end
+        def each; %w{ hi mom }.each { |x| yield x }; end
+      }.new
+
+      app = Rack::Lock.new(lambda { |inner_env| [200, {}, response] }, lock)
+      response = app.call(env)[2]
+      list = []
+      response.each { |x| list << x }
+      list.should.equal %w{ hi mom }
+    end
+
+    should 'delegate to_path' do
+      lock = Lock.new
+      env  = Rack::MockRequest.env_for("/")
+
+      res = ['Hello World']
+      def res.to_path ; "/tmp/hello.txt" ; end
+
+      app = Rack::Lock.new(lambda { |inner_env| [200, {}, res] }, lock)
+      body = app.call(env)[2]
+
+      body.should.respond_to :to_path
+      body.to_path.should.equal "/tmp/hello.txt"
+    end
+
+    should 'not delegate to_path if body does not implement it' do
+      lock = Lock.new
+      env  = Rack::MockRequest.env_for("/")
+
+      res = ['Hello World']
+
+      app = Rack::Lock.new(lambda { |inner_env| [200, {}, res] }, lock)
+      body = app.call(env)[2]
+
+      body.should.not.respond_to :to_path
+    end
+  end
+
+  should 'call super on close' do
+    lock     = Lock.new
+    env      = Rack::MockRequest.env_for("/")
+    response = Class.new {
+      attr_accessor :close_called
+      def initialize; @close_called = false; end
+      def close; @close_called = true; end
+    }.new
+
+    app = Rack::Lock.new(lambda { |inner_env| [200, {}, response] }, lock)
+    app.call(env)
+    response.close_called.should.equal false
+    response.close
+    response.close_called.should.equal true
+  end
+
+  should "not unlock until body is closed" do
+    lock     = Lock.new
+    env      = Rack::MockRequest.env_for("/")
+    response = Object.new
+    app      = Rack::Lock.new(lambda { |inner_env| [200, {}, response] }, lock)
+    lock.synchronized.should.equal false
+    response = app.call(env)[2]
+    lock.synchronized.should.equal true
+    response.close
+    lock.synchronized.should.equal false
+  end
+
+  should "return value from app" do
+    lock = Lock.new
+    env  = Rack::MockRequest.env_for("/")
+    body = [200, {}, %w{ hi mom }]
+    app  = Rack::Lock.new(lambda { |inner_env| body }, lock)
+    app.call(env).should.equal body
+  end
+
   should "call synchronize on lock" do
     lock = Lock.new
     env = Rack::MockRequest.env_for("/")
-    app = Rack::Lock.new(lambda { |inner_env| }, lock)
+    app = Rack::Lock.new(lambda { |inner_env|
+      [200, {}, %w{ a b c }]
+    }, lock)
     lock.synchronized.should.equal false
     app.call(env)
     lock.synchronized.should.equal true
   end
 
+  should "unlock if the app raises" do
+    lock = Lock.new
+    env = Rack::MockRequest.env_for("/")
+    app = Rack::Lock.new(lambda { raise Exception }, lock)
+    lambda { app.call(env) }.should.raise(Exception)
+    lock.synchronized.should.equal false
+  end
+
   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
+    app = Rack::Lock.new(lambda { |env|
+      env['rack.multithread'].should.equal false
+      [200, {}, %w{ a b c }]
+    })
+    app.call(Rack::MockRequest.env_for("/"))
   end
 
   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
+    app = Class.new(Rack::Lock) {
+      def call(env)
+        env['rack.multithread'].should.equal true
+        super
+      end
+    }.new(lambda { |env| [200, {}, %w{ a b c }] })
+    app.call(Rack::MockRequest.env_for("/"))
   end
 end

data/test/spec_methodoverride.rb

@@ -22,12 +22,12 @@ describe Rack::MethodOverride do
   should "modify REQUEST_METHOD for POST requests when X-HTTP-Method-Override is set" do
     env = Rack::MockRequest.env_for("/",
             :method => "POST",
-            "HTTP_X_HTTP_METHOD_OVERRIDE" => "PUT"
+            "HTTP_X_HTTP_METHOD_OVERRIDE" => "PATCH"
           )
     app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
     req = app.call(env)
 
-    req.env["REQUEST_METHOD"].should.equal "PUT"
+    req.env["REQUEST_METHOD"].should.equal "PATCH"
   end
 
   should "not modify REQUEST_METHOD if the method is unknown" do

data/test/spec_mock.rb

@@ -167,7 +167,7 @@ describe Rack::MockRequest do
   end
 
   should "accept params and build multipart encoded params for POST requests" do
-    files = Rack::Utils::Multipart::UploadedFile.new(File.join(File.dirname(__FILE__), "multipart", "file1.txt"))
+    files = Rack::Multipart::UploadedFile.new(File.join(File.dirname(__FILE__), "multipart", "file1.txt"))
     res = Rack::MockRequest.new(app).post("/foo", :params => { "submit-name" => "Larry", "files" => files })
     env = YAML.load(res.body)
     env["REQUEST_METHOD"].should.equal "POST"
@@ -179,7 +179,7 @@ describe Rack::MockRequest do
 
   should "behave valid according to the Rack spec" do
     lambda {
-      res = Rack::MockRequest.new(app).
+      Rack::MockRequest.new(app).
         get("https://bla.example.org:9292/meh/foo?bar", :lint => true)
     }.should.not.raise(Rack::Lint::LintError)
   end
@@ -214,7 +214,7 @@ describe 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 > 0
+    res.content_length.should.not.equal 0
     res.location.should.be.nil
   end
 

data/test/spec_mongrel.rb

@@ -177,7 +177,6 @@ describe Rack::Handler::Mongrel do
   @acc.raise Mongrel::StopServer
 end
 
-rescue LoadError => ex
-  warn ex
+rescue LoadError
   warn "Skipping Rack::Handler::Mongrel tests (Mongrel is required). `gem install mongrel` and try again."
 end

data/test/spec_multipart.rb

@@ -0,0 +1,279 @@
+require 'rack/utils'
+require 'rack/mock'
+
+describe Rack::Multipart do
+  def multipart_fixture(name)
+    file = multipart_file(name)
+    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
+
+  def multipart_file(name)
+    File.join(File.dirname(__FILE__), "multipart", name.to_s)
+  end
+
+  should "return nil if content type is not multipart" do
+    env = Rack::MockRequest.env_for("/",
+            "CONTENT_TYPE" => 'application/x-www-form-urlencoded')
+    Rack::Multipart.parse_multipart(env).should.equal nil
+  end
+
+  should "parse multipart content when content type present but filename is not" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:content_type_and_no_filename))
+    params = Rack::Multipart.parse_multipart(env)
+    params["text"].should.equal "contents"
+  end
+
+  should "parse multipart form webkit style" do
+    env = Rack::MockRequest.env_for '/', multipart_fixture(:webkit)
+    env['CONTENT_TYPE'] = "multipart/form-data; boundary=----WebKitFormBoundaryWLHCs9qmcJJoyjKR"
+    params = Rack::Multipart.parse_multipart(env)
+    params['profile']['bio'].should.include 'hello'
+  end
+
+  should "parse multipart upload with text file" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:text))
+    params = Rack::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["submit-name-with-content"].should.equal "Berry"
+    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
+
+  should "parse multipart upload with nested parameters" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:nested))
+    params = Rack::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
+
+  should "parse multipart upload with binary file" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:binary))
+    params = Rack::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
+
+  should "parse multipart upload with empty file" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:empty))
+    params = Rack::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
+
+  should "parse multipart upload with filename with semicolons" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:semicolon))
+    params = Rack::Multipart.parse_multipart(env)
+    params["files"][:type].should.equal "text/plain"
+    params["files"][:filename].should.equal "fi;le1.txt"
+    params["files"][:head].should.equal "Content-Disposition: form-data; " +
+      "name=\"files\"; filename=\"fi;le1.txt\"\r\n" +
+      "Content-Type: text/plain\r\n"
+    params["files"][:name].should.equal "files"
+    params["files"][:tempfile].read.should.equal "contents"
+  end
+
+  should "not include file params if no file was selected" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:none))
+    params = Rack::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["files"].should.equal nil
+    params.keys.should.not.include "files"
+  end
+
+  should "parse IE multipart upload and clean up filename" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:ie))
+    params = Rack::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
+
+  should "parse filename and modification param" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:filename_and_modification_param))
+    params = Rack::Multipart.parse_multipart(env)
+    params["files"][:type].should.equal "image/jpeg"
+    params["files"][:filename].should.equal "genome.jpeg"
+    params["files"][:head].should.equal "Content-Type: image/jpeg\r\n" +
+      "Content-Disposition: attachment; " +
+      "name=\"files\"; " +
+      "filename=genome.jpeg; " +
+      "modification-date=\"Wed, 12 Feb 1997 16:29:51 -0500\";\r\n" +
+      "Content-Description: a complete map of the human genome\r\n"
+    params["files"][:name].should.equal "files"
+    params["files"][:tempfile].read.should.equal "contents"
+  end
+
+  should "parse filename with escaped quotes" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:filename_with_escaped_quotes))
+    params = Rack::Multipart.parse_multipart(env)
+    params["files"][:type].should.equal "application/octet-stream"
+    params["files"][:filename].should.equal "escape \"quotes"
+    params["files"][:head].should.equal "Content-Disposition: form-data; " +
+      "name=\"files\"; " +
+      "filename=\"escape \\\"quotes\"\r\n" +
+      "Content-Type: application/octet-stream\r\n"
+    params["files"][:name].should.equal "files"
+    params["files"][:tempfile].read.should.equal "contents"
+  end
+
+  should "parse filename with percent escaped quotes" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:filename_with_percent_escaped_quotes))
+    params = Rack::Multipart.parse_multipart(env)
+    params["files"][:type].should.equal "application/octet-stream"
+    params["files"][:filename].should.equal "escape \"quotes"
+    params["files"][:head].should.equal "Content-Disposition: form-data; " +
+      "name=\"files\"; " +
+      "filename=\"escape %22quotes\"\r\n" +
+      "Content-Type: application/octet-stream\r\n"
+    params["files"][:name].should.equal "files"
+    params["files"][:tempfile].read.should.equal "contents"
+  end
+
+  should "parse filename with unescaped quotes" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:filename_with_unescaped_quotes))
+    params = Rack::Multipart.parse_multipart(env)
+    params["files"][:type].should.equal "application/octet-stream"
+    params["files"][:filename].should.equal "escape \"quotes"
+    params["files"][:head].should.equal "Content-Disposition: form-data; " +
+      "name=\"files\"; " +
+      "filename=\"escape \"quotes\"\r\n" +
+      "Content-Type: application/octet-stream\r\n"
+    params["files"][:name].should.equal "files"
+    params["files"][:tempfile].read.should.equal "contents"
+  end
+
+  should "parse filename with escaped quotes and modification param" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:filename_with_escaped_quotes_and_modification_param))
+    params = Rack::Multipart.parse_multipart(env)
+    params["files"][:type].should.equal "image/jpeg"
+    params["files"][:filename].should.equal "\"human\" genome.jpeg"
+    params["files"][:head].should.equal "Content-Type: image/jpeg\r\n" +
+      "Content-Disposition: attachment; " +
+      "name=\"files\"; " +
+      "filename=\"\"human\" genome.jpeg\"; " +
+      "modification-date=\"Wed, 12 Feb 1997 16:29:51 -0500\";\r\n" +
+      "Content-Description: a complete map of the human genome\r\n"
+    params["files"][:name].should.equal "files"
+    params["files"][:tempfile].read.should.equal "contents"
+  end
+
+  it "rewinds input after parsing upload" do
+    options = multipart_fixture(:text)
+    input = options[:input]
+    env = Rack::MockRequest.env_for("/", options)
+    params = Rack::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["files"][:filename].should.equal "file1.txt"
+    input.read.length.should.equal 307
+  end
+
+  it "builds multipart body" do
+    files = Rack::Multipart::UploadedFile.new(multipart_file("file1.txt"))
+    data  = Rack::Multipart.build_multipart("submit-name" => "Larry", "files" => files)
+
+    options = {
+      "CONTENT_TYPE" => "multipart/form-data; boundary=AaB03x",
+      "CONTENT_LENGTH" => data.length.to_s,
+      :input => StringIO.new(data)
+    }
+    env = Rack::MockRequest.env_for("/", options)
+    params = Rack::Multipart.parse_multipart(env)
+    params["submit-name"].should.equal "Larry"
+    params["files"][:filename].should.equal "file1.txt"
+    params["files"][:tempfile].read.should.equal "contents"
+  end
+
+  it "builds nested multipart body" do
+    files = Rack::Multipart::UploadedFile.new(multipart_file("file1.txt"))
+    data  = Rack::Multipart.build_multipart("people" => [{"submit-name" => "Larry", "files" => files}])
+
+    options = {
+      "CONTENT_TYPE" => "multipart/form-data; boundary=AaB03x",
+      "CONTENT_LENGTH" => data.length.to_s,
+      :input => StringIO.new(data)
+    }
+    env = Rack::MockRequest.env_for("/", options)
+    params = Rack::Multipart.parse_multipart(env)
+    params["people"][0]["submit-name"].should.equal "Larry"
+    params["people"][0]["files"][:filename].should.equal "file1.txt"
+    params["people"][0]["files"][:tempfile].read.should.equal "contents"
+  end
+
+  it "can parse fields that end at the end of the buffer" do
+    input = File.read(multipart_file("bad_robots"))
+
+    req = Rack::Request.new Rack::MockRequest.env_for("/",
+                      "CONTENT_TYPE" => "multipart/form-data, boundary=1yy3laWhgX31qpiHinh67wJXqKalukEUTvqTzmon",
+                      "CONTENT_LENGTH" => input.size,
+                      :input => input)
+
+    req.POST['file.path'].should.equal "/var/tmp/uploads/4/0001728414"
+    req.POST['addresses'].should.not.equal nil
+  end
+
+  it "builds complete params with the chunk size of 16384 slicing exactly on boundary" do
+    data = File.open(multipart_file("fail_16384_nofile")) { |f| f.read }.gsub(/\n/, "\r\n")
+    options = {
+      "CONTENT_TYPE" => "multipart/form-data; boundary=----WebKitFormBoundaryWsY0GnpbI5U7ztzo",
+      "CONTENT_LENGTH" => data.length.to_s,
+      :input => StringIO.new(data)
+    }
+    env = Rack::MockRequest.env_for("/", options)
+    params = Rack::Multipart.parse_multipart(env)
+
+    params.should.not.equal nil
+    params.keys.should.include "AAAAAAAAAAAAAAAAAAA"
+    params["AAAAAAAAAAAAAAAAAAA"].keys.should.include "PLAPLAPLA_MEMMEMMEMM_ATTRATTRER"
+    params["AAAAAAAAAAAAAAAAAAA"]["PLAPLAPLA_MEMMEMMEMM_ATTRATTRER"].keys.should.include "new"
+    params["AAAAAAAAAAAAAAAAAAA"]["PLAPLAPLA_MEMMEMMEMM_ATTRATTRER"]["new"].keys.should.include "-2"
+    params["AAAAAAAAAAAAAAAAAAA"]["PLAPLAPLA_MEMMEMMEMM_ATTRATTRER"]["new"]["-2"].keys.should.include "ba_unit_id"
+    params["AAAAAAAAAAAAAAAAAAA"]["PLAPLAPLA_MEMMEMMEMM_ATTRATTRER"]["new"]["-2"]["ba_unit_id"].should.equal "1017"
+  end
+
+  should "return nil if no UploadedFiles were used" do
+    data = Rack::Multipart.build_multipart("people" => [{"submit-name" => "Larry", "files" => "contents"}])
+    data.should.equal nil
+  end
+
+  should "raise ArgumentError if params is not a Hash" do
+    lambda { Rack::Multipart.build_multipart("foo=bar") }.
+      should.raise(ArgumentError).
+      message.should.equal "value must be a Hash"
+  end
+
+end