rack 1.4.1 → 1.4.2

data/test/spec_session_cookie.rb

@@ -1,4 +1,5 @@
 require 'rack/session/cookie'
+require 'rack/lint'
 require 'rack/mock'
 
 describe Rack::Session::Cookie do
@@ -9,7 +10,7 @@ describe Rack::Session::Cookie do
     hash.delete("session_id")
     Rack::Response.new(hash.inspect).to_a
   end
-
+  
   session_id = lambda do |env|
     Rack::Response.new(env["rack.session"].to_hash.inspect).to_a
   end
@@ -24,6 +25,50 @@ describe Rack::Session::Cookie do
     Rack::Response.new("Nothing").to_a
   end
 
+  renewer = lambda do |env|
+    env["rack.session.options"][:renew] = true
+    Rack::Response.new("Nothing").to_a
+  end
+
+  only_session_id = lambda do |env|
+    Rack::Response.new(env["rack.session"]["session_id"].to_s).to_a
+  end
+
+  bigcookie = lambda do |env|
+    env["rack.session"]["cookie"] = "big" * 3000
+    Rack::Response.new(env["rack.session"].inspect).to_a
+  end
+
+  destroy_session = lambda do |env|
+    env["rack.session"].destroy
+    Rack::Response.new("Nothing").to_a
+  end
+
+  def response_for(options={})
+    request_options = options.fetch(:request, {})
+    cookie = if options[:cookie].is_a?(Rack::Response)
+      options[:cookie]["Set-Cookie"]
+    else
+      options[:cookie]
+    end
+    request_options["HTTP_COOKIE"] = cookie || ""
+
+    app_with_cookie = Rack::Session::Cookie.new(*options[:app])
+    app_with_cookie = Rack::Lint.new(app_with_cookie)
+    Rack::MockRequest.new(app_with_cookie).get("/", request_options)
+  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
@@ -57,6 +102,14 @@ 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
@@ -291,4 +344,18 @@ describe Rack::Session::Cookie do
     res = Rack::MockRequest.new(app).get("/", 'rack.session' => {:foo => 'bar'})
     res.body.should.match(/foo/)
   end
+
+  it "allows modifying session data with session data from middleware in front" do
+    request = { 'rack.session' => { :foo => 'bar' }}
+    response = response_for(:app => incrementor, :request => request)
+    response.body.should.match(/counter/)
+    response.body.should.match(/foo/)
+  end
+
+  it "allows modifying session data with session data from middleware in front" do
+    request = { 'rack.session' => { :foo => 'bar' }}
+    response = response_for(:app => incrementor, :request => request)
+    response.body.should.match(/counter/)
+    response.body.should.match(/foo/)
+  end
 end

data/test/spec_session_memcache.rb

@@ -1,5 +1,6 @@
 begin
   require 'rack/session/memcache'
+  require 'rack/lint'
   require 'rack/mock'
   require 'thread'
 
@@ -11,22 +12,23 @@ begin
       env["rack.session"]["counter"] += 1
       Rack::Response.new(env["rack.session"].inspect).to_a
     end
-    drop_session = proc do |env|
+    drop_session = Rack::Lint.new(proc do |env|
       env['rack.session.options'][:drop] = true
       incrementor.call(env)
-    end
-    renew_session = proc do |env|
+    end)
+    renew_session = Rack::Lint.new(proc do |env|
       env['rack.session.options'][:renew] = true
       incrementor.call(env)
-    end
-    defer_session = proc do |env|
+    end)
+    defer_session = Rack::Lint.new(proc do |env|
       env['rack.session.options'][:defer] = true
       incrementor.call(env)
-    end
-    skip_session = proc do |env|
+    end)
+    skip_session = Rack::Lint.new(proc do |env|
       env['rack.session.options'][:skip] = true
       incrementor.call(env)
-    end
+    end)
+    incrementor = Rack::Lint.new(incrementor)
 
     # test memcache connection
     Rack::Session::Memcache.new(incrementor)

data/test/spec_session_pool.rb

@@ -1,4 +1,5 @@
 require 'thread'
+require 'rack/lint'
 require 'rack/mock'
 require 'rack/session/pool'
 
@@ -12,28 +13,30 @@ describe Rack::Session::Pool do
     Rack::Response.new(env["rack.session"].inspect).to_a
   end
 
-  session_id = lambda do |env|
+  session_id = Rack::Lint.new(lambda do |env|
     Rack::Response.new(env["rack.session"].inspect).to_a
-  end
+  end)
 
-  nothing = lambda do |env|
+  nothing = Rack::Lint.new(lambda do |env|
     Rack::Response.new("Nothing").to_a
-  end
+  end)
 
-  drop_session = lambda do |env|
+  drop_session = Rack::Lint.new(lambda do |env|
     env['rack.session.options'][:drop] = true
     incrementor.call(env)
-  end
+  end)
 
-  renew_session = lambda do |env|
+  renew_session = Rack::Lint.new(lambda do |env|
     env['rack.session.options'][:renew] = true
     incrementor.call(env)
-  end
+  end)
 
-  defer_session = lambda do |env|
+  defer_session = Rack::Lint.new(lambda do |env|
     env['rack.session.options'][:defer] = true
     incrementor.call(env)
-  end
+  end)
+  
+  incrementor = Rack::Lint.new(incrementor)
 
   it "creates a new cookie" do
     pool = Rack::Session::Pool.new(incrementor)

data/test/spec_showexceptions.rb

@@ -1,12 +1,17 @@
 require 'rack/showexceptions'
+require 'rack/lint'
 require 'rack/mock'
 
 describe Rack::ShowExceptions do
+  def show_exceptions(app)
+    Rack::Lint.new Rack::ShowExceptions.new(app)
+  end
+  
   it "catches exceptions" do
     res = nil
 
     req = Rack::MockRequest.new(
-      Rack::ShowExceptions.new(
+      show_exceptions(
         lambda{|env| raise RuntimeError }
     ))
 
@@ -25,7 +30,7 @@ describe Rack::ShowExceptions do
     res = nil
 
     req = Rack::MockRequest.new(
-      Rack::ShowExceptions.new(
+      show_exceptions(
         lambda{|env| raise RuntimeError, "It was never supposed to work" }
     ))
 
@@ -46,7 +51,7 @@ describe Rack::ShowExceptions do
     res = nil
 
     req = Rack::MockRequest.new(
-      Rack::ShowExceptions.new(
+      show_exceptions(
         lambda{|env| raise RuntimeError, "It was never supposed to work" }
     ))
 
@@ -68,7 +73,7 @@ describe Rack::ShowExceptions do
     res = nil
 
     req = Rack::MockRequest.new(
-      Rack::ShowExceptions.new(
+      show_exceptions(
         lambda{|env| raise RuntimeError, "", [] }
       )
     )

data/test/spec_showstatus.rb

@@ -1,10 +1,15 @@
 require 'rack/showstatus'
+require 'rack/lint'
 require 'rack/mock'
 
 describe Rack::ShowStatus do
+  def show_status(app)
+    Rack::Lint.new Rack::ShowStatus.new(app)
+  end
+  
   should "provide a default status message" do
     req = Rack::MockRequest.new(
-      Rack::ShowStatus.new(lambda{|env|
+      show_status(lambda{|env|
         [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
     }))
 
@@ -19,7 +24,7 @@ describe Rack::ShowStatus do
 
   should "let the app provide additional information" do
     req = Rack::MockRequest.new(
-      Rack::ShowStatus.new(
+      show_status(
         lambda{|env|
           env["rack.showstatus.detail"] = "gone too meta."
           [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
@@ -37,7 +42,7 @@ describe Rack::ShowStatus do
 
   should "not replace existing messages" do
     req = Rack::MockRequest.new(
-      Rack::ShowStatus.new(
+      show_status(
         lambda{|env|
           [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
     }))
@@ -52,7 +57,7 @@ describe Rack::ShowStatus do
     headers = {"WWW-Authenticate" => "Basic blah"}
 
     req = Rack::MockRequest.new(
-      Rack::ShowStatus.new(lambda{|env| [401, headers, []] }))
+      show_status(lambda{|env| [401, headers, []] }))
     res = req.get("/", :lint => true)
 
     res["WWW-Authenticate"].should.equal("Basic blah")
@@ -60,7 +65,7 @@ describe Rack::ShowStatus do
 
   should "replace existing messages if there is detail" do
     req = Rack::MockRequest.new(
-      Rack::ShowStatus.new(
+      show_status(
         lambda{|env|
           env["rack.showstatus.detail"] = "gone too meta."
           [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]

data/test/spec_static.rb

@@ -1,22 +1,27 @@
 require 'rack/static'
+require 'rack/lint'
 require 'rack/mock'
 
 class DummyApp
   def call(env)
-    [200, {}, ["Hello World"]]
+    [200, {"Content-Type" => "text/plain"}, ["Hello World"]]
   end
 end
 
 describe Rack::Static do
+  def static(app, *args)
+    Rack::Lint.new Rack::Static.new(app, *args)
+  end
+
   root = File.expand_path(File.dirname(__FILE__))
 
   OPTIONS = {:urls => ["/cgi"], :root => root}
-  STATIC_OPTIONS = {:urls => [""], :root => root, :index => 'static/index.html'}
+  STATIC_OPTIONS = {:urls => [""], :root => "#{root}/static", :index => '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))
+  @request = Rack::MockRequest.new(static(DummyApp.new, OPTIONS))
+  @static_request = Rack::MockRequest.new(static(DummyApp.new, STATIC_OPTIONS))
+  @hash_request = Rack::MockRequest.new(static(DummyApp.new, HASH_OPTIONS))
 
   it "serves files" do
     res = @request.get("/cgi/test")
@@ -35,12 +40,19 @@ describe Rack::Static do
     res.body.should == "Hello World"
   end
 
-  it "calls index file when requesting root" do
+  it "calls index file when requesting root in the given folder" do
     res = @static_request.get("/")
     res.should.be.ok
     res.body.should =~ /index!/
+
+    res = @static_request.get("/other/")
+    res.should.be.not_found
+
+    res = @static_request.get("/another/")
+    res.should.be.ok
+    res.body.should =~ /another index!/
   end
-  
+
   it "doesn't call index file if :index option was omitted" do
     res = @request.get("/")
     res.body.should == "Hello World"
@@ -58,12 +70,76 @@ describe Rack::Static do
     res.body.should == "Hello World"
   end
 
-  it "supports serving fixed cache-control" do
+  it "supports serving fixed cache-control (legacy option)" do
     opts = OPTIONS.merge(:cache_control => 'public')
-    request = Rack::MockRequest.new(Rack::Static.new(DummyApp.new, opts))
+    request = Rack::MockRequest.new(static(DummyApp.new, opts))
     res = request.get("/cgi/test")
     res.should.be.ok
     res.headers['Cache-Control'].should == 'public'
   end
 
+  HEADER_OPTIONS = {:urls => ["/cgi"], :root => root, :header_rules => [
+    [:all, {'Cache-Control' => 'public, max-age=100'}],
+    [:fonts, {'Cache-Control' => 'public, max-age=200'}],
+    [%w(png jpg), {'Cache-Control' => 'public, max-age=300'}],
+    ['/cgi/assets/folder/', {'Cache-Control' => 'public, max-age=400'}],
+    ['cgi/assets/javascripts', {'Cache-Control' => 'public, max-age=500'}],
+    [/\.(css|erb)\z/, {'Cache-Control' => 'public, max-age=600'}]
+  ]}
+  @header_request = Rack::MockRequest.new(static(DummyApp.new, HEADER_OPTIONS))
+
+  it "supports header rule :all" do
+    # Headers for all files via :all shortcut
+    res = @header_request.get('/cgi/assets/index.html')
+    res.should.be.ok
+    res.headers['Cache-Control'].should == 'public, max-age=100'
+  end
+
+  it "supports header rule :fonts" do
+    # Headers for web fonts via :fonts shortcut
+    res = @header_request.get('/cgi/assets/fonts/font.eot')
+    res.should.be.ok
+    res.headers['Cache-Control'].should == 'public, max-age=200'
+  end
+
+  it "supports file extension header rules provided as an Array" do
+    # Headers for file extensions via array
+    res = @header_request.get('/cgi/assets/images/image.png')
+    res.should.be.ok
+    res.headers['Cache-Control'].should == 'public, max-age=300'
+  end
+
+  it "supports folder rules provided as a String" do
+    # Headers for files in folder via string
+    res = @header_request.get('/cgi/assets/folder/test.js')
+    res.should.be.ok
+    res.headers['Cache-Control'].should == 'public, max-age=400'
+  end
+
+  it "supports folder header rules provided as a String not starting with a slash" do
+    res = @header_request.get('/cgi/assets/javascripts/app.js')
+    res.should.be.ok
+    res.headers['Cache-Control'].should == 'public, max-age=500'
+  end
+
+  it "supports flexible header rules provided as Regexp" do
+    # Flexible Headers via Regexp
+    res = @header_request.get('/cgi/assets/stylesheets/app.css')
+    res.should.be.ok
+    res.headers['Cache-Control'].should == 'public, max-age=600'
+  end
+
+  it "prioritizes header rules over fixed cache-control setting (legacy option)" do
+    opts = OPTIONS.merge(
+      :cache_control => 'public, max-age=24',
+      :header_rules => [
+        [:all, {'Cache-Control' => 'public, max-age=42'}]
+      ])
+
+    request = Rack::MockRequest.new(static(DummyApp.new, opts))
+    res = request.get("/cgi/test")
+    res.should.be.ok
+    res.headers['Cache-Control'].should == 'public, max-age=42'
+  end
+
 end

data/test/spec_urlmap.rb

@@ -10,11 +10,11 @@ describe Rack::URLMap do
         'Content-Type' => 'text/plain'
       }, [""]]
     }
-    map = Rack::URLMap.new({
+    map = Rack::Lint.new(Rack::URLMap.new({
       'http://foo.org/bar' => app,
       '/foo' => app,
       '/foo/bar' => app
-    })
+    }))
 
     res = Rack::MockRequest.new(map).get("/")
     res.should.be.not_found
@@ -66,7 +66,7 @@ describe Rack::URLMap do
 
 
   it "dispatches hosts correctly" do
-    map = Rack::URLMap.new("http://foo.org/" => lambda { |env|
+    map = Rack::Lint.new(Rack::URLMap.new("http://foo.org/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
                                 "X-Position" => "foo.org",
@@ -90,7 +90,7 @@ describe Rack::URLMap do
                                 "X-Position" => "default.org",
                                 "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
                               }, [""]]}
-                           )
+                           ))
 
     res = Rack::MockRequest.new(map).get("/")
     res.should.be.ok
@@ -124,7 +124,7 @@ describe Rack::URLMap do
   end
 
   should "be nestable" do
-    map = Rack::URLMap.new("/foo" =>
+    map = Rack::Lint.new(Rack::URLMap.new("/foo" =>
       Rack::URLMap.new("/bar" =>
         Rack::URLMap.new("/quux" =>  lambda { |env|
                            [200,
@@ -133,7 +133,7 @@ describe Rack::URLMap do
                               "X-PathInfo" => env["PATH_INFO"],
                               "X-ScriptName" => env["SCRIPT_NAME"],
                             }, [""]]}
-                         )))
+                         ))))
 
     res = Rack::MockRequest.new(map).get("/foo/bar")
     res.should.be.not_found
@@ -146,7 +146,7 @@ describe Rack::URLMap do
   end
 
   should "route root apps correctly" do
-    map = Rack::URLMap.new("/" => lambda { |env|
+    map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
                                 "X-Position" => "root",
@@ -160,7 +160,7 @@ describe Rack::URLMap do
                                 "X-PathInfo" => env["PATH_INFO"],
                                 "X-ScriptName" => env["SCRIPT_NAME"]
                               }, [""]]}
-                           )
+                           ))
 
     res = Rack::MockRequest.new(map).get("/foo/bar")
     res.should.be.ok
@@ -188,7 +188,7 @@ describe Rack::URLMap do
   end
 
   should "not squeeze slashes" do
-    map = Rack::URLMap.new("/" => lambda { |env|
+    map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
                                 "X-Position" => "root",
@@ -202,7 +202,7 @@ describe Rack::URLMap do
                                 "X-PathInfo" => env["PATH_INFO"],
                                 "X-ScriptName" => env["SCRIPT_NAME"]
                               }, [""]]}
-                           )
+                           ))
 
     res = Rack::MockRequest.new(map).get("/http://example.org/bar")
     res.should.be.ok