rack 1.1.6 → 1.2.0

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,33 +78,7 @@ context "Rack::Request" do
     req.params.should.equal "foo" => "bar", "quux" => "bla"
   end
 
-  specify "limit the keys from the GET query string" do
-    env = Rack::MockRequest.env_for("/?foo=bar")
-
-    old, Rack::Utils.key_space_limit = Rack::Utils.key_space_limit, 1
-    begin
-      req = Rack::Request.new(env)
-      lambda { req.GET }.should.raise(RangeError)
-    ensure
-      Rack::Utils.key_space_limit = old
-    end
-  end
-
-  specify "limit the keys from the POST form data" do
-    env = Rack::MockRequest.env_for("",
-            "REQUEST_METHOD" => 'POST',
-            :input => "foo=bar&quux=bla")
-
-    old, Rack::Utils.key_space_limit = Rack::Utils.key_space_limit, 1
-    begin
-      req = Rack::Request.new(env)
-      lambda { req.POST }.should.raise(RangeError)
-    ensure
-      Rack::Utils.key_space_limit = old
-    end
-  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',
@@ -117,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',
@@ -131,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',
@@ -141,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("/",
@@ -151,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'
@@ -183,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']
@@ -191,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"
@@ -201,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)"
@@ -211,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",
@@ -229,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
 
@@ -238,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"
@@ -247,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"
@@ -266,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.
@@ -289,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.
@@ -307,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')
@@ -321,30 +294,7 @@ context "Rack::Request" do
       req.media_type_params['bling'].should.equal 'bam'
   end
 
-  specify "raise RangeError if the key space is exhausted" do
-    input = <<EOF
---AaB03x\r
-Content-Disposition: form-data; name="text"\r
-Content-Type: text/plain; charset=US-ASCII\r
-\r
-contents\r
---AaB03x--\r
-EOF
-
-    env = Rack::MockRequest.env_for("/", 
-                      "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x",
-                      "CONTENT_LENGTH" => input.size,
-                      :input => input)
-
-    old, Rack::Utils.key_space_limit = Rack::Utils.key_space_limit, 1
-    begin
-      lambda { Rack::Utils::Multipart.parse_multipart(env) }.should.raise(RangeError)
-    ensure
-      Rack::Utils.key_space_limit = old
-    end
-  end
-
-  specify "can parse multipart form data" do
+  should "parse multipart form data" do
     # Adapted from RFC 1867.
     input = <<EOF
 --AaB03x\r
@@ -383,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
@@ -405,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
@@ -444,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
@@ -465,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
@@ -489,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
@@ -521,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
@@ -537,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
@@ -559,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
@@ -568,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)
@@ -580,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)
@@ -591,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