rack 1.1.6 → 1.6.9

data/test/spec_showstatus.rb

@@ -0,0 +1,103 @@
+require 'rack/showstatus'
+require 'rack/lint'
+require 'rack/mock'
+require 'rack/utils'
+
+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(
+      show_status(lambda{|env|
+        [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
+    }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+    res.should.be.not.empty
+
+    res["Content-Type"].should.equal("text/html")
+    res.should =~ /404/
+    res.should =~ /Not Found/
+  end
+
+  should "let the app provide additional information" do
+    req = Rack::MockRequest.new(
+      show_status(
+        lambda{|env|
+          env["rack.showstatus.detail"] = "gone too meta."
+          [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
+    }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+    res.should.be.not.empty
+
+    res["Content-Type"].should.equal("text/html")
+    res.should =~ /404/
+    res.should =~ /Not Found/
+    res.should =~ /too meta/
+  end
+
+  should "escape error" do
+    detail = "<script>alert('hi \"')</script>"
+    req = Rack::MockRequest.new(
+      show_status(
+        lambda{|env|
+          env["rack.showstatus.detail"] = detail
+          [500, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
+    }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not.empty
+
+    res["Content-Type"].should.equal("text/html")
+    res.should =~ /500/
+    res.should.not.include detail
+    res.body.should.include Rack::Utils.escape_html(detail)
+  end
+
+  should "not replace existing messages" do
+    req = Rack::MockRequest.new(
+      show_status(
+        lambda{|env|
+          [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
+    }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+
+    res.body.should == "foo!"
+  end
+
+  should "pass on original headers" do
+    headers = {"WWW-Authenticate" => "Basic blah"}
+
+    req = Rack::MockRequest.new(
+      show_status(lambda{|env| [401, headers, []] }))
+    res = req.get("/", :lint => true)
+
+    res["WWW-Authenticate"].should.equal("Basic blah")
+  end
+
+  should "replace existing messages if there is detail" do
+    req = Rack::MockRequest.new(
+      show_status(
+        lambda{|env|
+          env["rack.showstatus.detail"] = "gone too meta."
+          [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
+    }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+    res.should.be.not.empty
+
+    res["Content-Type"].should.equal("text/html")
+    res["Content-Length"].should.not.equal("4")
+    res.should =~ /404/
+    res.should =~ /too meta/
+    res.body.should.not =~ /foo/
+  end
+end

data/test/spec_static.rb

@@ -0,0 +1,145 @@
+require 'rack/static'
+require 'rack/lint'
+require 'rack/mock'
+
+class DummyApp
+  def call(env)
+    [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}/static", :index => 'index.html'}
+  HASH_OPTIONS = {:urls => {"/cgi/sekret" => 'cgi/test'}, :root => root}
+
+  @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")
+    res.should.be.ok
+    res.body.should =~ /ruby/
+  end
+
+  it "404s if url root is known but it can't find the file" do
+    res = @request.get("/cgi/foo")
+    res.should.be.not_found
+  end
+
+  it "calls down the chain if url root is not known" do
+    res = @request.get("/something/else")
+    res.should.be.ok
+    res.body.should == "Hello World"
+  end
+
+  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"
+  end
+
+  it "serves hidden files" do
+    res = @hash_request.get("/cgi/sekret")
+    res.should.be.ok
+    res.body.should =~ /ruby/
+  end
+
+  it "calls down the chain if the URI is not specified" do
+    res = @hash_request.get("/something/else")
+    res.should.be.ok
+    res.body.should == "Hello World"
+  end
+
+  it "supports serving fixed cache-control (legacy option)" do
+    opts = OPTIONS.merge(:cache_control => 'public')
+    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_tempfile_reaper.rb

@@ -0,0 +1,63 @@
+require 'rack/tempfile_reaper'
+require 'rack/lint'
+require 'rack/mock'
+
+describe Rack::TempfileReaper do
+  class MockTempfile
+    attr_reader :closed
+
+    def initialize
+      @closed = false
+    end
+
+    def close!
+      @closed = true
+    end
+  end
+
+  before do
+    @env = Rack::MockRequest.env_for
+  end
+
+  def call(app)
+    Rack::Lint.new(Rack::TempfileReaper.new(app)).call(@env)
+  end
+
+  should 'do nothing (i.e. not bomb out) without env[rack.tempfiles]' do
+    app = lambda { |_| [200, {}, ['Hello, World!']] }
+    response = call(app)
+    response[2].close
+    response[0].should.equal(200)
+  end
+
+  should 'close env[rack.tempfiles] when body is closed' do
+    tempfile1, tempfile2 = MockTempfile.new, MockTempfile.new
+    @env['rack.tempfiles'] = [ tempfile1, tempfile2 ]
+    app = lambda { |_| [200, {}, ['Hello, World!']] }
+    call(app)[2].close
+    tempfile1.closed.should.equal true
+    tempfile2.closed.should.equal true
+  end
+
+  should 'initialize env[rack.tempfiles] when not already present' do
+    tempfile = MockTempfile.new
+    app = lambda do |env|
+      env['rack.tempfiles'] << tempfile
+      [200, {}, ['Hello, World!']]
+    end
+    call(app)[2].close
+    tempfile.closed.should.equal true
+  end
+
+  should 'append env[rack.tempfiles] when already present' do
+    tempfile1, tempfile2 = MockTempfile.new, MockTempfile.new
+    @env['rack.tempfiles'] = [ tempfile1 ]
+    app = lambda do |env|
+      env['rack.tempfiles'] << tempfile2
+      [200, {}, ['Hello, World!']]
+    end
+    call(app)[2].close
+    tempfile1.closed.should.equal true
+    tempfile2.closed.should.equal true
+  end
+end

data/test/{spec_rack_thin.rb → spec_thin.rb}

@@ -1,50 +1,47 @@
-require 'test/spec'
-
 begin
 require 'rack/handler/thin'
-require 'testrequest'
+require File.expand_path('../testrequest', __FILE__)
 require 'timeout'
-  
-context "Rack::Handler::Thin" do
-  include TestRequest::Helpers
-  
-  setup do
-    @app = Rack::Lint.new(TestRequest.new)
-    @server = nil
-    Thin::Logging.silent = true
-    @thread = Thread.new do
-      Rack::Handler::Thin.run(@app, :Host => @host='0.0.0.0', :Port => @port=9204) do |server|
-        @server = server
-      end
+
+describe Rack::Handler::Thin do
+  extend TestRequest::Helpers
+
+  @app = Rack::Lint.new(TestRequest.new)
+  @server = nil
+  Thin::Logging.silent = true
+
+  @thread = Thread.new do
+    Rack::Handler::Thin.run(@app, :Host => @host='127.0.0.1', :Port => @port=9204, :tag => "tag") do |server|
+      @server = server
     end
-    Thread.pass until @server && @server.running?
   end
 
-  specify "should respond" do
-    lambda {
-      GET("/")
-    }.should.not.raise
+  Thread.pass until @server && @server.running?
+
+  should "respond" do
+    GET("/")
+    response.should.not.be.nil
   end
 
-  specify "should be a Thin" do
+  should "be a Thin" do
     GET("/")
-    status.should.be 200
+    status.should.equal 200
     response["SERVER_SOFTWARE"].should =~ /thin/
     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
 
-  specify "should have rack headers" do
+  should "have rack headers" do
     GET("/")
-    response["rack.version"].should.equal [0,3]
-    response["rack.multithread"].should.be false
-    response["rack.multiprocess"].should.be false
-    response["rack.run_once"].should.be false
+    response["rack.version"].should.equal [1,0]
+    response["rack.multithread"].should.equal false
+    response["rack.multiprocess"].should.equal false
+    response["rack.run_once"].should.equal false
   end
 
-  specify "should have CGI headers on GET" do
+  should "have CGI headers on GET" do
     GET("/")
     response["REQUEST_METHOD"].should.equal "GET"
     response["REQUEST_PATH"].should.equal "/"
@@ -59,7 +56,7 @@ context "Rack::Handler::Thin" do
     response["QUERY_STRING"].should.equal "quux=1"
   end
 
-  specify "should have CGI headers on POST" do
+  should "have CGI headers on POST" do
     POST("/", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
     status.should.equal 200
     response["REQUEST_METHOD"].should.equal "POST"
@@ -69,21 +66,24 @@ context "Rack::Handler::Thin" do
     response["test.postdata"].should.equal "rack-form-data=23"
   end
 
-  specify "should support HTTP auth" do
+  should "support HTTP auth" do
     GET("/test", {:user => "ruth", :passwd => "secret"})
     response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
   end
 
-  specify "should set status" do
+  should "set status" do
     GET("/test?secret")
     status.should.equal 403
     response["rack.url_scheme"].should.equal "http"
   end
 
-  teardown do
-    @server.stop!
-    @thread.kill
+  should "set tag for server" do
+    @server.tag.should.equal 'tag'
   end
+
+  @server.stop!
+  @thread.kill
+
 end
 
 rescue LoadError

data/test/{spec_rack_urlmap.rb → spec_urlmap.rb}

@@ -1,10 +1,8 @@
-require 'test/spec'
-
 require 'rack/urlmap'
 require 'rack/mock'
 
-context "Rack::URLMap" do
-  specify "dispatches paths correctly" do
+describe Rack::URLMap do
+  it "dispatches paths correctly" do
     app = lambda { |env|
       [200, {
         'X-ScriptName' => env['SCRIPT_NAME'],
@@ -12,11 +10,11 @@ context "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
@@ -67,8 +65,8 @@ context "Rack::URLMap" do
   end
 
 
-  specify "dispatches hosts correctly" do
-    map = Rack::URLMap.new("http://foo.org/" => lambda { |env|
+  it "dispatches hosts correctly" do
+    map = Rack::Lint.new(Rack::URLMap.new("http://foo.org/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
                                 "X-Position" => "foo.org",
@@ -92,7 +90,7 @@ context "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
@@ -112,7 +110,7 @@ context "Rack::URLMap" do
 
     res = Rack::MockRequest.new(map).get("http://foo.org/")
     res.should.be.ok
-    res["X-Position"].should.equal "default.org"
+    res["X-Position"].should.equal "foo.org"
 
     res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "example.org")
     res.should.be.ok
@@ -125,8 +123,8 @@ context "Rack::URLMap" do
     res["X-Position"].should.equal "default.org"
   end
 
-  specify "should be nestable" do
-    map = Rack::URLMap.new("/foo" =>
+  should "be nestable" do
+    map = Rack::Lint.new(Rack::URLMap.new("/foo" =>
       Rack::URLMap.new("/bar" =>
         Rack::URLMap.new("/quux" =>  lambda { |env|
                            [200,
@@ -135,7 +133,7 @@ context "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
@@ -147,8 +145,8 @@ context "Rack::URLMap" do
     res["X-ScriptName"].should.equal "/foo/bar/quux"
   end
 
-  specify "should route root apps correctly" do
-    map = Rack::URLMap.new("/" => lambda { |env|
+  should "route root apps correctly" do
+    map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
                                 "X-Position" => "root",
@@ -162,7 +160,7 @@ context "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
@@ -189,8 +187,8 @@ context "Rack::URLMap" do
     res["X-ScriptName"].should.equal ""
   end
 
-  specify "should not squeeze slashes" do
-    map = Rack::URLMap.new("/" => lambda { |env|
+  should "not squeeze slashes" do
+    map = Rack::Lint.new(Rack::URLMap.new("/" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
                                 "X-Position" => "root",
@@ -204,7 +202,7 @@ context "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
@@ -212,4 +210,27 @@ context "Rack::URLMap" do
     res["X-PathInfo"].should.equal "/http://example.org/bar"
     res["X-ScriptName"].should.equal ""
   end
+
+  should "not be case sensitive with hosts" do
+    map = Rack::Lint.new(Rack::URLMap.new("http://example.org/" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "root",
+                                "X-PathInfo" => env["PATH_INFO"],
+                                "X-ScriptName" => env["SCRIPT_NAME"]
+                              }, [""]]}
+                           ))
+
+    res = Rack::MockRequest.new(map).get("http://example.org/")
+    res.should.be.ok
+    res["X-Position"].should.equal "root"
+    res["X-PathInfo"].should.equal "/"
+    res["X-ScriptName"].should.equal ""
+
+    res = Rack::MockRequest.new(map).get("http://EXAMPLE.ORG/")
+    res.should.be.ok
+    res["X-Position"].should.equal "root"
+    res["X-PathInfo"].should.equal "/"
+    res["X-ScriptName"].should.equal ""
+  end
 end