rack 1.3.10 → 1.4.0

data/test/spec_sendfile.rb

@@ -40,6 +40,7 @@ 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'
     end
   end
@@ -48,6 +49,7 @@ 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'
     end
   end
@@ -60,6 +62,7 @@ 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'
     end
   end

data/test/spec_server.rb

@@ -10,13 +10,6 @@ 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"
@@ -68,8 +61,8 @@ describe Rack::Server do
       :daemonize   => false,
       :server      => 'webrick'
     )
-    t = Thread.new { server.start }
-    until t.status == 'sleep'; t.join(0.01) end
+    t = Thread.new { server.start { |s| Thread.current[:server] = s } }
+    t.join(0.01) until t[:server] && t[:server].status != :Stop
     body = open("http://127.0.0.1:#{server.options[:Port]}/") { |f| f.read }
     body.should.eql('success')
 
@@ -78,44 +71,4 @@ 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

data/test/spec_session_cookie.rb

@@ -11,7 +11,7 @@ describe Rack::Session::Cookie do
   end
 
   session_id = lambda do |env|
-    Rack::Response.new(env["rack.session"].inspect).to_a
+    Rack::Response.new(env["rack.session"].to_hash.inspect).to_a
   end
 
   session_option = lambda do |opt|
@@ -24,17 +24,6 @@ describe Rack::Session::Cookie do
     Rack::Response.new("Nothing").to_a
   end
 
-  before do
-    @warnings = warnings = []
-    Rack::Session::Cookie.class_eval do
-      define_method(:warn) { |m| warnings << m }
-    end
-  end
-
-  after do
-    Rack::Session::Cookie.class_eval { remove_method :warn }
-  end
-
   describe 'Base64' do
     it 'uses base64 to encode' do
       coder = Rack::Session::Cookie::Base64.new
@@ -68,14 +57,6 @@ describe Rack::Session::Cookie do
     end
   end
 
-  it "warns if no secret is given" do
-    cookie = Rack::Session::Cookie.new(incrementor)
-    @warnings.first.should =~ /no secret/i
-    @warnings.clear
-    cookie = Rack::Session::Cookie.new(incrementor, :secret => 'abc')
-    @warnings.should.be.empty?
-  end
-
   it 'uses a coder' do
     identity = Class.new {
       attr_reader :calls
@@ -118,18 +99,23 @@ describe Rack::Session::Cookie do
   end
 
   only_session_id = lambda do |env|
-    Rack::Response.new(env["rack.session"]["session_id"]).to_a
+    Rack::Response.new(env["rack.session"]["session_id"].to_s).to_a
   end
 
   it "renew session id" do
     res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).get("/")
     res = Rack::MockRequest.new(Rack::Session::Cookie.new(only_session_id)).
       get("/", "HTTP_COOKIE" => res["Set-Cookie"])
+
+    res.body.should.not.equal ""
     old_session_id = res.body
+
     res = Rack::MockRequest.new(Rack::Session::Cookie.new(renewer)).
       get("/", "HTTP_COOKIE" => res["Set-Cookie"])
     res = Rack::MockRequest.new(Rack::Session::Cookie.new(only_session_id)).
       get("/", "HTTP_COOKIE" => res["Set-Cookie"])
+
+    res.body.should.not.equal ""
     res.body.should.not.equal old_session_id
   end
 
@@ -163,6 +149,18 @@ describe Rack::Session::Cookie do
     res.body.should.equal '{"counter"=>3}'
   end
 
+  it "loads from a cookie wih accept-only integrity hash for graceful key rotation" do
+    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).get("/")
+    cookie = res["Set-Cookie"]
+    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test2', :old_secret => 'test')).
+      get("/", "HTTP_COOKIE" => cookie)
+    res.body.should.equal '{"counter"=>2}'
+    cookie = res["Set-Cookie"]
+    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test3', :old_secret => 'test2')).
+      get("/", "HTTP_COOKIE" => cookie)
+    res.body.should.equal '{"counter"=>3}'
+  end
+
   it "ignores tampered with session cookies" do
     app = Rack::Session::Cookie.new(incrementor, :secret => 'test')
     response1 = Rack::MockRequest.new(app).get("/")
@@ -177,6 +175,38 @@ describe Rack::Session::Cookie do
     response2.body.should.equal '{"counter"=>1}'
   end
 
+  describe "1.9 bugs relating to inspecting yet-to-be-loaded from cookie data: Rack::Session::Abstract::SessionHash" do
+
+    it "can handle Rack::Lint middleware" do
+      app = Rack::Session::Cookie.new(incrementor)
+      res = Rack::MockRequest.new(app).get("/")
+
+      app = Rack::Session::Cookie.new(Rack::Lint.new(session_id))
+      res = Rack::MockRequest.new(app).get("/", "HTTP_COOKIE" => res["Set-Cookie"])
+      res.body.should.not.be.nil
+    end
+
+    it "can handle a middleware that inspects the env" do
+      class TestEnvInspector
+        def initialize(app)
+          @app = app
+        end
+        def call(env)
+          env.inspect
+          @app.call(env)
+        end
+      end
+
+      app = Rack::Session::Cookie.new(incrementor)
+      res = Rack::MockRequest.new(app).get("/")
+
+      app = Rack::Session::Cookie.new(TestEnvInspector.new(session_id))
+      res = Rack::MockRequest.new(app).get("/", "HTTP_COOKIE" => res["Set-Cookie"])
+      res.body.should.not.be.nil
+    end
+
+  end
+
   it "returns the session id in the session hash" do
     app = Rack::Session::Cookie.new(incrementor)
     res = Rack::MockRequest.new(app).get("/")
@@ -211,10 +241,16 @@ describe Rack::Session::Cookie do
 
   it "returns even if not read/written if :expire_after is set" do
     app = Rack::Session::Cookie.new(nothing, :expire_after => 3600)
-    res = Rack::MockRequest.new(app).get("/")
+    res = Rack::MockRequest.new(app).get("/", 'rack.session' => {'not' => 'empty'})
     res["Set-Cookie"].should.not.be.nil
   end
 
+  it "returns no cookie if no data was written and no session was created previously, even if :expire_after is set" do
+    app = Rack::Session::Cookie.new(nothing, :expire_after => 3600)
+    res = Rack::MockRequest.new(app).get("/")
+    res["Set-Cookie"].should.be.nil
+  end
+
   it "exposes :secret in env['rack.session.option']" do
     app = Rack::Session::Cookie.new(session_option[:secret], :secret => "foo")
     res = Rack::MockRequest.new(app).get("/")

data/test/spec_session_memcache.rb

@@ -23,6 +23,10 @@ begin
       env['rack.session.options'][:defer] = true
       incrementor.call(env)
     end
+    skip_session = proc do |env|
+      env['rack.session.options'][:skip] = true
+      incrementor.call(env)
+    end
 
     # test memcache connection
     Rack::Session::Memcache.new(incrementor)
@@ -168,14 +172,40 @@ begin
       res4.body.should.equal '{"counter"=>1}'
     end
 
-    it "omits cookie with :defer option" do
+    it "omits cookie with :defer option but still updates the state" do
       pool = Rack::Session::Memcache.new(incrementor)
+      count = Rack::Utils::Context.new(pool, incrementor)
       defer = Rack::Utils::Context.new(pool, defer_session)
       dreq = Rack::MockRequest.new(defer)
+      creq = Rack::MockRequest.new(count)
 
       res0 = dreq.get("/")
       res0["Set-Cookie"].should.equal nil
       res0.body.should.equal '{"counter"=>1}'
+
+      res0 = creq.get("/")
+      res1 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
+      res1.body.should.equal '{"counter"=>2}'
+      res2 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
+      res2.body.should.equal '{"counter"=>3}'
+    end
+
+    it "omits cookie and state update with :skip option" do
+      pool = Rack::Session::Memcache.new(incrementor)
+      count = Rack::Utils::Context.new(pool, incrementor)
+      skip = Rack::Utils::Context.new(pool, skip_session)
+      sreq = Rack::MockRequest.new(skip)
+      creq = Rack::MockRequest.new(count)
+
+      res0 = sreq.get("/")
+      res0["Set-Cookie"].should.equal nil
+      res0.body.should.equal '{"counter"=>1}'
+
+      res0 = creq.get("/")
+      res1 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
+      res1.body.should.equal '{"counter"=>2}'
+      res2 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
+      res2.body.should.equal '{"counter"=>2}'
     end
 
     it "updates deep hashes correctly" do

data/test/spec_session_pool.rb

@@ -181,20 +181,26 @@ describe Rack::Session::Pool do
   end
 
   it "does not return a cookie if cookie was not read/written" do
-    app = Rack::Session::Cookie.new(nothing, :secret => 'abc')
+    app = Rack::Session::Pool.new(nothing)
     res = Rack::MockRequest.new(app).get("/")
     res["Set-Cookie"].should.be.nil
   end
 
   it "does not return a cookie if cookie was not written (only read)" do
-    app = Rack::Session::Cookie.new(session_id, :secret => 'abc')
+    app = Rack::Session::Pool.new(session_id)
     res = Rack::MockRequest.new(app).get("/")
     res["Set-Cookie"].should.be.nil
   end
 
   it "returns even if not read/written if :expire_after is set" do
-    app = Rack::Session::Cookie.new(nothing, :expire_after => 3600, :secret => 'abc')
-    res = Rack::MockRequest.new(app).get("/")
+    app = Rack::Session::Pool.new(nothing, :expire_after => 3600)
+    res = Rack::MockRequest.new(app).get("/", 'rack.session' => {'not' => 'empty'})
     res["Set-Cookie"].should.not.be.nil
   end
+
+  it "returns no cookie if no data was written and no session was created previously, even if :expire_after is set" do
+    app = Rack::Session::Pool.new(nothing, :expire_after => 3600)
+    res = Rack::MockRequest.new(app).get("/")
+    res["Set-Cookie"].should.be.nil
+  end
 end

data/test/spec_static.rb

@@ -11,9 +11,11 @@ describe Rack::Static do
   root = File.expand_path(File.dirname(__FILE__))
 
   OPTIONS = {:urls => ["/cgi"], :root => root}
+  STATIC_OPTIONS = {:urls => [""], :root => root, :index => 'static/index.html'}
   HASH_OPTIONS = {:urls => {"/cgi/sekret" => 'cgi/test'}, :root => root}
 
   @request = Rack::MockRequest.new(Rack::Static.new(DummyApp.new, OPTIONS))
+  @static_request = Rack::MockRequest.new(Rack::Static.new(DummyApp.new, STATIC_OPTIONS))
   @hash_request = Rack::MockRequest.new(Rack::Static.new(DummyApp.new, HASH_OPTIONS))
 
   it "serves files" do
@@ -33,6 +35,12 @@ describe Rack::Static do
     res.body.should == "Hello World"
   end
 
+  it "calls index file when requesting root" do
+    res = @static_request.get("/")
+    res.should.be.ok
+    res.body.should =~ /index!/
+  end
+
   it "serves hidden files" do
     res = @hash_request.get("/cgi/sekret")
     res.should.be.ok

data/test/spec_thin.rb

@@ -11,7 +11,7 @@ describe Rack::Handler::Thin do
   Thin::Logging.silent = true
 
   @thread = Thread.new do
-    Rack::Handler::Thin.run(@app, :Host => @host='0.0.0.0', :Port => @port=9204) do |server|
+    Rack::Handler::Thin.run(@app, :Host => @host='127.0.0.1', :Port => @port=9204) do |server|
       @server = server
     end
   end
@@ -30,7 +30,7 @@ describe Rack::Handler::Thin do
     response["HTTP_VERSION"].should.equal "HTTP/1.1"
     response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
     response["SERVER_PORT"].should.equal "9204"
-    response["SERVER_NAME"].should.equal "0.0.0.0"
+    response["SERVER_NAME"].should.equal "127.0.0.1"
   end
 
   should "have rack headers" do

data/test/spec_utils.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 require 'rack/utils'
 require 'rack/mock'
-require 'timeout'
 
 describe Rack::Utils do
   def kcodeu
@@ -12,6 +11,16 @@ describe Rack::Utils do
     $KCODE = default_kcode if one8
   end
 
+  should "round trip binary data" do
+    r = [218, 0].pack 'CC'
+    if defined?(::Encoding)
+      z = Rack::Utils.unescape(Rack::Utils.escape(r), Encoding::BINARY)
+    else
+      z = Rack::Utils.unescape(Rack::Utils.escape(r))
+    end
+    r.should.equal z
+  end
+
   should "escape correctly" do
     Rack::Utils.escape("fo<o>bar").should.equal "fo%3Co%3Ebar"
     Rack::Utils.escape("a space").should.equal "a+space"
@@ -43,7 +52,7 @@ describe Rack::Utils do
     should "unescape multibyte characters correctly if $KCODE is set to 'U'" do
       kcodeu do
         Rack::Utils.unescape('%E3%81%BE%E3%81%A4+%E3%82%82%E3%81%A8').should.equal(
-        "\xE3\x81\xBE\xE3\x81\xA4 \xE3\x82\x82\xE3\x81\xA8".unpack("a*")[0])
+          "\xE3\x81\xBE\xE3\x81\xA4 \xE3\x82\x82\xE3\x81\xA8".unpack("a*")[0])
       end
     end
   end
@@ -94,14 +103,6 @@ describe Rack::Utils do
     Rack::Utils.parse_query("my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F").
       should.equal "my weird field" => "q1!2\"'w$5&7/z8)?"
     Rack::Utils.parse_query("foo%3Dbaz=bar").should.equal "foo=baz" => "bar"
-    Rack::Utils.parse_query("=").should.equal "" => ""
-    Rack::Utils.parse_query("=value").should.equal "" => "value"
-    Rack::Utils.parse_query("key=").should.equal "key" => ""
-    Rack::Utils.parse_query("&key&").should.equal "key" => nil
-    Rack::Utils.parse_query(";key;", ";,").should.equal "key" => nil
-    Rack::Utils.parse_query(",key,", ";,").should.equal "key" => nil
-    Rack::Utils.parse_query(";foo=bar,;", ";,").should.equal "foo" => "bar"
-    Rack::Utils.parse_query(",foo=bar;,", ";,").should.equal "foo" => "bar"
   end
 
   should "parse nested query strings correctly" do
@@ -216,22 +217,22 @@ describe Rack::Utils do
     # unordered hash. Test that build_nested_query performs the inverse
     # function of parse_nested_query.
     [{"foo" => nil, "bar" => ""},
-     {"foo" => "bar", "baz" => ""},
-     {"foo" => ["1", "2"]},
-     {"foo" => "bar", "baz" => ["1", "2", "3"]},
-     {"foo" => ["bar"], "baz" => ["1", "2", "3"]},
-     {"foo" => ["1", "2"]},
-     {"foo" => "bar", "baz" => ["1", "2", "3"]},
-     {"x" => {"y" => {"z" => "1"}}},
-     {"x" => {"y" => {"z" => ["1"]}}},
-     {"x" => {"y" => {"z" => ["1", "2"]}}},
-     {"x" => {"y" => [{"z" => "1"}]}},
-     {"x" => {"y" => [{"z" => ["1"]}]}},
-     {"x" => {"y" => [{"z" => "1", "w" => "2"}]}},
-     {"x" => {"y" => [{"v" => {"w" => "1"}}]}},
-     {"x" => {"y" => [{"z" => "1", "v" => {"w" => "2"}}]}},
-     {"x" => {"y" => [{"z" => "1"}, {"z" => "2"}]}},
-     {"x" => {"y" => [{"z" => "1", "w" => "a"}, {"z" => "2", "w" => "3"}]}}
+      {"foo" => "bar", "baz" => ""},
+      {"foo" => ["1", "2"]},
+      {"foo" => "bar", "baz" => ["1", "2", "3"]},
+      {"foo" => ["bar"], "baz" => ["1", "2", "3"]},
+      {"foo" => ["1", "2"]},
+      {"foo" => "bar", "baz" => ["1", "2", "3"]},
+      {"x" => {"y" => {"z" => "1"}}},
+      {"x" => {"y" => {"z" => ["1"]}}},
+      {"x" => {"y" => {"z" => ["1", "2"]}}},
+      {"x" => {"y" => [{"z" => "1"}]}},
+      {"x" => {"y" => [{"z" => ["1"]}]}},
+      {"x" => {"y" => [{"z" => "1", "w" => "2"}]}},
+      {"x" => {"y" => [{"v" => {"w" => "1"}}]}},
+      {"x" => {"y" => [{"z" => "1", "v" => {"w" => "2"}}]}},
+      {"x" => {"y" => [{"z" => "1"}, {"z" => "2"}]}},
+      {"x" => {"y" => [{"z" => "1", "w" => "a"}, {"z" => "2", "w" => "3"}]}}
     ].each { |params|
       qs = Rack::Utils.build_nested_query(params)
       Rack::Utils.parse_nested_query(qs).should.equal params
@@ -242,6 +243,17 @@ describe Rack::Utils do
       message.should.equal "value must be a Hash"
   end
 
+  should "parse query strings that have a non-existent value" do
+    key = "post/2011/08/27/Deux-%22rat%C3%A9s%22-de-l-Universit"
+    Rack::Utils.parse_query(key).should.equal Rack::Utils.unescape(key) => nil
+  end
+
+  should "build query strings without = with non-existent values" do
+    key = "post/2011/08/27/Deux-%22rat%C3%A9s%22-de-l-Universit"
+    key = Rack::Utils.unescape(key)
+    Rack::Utils.build_query(key => nil).should.equal Rack::Utils.escape(key)
+  end
+
   should "escape html entities [&><'\"/]" do
     Rack::Utils.escape_html("foo").should.equal "foo"
     Rack::Utils.escape_html("f&o").should.equal "f&amp;o"
@@ -301,11 +313,6 @@ describe Rack::Utils do
     Rack::Utils.bytesize("FOO\xE2\x82\xAC").should.equal 6
   end
 
-  should "should perform constant time string comparison" do
-    Rack::Utils.secure_compare('a', 'a').should.equal true
-    Rack::Utils.secure_compare('a', 'b').should.equal false
-  end
-
   should "return status code for integer" do
     Rack::Utils.status_code(200).should.equal 200
   end
@@ -340,10 +347,6 @@ describe Rack::Utils, "byte_range" do
     Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=499-499"},500).should.equal [(499..499)]
   end
 
-  should "parse several byte ranges" do
-    Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=500-600,601-999"},1000).should.equal [(500..600),(601..999)]
-  end
-
   should "truncate byte ranges" do
     Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=123-999"},500).should.equal [(123..499)]
     Rack::Utils.byte_ranges({"HTTP_RANGE" => "bytes=600-999"},500).should.equal []