rack 1.0.1 → 1.1.0

data/test/spec_rack_mongrel.rb

@@ -6,14 +6,14 @@ require 'rack/urlmap'
 require 'rack/lint'
 require 'testrequest'
 require 'timeout'
-  
+
 Thread.abort_on_exception = true
 $tcp_defer_accept_opts = nil
 $tcp_cork_opts = nil
 
 context "Rack::Handler::Mongrel" do
   include TestRequest::Helpers
-  
+
   setup do
     server = Mongrel::HttpServer.new(@host='0.0.0.0', @port=9201)
     server.register('/test',
@@ -41,7 +41,7 @@ context "Rack::Handler::Mongrel" do
 
   specify "should have rack headers" do
     GET("/test")
-    response["rack.version"].should.equal [1,0]
+    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
@@ -52,7 +52,7 @@ context "Rack::Handler::Mongrel" do
     response["REQUEST_METHOD"].should.equal "GET"
     response["SCRIPT_NAME"].should.equal "/test"
     response["REQUEST_PATH"].should.equal "/test"
-    response["PATH_INFO"].should.be.nil
+    response["PATH_INFO"].should.be.equal ""
     response["QUERY_STRING"].should.equal ""
     response["test.postdata"].should.equal ""
 

data/test/spec_rack_nulllogger.rb

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

data/test/spec_rack_request.rb

@@ -35,9 +35,18 @@ context "Rack::Request" do
     req.host.should.equal "www2.example.org"
 
     req = Rack::Request.new \
-      Rack::MockRequest.env_for("/", "SERVER_NAME" => "example.org:9292")
+      Rack::MockRequest.env_for("/", "SERVER_NAME" => "example.org", "SERVER_PORT" => "9292")
     req.host.should.equal "example.org"
 
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/", "HTTP_HOST" => "localhost:81", "HTTP_X_FORWARDED_HOST" => "example.org:9292")
+    req.host.should.equal "example.org"
+
+    env = Rack::MockRequest.env_for("/", "SERVER_ADDR" => "192.168.1.1", "SERVER_PORT" => "9292")
+    env.delete("SERVER_NAME")
+    req = Rack::Request.new(env)
+    req.host.should.equal "192.168.1.1"
+
     env = Rack::MockRequest.env_for("/")
     env.delete("SERVER_NAME")
     req = Rack::Request.new(env)
@@ -52,9 +61,16 @@ context "Rack::Request" do
     req.params.should.equal "foo" => "bar", "quux" => "bla"
   end
 
-  specify "can parse POST data" do
+  specify "raises 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
     req = Rack::Request.new \
-      Rack::MockRequest.env_for("/?foo=quux", :input => "foo=bar&quux=bla")
+      Rack::MockRequest.env_for("/?foo=quux",
+        "REQUEST_METHOD" => 'POST',
+        :input => "foo=bar&quux=bla")
     req.content_type.should.be.nil
     req.media_type.should.be.nil
     req.query_string.should.equal "foo=quux"
@@ -63,7 +79,7 @@ context "Rack::Request" do
     req.params.should.equal "foo" => "bar", "quux" => "bla"
   end
 
-  specify "can parse POST data with explicit content type" do
+  specify "can 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',
@@ -78,6 +94,7 @@ context "Rack::Request" do
   specify "does 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',
         "CONTENT_TYPE" => 'text/plain;charset=utf-8',
         :input => "foo=bar&quux=bla")
     req.content_type.should.equal 'text/plain;charset=utf-8'
@@ -88,6 +105,16 @@ 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
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/?foo=quux",
+        "REQUEST_METHOD" => 'PUT',
+        "CONTENT_TYPE" => 'application/x-www-form-urlencoded',
+        :input => "foo=bar&quux=bla")
+    req.POST.should.equal "foo" => "bar", "quux" => "bla"
+    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 \
@@ -100,7 +127,8 @@ context "Rack::Request" do
 
   specify "cleans up Safari's ajax POST body" do
     req = Rack::Request.new \
-      Rack::MockRequest.env_for("/", :input => "foo=bar&quux=bla\0")
+      Rack::MockRequest.env_for("/",
+        'REQUEST_METHOD' => 'POST', :input => "foo=bar&quux=bla\0")
     req.POST.should.equal "foo" => "bar", "quux" => "bla"
   end
 
@@ -147,9 +175,21 @@ context "Rack::Request" do
     req.referer.should.equal "/"
   end
 
+  specify "user agent should be extracted correct" 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)"
+
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/")
+    req.user_agent.should.equal nil
+  end
+
   specify "can cache, but invalidates the cache" do
     req = Rack::Request.new \
-      Rack::MockRequest.env_for("/?foo=quux", :input => "foo=bar&quux=bla")
+      Rack::MockRequest.env_for("/?foo=quux",
+        "CONTENT_TYPE" => "application/x-www-form-urlencoded",
+        :input => "foo=bar&quux=bla")
     req.GET.should.equal "foo" => "quux"
     req.GET.should.equal "foo" => "quux"
     req.env["QUERY_STRING"] = "bla=foo"
@@ -424,6 +464,7 @@ Content-Transfer-Encoding: base64\r
 /9j/4AAQSkZJRgABAQAAAQABAAD//gA+Q1JFQVRPUjogZ2QtanBlZyB2MS4wICh1c2luZyBJSkcg\r
 --AaB03x--\r
 EOF
+    input.force_encoding("ASCII-8BIT") if input.respond_to? :force_encoding
     res = Rack::MockRequest.new(Rack::Lint.new(app)).get "/",
       "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x",
       "CONTENT_LENGTH" => input.size.to_s, "rack.input" => StringIO.new(input)

data/test/spec_rack_response.rb

@@ -118,6 +118,9 @@ context "Rack::Response" do
 
     r = Rack::Response.new([], 500)
     r.status.should.equal 500
+
+    r = Rack::Response.new([], "200 OK")
+    r.status.should.equal 200
   end
 
   specify "has a constructor that can take a block" do

data/test/spec_rack_runtime.rb

@@ -0,0 +1,35 @@
+require 'test/spec'
+require 'rack/mock'
+require 'rack/runtime'
+
+context "Rack::Runtime" do
+  specify "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[1]['X-Runtime'].should =~ /[\d\.]+/
+  end
+
+  specify "does not 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[1]['X-Runtime'].should == "foobar"
+  end
+
+  specify "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[1]['X-Runtime-Test'].should =~ /[\d\.]+/
+  end
+
+  specify "should allow multiple timers to be set" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] }
+    runtime1 = Rack::Runtime.new(app, "App")
+    runtime2 = Rack::Runtime.new(runtime1, "All")
+    response = runtime2.call({})
+
+    response[1]['X-Runtime-App'].should =~ /[\d\.]+/
+    response[1]['X-Runtime-All'].should =~ /[\d\.]+/
+
+    Float(response[1]['X-Runtime-All']).should > Float(response[1]['X-Runtime-App'])
+  end
+end

data/test/spec_rack_sendfile.rb

@@ -0,0 +1,86 @@
+require 'test/spec'
+require 'rack/mock'
+require 'rack/sendfile'
+
+context "Rack::File" do
+  specify "should respond to #to_path" do
+    Rack::File.new(Dir.pwd).should.respond_to :to_path
+  end
+end
+
+context "Rack::Sendfile" do
+  def sendfile_body
+    res = ['Hello World']
+    def res.to_path ; "/tmp/hello.txt" ; end
+    res
+  end
+
+  def simple_app(body=sendfile_body)
+    lambda { |env| [200, {'Content-Type' => 'text/plain'}, body] }
+  end
+
+  def sendfile_app(body=sendfile_body)
+    Rack::Sendfile.new(simple_app(body))
+  end
+
+  setup do
+    @request = Rack::MockRequest.new(sendfile_app)
+  end
+
+  def request(headers={})
+    yield @request.get('/', headers)
+  end
+
+  specify "does nothing when no X-Sendfile-Type header present" do
+    request do |response|
+      response.should.be.ok
+      response.body.should.equal 'Hello World'
+      response.headers.should.not.include 'X-Sendfile'
+    end
+  end
+
+  specify "sets X-Sendfile response header and discards body" do
+    request 'HTTP_X_SENDFILE_TYPE' => 'X-Sendfile' do |response|
+      response.should.be.ok
+      response.body.should.be.empty
+      response.headers['X-Sendfile'].should.equal '/tmp/hello.txt'
+    end
+  end
+
+  specify "sets X-Lighttpd-Send-File response header and discards body" do
+    request 'HTTP_X_SENDFILE_TYPE' => 'X-Lighttpd-Send-File' do |response|
+      response.should.be.ok
+      response.body.should.be.empty
+      response.headers['X-Lighttpd-Send-File'].should.equal '/tmp/hello.txt'
+    end
+  end
+
+  specify "sets X-Accel-Redirect response header and discards body" do
+    headers = {
+      'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect',
+      'HTTP_X_ACCEL_MAPPING' => '/tmp/=/foo/bar/'
+    }
+    request headers do |response|
+      response.should.be.ok
+      response.body.should.be.empty
+      response.headers['X-Accel-Redirect'].should.equal '/foo/bar/hello.txt'
+    end
+  end
+
+  specify 'writes to rack.error when no X-Accel-Mapping is specified' do
+    request 'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect' do |response|
+      response.should.be.ok
+      response.body.should.equal 'Hello World'
+      response.headers.should.not.include 'X-Accel-Redirect'
+      response.errors.should.include 'X-Accel-Mapping'
+    end
+  end
+
+  specify 'does nothing when body does not respond to #to_path' do
+    @request = Rack::MockRequest.new(sendfile_app(['Not a file...']))
+    request 'HTTP_X_SENDFILE_TYPE' => 'X-Sendfile' do |response|
+      response.body.should.equal 'Not a file...'
+      response.headers.should.not.include 'X-Sendfile'
+    end
+  end
+end

data/test/spec_rack_session_cookie.rb

@@ -46,16 +46,7 @@ context "Rack::Session::Cookie" do
         get("/", :fatal => true)
     }.should.raise(Rack::MockRequest::FatalWarning)
   end
-  
-  specify "creates a new cookie with integrity hash" do
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).get("/")
-    if RUBY_VERSION < "1.9"
-      res["Set-Cookie"].should.match("rack.session=BAh7BiIMY291bnRlcmkG%0A--1439b4d37b9d4b04c603848382f712d6fcd31088")
-    else
-      res["Set-Cookie"].should.match("rack.session=BAh7BkkiDGNvdW50ZXIGOg1lbmNvZGluZyINVVMtQVNDSUlpBg%3D%3D%0A--d7a6637b94d2728194a96c18484e1f7ed9074a83")
-    end
-  end
-  
+
   specify "loads from a cookie wih integrity hash" do
     res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).get("/")
     cookie = res["Set-Cookie"]

data/test/spec_rack_session_memcache.rb

@@ -8,7 +8,7 @@ begin
 
   context "Rack::Session::Memcache" do
     session_key = Rack::Session::Memcache::DEFAULT_OPTIONS[:key]
-    session_match = /#{session_key}=[0-9a-fA-F]+;/
+    session_match = /#{session_key}=([0-9a-fA-F]+);/
     incrementor = lambda do |env|
       env["rack.session"]["counter"] ||= 0
       env["rack.session"]["counter"] += 1
@@ -27,14 +27,20 @@ begin
       incrementor.call(env)
     end
 
-    specify "MemCache can connect to existing server" do
-      test_pool = MemCache.new :namespace => 'test:rack:session'
+    specify "faults on no connection" do
+      if RUBY_VERSION < "1.9"
+        lambda do
+          Rack::Session::Memcache.new incrementor, :memcache_server => 'nosuchserver'
+        end.should.raise
+      else
+        lambda do
+          Rack::Session::Memcache.new incrementor, :memcache_server => 'nosuchserver'
+        end.should.raise ArgumentError
+      end
     end
 
-    specify "faults on no connection" do
-      lambda do
-        Rack::Session::Memcache.new(incrementor, :memcache_server => '')
-      end.should.raise
+    specify "connect to existing server" do
+      test_pool = MemCache.new incrementor, :namespace => 'test:rack:session'
     end
 
     specify "creates a new cookie" do
@@ -151,6 +157,31 @@ begin
       res3.body.should.equal '{"counter"=>4}'
     end
 
+    specify "deep hashes are correctly updated" do
+      store = nil
+      hash_check = proc do |env|
+        session = env['rack.session']
+        unless session.include? 'test'
+          session.update :a => :b, :c => { :d => :e },
+            :f => { :g => { :h => :i} }, 'test' => true
+        else
+          session[:f][:g][:h] = :j
+        end
+        [200, {}, session.inspect]
+      end
+      pool = Rack::Session::Memcache.new(hash_check)
+      req = Rack::MockRequest.new(pool)
+
+      res0 = req.get("/")
+      session_id = (cookie = res0["Set-Cookie"])[session_match, 1]
+      ses0 = pool.pool.get(session_id, true)
+
+      res1 = req.get("/", "HTTP_COOKIE" => cookie)
+      ses1 = pool.pool.get(session_id, true)
+
+      ses1.should.not.equal ses0
+    end
+
     # anyone know how to do this better?
     specify "multithread: should cleanly merge sessions" do
       next unless $DEBUG
@@ -161,7 +192,7 @@ begin
       res = req.get('/')
       res.body.should.equal '{"counter"=>1}'
       cookie = res["Set-Cookie"]
-      sess_id = cookie[/#{pool.key}=([^,;]+)/,1]
+      session_id = cookie[session_match, 1]
 
       delta_incrementor = lambda do |env|
         # emulate disconjoinment of threading
@@ -178,12 +209,12 @@ begin
           run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
         end
       end.reverse.map{|t| t.run.join.value }
-      r.each do |res|
-        res['Set-Cookie'].should.equal cookie
-        res.body.should.include '"counter"=>2'
+      r.each do |request|
+        request['Set-Cookie'].should.equal cookie
+        request.body.should.include '"counter"=>2'
       end
 
-      session = pool.pool.get(sess_id)
+      session = pool.pool.get(session_id)
       session.size.should.be tnum+1 # counter
       session['counter'].should.be 2 # meeeh
 
@@ -202,12 +233,12 @@ begin
           run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
         end
       end.reverse.map{|t| t.run.join.value }
-      r.each do |res|
-        res['Set-Cookie'].should.equal cookie
-        res.body.should.include '"counter"=>3'
+      r.each do |request|
+        request['Set-Cookie'].should.equal cookie
+        request.body.should.include '"counter"=>3'
       end
 
-      session = pool.pool.get(sess_id)
+      session = pool.pool.get(session_id)
       session.size.should.be tnum+1
       session['counter'].should.be 3
 
@@ -224,17 +255,19 @@ begin
           run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
         end
       end.reverse.map{|t| t.run.join.value }
-      r.each do |res|
-        res['Set-Cookie'].should.equal cookie
-        res.body.should.include '"foo"=>"bar"'
+      r.each do |request|
+        request['Set-Cookie'].should.equal cookie
+        request.body.should.include '"foo"=>"bar"'
       end
 
-      session = pool.pool.get(sess_id)
+      session = pool.pool.get(session_id)
       session.size.should.be r.size+1
       session['counter'].should.be.nil?
       session['foo'].should.equal 'bar'
     end
   end
+rescue RuntimeError
+  $stderr.puts "Skipping Rack::Session::Memcache tests. Start memcached and try again."
 rescue LoadError
   $stderr.puts "Skipping Rack::Session::Memcache tests (Memcache is required). `gem install memcache-client` and try again."
 end

data/test/spec_rack_urlmap.rb

@@ -44,6 +44,12 @@ context "Rack::URLMap" do
     res["X-ScriptName"].should.equal "/foo/bar"
     res["X-PathInfo"].should.equal "/"
 
+    res = Rack::MockRequest.new(map).get("/foo///bar//quux")
+    res.status.should.equal 200
+    res.should.be.ok
+    res["X-ScriptName"].should.equal "/foo/bar"
+    res["X-PathInfo"].should.equal "//quux"
+
     res = Rack::MockRequest.new(map).get("/foo/quux", "SCRIPT_NAME" => "/bleh")
     res.should.be.ok
     res["X-ScriptName"].should.equal "/bleh/foo"
@@ -182,4 +188,28 @@ context "Rack::URLMap" do
     res["X-PathInfo"].should.equal "/"
     res["X-ScriptName"].should.equal ""
   end
+
+  specify "should not squeeze slashes" do
+    map = Rack::URLMap.new("/" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "root",
+                                "X-PathInfo" => env["PATH_INFO"],
+                                "X-ScriptName" => env["SCRIPT_NAME"]
+                              }, [""]]},
+                           "/foo" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "foo",
+                                "X-PathInfo" => env["PATH_INFO"],
+                                "X-ScriptName" => env["SCRIPT_NAME"]
+                              }, [""]]}
+                           )
+
+    res = Rack::MockRequest.new(map).get("/http://example.org/bar")
+    res.should.be.ok
+    res["X-Position"].should.equal "root"
+    res["X-PathInfo"].should.equal "/http://example.org/bar"
+    res["X-ScriptName"].should.equal ""
+  end
 end