rack 1.4.1 → 1.4.2

data/test/spec_methodoverride.rb

@@ -3,20 +3,24 @@ require 'rack/methodoverride'
 require 'rack/mock'
 
 describe Rack::MethodOverride do
+  def app
+    Rack::Lint.new(Rack::MethodOverride.new(lambda {|e|
+      [200, {"Content-Type" => "text/plain"}, []]
+    }))
+  end
+  
   should "not affect GET requests" do
     env = Rack::MockRequest.env_for("/?_method=delete", :method => "GET")
-    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
-    req = app.call(env)
+    app.call env
 
-    req.env["REQUEST_METHOD"].should.equal "GET"
+    env["REQUEST_METHOD"].should.equal "GET"
   end
 
   should "modify REQUEST_METHOD for POST requests when _method parameter is set" do
     env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=put")
-    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
-    req = app.call(env)
+    app.call env
 
-    req.env["REQUEST_METHOD"].should.equal "PUT"
+    env["REQUEST_METHOD"].should.equal "PUT"
   end
 
   should "modify REQUEST_METHOD for POST requests when X-HTTP-Method-Override is set" do
@@ -24,36 +28,32 @@ describe Rack::MethodOverride do
             :method => "POST",
             "HTTP_X_HTTP_METHOD_OVERRIDE" => "PATCH"
           )
-    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
-    req = app.call(env)
+    app.call env
 
-    req.env["REQUEST_METHOD"].should.equal "PATCH"
+    env["REQUEST_METHOD"].should.equal "PATCH"
   end
 
   should "not modify REQUEST_METHOD if the method is unknown" do
     env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=foo")
-    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
-    req = app.call(env)
+    app.call env
 
-    req.env["REQUEST_METHOD"].should.equal "POST"
+    env["REQUEST_METHOD"].should.equal "POST"
   end
 
   should "not modify REQUEST_METHOD when _method is nil" do
     env = Rack::MockRequest.env_for("/", :method => "POST", :input => "foo=bar")
-    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
-    req = app.call(env)
+    app.call env
 
-    req.env["REQUEST_METHOD"].should.equal "POST"
+    env["REQUEST_METHOD"].should.equal "POST"
   end
 
   should "store the original REQUEST_METHOD prior to overriding" do
     env = Rack::MockRequest.env_for("/",
             :method => "POST",
             :input  => "_method=options")
-    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
-    req = app.call(env)
+    app.call env
 
-    req.env["rack.methodoverride.original_method"].should.equal "POST"
+    env["rack.methodoverride.original_method"].should.equal "POST"
   end
 
   should "not modify REQUEST_METHOD when given invalid multipart form data" do
@@ -63,11 +63,10 @@ content-disposition: form-data; name="huge"; filename="huge"\r
 EOF
     env = Rack::MockRequest.env_for("/",
                       "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x",
-                      "CONTENT_LENGTH" => input.size,
+                      "CONTENT_LENGTH" => input.size.to_s,
                       :method => "POST", :input => input)
-    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
-    req = app.call(env)
+    app.call env
 
-    req.env["REQUEST_METHOD"].should.equal "POST"
+    env["REQUEST_METHOD"].should.equal "POST"
   end
 end

data/test/spec_mock.rb

@@ -1,8 +1,9 @@
 require 'yaml'
+require 'rack/lint'
 require 'rack/mock'
 require 'stringio'
 
-app = lambda { |env|
+app = Rack::Lint.new(lambda { |env|
   req = Rack::Request.new(env)
 
   env["mock.postdata"] = env["rack.input"].read
@@ -11,10 +12,11 @@ app = lambda { |env|
     env["rack.errors"].flush
   end
 
-  Rack::Response.new(env.to_yaml,
+  body = req.head? ? "" : env.to_yaml
+  Rack::Response.new(body,
                      req.GET["status"] || 200,
                      "Content-Type" => "text/yaml").finish
-}
+})
 
 describe Rack::MockRequest do
   should "return a MockResponse" do
@@ -55,13 +57,16 @@ describe Rack::MockRequest do
     env = YAML.load(res.body)
     env["REQUEST_METHOD"].should.equal "PUT"
 
-    res = Rack::MockRequest.new(app).delete("", :input => "foo")
+    res = Rack::MockRequest.new(app).patch("", :input => "foo")
     env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "DELETE"
+    env["REQUEST_METHOD"].should.equal "PATCH"
 
-    res = Rack::MockRequest.new(app).head("", :input => "foo")
+    res = Rack::MockRequest.new(app).delete("", :input => "foo")
     env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "HEAD"
+    env["REQUEST_METHOD"].should.equal "DELETE"
+    
+    Rack::MockRequest.env_for("/", :method => "HEAD")["REQUEST_METHOD"].
+      should.equal "HEAD"
 
     Rack::MockRequest.env_for("/", :method => "OPTIONS")["REQUEST_METHOD"].
       should.equal "OPTIONS"

data/test/spec_multipart.rb

@@ -360,4 +360,33 @@ EOF
     params.should.equal({"description"=>"Very very blue"})
   end
 
+  should "parse multipart upload with no content-length header" do
+    env = Rack::MockRequest.env_for '/', multipart_fixture(:webkit)
+    env['CONTENT_TYPE'] = "multipart/form-data; boundary=----WebKitFormBoundaryWLHCs9qmcJJoyjKR"
+    env.delete 'CONTENT_LENGTH'
+    params = Rack::Multipart.parse_multipart(env)
+    params['profile']['bio'].should.include 'hello'
+  end
+
+  should "parse very long unquoted multipart file names" do
+    data = <<-EOF
+--AaB03x\r
+Content-Type: text/plain\r
+Content-Disposition: attachment; name=file; filename=#{'long' * 100}\r
+\r
+contents\r
+--AaB03x--\r
+    EOF
+
+    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::Utils::Multipart.parse_multipart(env)
+
+    params["file"][:filename].should.equal('long' * 100)
+  end
+
 end

data/test/spec_nulllogger.rb

@@ -1,12 +1,23 @@
+require 'enumerator'
+require 'rack/lint'
+require 'rack/mock'
 require 'rack/nulllogger'
 
 describe Rack::NullLogger do
+  ::Enumerator = ::Enumerable::Enumerator unless Object.const_defined?(:Enumerator)
+  
   should "act as a noop logger" do
     app = lambda { |env|
       env['rack.logger'].warn "b00m"
       [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]]
     }
-    logger = Rack::NullLogger.new(app)
-    lambda{ logger.call({}) }.should.not.raise
+    
+    logger = Rack::Lint.new(Rack::NullLogger.new(app))
+    
+    res = logger.call(Rack::MockRequest.env_for)
+    res[0..1].should.equal [
+      200, {'Content-Type' => 'text/plain'}
+    ]
+    Enumerator.new(res[2]).to_a.should.equal ["Hello, World!"]
   end
 end

data/test/spec_recursive.rb

@@ -1,3 +1,4 @@
+require 'rack/lint'
 require 'rack/recursive'
 require 'rack/mock'
 
@@ -28,11 +29,14 @@ describe Rack::Recursive do
   @app4 = lambda { |env|
     raise Rack::ForwardRequest.new("http://example.org/app1/quux?meh")
   }
+  
+  def recursive(map)
+    Rack::Lint.new Rack::Recursive.new(Rack::URLMap.new(map))
+  end
 
   should "allow for subrequests" do
-    res = Rack::MockRequest.new(Rack::Recursive.new(
-                                  Rack::URLMap.new("/app1" => @app1,
-                                                   "/app2" => @app2))).
+    res = Rack::MockRequest.new(recursive("/app1" => @app1,
+                                          "/app2" => @app2)).
       get("/app2")
 
     res.should.be.ok
@@ -41,9 +45,8 @@ describe Rack::Recursive 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,
-                                               "/2" => @app2)))
+                           "/app" => recursive("/1" => @app1,
+                                               "/2" => @app2))
 
     lambda {
       Rack::MockRequest.new(app).get("/app/2")
@@ -52,9 +55,9 @@ describe Rack::Recursive do
   end
 
   should "support forwarding" do
-    app = Rack::Recursive.new(Rack::URLMap.new("/app1" => @app1,
-                                               "/app3" => @app3,
-                                               "/app4" => @app4))
+    app = recursive("/app1" => @app1,
+                    "/app3" => @app3,
+                    "/app4" => @app4)
 
     res = Rack::MockRequest.new(app).get("/app3")
     res.should.be.ok

data/test/spec_request.rb

@@ -411,9 +411,9 @@ describe Rack::Request do
     req.cookies.should.equal 'foo' => 'bar'
   end
 
-  should "raise any errors on every request" do
+  should "pass through non-uri escaped cookies as-is" do
     req = Rack::Request.new Rack::MockRequest.env_for("", "HTTP_COOKIE" => "foo=%")
-    2.times { proc { req.cookies }.should.raise(ArgumentError) }
+    req.cookies["foo"].should == "%"
   end
 
   should "parse cookies according to RFC 2109" do

data/test/spec_response.rb

@@ -280,4 +280,34 @@ describe Rack::Response do
     res.close
     res.body.should.be.closed
   end
+
+  it "calls close on #body when 204, 205, or 304" do
+    res = Rack::Response.new
+    res.body = StringIO.new
+    res.finish
+    res.body.should.not.be.closed
+
+    res.status = 204
+    _, _, b = res.finish
+    res.body.should.be.closed
+    b.should.not == res.body
+
+    res.body = StringIO.new
+    res.status = 205
+    _, _, b = res.finish
+    res.body.should.be.closed
+    b.should.not == res.body
+
+    res.body = StringIO.new
+    res.status = 304
+    _, _, b = res.finish
+    res.body.should.be.closed
+    b.should.not == res.body
+  end
+
+  it "wraps the body from #to_ary to prevent infinite loops" do
+    res = Rack::Response.new
+    res.finish.last.should.not.respond_to?(:to_ary)
+    lambda { res.finish.last.to_ary }.should.raise(NoMethodError)
+  end
 end

data/test/spec_runtime.rb

@@ -1,27 +1,37 @@
+require 'rack/lint'
+require 'rack/mock'
 require 'rack/runtime'
 
 describe Rack::Runtime do
+  def runtime_app(app, *args)
+    Rack::Lint.new Rack::Runtime.new(app, *args)
+  end
+  
+  def request
+    Rack::MockRequest.env_for
+  end
+  
   it "sets X-Runtime is none is set" do
     app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] }
-    response = Rack::Runtime.new(app).call({})
+    response = runtime_app(app).call(request)
     response[1]['X-Runtime'].should =~ /[\d\.]+/
   end
 
   it "doesn't set the X-Runtime if it is already set" do
     app = lambda { |env| [200, {'Content-Type' => 'text/plain', "X-Runtime" => "foobar"}, "Hello, World!"] }
-    response = Rack::Runtime.new(app).call({})
+    response = runtime_app(app).call(request)
     response[1]['X-Runtime'].should == "foobar"
   end
 
   should "allow a suffix to be set" do
     app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] }
-    response = Rack::Runtime.new(app, "Test").call({})
+    response = runtime_app(app, "Test").call(request)
     response[1]['X-Runtime-Test'].should =~ /[\d\.]+/
   end
 
   should "allow multiple timers to be set" do
     app = lambda { |env| sleep 0.1; [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] }
-    runtime = Rack::Runtime.new(app, "App")
+    runtime = runtime_app(app, "App")
 
     # wrap many times to guarantee a measurable difference
     100.times do |i|
@@ -29,7 +39,7 @@ describe Rack::Runtime do
     end
     runtime = Rack::Runtime.new(runtime, "All")
 
-    response = runtime.call({})
+    response = runtime.call(request)
 
     response[1]['X-Runtime-App'].should =~ /[\d\.]+/
     response[1]['X-Runtime-All'].should =~ /[\d\.]+/

data/test/spec_sendfile.rb

@@ -1,3 +1,5 @@
+require 'fileutils'
+require 'rack/lint'
 require 'rack/sendfile'
 require 'rack/mock'
 
@@ -9,8 +11,9 @@ end
 
 describe Rack::Sendfile do
   def sendfile_body
+    FileUtils.touch "/tmp/rack_sendfile"
     res = ['Hello World']
-    def res.to_path ; "/tmp/hello.txt" ; end
+    def res.to_path ; "/tmp/rack_sendfile" ; end
     res
   end
 
@@ -19,7 +22,7 @@ describe Rack::Sendfile do
   end
 
   def sendfile_app(body=sendfile_body)
-    Rack::Sendfile.new(simple_app(body))
+    Rack::Lint.new Rack::Sendfile.new(simple_app(body))
   end
 
   @request = Rack::MockRequest.new(sendfile_app)
@@ -40,8 +43,8 @@ describe Rack::Sendfile do
     request 'HTTP_X_SENDFILE_TYPE' => 'X-Sendfile' do |response|
       response.should.be.ok
       response.body.should.be.empty
-      response.headers['Content-Length'].should == '0'
-      response.headers['X-Sendfile'].should.equal '/tmp/hello.txt'
+      response.headers['Content-Length'].should.equal '0'
+      response.headers['X-Sendfile'].should.equal '/tmp/rack_sendfile'
     end
   end
 
@@ -49,8 +52,8 @@ describe Rack::Sendfile do
     request 'HTTP_X_SENDFILE_TYPE' => 'X-Lighttpd-Send-File' do |response|
       response.should.be.ok
       response.body.should.be.empty
-      response.headers['Content-Length'].should == '0'
-      response.headers['X-Lighttpd-Send-File'].should.equal '/tmp/hello.txt'
+      response.headers['Content-Length'].should.equal '0'
+      response.headers['X-Lighttpd-Send-File'].should.equal '/tmp/rack_sendfile'
     end
   end
 
@@ -62,8 +65,8 @@ describe Rack::Sendfile do
     request headers do |response|
       response.should.be.ok
       response.body.should.be.empty
-      response.headers['Content-Length'].should == '0'
-      response.headers['X-Accel-Redirect'].should.equal '/foo/bar/hello.txt'
+      response.headers['Content-Length'].should.equal '0'
+      response.headers['X-Accel-Redirect'].should.equal '/foo/bar/rack_sendfile'
     end
   end
 

data/test/spec_server.rb

@@ -10,6 +10,13 @@ describe Rack::Server do
     lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['success']] }
   end
 
+  def with_stderr
+    old, $stderr = $stderr, StringIO.new
+    yield $stderr
+  ensure
+    $stderr = old
+  end
+
   it "overrides :config if :app is passed in" do
     server = Rack::Server.new(:app => "FOO")
     server.app.should == "FOO"
@@ -71,4 +78,44 @@ describe Rack::Server do
     open(pidfile) { |f| f.read.should.eql $$.to_s }
   end
 
+  should "check pid file presence and running process" do
+    pidfile = Tempfile.open('pidfile') { |f| f.write($$); break f }.path
+    server = Rack::Server.new(:pid => pidfile)
+    server.send(:pidfile_process_status).should.eql :running
+  end
+
+  should "check pid file presence and dead process" do
+    dead_pid = `echo $$`.to_i
+    pidfile = Tempfile.open('pidfile') { |f| f.write(dead_pid); break f }.path
+    server = Rack::Server.new(:pid => pidfile)
+    server.send(:pidfile_process_status).should.eql :dead
+  end
+
+  should "check pid file presence and exited process" do
+    pidfile = Tempfile.open('pidfile') { |f| break f }.path
+    ::File.delete(pidfile)
+    server = Rack::Server.new(:pid => pidfile)
+    server.send(:pidfile_process_status).should.eql :exited
+  end
+
+  should "check pid file presence and not owned process" do
+    pidfile = Tempfile.open('pidfile') { |f| f.write(1); break f }.path
+    server = Rack::Server.new(:pid => pidfile)
+    server.send(:pidfile_process_status).should.eql :not_owned
+  end
+
+  should "inform the user about existing pidfiles with running processes" do
+    pidfile = Tempfile.open('pidfile') { |f| f.write(1); break f }.path
+    server = Rack::Server.new(:pid => pidfile)
+    with_stderr do |err|
+      should.raise(SystemExit) do
+        server.start
+      end
+      err.rewind
+      output = err.read
+      output.should.match(/already running/)
+      output.should.include? pidfile
+    end
+  end
+
 end