rack 1.1.6 → 1.2.0

data/{test/spec_rack_thin.rb → spec/spec_thin.rb}

@@ -1,34 +1,31 @@
-require 'test/spec'
-
 begin
 require 'rack/handler/thin'
-require 'testrequest'
+require File.expand_path('../testrequest', __FILE__)
 require 'timeout'
-  
-context "Rack::Handler::Thin" do
-  include TestRequest::Helpers
-  
-  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=9204) do |server|
-        @server = server
-      end
+
+describe Rack::Handler::Thin do
+  extend TestRequest::Helpers
+
+  @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=9204) do |server|
+      @server = server
     end
-    Thread.pass until @server && @server.running?
   end
 
-  specify "should respond" do
-    lambda {
-      GET("/")
-    }.should.not.raise
+  Thread.pass until @server && @server.running?
+
+  should "respond" do
+    GET("/")
+    response.should.not.be.nil
   end
 
-  specify "should be a Thin" do
+  should "be a Thin" do
     GET("/")
-    status.should.be 200
+    status.should.equal 200
     response["SERVER_SOFTWARE"].should =~ /thin/
     response["HTTP_VERSION"].should.equal "HTTP/1.1"
     response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
@@ -36,15 +33,15 @@ context "Rack::Handler::Thin" do
     response["SERVER_NAME"].should.equal "0.0.0.0"
   end
 
-  specify "should have rack headers" do
+  should "have rack headers" do
     GET("/")
-    response["rack.version"].should.equal [0,3]
-    response["rack.multithread"].should.be false
-    response["rack.multiprocess"].should.be false
-    response["rack.run_once"].should.be false
+    response["rack.version"].should.equal [1,0]
+    response["rack.multithread"].should.equal false
+    response["rack.multiprocess"].should.equal false
+    response["rack.run_once"].should.equal false
   end
 
-  specify "should have CGI headers on GET" do
+  should "have CGI headers on GET" do
     GET("/")
     response["REQUEST_METHOD"].should.equal "GET"
     response["REQUEST_PATH"].should.equal "/"
@@ -59,7 +56,7 @@ context "Rack::Handler::Thin" do
     response["QUERY_STRING"].should.equal "quux=1"
   end
 
-  specify "should have CGI headers on POST" do
+  should "have CGI headers on POST" do
     POST("/", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
     status.should.equal 200
     response["REQUEST_METHOD"].should.equal "POST"
@@ -69,21 +66,19 @@ context "Rack::Handler::Thin" do
     response["test.postdata"].should.equal "rack-form-data=23"
   end
 
-  specify "should support HTTP auth" do
+  should "support HTTP auth" do
     GET("/test", {:user => "ruth", :passwd => "secret"})
     response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
   end
 
-  specify "should set status" do
+  should "set status" do
     GET("/test?secret")
     status.should.equal 403
     response["rack.url_scheme"].should.equal "http"
   end
 
-  teardown do
-    @server.stop!
-    @thread.kill
-  end
+  @server.stop!
+  @thread.kill
 end
 
 rescue LoadError

data/{test/spec_rack_urlmap.rb → spec/spec_urlmap.rb}

@@ -1,10 +1,8 @@
-require 'test/spec'
-
 require 'rack/urlmap'
 require 'rack/mock'
 
-context "Rack::URLMap" do
-  specify "dispatches paths correctly" do
+describe Rack::URLMap do
+  it "dispatches paths correctly" do
     app = lambda { |env|
       [200, {
         'X-ScriptName' => env['SCRIPT_NAME'],
@@ -67,7 +65,7 @@ context "Rack::URLMap" do
   end
 
 
-  specify "dispatches hosts correctly" do
+  it "dispatches hosts correctly" do
     map = Rack::URLMap.new("http://foo.org/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
@@ -125,7 +123,7 @@ context "Rack::URLMap" do
     res["X-Position"].should.equal "default.org"
   end
 
-  specify "should be nestable" do
+  should "be nestable" do
     map = Rack::URLMap.new("/foo" =>
       Rack::URLMap.new("/bar" =>
         Rack::URLMap.new("/quux" =>  lambda { |env|
@@ -147,7 +145,7 @@ context "Rack::URLMap" do
     res["X-ScriptName"].should.equal "/foo/bar/quux"
   end
 
-  specify "should route root apps correctly" do
+  should "route root apps correctly" do
     map = Rack::URLMap.new("/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
@@ -189,7 +187,7 @@ context "Rack::URLMap" do
     res["X-ScriptName"].should.equal ""
   end
 
-  specify "should not squeeze slashes" do
+  should "not squeeze slashes" do
     map = Rack::URLMap.new("/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",

data/{test/spec_rack_utils.rb → spec/spec_utils.rb}

@@ -1,18 +1,15 @@
-require 'test/spec'
-
 require 'rack/utils'
-require 'rack/lint'
 require 'rack/mock'
 
-context "Rack::Utils" do
-  specify "should escape correctly" do
+describe Rack::Utils do
+  should "escape correctly" do
     Rack::Utils.escape("fo<o>bar").should.equal "fo%3Co%3Ebar"
     Rack::Utils.escape("a space").should.equal "a+space"
     Rack::Utils.escape("q1!2\"'w$5&7/z8)?\\").
       should.equal "q1%212%22%27w%245%267%2Fz8%29%3F%5C"
   end
 
-  specify "should escape correctly for multibyte characters" do
+  should "escape correctly for multibyte characters" do
     matz_name = "\xE3\x81\xBE\xE3\x81\xA4\xE3\x82\x82\xE3\x81\xA8".unpack("a*")[0] # Matsumoto
     matz_name.force_encoding("UTF-8") if matz_name.respond_to? :force_encoding
     Rack::Utils.escape(matz_name).should.equal '%E3%81%BE%E3%81%A4%E3%82%82%E3%81%A8'
@@ -21,7 +18,7 @@ context "Rack::Utils" do
     Rack::Utils.escape(matz_name_sep).should.equal '%E3%81%BE%E3%81%A4+%E3%82%82%E3%81%A8'
   end
 
-  specify "should unescape correctly" do
+  should "unescape correctly" do
     Rack::Utils.unescape("fo%3Co%3Ebar").should.equal "fo<o>bar"
     Rack::Utils.unescape("a+space").should.equal "a space"
     Rack::Utils.unescape("a%20space").should.equal "a space"
@@ -29,7 +26,7 @@ context "Rack::Utils" do
       should.equal "q1!2\"'w$5&7/z8)?\\"
   end
 
-  specify "should parse query strings correctly" do
+  should "parse query strings correctly" do
     Rack::Utils.parse_query("foo=bar").
       should.equal "foo" => "bar"
     Rack::Utils.parse_query("foo=\"bar\"").
@@ -43,7 +40,7 @@ context "Rack::Utils" do
     Rack::Utils.parse_query("foo%3Dbaz=bar").should.equal "foo=baz" => "bar"
   end
 
-  specify "should parse nested query strings correctly" do
+  should "parse nested query strings correctly" do
     Rack::Utils.parse_nested_query("foo").
       should.equal "foo" => nil
     Rack::Utils.parse_nested_query("foo=").
@@ -121,7 +118,7 @@ context "Rack::Utils" do
       message.should.equal "expected Array (got String) for param `y'"
   end
 
-  specify "should build query strings correctly" do
+  should "build query strings correctly" do
     Rack::Utils.build_query("foo" => "bar").should.equal "foo=bar"
     Rack::Utils.build_query("foo" => ["bar", "quux"]).
       should.equal "foo=bar&foo=quux"
@@ -131,7 +128,7 @@ context "Rack::Utils" do
       should.equal "my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F"
   end
 
-  specify "should build nested query strings correctly" do
+  should "build nested query strings correctly" do
     Rack::Utils.build_nested_query("foo" => nil).should.equal "foo"
     Rack::Utils.build_nested_query("foo" => "").should.equal "foo="
     Rack::Utils.build_nested_query("foo" => "bar").should.equal "foo=bar"
@@ -178,7 +175,7 @@ context "Rack::Utils" do
       message.should.equal "value must be a Hash"
   end
 
-  specify "should figure out which encodings are acceptable" do
+  should "figure out which encodings are acceptable" do
     helper = lambda do |a, b|
       request = Rack::Request.new(Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => a))
       Rack::Utils.select_best_encoding(a, b)
@@ -201,48 +198,43 @@ context "Rack::Utils" do
     helper.call(%w(foo bar baz identity), [["*", 0], ["identity", 0.1]]).should.equal("identity")
   end
 
-  specify "should return the bytesize of String" do
+  should "return the bytesize of String" do
     Rack::Utils.bytesize("FOO\xE2\x82\xAC").should.equal 6
   end
 
-  specify "should perform constant time string comparison" do
-    Rack::Utils.secure_compare('a', 'a').should.equal true
-    Rack::Utils.secure_compare('a', 'b').should.equal false
-  end
-
-  specify "should return status code for integer" do
+  should "return status code for integer" do
     Rack::Utils.status_code(200).should.equal 200
   end
 
-  specify "should return status code for string" do
+  should "return status code for string" do
     Rack::Utils.status_code("200").should.equal 200
   end
 
-  specify "should return status code for symbol" do
+  should "return status code for symbol" do
     Rack::Utils.status_code(:ok).should.equal 200
   end
 end
 
-context "Rack::Utils::HeaderHash" do
-  specify "should retain header case" do
+describe Rack::Utils::HeaderHash do
+  should "retain header case" do
     h = Rack::Utils::HeaderHash.new("Content-MD5" => "d5ff4e2a0 ...")
     h['ETag'] = 'Boo!'
     h.to_hash.should.equal "Content-MD5" => "d5ff4e2a0 ...", "ETag" => 'Boo!'
   end
 
-  specify "should check existence of keys case insensitively" do
+  should "check existence of keys case insensitively" do
     h = Rack::Utils::HeaderHash.new("Content-MD5" => "d5ff4e2a0 ...")
     h.should.include 'content-md5'
     h.should.not.include 'ETag'
   end
 
-  specify "should merge case-insensitively" do
+  should "merge case-insensitively" do
     h = Rack::Utils::HeaderHash.new("ETag" => 'HELLO', "content-length" => '123')
     merged = h.merge("Etag" => 'WORLD', 'Content-Length' => '321', "Foo" => 'BAR')
     merged.should.equal "Etag"=>'WORLD', "Content-Length"=>'321', "Foo"=>'BAR'
   end
 
-  specify "should overwrite case insensitively and assume the new key's case" do
+  should "overwrite case insensitively and assume the new key's case" do
     h = Rack::Utils::HeaderHash.new("Foo-Bar" => "baz")
     h["foo-bar"] = "bizzle"
     h["FOO-BAR"].should.equal "bizzle"
@@ -250,55 +242,55 @@ context "Rack::Utils::HeaderHash" do
     h.to_hash.should.equal "foo-bar" => "bizzle"
   end
 
-  specify "should be converted to real Hash" do
+  should "be converted to real Hash" 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
+  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
 
-  specify "should replace hashes correctly" do
+  should "replace hashes correctly" do
     h = Rack::Utils::HeaderHash.new("Foo-Bar" => "baz")
     j = {"foo" => "bar"}
     h.replace(j)
     h["foo"].should.equal "bar"
   end
 
-  specify "should be able to delete the given key case-sensitively" do
+  should "be able to delete the given key case-sensitively" do
     h = Rack::Utils::HeaderHash.new("foo" => "bar")
     h.delete("foo")
     h["foo"].should.be.nil
     h["FOO"].should.be.nil
   end
 
-  specify "should be able to delete the given key case-insensitively" do
+  should "be able to delete the given key case-insensitively" do
     h = Rack::Utils::HeaderHash.new("foo" => "bar")
     h.delete("FOO")
     h["foo"].should.be.nil
     h["FOO"].should.be.nil
   end
 
-  specify "should return the deleted value when #delete is called on an existing key" do
+  should "return the deleted value when #delete is called on an existing key" do
     h = Rack::Utils::HeaderHash.new("foo" => "bar")
     h.delete("Foo").should.equal("bar")
   end
 
-  specify "should return nil when #delete is called on a non-existant key" do
+  should "return nil when #delete is called on a non-existant key" do
     h = Rack::Utils::HeaderHash.new("foo" => "bar")
     h.delete("Hello").should.be.nil
   end
 
-  specify "should avoid unnecessary object creation if possible" do
+  should "avoid unnecessary object creation if possible" do
     a = Rack::Utils::HeaderHash.new("foo" => "bar")
     b = Rack::Utils::HeaderHash.new(a)
     b.object_id.should.equal(a.object_id)
     b.should.equal(a)
   end
 
-  specify "should convert Array values to Strings when responding to #each" do
+  should "convert Array values to Strings when responding to #each" do
     h = Rack::Utils::HeaderHash.new("foo" => ["bar", "baz"])
     h.each do |k,v|
       k.should.equal("foo")
@@ -308,7 +300,7 @@ context "Rack::Utils::HeaderHash" do
 
 end
 
-context "Rack::Utils::Context" do
+describe Rack::Utils::Context do
   class ContextTest
     attr_reader :app
     def initialize app; @app=app; end
@@ -321,7 +313,7 @@ context "Rack::Utils::Context" do
   test_target4 = proc{|e| [200,{'Content-Type'=>'text/plain', 'Content-Length'=>'0'},['']] }
   test_app = ContextTest.new test_target4
 
-  specify "should set context correctly" do
+  should "set context correctly" do
     test_app.app.should.equal test_target4
     c1 = Rack::Utils::Context.new(test_app, test_target1)
     c1.for.should.equal test_app
@@ -331,7 +323,7 @@ context "Rack::Utils::Context" do
     c2.app.should.equal test_target2
   end
 
-  specify "should alter app on recontexting" do
+  should "alter app on recontexting" do
     c1 = Rack::Utils::Context.new(test_app, test_target1)
     c2 = c1.recontext(test_target2)
     c2.for.should.equal test_app
@@ -341,7 +333,7 @@ context "Rack::Utils::Context" do
     c3.app.should.equal test_target3
   end
 
-  specify "should run different apps" do
+  should "run different apps" do
     c1 = Rack::Utils::Context.new test_app, test_target1
     c2 = c1.recontext test_target2
     c3 = c2.recontext test_target3
@@ -355,21 +347,37 @@ context "Rack::Utils::Context" do
     r3 = c3.call(:misc_symbol)
     r3.should.be.nil
     r4 = Rack::MockRequest.new(a4).get('/')
-    r4.status.should.be 200
+    r4.status.should.equal 200
     r5 = Rack::MockRequest.new(a5).get('/')
-    r5.status.should.be 200
+    r5.status.should.equal 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
+describe Rack::Utils::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::Utils::Multipart.parse_multipart(env).should.equal nil
   end
 
-  specify "should parse multipart upload with text file" do
+  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"
@@ -382,7 +390,7 @@ context "Rack::Utils::Multipart" do
     params["files"][:tempfile].read.should.equal "contents"
   end
 
-  specify "should parse multipart upload with nested parameters" do
+  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"
@@ -395,7 +403,7 @@ context "Rack::Utils::Multipart" do
     params["foo"]["files"][:tempfile].read.should.equal "contents"
   end
 
-  specify "should parse multipart upload with binary file" do
+  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"
@@ -408,7 +416,7 @@ context "Rack::Utils::Multipart" do
     params["files"][:tempfile].read.length.should.equal 26473
   end
 
-  specify "should parse multipart upload with empty file" do
+  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"
@@ -421,7 +429,7 @@ context "Rack::Utils::Multipart" do
     params["files"][:tempfile].read.should.equal ""
   end
 
-  specify "should parse multipart upload with filename with semicolons" do
+  should "parse multipart upload with filename with semicolons" do
     env = Rack::MockRequest.env_for("/", multipart_fixture(:semicolon))
     params = Rack::Utils::Multipart.parse_multipart(env)
     params["files"][:type].should.equal "text/plain"
@@ -433,7 +441,7 @@ context "Rack::Utils::Multipart" do
     params["files"][:tempfile].read.should.equal "contents"
   end
 
-  specify "should not include file params if no file was selected" do
+  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"
@@ -441,7 +449,7 @@ context "Rack::Utils::Multipart" do
     params.keys.should.not.include "files"
   end
 
-  specify "should parse IE multipart upload and clean up filename" do
+  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"
@@ -454,7 +462,76 @@ context "Rack::Utils::Multipart" do
     params["files"][:tempfile].read.should.equal "contents"
   end
 
-  specify "rewinds input after parsing upload" do
+  should "parse filename and modification param" do
+    env = Rack::MockRequest.env_for("/", multipart_fixture(:filename_and_modification_param))
+    params = Rack::Utils::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::Utils::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::Utils::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::Utils::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::Utils::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)
@@ -464,7 +541,7 @@ context "Rack::Utils::Multipart" do
     input.read.length.should.equal 197
   end
 
-  specify "builds multipart body" do
+  it "builds multipart body" do
     files = Rack::Utils::Multipart::UploadedFile.new(multipart_file("file1.txt"))
     data  = Rack::Utils::Multipart.build_multipart("submit-name" => "Larry", "files" => files)
 
@@ -480,7 +557,7 @@ context "Rack::Utils::Multipart" do
     params["files"][:tempfile].read.should.equal "contents"
   end
 
-  specify "builds nested multipart body" do
+  it "builds nested multipart body" do
     files = Rack::Utils::Multipart::UploadedFile.new(multipart_file("file1.txt"))
     data  = Rack::Utils::Multipart.build_multipart("people" => [{"submit-name" => "Larry", "files" => files}])
 
@@ -496,7 +573,7 @@ context "Rack::Utils::Multipart" do
     params["people"][0]["files"][:tempfile].read.should.equal "contents"
   end
 
-  specify "can parse fields that end at the end of the buffer" do
+  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("/",
@@ -508,7 +585,7 @@ context "Rack::Utils::Multipart" do
     req.POST['addresses'].should.not.equal nil
   end
 
-  specify "builds complete params with the chunk size of 16384 slicing exactly on boundary" do
+  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",
@@ -527,31 +604,14 @@ context "Rack::Utils::Multipart" do
     params["AAAAAAAAAAAAAAAAAAA"]["PLAPLAPLA_MEMMEMMEMM_ATTRATTRER"]["new"]["-2"]["ba_unit_id"].should.equal "1017"
   end
 
-  specify "should return nil if no UploadedFiles were used" do
+  should "return nil if no UploadedFiles were used" do
     data = Rack::Utils::Multipart.build_multipart("people" => [{"submit-name" => "Larry", "files" => "contents"}])
     data.should.equal nil
   end
 
-  specify "should raise ArgumentError if params is not a Hash" do
+  should "raise ArgumentError if params is not a Hash" do
     lambda { Rack::Utils::Multipart.build_multipart("foo=bar") }.
       should.raise(ArgumentError).
       message.should.equal "value must be a Hash"
   end
-
-  private
-    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
 end