rack 1.2.8 → 1.3.0.beta

data/test/spec_request.rb

@@ -16,6 +16,7 @@ describe Rack::Request do
     req.should.not.be.put
     req.should.not.be.delete
     req.should.not.be.head
+    req.should.not.be.patch
 
     req.script_name.should.equal ""
     req.path_info.should.equal "/"
@@ -52,6 +53,70 @@ describe Rack::Request do
     req.host.should.equal ""
   end
 
+  should "figure out the correct port" do
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "HTTP_HOST" => "www2.example.org")
+    req.port.should.equal 80
+
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "HTTP_HOST" => "www2.example.org:81")
+    req.port.should.equal 81
+
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "SERVER_NAME" => "example.org", "SERVER_PORT" => "9292")
+    req.port.should.equal 9292
+
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "HTTP_HOST" => "localhost:81", "HTTP_X_FORWARDED_HOST" => "example.org:9292")
+    req.port.should.equal 9292
+
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "HTTP_HOST" => "localhost:81", "HTTP_X_FORWARDED_HOST" => "example.org")
+    req.port.should.equal 80
+
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "HTTP_HOST" => "localhost:81", "HTTP_X_FORWARDED_HOST" => "example.org", "HTTP_X_FORWARDED_SSL" => "on")
+    req.port.should.equal 443
+
+     req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "HTTP_HOST" => "localhost:81", "HTTP_X_FORWARDED_HOST" => "example.org", "HTTP_X_FORWARDED_PROTO" => "https")
+    req.port.should.equal 443
+
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "HTTP_HOST" => "localhost:81", "HTTP_X_FORWARDED_HOST" => "example.org", "HTTP_X_FORWARDED_PORT" => "9393")
+    req.port.should.equal 9393
+
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "HTTP_HOST" => "localhost:81", "HTTP_X_FORWARDED_HOST" => "example.org:9393", "SERVER_PORT" => "80")
+    req.port.should.equal 9393
+
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "HTTP_HOST" => "localhost:81", "HTTP_X_FORWARDED_HOST" => "example.org", "SERVER_PORT" => "9393")
+    req.port.should.equal 80
+  end
+
+  should "figure out the correct host with port" do
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "HTTP_HOST" => "www2.example.org")
+    req.host_with_port.should.equal "www2.example.org"
+
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "HTTP_HOST" => "localhost:81")
+    req.host_with_port.should.equal "localhost:81"
+
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "SERVER_NAME" => "example.org", "SERVER_PORT" => "9292")
+    req.host_with_port.should.equal "example.org:9292"
+
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "HTTP_HOST" => "localhost:81", "HTTP_X_FORWARDED_HOST" => "example.org:9292")
+    req.host_with_port.should.equal "example.org:9292"
+
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "HTTP_HOST" => "localhost:81", "HTTP_X_FORWARDED_HOST" => "example.org", "SERVER_PORT" => "9393")
+    req.host_with_port.should.equal "example.org"
+  end
+
   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"
@@ -60,6 +125,20 @@ describe Rack::Request do
     req.params.should.equal "foo" => "bar", "quux" => "bla"
   end
 
+  should "not unify GET and POST when calling params" do
+    mr = Rack::MockRequest.env_for("/?foo=quux",
+      "REQUEST_METHOD" => 'POST',
+      :input => "foo=bar&quux=bla"
+    )
+    req = Rack::Request.new mr
+
+    req.params
+
+    req.GET.should.equal "foo" => "quux"
+    req.POST.should.equal "foo" => "bar", "quux" => "bla"
+    req.params.should.equal req.GET.merge(req.POST)
+  end
+
   should "raise if rack.input is missing" do
     req = Rack::Request.new({})
     lambda { req.POST }.should.raise(RuntimeError)
@@ -78,32 +157,6 @@ describe Rack::Request do
     req.params.should.equal "foo" => "bar", "quux" => "bla"
   end
 
-  should "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
-
-  should "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
-
   should "parse POST data with explicit content type regardless of method" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/",
@@ -197,7 +250,7 @@ describe Rack::Request do
 
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/")
-    req.referer.should.equal "/"
+    req.referer.should.equal nil
   end
 
   should "extract user agent correctly" do
@@ -210,6 +263,24 @@ describe Rack::Request do
     req.user_agent.should.equal nil
   end
 
+  should "treat missing content type as nil" do
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/")
+    req.content_type.should.equal nil
+  end
+
+  should "treat empty content type as nil" do
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "CONTENT_TYPE" => "")
+    req.content_type.should.equal nil
+  end
+
+  should "return nil media type for empty content type" do
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "CONTENT_TYPE" => "")
+    req.media_type.should.equal nil
+  end
+
   should "cache, but invalidates the cache" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/?foo=quux",
@@ -237,6 +308,40 @@ describe Rack::Request do
     req.should.be.xhr
   end
 
+  should "ssl detection" do
+    request = Rack::Request.new(Rack::MockRequest.env_for("/"))
+    request.scheme.should.equal "http"
+    request.should.not.be.ssl?
+
+    request = Rack::Request.new(Rack::MockRequest.env_for("/", 'HTTPS' => 'on'))
+    request.scheme.should.equal "https"
+    request.should.be.ssl?
+
+    request = Rack::Request.new(Rack::MockRequest.env_for("/", 'rack.url_scheme' => 'https'))
+    request.scheme.should.equal "https"
+    request.should.be.ssl?
+
+    request = Rack::Request.new(Rack::MockRequest.env_for("/", 'HTTP_HOST' => 'www.example.org:8080'))
+    request.scheme.should.equal "http"
+    request.should.not.be.ssl?
+
+    request = Rack::Request.new(Rack::MockRequest.env_for("/", 'HTTP_HOST' => 'www.example.org:8443', 'HTTPS' => 'on'))
+    request.scheme.should.equal "https"
+    request.should.be.ssl?
+
+    request = Rack::Request.new(Rack::MockRequest.env_for("/", 'HTTP_HOST' => 'www.example.org:8443', 'HTTP_X_FORWARDED_SSL' => 'on'))
+    request.scheme.should.equal "https"
+    request.should.be.ssl?
+
+    request = Rack::Request.new(Rack::MockRequest.env_for("/", 'HTTP_X_FORWARDED_PROTO' => 'https'))
+    request.scheme.should.equal "https"
+    request.should.be.ssl?
+
+    request = Rack::Request.new(Rack::MockRequest.env_for("/", 'HTTP_X_FORWARDED_PROTO' => 'https, http, http'))
+    request.scheme.should.equal "https"
+    request.should.be.ssl
+  end
+
   should "parse cookies" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("", "HTTP_COOKIE" => "foo=bar;quux=h&m")
@@ -252,6 +357,18 @@ describe Rack::Request do
     req.cookies.should.equal 'foo' => 'bar'
   end
 
+  should 'parse cookies with quotes' do
+    req = Rack::Request.new Rack::MockRequest.env_for('', {
+      'HTTP_COOKIE' => '$Version="1"; Customer="WILE_E_COYOTE"; $Path="/acme"; Part_Number="Rocket_Launcher_0001"; $Path="/acme"'
+    })
+    req.cookies.should.equal({
+      '$Version'    => '"1"',
+      'Customer'    => '"WILE_E_COYOTE"',
+      '$Path'       => '"/acme"',
+      'Part_Number' => '"Rocket_Launcher_0001"',
+    })
+  end
+
   should "provide setters" do
     req = Rack::Request.new(e=Rack::MockRequest.env_for(""))
     req.script_name.should.equal ""
@@ -270,6 +387,13 @@ describe Rack::Request do
     req.env.should == e
   end
 
+  should "restore the base URL" do
+    Rack::Request.new(Rack::MockRequest.env_for("")).base_url.
+      should.equal "http://example.org"
+    Rack::Request.new(Rack::MockRequest.env_for("", "SCRIPT_NAME" => "/foo")).base_url.
+      should.equal "http://example.org"
+  end
+
   should "restore the URL" do
     Rack::Request.new(Rack::MockRequest.env_for("")).url.
       should.equal "http://example.org/"
@@ -320,29 +444,71 @@ describe Rack::Request do
       req.media_type_params['bling'].should.equal 'bam'
   end
 
-  should "raise RangeError if the key space is exhausted" do
+  should "parse with junk before boundry" do
+    # Adapted from RFC 1867.
     input = <<EOF
+blah blah\r
+\r
+--AaB03x\r
+content-disposition: form-data; name="reply"\r
+\r
+yes\r
 --AaB03x\r
-Content-Disposition: form-data; name="text"\r
-Content-Type: text/plain; charset=US-ASCII\r
+content-disposition: form-data; name="fileupload"; filename="dj.jpg"\r
+Content-Type: image/jpeg\r
+Content-Transfer-Encoding: base64\r
 \r
-contents\r
+/9j/4AAQSkZJRgABAQAAAQABAAD//gA+Q1JFQVRPUjogZ2QtanBlZyB2MS4wICh1c2luZyBJSkcg\r
 --AaB03x--\r
 EOF
+    req = Rack::Request.new Rack::MockRequest.env_for("/",
+                      "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x",
+                      "CONTENT_LENGTH" => input.size,
+                      :input => input)
+
+    req.POST.should.include "fileupload"
+    req.POST.should.include "reply"
+
+    req.should.be.form_data
+    req.content_length.should.equal input.size
+    req.media_type.should.equal 'multipart/form-data'
+    req.media_type_params.should.include 'boundary'
+    req.media_type_params['boundary'].should.equal 'AaB03x'
+
+    req.POST["reply"].should.equal "yes"
+
+    f = req.POST["fileupload"]
+    f.should.be.kind_of Hash
+    f[:type].should.equal "image/jpeg"
+    f[:filename].should.equal "dj.jpg"
+    f.should.include :tempfile
+    f[:tempfile].size.should.equal 76
+  end
+
+  should "not infinite loop with a malformed HTTP request" do
+    # Adapted from RFC 1867.
+    input = <<EOF
+--AaB03x
+content-disposition: form-data; name="reply"
 
-    env = Rack::MockRequest.env_for("/", 
+yes
+--AaB03x
+content-disposition: form-data; name="fileupload"; filename="dj.jpg"
+Content-Type: image/jpeg
+Content-Transfer-Encoding: base64
+
+/9j/4AAQSkZJRgABAQAAAQABAAD//gA+Q1JFQVRPUjogZ2QtanBlZyB2MS4wICh1c2luZyBJSkcg
+--AaB03x--
+EOF
+    req = Rack::Request.new 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
+    lambda{req.POST}.should.raise(EOFError)
   end
 
+
   should "parse multipart form data" do
     # Adapted from RFC 1867.
     input = <<EOF
@@ -443,6 +609,24 @@ EOF
     lambda { req.POST }.should.raise(EOFError)
   end
 
+  should "correctly parse the part name from Content-Id header" do
+    input = <<EOF
+--AaB03x\r
+Content-Type: text/xml; charset=utf-8\r
+Content-Id: <soap-start>\r
+Content-Transfer-Encoding: 7bit\r
+\r
+foo\r
+--AaB03x--\r
+EOF
+    req = Rack::Request.new Rack::MockRequest.env_for("/",
+                      "CONTENT_TYPE" => "multipart/related, boundary=AaB03x",
+                      "CONTENT_LENGTH" => input.size,
+                      :input => input)
+
+    req.params.keys.should.equal ["<soap-start>"]
+  end
+
   should "not try to interpret binary as utf8" do
     if /regexp/.respond_to?(:kcode) # < 1.9
       begin

data/test/spec_response.rb

@@ -23,7 +23,7 @@ describe Rack::Response do
   it "can be written to" do
     response = Rack::Response.new
 
-    status, header, body = response.finish do
+    _, _, body = response.finish do
       response.write "foo"
       response.write "bar"
       response.write "baz"
@@ -42,6 +42,11 @@ describe Rack::Response do
     response["Content-Type"].should.equal "text/plain"
   end
 
+  it "can override the initial Content-Type with a different case" do
+    response = Rack::Response.new("", 200, "content-type" => "text/plain")
+    response["Content-Type"].should.equal "text/plain"
+  end
+
   it "can set cookies" do
     response = Rack::Response.new
 
@@ -147,7 +152,7 @@ describe Rack::Response do
       res.status = 404
       res.write "foo"
     }
-    status, header, body = r.finish
+    status, _, body = r.finish
     str = ""; body.each { |part| str << part }
     str.should.equal "foo"
     status.should.equal 404
@@ -155,10 +160,11 @@ describe Rack::Response do
 
   it "doesn't return invalid responses" do
     r = Rack::Response.new(["foo", "bar"], 204)
-    status, header, body = r.finish
+    _, header, body = r.finish
     str = ""; body.each { |part| str << part }
     str.should.be.empty
     header["Content-Type"].should.equal nil
+    header['Content-Length'].should.equal nil
 
     lambda {
       Rack::Response.new(Object.new)

data/test/spec_server.rb

@@ -0,0 +1,74 @@
+require 'rack'
+require 'rack/server'
+require 'tempfile'
+require 'socket'
+require 'open-uri'
+
+describe Rack::Server do
+
+  def app
+    lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['success']] }
+  end
+
+  it "overrides :config if :app is passed in" do
+    server = Rack::Server.new(:app => "FOO")
+    server.app.should == "FOO"
+  end
+
+  should "not include Rack::Lint in deployment or none environments" do
+    server = Rack::Server.new(:app => 'foo')
+    server.middleware['deployment'].flatten.should.not.include(Rack::Lint)
+    server.middleware['none'].flatten.should.not.include(Rack::Lint)
+  end
+
+  should "not include Rack::ShowExceptions in deployment or none environments" do
+    server = Rack::Server.new(:app => 'foo')
+    server.middleware['deployment'].flatten.should.not.include(Rack::ShowExceptions)
+    server.middleware['none'].flatten.should.not.include(Rack::ShowExceptions)
+  end
+
+  should "support CGI" do
+    begin
+      o, ENV["REQUEST_METHOD"] = ENV["REQUEST_METHOD"], 'foo'
+      server = Rack::Server.new(:app => 'foo')
+      server.server.name =~ /CGI/
+      Rack::Server.logging_middleware.call(server).should.eql(nil)
+    ensure
+      ENV['REQUEST_METHOD'] = o
+    end
+  end
+
+  should "not force any middleware under the none configuration" do
+    server = Rack::Server.new(:app => 'foo')
+    server.middleware['none'].should.be.empty
+  end
+
+  should "use a full path to the pidfile" do
+    # avoids issues with daemonize chdir
+    opts = Rack::Server.new.send(:parse_options, %w[--pid testing.pid])
+    opts[:pid].should.eql(::File.expand_path('testing.pid'))
+  end
+
+  should "run a server" do
+    pidfile = Tempfile.open('pidfile') { |f| break f }.path
+    FileUtils.rm pidfile
+    server = Rack::Server.new(
+      :app         => app,
+      :environment => 'none',
+      :pid         => pidfile,
+      :Port        => TCPServer.open('127.0.0.1', 0){|s| s.addr[1] },
+      :Host        => '127.0.0.1',
+      :daemonize   => false,
+      :server      => 'webrick'
+    )
+    t = Thread.new { server.start }
+    until t.status == 'sleep'; t.join(0.01) end
+    body = open("http://127.0.0.1:#{server.options[:Port]}/") { |f| f.read }
+    body.should.eql('success')
+
+    Process.kill(:INT, $$)
+    t.join
+    open(pidfile) { |f| f.read.should.eql $$.to_s }
+  end
+
+end