rack 0.4.0 → 0.9.0

data/test/spec_rack_content_length.rb

@@ -0,0 +1,43 @@
+require 'rack/mock'
+require 'rack/content_length'
+
+context "Rack::ContentLength" do
+  specify "sets Content-Length on String bodies if none is set" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] }
+    response = Rack::ContentLength.new(app).call({})
+    response[1]['Content-Length'].should.equal '13'
+  end
+
+  specify "sets Content-Length on Array bodies if none is set" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
+    response = Rack::ContentLength.new(app).call({})
+    response[1]['Content-Length'].should.equal '13'
+  end
+
+  specify "does not set Content-Length on variable length bodies" do
+    body = lambda { "Hello World!" }
+    def body.each ; yield call ; end
+
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, body] }
+    response = Rack::ContentLength.new(app).call({})
+    response[1]['Content-Length'].should.be.nil
+  end
+
+  specify "does not change Content-Length if it is already set" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'Content-Length' => '1'}, "Hello, World!"] }
+    response = Rack::ContentLength.new(app).call({})
+    response[1]['Content-Length'].should.equal '1'
+  end
+
+  specify "does not set Content-Length on 304 responses" do
+    app = lambda { |env| [304, {'Content-Type' => 'text/plain'}, []] }
+    response = Rack::ContentLength.new(app).call({})
+    response[1]['Content-Length'].should.equal nil
+  end
+
+  specify "does not set Content-Length when Transfer-Encoding is chunked" do
+    app = lambda { |env| [200, {'Transfer-Encoding' => 'chunked'}, []] }
+    response = Rack::ContentLength.new(app).call({})
+    response[1]['Content-Length'].should.equal nil
+  end
+end

data/test/spec_rack_deflater.rb

@@ -3,10 +3,11 @@ require 'test/spec'
 require 'rack/mock'
 require 'rack/deflater'
 require 'stringio'
+require 'time'  # for Time#httpdate
 
 context "Rack::Deflater" do
-  def build_response(body, accept_encoding, headers = {})
-    app = lambda { |env| [200, {}, body] }
+  def build_response(status, body, accept_encoding, headers = {})
+    app = lambda { |env| [status, {}, body] }
     request = Rack::MockRequest.env_for("", headers.merge("HTTP_ACCEPT_ENCODING" => accept_encoding))
     response = Rack::Deflater.new(app).call(request)
 
@@ -17,19 +18,19 @@ context "Rack::Deflater" do
     body = Object.new
     class << body; def each; yield("foo"); yield("bar"); end; end
 
-    response = build_response(body, "deflate")
+    response = build_response(200, body, "deflate")
 
     response[0].should.equal(200)
-    response[1].should.equal({ "Content-Encoding" => "deflate" })
+    response[1].should.equal({ "Content-Encoding" => "deflate", "Vary" => "Accept-Encoding" })
     response[2].to_s.should.equal("K\313\317OJ,\002\000")
   end
 
   # TODO: This is really just a special case of the above...
   specify "should be able to deflate String bodies" do
-    response = build_response("Hello world!", "deflate")
+    response = build_response(200, "Hello world!", "deflate")
 
     response[0].should.equal(200)
-    response[1].should.equal({ "Content-Encoding" => "deflate" })
+    response[1].should.equal({ "Content-Encoding" => "deflate", "Vary" => "Accept-Encoding" })
     response[2].to_s.should.equal("\363H\315\311\311W(\317/\312IQ\004\000")
   end
 
@@ -37,10 +38,10 @@ context "Rack::Deflater" do
     body = Object.new
     class << body; def each; yield("foo"); yield("bar"); end; end
 
-    response = build_response(body, "gzip")
+    response = build_response(200, body, "gzip")
 
     response[0].should.equal(200)
-    response[1].should.equal({ "Content-Encoding" => "gzip" })
+    response[1].should.equal({ "Content-Encoding" => "gzip", "Vary" => "Accept-Encoding" })
 
     io = StringIO.new(response[2].to_s)
     gz = Zlib::GzipReader.new(io)
@@ -49,22 +50,56 @@ context "Rack::Deflater" do
   end
 
   specify "should be able to fallback to no deflation" do
-    response = build_response("Hello world!", "superzip")
+    response = build_response(200, "Hello world!", "superzip")
 
     response[0].should.equal(200)
-    response[1].should.equal({})
+    response[1].should.equal({ "Vary" => "Accept-Encoding" })
     response[2].should.equal("Hello world!")
   end
 
+  specify "should be able to skip when there is no response entity body" do
+    response = build_response(304, [], "gzip")
+
+    response[0].should.equal(304)
+    response[1].should.equal({})
+    response[2].should.equal([])
+  end
+
   specify "should handle the lack of an acceptable encoding" do
-    response1 = build_response("Hello world!", "identity;q=0", "PATH_INFO" => "/")
+    response1 = build_response(200, "Hello world!", "identity;q=0", "PATH_INFO" => "/")
     response1[0].should.equal(406)
     response1[1].should.equal({"Content-Type" => "text/plain"})
-    response1[2].should.equal("An acceptable encoding for the requested resource / could not be found.")
+    response1[2].should.equal(["An acceptable encoding for the requested resource / could not be found."])
 
-    response2 = build_response("Hello world!", "identity;q=0", "SCRIPT_NAME" => "/foo", "PATH_INFO" => "/bar")
+    response2 = build_response(200, "Hello world!", "identity;q=0", "SCRIPT_NAME" => "/foo", "PATH_INFO" => "/bar")
     response2[0].should.equal(406)
     response2[1].should.equal({"Content-Type" => "text/plain"})
-    response2[2].should.equal("An acceptable encoding for the requested resource /foo/bar could not be found.")
+    response2[2].should.equal(["An acceptable encoding for the requested resource /foo/bar could not be found."])
+  end
+
+  specify "should handle gzip response with Last-Modified header" do
+    last_modified = Time.now.httpdate
+
+    app = lambda { |env| [200, { "Last-Modified" => last_modified }, "Hello World!"] }
+    request = Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => "gzip")
+    response = Rack::Deflater.new(app).call(request)
+
+    response[0].should.equal(200)
+    response[1].should.equal({ "Content-Encoding" => "gzip", "Vary" => "Accept-Encoding", "Last-Modified" => last_modified })
+
+    io = StringIO.new(response[2].to_s)
+    gz = Zlib::GzipReader.new(io)
+    gz.read.should.equal("Hello World!")
+    gz.close
+  end
+
+  specify "should do nothing when no-transform Cache-Control directive present" do
+    app = lambda { |env| [200, {'Cache-Control' => 'no-transform'}, ['Hello World!']] }
+    request = Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => "gzip")
+    response = Rack::Deflater.new(app).call(request)
+
+    response[0].should.equal(200)
+    response[1].should.not.include "Content-Encoding"
+    response[2].join.should.equal("Hello World!")
   end
 end

data/test/spec_rack_file.rb

@@ -47,4 +47,11 @@ context "Rack::File" do
 
     res.should.be.not_found
   end
+
+  specify "detects SystemCallErrors" do
+    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
+      get("/cgi")
+
+    res.should.be.not_found
+  end
 end

data/test/spec_rack_handler.rb

@@ -2,10 +2,10 @@ require 'test/spec'
 
 require 'rack/handler'
 
-context "Rack::Handler" do
-  class Rack::Handler::Lobster; end
-  class RockLobster; end
+class Rack::Handler::Lobster; end
+class RockLobster; end
 
+context "Rack::Handler" do
   specify "has registered default handlers" do
     Rack::Handler.get('cgi').should.equal Rack::Handler::CGI
     Rack::Handler.get('fastcgi').should.equal Rack::Handler::FastCGI

data/test/spec_rack_head.rb

@@ -0,0 +1,30 @@
+require 'rack/head'
+require 'rack/mock'
+
+context "Rack::Head" do
+  def test_response(headers = {})
+    app = lambda { |env| [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]] }
+    request = Rack::MockRequest.env_for("/", headers)
+    response = Rack::Head.new(app).call(request)
+
+    return response
+  end
+
+  specify "passes GET, POST, PUT, DELETE, OPTIONS, TRACE requests" do
+    %w[GET POST PUT DELETE OPTIONS TRACE].each do |type|
+      resp = test_response("REQUEST_METHOD" => type)
+
+      resp[0].should.equal(200)
+      resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"})
+      resp[2].should.equal(["foo"])
+    end
+  end
+
+  specify "removes body from HEAD requests" do
+    resp = test_response("REQUEST_METHOD" => "HEAD")
+
+    resp[0].should.equal(200)
+    resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"})
+    resp[2].should.equal([])
+  end
+end

data/test/spec_rack_lint.rb

@@ -67,9 +67,9 @@ context "Rack::Lint" do
       message.should.match(/url_scheme unknown/)
 
     lambda {
-      Rack::Lint.new(nil).call(env("REQUEST_METHOD" => "FUCKUP"))
+      Rack::Lint.new(nil).call(env("REQUEST_METHOD" => "FUCKUP?"))
     }.should.raise(Rack::Lint::LintError).
-      message.should.match(/REQUEST_METHOD unknown/)
+      message.should.match(/REQUEST_METHOD/)
 
     lambda {
       Rack::Lint.new(nil).call(env("SCRIPT_NAME" => "howdy"))
@@ -203,6 +203,47 @@ context "Rack::Lint" do
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/No Content-Type/)
+
+    [100, 101, 204, 304].each do |status|
+      lambda {
+        Rack::Lint.new(lambda { |env|
+                         [status, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                       }).call(env({}))
+      }.should.raise(Rack::Lint::LintError).
+        message.should.match(/Content-Type header found/)
+    end
+  end
+
+  specify "notices content-length errors" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Content-type" => "text/plain"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/No Content-Length/)
+
+    [100, 101, 204, 304].each do |status|
+      lambda {
+        Rack::Lint.new(lambda { |env|
+                         [status, {"Content-length" => "0"}, ""]
+                       }).call(env({}))
+      }.should.raise(Rack::Lint::LintError).
+        message.should.match(/Content-Length header found/)
+    end
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Content-type" => "text/plain", "Content-Length" => "0", "Transfer-Encoding" => "chunked"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/Content-Length header should not be used/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Content-type" => "text/plain", "Content-Length" => "1"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/Content-Length header was 1, but should be 0/)
   end
 
   specify "notices body errors" do
@@ -300,4 +341,40 @@ context "Rack::Lint" do
       message.should.match(/close must not be called/)
   end
 
+  specify "notices HEAD errors" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Content-type" => "test/plain", "Content-length" => "3"}, []]
+                     }).call(env({"REQUEST_METHOD" => "HEAD"}))
+    }.should.not.raise
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Content-type" => "test/plain", "Content-length" => "3"}, "foo"]
+                     }).call(env({"REQUEST_METHOD" => "HEAD"}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/body was given for HEAD/)
+  end
+end
+
+context "Rack::Lint::InputWrapper" do
+  specify "delegates :size to underlying IO object" do
+    class IOMock
+      def size
+        101
+      end
+    end
+
+    wrapper = Rack::Lint::InputWrapper.new(IOMock.new)
+    wrapper.size.should == 101
+  end
+
+  specify "delegates :rewind to underlying IO object" do
+    io = StringIO.new("123")
+    wrapper = Rack::Lint::InputWrapper.new(io)
+    wrapper.read.should == "123"
+    wrapper.read.should == ""
+    wrapper.rewind
+    wrapper.read.should == "123"
+  end
 end

data/test/spec_rack_methodoverride.rb

@@ -0,0 +1,60 @@
+require 'test/spec'
+
+require 'rack/mock'
+require 'rack/methodoverride'
+require 'stringio'
+
+context "Rack::MethodOverride" do
+  specify "should not affect GET requests" do
+    env = Rack::MockRequest.env_for("/?_method=delete", :method => "GET")
+    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
+    req = app.call(env)
+
+    req.env["REQUEST_METHOD"].should.equal "GET"
+  end
+
+  specify "_method parameter should modify REQUEST_METHOD for POST requests" do
+    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=put")
+    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
+    req = app.call(env)
+
+    req.env["REQUEST_METHOD"].should.equal "PUT"
+  end
+
+  specify "X-HTTP-Method-Override header should modify REQUEST_METHOD for POST requests" do
+    env = Rack::MockRequest.env_for("/",
+            :method => "POST",
+            "HTTP_X_HTTP_METHOD_OVERRIDE" => "PUT"
+          )
+    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
+    req = app.call(env)
+
+    req.env["REQUEST_METHOD"].should.equal "PUT"
+  end
+
+  specify "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 { |env| Rack::Request.new(env) })
+    req = app.call(env)
+
+    req.env["REQUEST_METHOD"].should.equal "POST"
+  end
+
+  specify "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 { |env| Rack::Request.new(env) })
+    req = app.call(env)
+
+    req.env["REQUEST_METHOD"].should.equal "POST"
+  end
+
+  specify "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 { |env| Rack::Request.new(env) })
+    req = app.call(env)
+
+    req.env["rack.methodoverride.original_method"].should.equal "POST"
+  end
+end

data/test/spec_rack_mock.rb

@@ -125,7 +125,7 @@ context "Rack::MockResponse" do
     res.original_headers["Content-Type"].should.equal "text/yaml"
     res["Content-Type"].should.equal "text/yaml"
     res.content_type.should.equal "text/yaml"
-    res.content_length.should.be.nil
+    res.content_length.should.be 381  # needs change often.
     res.location.should.be.nil
   end
 

data/test/spec_rack_mongrel.rb

@@ -5,7 +5,8 @@ require 'rack/handler/mongrel'
 require 'rack/urlmap'
 require 'rack/lint'
 require 'testrequest'
-
+require 'timeout'
+  
 Thread.abort_on_exception = true
 $tcp_defer_accept_opts = nil
 $tcp_cork_opts = nil
@@ -17,6 +18,8 @@ context "Rack::Handler::Mongrel" 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
 
@@ -160,6 +163,22 @@ context "Rack::Handler::Mongrel" do
     block_ran.should.be true
   end
 
+  specify "should stream #each part of the response" do
+    body = ''
+    begin
+      Timeout.timeout(1) do
+        Net::HTTP.start(@host, @port) do |http|
+          get = Net::HTTP::Get.new('/stream')
+          http.request(get) do |response|
+            response.read_body { |part| body << part }
+          end
+        end
+      end
+    rescue Timeout::Error
+    end
+    body.should.not.be.empty
+  end
+
   teardown do
     @acc.raise Mongrel::StopServer
   end

data/test/spec_rack_request.rb

@@ -83,6 +83,26 @@ context "Rack::Request" do
     req.body.read.should.equal "foo=bar&quux=bla"
   end
 
+  specify "rewinds input after parsing POST data" do
+    input = StringIO.new("foo=bar&quux=bla")
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/",
+        "CONTENT_TYPE" => 'application/x-www-form-urlencoded;foo=bar',
+        :input => input)
+    req.params.should.equal "foo" => "bar", "quux" => "bla"
+    input.read.should.equal "foo=bar&quux=bla"
+  end
+
+  specify "does not rewind unwindable CGI input" do
+    input = StringIO.new("foo=bar&quux=bla")
+    input.instance_eval "undef :rewind"
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/",
+        "CONTENT_TYPE" => 'application/x-www-form-urlencoded;foo=bar',
+        :input => input)
+    req.params.should.equal "foo" => "bar", "quux" => "bla"
+  end
+
   specify "can get value by key from params with #[]" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("?foo=quux")
@@ -289,7 +309,7 @@ EOF
                       "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x",
                       "CONTENT_LENGTH" => input.size,
                       :input => input)
-    
+
     req.POST["huge"][:tempfile].size.should.equal 32768
     req.POST["mean"][:tempfile].size.should.equal 10
     req.POST["mean"][:tempfile].read.should.equal "--AaB03xha"
@@ -398,4 +418,29 @@ EOF
 
     lambda { parser.call("gzip ; q=1.0") }.should.raise(RuntimeError)
   end
+
+  specify 'should provide ip information' do
+    app = lambda { |env|
+      request = Rack::Request.new(env)
+      response = Rack::Response.new
+      response.write request.ip
+      response.finish
+    }
+
+    mock = Rack::MockRequest.new(Rack::Lint.new(app))
+    res = mock.get '/', 'REMOTE_ADDR' => '123.123.123.123'
+    res.body.should == '123.123.123.123'
+
+    res = mock.get '/',
+      'REMOTE_ADDR' => '123.123.123.123',
+      'HTTP_X_FORWARDED_FOR' => '234.234.234.234'
+
+    res.body.should == '234.234.234.234'
+
+    res = mock.get '/',
+      'REMOTE_ADDR' => '123.123.123.123',
+      'HTTP_X_FORWARDED_FOR' => '234.234.234.234,212.212.212.212'
+
+    res.body.should == '212.212.212.212'
+  end
 end