rack 1.1.0 → 1.2.0

data/{test/spec_rack_mongrel.rb → spec/spec_mongrel.rb}

@@ -1,37 +1,32 @@
-require 'test/spec'
-
 begin
+require 'rack'
 require 'rack/handler/mongrel'
-require 'rack/urlmap'
-require 'rack/lint'
-require 'testrequest'
+require File.expand_path('../testrequest', __FILE__)
 require 'timeout'
 
 Thread.abort_on_exception = true
 $tcp_defer_accept_opts = nil
 $tcp_cork_opts = nil
 
-context "Rack::Handler::Mongrel" do
-  include TestRequest::Helpers
+describe Rack::Handler::Mongrel do
+  extend TestRequest::Helpers
 
-  setup do
-    server = Mongrel::HttpServer.new(@host='0.0.0.0', @port=9201)
-    server.register('/test',
-                    Rack::Handler::Mongrel.new(Rack::Lint.new(TestRequest.new)))
-    server.register('/stream',
-                    Rack::Handler::Mongrel.new(Rack::Lint.new(StreamingRequest)))
-    @acc = server.run
-  end
+  @server = Mongrel::HttpServer.new(@host='0.0.0.0', @port=9201)
+  @server.register('/test',
+                  Rack::Handler::Mongrel.new(Rack::Lint.new(TestRequest.new)))
+  @server.register('/stream',
+                  Rack::Handler::Mongrel.new(Rack::Lint.new(StreamingRequest)))
+  @acc = @server.run
 
-  specify "should respond" do
+  should "respond" do
     lambda {
       GET("/test")
     }.should.not.raise
   end
 
-  specify "should be a Mongrel" do
+  should "be a Mongrel" do
     GET("/test")
-    status.should.be 200
+    status.should.equal 200
     response["SERVER_SOFTWARE"].should =~ /Mongrel/
     response["HTTP_VERSION"].should.equal "HTTP/1.1"
     response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
@@ -39,15 +34,15 @@ context "Rack::Handler::Mongrel" 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"
@@ -64,7 +59,7 @@ context "Rack::Handler::Mongrel" 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"
@@ -75,18 +70,18 @@ context "Rack::Handler::Mongrel" 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 provide a .run" do
+  should "provide a .run" do
     block_ran = false
     Thread.new {
       Rack::Handler::Mongrel.run(lambda {}, {:Port => 9211}) { |server|
@@ -95,16 +90,16 @@ context "Rack::Handler::Mongrel" do
       }
     }
     sleep 1
-    block_ran.should.be true
+    block_ran.should.be.true
   end
 
-  specify "should provide a .run that maps a hash" do
+  should "provide a .run that maps a hash" do
     block_ran = false
     Thread.new {
       map = {'/'=>lambda{},'/foo'=>lambda{}}
       Rack::Handler::Mongrel.run(map, :map => true, :Port => 9221) { |server|
         server.should.be.kind_of Mongrel::HttpServer
-        server.classifier.uris.size.should.be 2
+        server.classifier.uris.size.should.equal 2
         server.classifier.uris.should.not.include '/arf'
         server.classifier.uris.should.include '/'
         server.classifier.uris.should.include '/foo'
@@ -112,16 +107,16 @@ context "Rack::Handler::Mongrel" do
       }
     }
     sleep 1
-    block_ran.should.be true
+    block_ran.should.be.true
   end
 
-  specify "should provide a .run that maps a urlmap" do
+  should "provide a .run that maps a urlmap" do
     block_ran = false
     Thread.new {
       map = Rack::URLMap.new({'/'=>lambda{},'/bar'=>lambda{}})
       Rack::Handler::Mongrel.run(map, {:map => true, :Port => 9231}) { |server|
         server.should.be.kind_of Mongrel::HttpServer
-        server.classifier.uris.size.should.be 2
+        server.classifier.uris.size.should.equal 2
         server.classifier.uris.should.not.include '/arf'
         server.classifier.uris.should.include '/'
         server.classifier.uris.should.include '/bar'
@@ -129,10 +124,10 @@ context "Rack::Handler::Mongrel" do
       }
     }
     sleep 1
-    block_ran.should.be true
+    block_ran.should.be.true
   end
 
-  specify "should provide a .run that maps a urlmap restricting by host" do
+  should "provide a .run that maps a urlmap restricting by host" do
     block_ran = false
     Thread.new {
       map = Rack::URLMap.new({
@@ -148,22 +143,22 @@ context "Rack::Handler::Mongrel" do
       Rack::Handler::Mongrel.run(map, opt) { |server|
         server.should.be.kind_of Mongrel::HttpServer
         server.classifier.uris.should.include '/'
-        server.classifier.handler_map['/'].size.should.be 2
+        server.classifier.handler_map['/'].size.should.equal 2
         server.classifier.uris.should.include '/foo'
-        server.classifier.handler_map['/foo'].size.should.be 1
+        server.classifier.handler_map['/foo'].size.should.equal 1
         server.classifier.uris.should.include '/bar'
-        server.classifier.handler_map['/bar'].size.should.be 2
+        server.classifier.handler_map['/bar'].size.should.equal 2
         server.classifier.uris.should.not.include '/qux'
         server.classifier.uris.should.not.include '/arf'
-        server.classifier.uris.size.should.be 3
+        server.classifier.uris.size.should.equal 3
         block_ran = true
       }
     }
     sleep 1
-    block_ran.should.be true
+    block_ran.should.be.true
   end
 
-  specify "should stream #each part of the response" do
+  should "stream #each part of the response" do
     body = ''
     begin
       Timeout.timeout(1) do
@@ -179,11 +174,10 @@ context "Rack::Handler::Mongrel" do
     body.should.not.be.empty
   end
 
-  teardown do
-    @acc.raise Mongrel::StopServer
-  end
+  @acc.raise Mongrel::StopServer
 end
 
-rescue LoadError
-  $stderr.puts "Skipping Rack::Handler::Mongrel tests (Mongrel is required). `gem install mongrel` and try again."
+rescue LoadError => ex
+  warn ex
+  warn "Skipping Rack::Handler::Mongrel tests (Mongrel is required). `gem install mongrel` and try again."
 end

data/{test/spec_rack_nulllogger.rb → spec/spec_nulllogger.rb}

@@ -1,13 +1,12 @@
 require 'rack/nulllogger'
-require 'rack/lint'
-require 'rack/mock'
 
-context "Rack::NullLogger" do
-  specify "acks as a nop logger" do
+describe Rack::NullLogger do
+  should "act as a noop logger" do
     app = lambda { |env|
       env['rack.logger'].warn "b00m"
       [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]]
     }
-    Rack::NullLogger.new(app).call({})
+    logger = Rack::NullLogger.new(app)
+    lambda{ logger.call({}) }.should.not.raise
   end
 end

data/{test/spec_rack_recursive.rb → spec/spec_recursive.rb}

@@ -1,53 +1,45 @@
-require 'test/spec'
-
 require 'rack/recursive'
-require 'rack/urlmap'
-require 'rack/response'
 require 'rack/mock'
 
-context "Rack::Recursive" do
-  setup do
-
-    @app1 = lambda { |env|
-      res = Rack::Response.new
-      res["X-Path-Info"] = env["PATH_INFO"]
-      res["X-Query-String"] = env["QUERY_STRING"]
-      res.finish do |res|
-        res.write "App1"
-      end
-    }
+describe Rack::Recursive do
+  @app1 = lambda { |env|
+    res = Rack::Response.new
+    res["X-Path-Info"] = env["PATH_INFO"]
+    res["X-Query-String"] = env["QUERY_STRING"]
+    res.finish do |inner_res|
+      inner_res.write "App1"
+    end
+  }
 
-    @app2 = lambda { |env|
-      Rack::Response.new.finish do |res|
-        res.write "App2"
-        _, _, body = env['rack.recursive.include'].call(env, "/app1")
-        body.each { |b|
-          res.write b
-        }
-      end
-    }
+  @app2 = lambda { |env|
+    Rack::Response.new.finish do |res|
+      res.write "App2"
+      _, _, body = env['rack.recursive.include'].call(env, "/app1")
+      body.each { |b|
+        res.write b
+      }
+    end
+  }
 
-    @app3 = lambda { |env|
-      raise Rack::ForwardRequest.new("/app1")
-    }
+  @app3 = lambda { |env|
+    raise Rack::ForwardRequest.new("/app1")
+  }
 
-    @app4 = lambda { |env|
-      raise Rack::ForwardRequest.new("http://example.org/app1/quux?meh")
-    }
-
-  end
+  @app4 = lambda { |env|
+    raise Rack::ForwardRequest.new("http://example.org/app1/quux?meh")
+  }
 
-  specify "should allow for subrequests" do
+  should "allow for subrequests" do
     res = Rack::MockRequest.new(Rack::Recursive.new(
                                   Rack::URLMap.new("/app1" => @app1,
                                                    "/app2" => @app2))).
       get("/app2")
 
     res.should.be.ok
-    res.body.should.equal "App2App1"    
+    res.body.should.equal "App2App1"
   end
 
-  specify "should raise error on requests not below the app" do
+  should "raise error on requests not below the app" do
     app = Rack::URLMap.new("/app1" => @app1,
                            "/app" => Rack::Recursive.new(
                               Rack::URLMap.new("/1" => @app1,
@@ -59,7 +51,7 @@ context "Rack::Recursive" do
       message.should =~ /can only include below/
   end
 
-  specify "should support forwarding" do
+  should "support forwarding" do
     app = Rack::Recursive.new(Rack::URLMap.new("/app1" => @app1,
                                                "/app3" => @app3,
                                                "/app4" => @app4))

data/{test/spec_rack_request.rb → spec/spec_request.rb}

@@ -1,11 +1,10 @@
-require 'test/spec'
 require 'stringio'
-
+require 'cgi'
 require 'rack/request'
 require 'rack/mock'
 
-context "Rack::Request" do
-  specify "wraps the rack variables" do
+describe Rack::Request do
+  should "wrap the rack variables" do
     req = Rack::Request.new(Rack::MockRequest.env_for("http://example.com:8080/"))
 
     req.body.should.respond_to? :gets
@@ -29,7 +28,7 @@ context "Rack::Request" do
     req.content_type.should.be.nil
   end
 
-  specify "can figure out the correct host" do
+  should "figure out the correct host" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/", "HTTP_HOST" => "www2.example.org")
     req.host.should.equal "www2.example.org"
@@ -53,7 +52,7 @@ context "Rack::Request" do
     req.host.should.equal ""
   end
 
-  specify "can parse the query string" do
+  should "parse the query string" do
     req = Rack::Request.new(Rack::MockRequest.env_for("/?foo=bar&quux=bla"))
     req.query_string.should.equal "foo=bar&quux=bla"
     req.GET.should.equal "foo" => "bar", "quux" => "bla"
@@ -61,12 +60,12 @@ context "Rack::Request" do
     req.params.should.equal "foo" => "bar", "quux" => "bla"
   end
 
-  specify "raises if rack.input is missing" do
+  should "raise if rack.input is missing" do
     req = Rack::Request.new({})
     lambda { req.POST }.should.raise(RuntimeError)
   end
 
-  specify "can parse POST data when method is POST and no Content-Type given" do
+  should "parse POST data when method is POST and no Content-Type given" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/?foo=quux",
         "REQUEST_METHOD" => 'POST',
@@ -79,7 +78,7 @@ context "Rack::Request" do
     req.params.should.equal "foo" => "bar", "quux" => "bla"
   end
 
-  specify "can parse POST data with explicit content type regardless of method" do
+  should "parse POST data with explicit content type regardless of method" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/",
         "CONTENT_TYPE" => 'application/x-www-form-urlencoded;foo=bar',
@@ -91,7 +90,7 @@ context "Rack::Request" do
     req.params.should.equal "foo" => "bar", "quux" => "bla"
   end
 
-  specify "does not parse POST data when media type is not form-data" do
+  should "not parse POST data when media type is not form-data" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/?foo=quux",
         "REQUEST_METHOD" => 'POST',
@@ -105,7 +104,7 @@ context "Rack::Request" do
     req.body.read.should.equal "foo=bar&quux=bla"
   end
 
-  specify "can parse POST data on PUT when media type is form-data" do
+  should "parse POST data on PUT when media type is form-data" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/?foo=quux",
         "REQUEST_METHOD" => 'PUT',
@@ -115,7 +114,7 @@ context "Rack::Request" do
     req.body.read.should.equal "foo=bar&quux=bla"
   end
 
-  specify "rewinds input after parsing POST data" do
+  should "rewind input after parsing POST data" do
     input = StringIO.new("foo=bar&quux=bla")
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/",
@@ -125,21 +124,21 @@ context "Rack::Request" do
     input.read.should.equal "foo=bar&quux=bla"
   end
 
-  specify "cleans up Safari's ajax POST body" do
+  should "clean up Safari's ajax POST body" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/",
         'REQUEST_METHOD' => 'POST', :input => "foo=bar&quux=bla\0")
     req.POST.should.equal "foo" => "bar", "quux" => "bla"
   end
 
-  specify "can get value by key from params with #[]" do
+  should "get value by key from params with #[]" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("?foo=quux")
     req['foo'].should.equal 'quux'
     req[:foo].should.equal 'quux'
   end
 
-  specify "can set value to key on params with #[]=" do
+  should "set value to key on params with #[]=" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("?foo=duh")
     req['foo'].should.equal 'duh'
@@ -157,7 +156,7 @@ context "Rack::Request" do
     req[:foo].should.equal 'jaz'
   end
 
-  specify "values_at answers values by keys in order given" do
+  should "return values for the keys in the order given from values_at" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("?foo=baz&wun=der&bar=ful")
     req.values_at('foo').should.equal ['baz']
@@ -165,7 +164,7 @@ context "Rack::Request" do
     req.values_at('bar', 'foo', 'wun').should.equal ['ful', 'baz', 'der']
   end
 
-  specify "referrer should be extracted correct" do
+  should "extract referrer correctly" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/", "HTTP_REFERER" => "/some/path")
     req.referer.should.equal "/some/path"
@@ -175,7 +174,7 @@ context "Rack::Request" do
     req.referer.should.equal "/"
   end
 
-  specify "user agent should be extracted correct" do
+  should "extract user agent correctly" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/", "HTTP_USER_AGENT" => "Mozilla/4.0 (compatible)")
     req.user_agent.should.equal "Mozilla/4.0 (compatible)"
@@ -185,7 +184,7 @@ context "Rack::Request" do
     req.user_agent.should.equal nil
   end
 
-  specify "can cache, but invalidates the cache" do
+  should "cache, but invalidates the cache" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/?foo=quux",
         "CONTENT_TYPE" => "application/x-www-form-urlencoded",
@@ -203,7 +202,7 @@ context "Rack::Request" do
     req.POST.should.equal "foo" => "bla", "quux" => "bar"
   end
 
-  specify "can figure out if called via XHR" do
+  should "figure out if called via XHR" do
     req = Rack::Request.new(Rack::MockRequest.env_for(""))
     req.should.not.be.xhr
 
@@ -212,7 +211,7 @@ context "Rack::Request" do
     req.should.be.xhr
   end
 
-  specify "can parse cookies" do
+  should "parse cookies" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("", "HTTP_COOKIE" => "foo=bar;quux=h&m")
     req.cookies.should.equal "foo" => "bar", "quux" => "h&m"
@@ -221,13 +220,13 @@ context "Rack::Request" do
     req.cookies.should.equal({})
   end
 
-  specify "parses cookies according to RFC 2109" do
+  should "parse cookies according to RFC 2109" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for('', 'HTTP_COOKIE' => 'foo=bar;foo=car')
     req.cookies.should.equal 'foo' => 'bar'
   end
 
-  specify "provides setters" do
+  should "provide setters" do
     req = Rack::Request.new(e=Rack::MockRequest.env_for(""))
     req.script_name.should.equal ""
     req.script_name = "/foo"
@@ -240,12 +239,12 @@ context "Rack::Request" do
     e["PATH_INFO"].should.equal "/foo"
   end
 
-  specify "provides the original env" do
-    req = Rack::Request.new(e=Rack::MockRequest.env_for(""))
-    req.env.should.be e
+  should "provide the original env" do
+    req = Rack::Request.new(e = Rack::MockRequest.env_for(""))
+    req.env.should == e
   end
 
-  specify "can restore the URL" do
+  should "restore the URL" do
     Rack::Request.new(Rack::MockRequest.env_for("")).url.
       should.equal "http://example.org/"
     Rack::Request.new(Rack::MockRequest.env_for("", "SCRIPT_NAME" => "/foo")).url.
@@ -263,7 +262,7 @@ context "Rack::Request" do
       should.equal "https://example.com:8080/foo?foo"
   end
 
-  specify "can restore the full path" do
+  should "restore the full path" do
     Rack::Request.new(Rack::MockRequest.env_for("")).fullpath.
       should.equal "/"
     Rack::Request.new(Rack::MockRequest.env_for("", "SCRIPT_NAME" => "/foo")).fullpath.
@@ -281,7 +280,7 @@ context "Rack::Request" do
       should.equal "/foo?foo"
   end
 
-  specify "can handle multiple media type parameters" do
+  should "handle multiple media type parameters" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/",
         "CONTENT_TYPE" => 'text/plain; foo=BAR,baz=bizzle dizzle;BLING=bam')
@@ -295,7 +294,7 @@ context "Rack::Request" do
       req.media_type_params['bling'].should.equal 'bam'
   end
 
-  specify "can parse multipart form data" do
+  should "parse multipart form data" do
     # Adapted from RFC 1867.
     input = <<EOF
 --AaB03x\r
@@ -334,7 +333,7 @@ EOF
     f[:tempfile].size.should.equal 76
   end
 
-  specify "can parse big multipart form data" do
+  should "parse big multipart form data" do
     input = <<EOF
 --AaB03x\r
 content-disposition: form-data; name="huge"; filename="huge"\r
@@ -356,7 +355,7 @@ EOF
     req.POST["mean"][:tempfile].read.should.equal "--AaB03xha"
   end
 
-  specify "can detect invalid multipart form data" do
+  should "detect invalid multipart form data" do
     input = <<EOF
 --AaB03x\r
 content-disposition: form-data; name="huge"; filename="huge"\r
@@ -395,12 +394,33 @@ EOF
     lambda { req.POST }.should.raise(EOFError)
   end
 
-  specify "shouldn't try to interpret binary as utf8" do
-    begin
-      original_kcode = $KCODE
-      $KCODE='UTF8'
+  should "not try to interpret binary as utf8" do
+    if /regexp/.respond_to?(:kcode) # < 1.9
+      begin
+        original_kcode = $KCODE
+        $KCODE='UTF8'
+
+        input = <<EOF
+--AaB03x\r
+content-disposition: form-data; name="fileupload"; filename="junk.a"\r
+content-type: application/octet-stream\r
+\r
+#{[0x36,0xCF,0x0A,0xF8].pack('c*')}\r
+--AaB03x--\r
+EOF
 
-      input = <<EOF
+        req = Rack::Request.new Rack::MockRequest.env_for("/",
+                          "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x",
+                          "CONTENT_LENGTH" => input.size,
+                          :input => input)
+
+        lambda{req.POST}.should.not.raise(EOFError)
+        req.POST["fileupload"][:tempfile].size.should.equal 4
+      ensure
+        $KCODE = original_kcode
+      end
+    else # >= 1.9
+        input = <<EOF
 --AaB03x\r
 content-disposition: form-data; name="fileupload"; filename="junk.a"\r
 content-type: application/octet-stream\r
@@ -416,13 +436,10 @@ EOF
 
       lambda{req.POST}.should.not.raise(EOFError)
       req.POST["fileupload"][:tempfile].size.should.equal 4
-    ensure
-      $KCODE = original_kcode
     end
   end
 
-
-  specify "should work around buggy 1.8.* Tempfile equality" do
+  should "work around buggy 1.8.* Tempfile equality" do
     input = <<EOF
 --AaB03x\r
 content-disposition: form-data; name="huge"; filename="huge"\r
@@ -440,11 +457,11 @@ EOF
                       "CONTENT_LENGTH" => input.size,
                       :input => rack_input)
 
-    lambda {req.POST}.should.not.raise
-    lambda {req.POST}.should.blaming("input re-processed!").not.raise
+    lambda{ req.POST }.should.not.raise
+    lambda{ req.POST }.should.not.raise("input re-processed!")
   end
 
-  specify "does conform to the Rack spec" do
+  should "conform to the Rack spec" do
     app = lambda { |env|
       content = Rack::Request.new(env).POST["file"].inspect
       size = content.respond_to?(:bytesize) ? content.bytesize : content.size
@@ -472,7 +489,7 @@ EOF
     res.should.be.ok
   end
 
-  specify "should parse Accept-Encoding correctly" do
+  should "parse Accept-Encoding correctly" do
     parser = lambda do |x|
       Rack::Request.new(Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => x)).accept_encoding
     end
@@ -488,7 +505,7 @@ EOF
     lambda { parser.call("gzip ; q=1.0") }.should.raise(RuntimeError)
   end
 
-  specify 'should provide ip information' do
+  should 'provide ip information' do
     app = lambda { |env|
       request = Rack::Request.new(env)
       response = Rack::Response.new
@@ -510,7 +527,13 @@ EOF
       'REMOTE_ADDR' => '123.123.123.123',
       'HTTP_X_FORWARDED_FOR' => '234.234.234.234,212.212.212.212'
 
-    res.body.should.equal '212.212.212.212'
+    res.body.should.equal '234.234.234.234'
+
+    res = mock.get '/',
+      'REMOTE_ADDR' => '123.123.123.123',
+      'HTTP_X_FORWARDED_FOR' => 'unknown,234.234.234.234,212.212.212.212'
+
+    res.body.should.equal '234.234.234.234'
   end
 
   class MyRequest < Rack::Request
@@ -519,7 +542,7 @@ EOF
     end
   end
 
-  specify "should allow subclass request to be instantiated after parent request" do
+  should "allow subclass request to be instantiated after parent request" do
     env = Rack::MockRequest.env_for("/?foo=bar")
 
     req1 = Rack::Request.new(env)
@@ -531,7 +554,7 @@ EOF
     req2.params.should.equal :foo => "bar"
   end
 
-  specify "should allow parent request to be instantiated after subclass request" do
+  should "allow parent request to be instantiated after subclass request" do
     env = Rack::MockRequest.env_for("/?foo=bar")
 
     req1 = MyRequest.new(env)
@@ -542,4 +565,16 @@ EOF
     req2.GET.should.equal "foo" => "bar"
     req2.params.should.equal "foo" => "bar"
   end
+
+  (0x20...0x7E).collect { |a|
+    b = a.chr
+    c = CGI.escape(b)
+    should "not strip '#{a}' => '#{c}' => '#{b}' escaped character from parameters when accessed as string" do
+      url = "/?foo=#{c}bar#{c}"
+      env = Rack::MockRequest.env_for(url)
+      req2 = Rack::Request.new(env)
+      req2.GET.should.equal "foo" => "#{b}bar#{b}"
+      req2.params.should.equal "foo" => "#{b}bar#{b}"
+    end
+  }
 end