rack 1.1.0 → 1.2.0

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,11 +26,11 @@ 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\"").
-      should.equal "foo" => "bar"
+      should.equal "foo" => "\"bar\""
     Rack::Utils.parse_query("foo=bar&foo=quux").
       should.equal "foo" => ["bar", "quux"]
     Rack::Utils.parse_query("foo=1&bar=2").
@@ -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=").
@@ -51,7 +48,7 @@ context "Rack::Utils" do
     Rack::Utils.parse_nested_query("foo=bar").
       should.equal "foo" => "bar"
     Rack::Utils.parse_nested_query("foo=\"bar\"").
-      should.equal "foo" => "bar"
+      should.equal "foo" => "\"bar\""
 
     Rack::Utils.parse_nested_query("foo=bar&foo=quux").
       should.equal "foo" => "quux"
@@ -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,43 +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 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"
@@ -245,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")
@@ -303,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
@@ -316,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
@@ -326,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
@@ -336,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
@@ -350,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"
@@ -377,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"
@@ -390,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"
@@ -403,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"
@@ -416,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"
@@ -428,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"
@@ -436,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"
@@ -449,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)
@@ -459,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)
 
@@ -475,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}])
 
@@ -491,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("/",
@@ -503,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",
@@ -522,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

data/{test/spec_rack_webrick.rb → spec/spec_webrick.rb}

@@ -1,35 +1,29 @@
-require 'test/spec'
-
-require 'rack/handler/webrick'
-require 'rack/lint'
-require 'rack/response'
-require 'testrequest'
+require 'rack/mock'
+require File.expand_path('../testrequest', __FILE__)
 
 Thread.abort_on_exception = true
 
-context "Rack::Handler::WEBrick" do
-  include TestRequest::Helpers
-
-  setup do
-    @server = WEBrick::HTTPServer.new(:Host => @host='0.0.0.0',
-                                      :Port => @port=9202,
-                                      :Logger => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN),
-                                      :AccessLog => [])
-    @server.mount "/test", Rack::Handler::WEBrick,
-      Rack::Lint.new(TestRequest.new)
-    Thread.new { @server.start }
-    trap(:INT) { @server.shutdown }
-  end
+describe Rack::Handler::WEBrick do
+  extend TestRequest::Helpers
+
+  @server = WEBrick::HTTPServer.new(:Host => @host='0.0.0.0',
+                                    :Port => @port=9202,
+                                    :Logger => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN),
+                                    :AccessLog => [])
+  @server.mount "/test", Rack::Handler::WEBrick,
+    Rack::Lint.new(TestRequest.new)
+  Thread.new { @server.start }
+  trap(:INT) { @server.shutdown }
 
-  specify "should respond" do
+  should "respond" do
     lambda {
       GET("/test")
     }.should.not.raise
   end
 
-  specify "should be a WEBrick" do
+  should "be a WEBrick" do
     GET("/test")
-    status.should.be 200
+    status.should.equal 200
     response["SERVER_SOFTWARE"].should =~ /WEBrick/
     response["HTTP_VERSION"].should.equal "HTTP/1.1"
     response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
@@ -37,15 +31,15 @@ context "Rack::Handler::WEBrick" do
     response["SERVER_NAME"].should.equal "0.0.0.0"
   end
 
-  specify "should have rack headers" do
+  should "have rack headers" do
     GET("/test")
     response["rack.version"].should.equal [1,1]
-    response["rack.multithread"].should.be true
-    response["rack.multiprocess"].should.be false
-    response["rack.run_once"].should.be false
+    response["rack.multithread"].should.be.true
+    response["rack.multiprocess"].should.be.false
+    response["rack.run_once"].should.be.false
   end
 
-  specify "should have CGI headers on GET" do
+  should "have CGI headers on GET" do
     GET("/test")
     response["REQUEST_METHOD"].should.equal "GET"
     response["SCRIPT_NAME"].should.equal "/test"
@@ -69,7 +63,7 @@ context "Rack::Handler::WEBrick" 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("/test", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
     status.should.equal 200
     response["REQUEST_METHOD"].should.equal "POST"
@@ -80,18 +74,18 @@ context "Rack::Handler::WEBrick" 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
 
-  specify "should correctly set cookies" do
+  should "correctly set cookies" do
     @server.mount "/cookie-test", Rack::Handler::WEBrick,
     Rack::Lint.new(lambda { |req|
                      res = Rack::Response.new
@@ -107,7 +101,7 @@ context "Rack::Handler::WEBrick" do
     }
   end
 
-  specify "should provide a .run" do
+  should "provide a .run" do
     block_ran = false
     catch(:done) {
       Rack::Handler::WEBrick.run(lambda {},
@@ -120,11 +114,9 @@ context "Rack::Handler::WEBrick" do
         throw :done
       }
     }
-    block_ran.should.be true
+    block_ran.should.be.true
     @s.shutdown
   end
 
-  teardown do
-    @server.shutdown
-  end
+  @server.shutdown
 end