rack 1.4.1 → 1.4.2

data/test/spec_file.rb

@@ -1,20 +1,23 @@
 require 'rack/file'
+require 'rack/lint'
 require 'rack/mock'
 
 describe Rack::File do
   DOCROOT = File.expand_path(File.dirname(__FILE__)) unless defined? DOCROOT
 
+  def file(*args)
+    Rack::Lint.new Rack::File.new(*args)
+  end
+
   should "serve files" do
-    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
-      get("/cgi/test")
+    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/test")
 
     res.should.be.ok
     res.should =~ /ruby/
   end
 
   should "set Last-Modified header" do
-    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
-      get("/cgi/test")
+    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/test")
 
     path = File.join(DOCROOT, "/cgi/test")
 
@@ -24,7 +27,7 @@ describe Rack::File do
 
   should "return 304 if file isn't modified since last serve" do
     path = File.join(DOCROOT, "/cgi/test")
-    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
+    res = Rack::MockRequest.new(file(DOCROOT)).
       get("/cgi/test", 'HTTP_IF_MODIFIED_SINCE' => File.mtime(path).httpdate)
 
     res.status.should.equal 304
@@ -33,22 +36,21 @@ describe Rack::File do
 
   should "return the file if it's modified since last serve" do
     path = File.join(DOCROOT, "/cgi/test")
-    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
+    res = Rack::MockRequest.new(file(DOCROOT)).
       get("/cgi/test", 'HTTP_IF_MODIFIED_SINCE' => (File.mtime(path) - 100).httpdate)
 
     res.should.be.ok
   end
 
   should "serve files with URL encoded filenames" do
-    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
-      get("/cgi/%74%65%73%74") # "/cgi/test"
+    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/%74%65%73%74") # "/cgi/test"
 
     res.should.be.ok
     res.should =~ /ruby/
   end
 
   should "allow safe directory traversal" do
-    req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT)))
+    req = Rack::MockRequest.new(file(DOCROOT))
 
     res = req.get('/cgi/../cgi/test')
     res.should.be.successful
@@ -61,7 +63,7 @@ describe Rack::File do
   end
 
   should "not allow unsafe directory traversal" do
-    req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT)))
+    req = Rack::MockRequest.new(file(DOCROOT))
 
     res = req.get("/../README")
     res.should.be.client_error
@@ -76,7 +78,7 @@ describe Rack::File do
   end
 
   should "allow files with .. in their name" do
-    req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT)))
+    req = Rack::MockRequest.new(file(DOCROOT))
     res = req.get("/cgi/..test")
     res.should.be.not_found
 
@@ -88,30 +90,26 @@ describe Rack::File do
   end
 
   should "not allow unsafe directory traversal with encoded periods" do
-    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
-      get("/%2E%2E/README")
+    res = Rack::MockRequest.new(file(DOCROOT)).get("/%2E%2E/README")
 
     res.should.be.client_error?
     res.should.be.not_found
   end
 
   should "allow safe directory traversal with encoded periods" do
-    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
-      get("/cgi/%2E%2E/cgi/test")
+    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/%2E%2E/cgi/test")
 
     res.should.be.successful
   end
 
   should "404 if it can't find the file" do
-    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
-      get("/cgi/blubb")
+    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/blubb")
 
     res.should.be.not_found
   end
 
   should "detect SystemCallErrors" do
-    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
-      get("/cgi")
+    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi")
 
     res.should.be.not_found
   end
@@ -130,7 +128,7 @@ describe Rack::File do
   should "return correct byte range in body" do
     env = Rack::MockRequest.env_for("/cgi/test")
     env["HTTP_RANGE"] = "bytes=22-33"
-    res = Rack::MockResponse.new(*Rack::File.new(DOCROOT).call(env))
+    res = Rack::MockResponse.new(*file(DOCROOT).call(env))
 
     res.status.should.equal 206
     res["Content-Length"].should.equal "12"
@@ -141,24 +139,43 @@ describe Rack::File do
   should "return error for unsatisfiable byte range" do
     env = Rack::MockRequest.env_for("/cgi/test")
     env["HTTP_RANGE"] = "bytes=1234-5678"
-    res = Rack::MockResponse.new(*Rack::File.new(DOCROOT).call(env))
+    res = Rack::MockResponse.new(*file(DOCROOT).call(env))
 
     res.status.should.equal 416
     res["Content-Range"].should.equal "bytes */193"
   end
 
-  should "support cache control options" do
+  should "support legacy cache control options provided as string" do
     env = Rack::MockRequest.env_for("/cgi/test")
-    status, heads, _ = Rack::File.new(DOCROOT, 'public, max-age=38').call(env)
+    status, heads, _ = file(DOCROOT, 'public, max-age=38').call(env)
 
     status.should.equal 200
     heads['Cache-Control'].should.equal 'public, max-age=38'
   end
 
+  should "support custom http headers" do
+    env = Rack::MockRequest.env_for("/cgi/test")
+    status, heads, _ = file(DOCROOT, 'Cache-Control' => 'public, max-age=38',
+     'Access-Control-Allow-Origin' => '*').call(env)
+
+    status.should.equal 200
+    heads['Cache-Control'].should.equal 'public, max-age=38'
+    heads['Access-Control-Allow-Origin'].should.equal '*'
+  end
+
+  should "support not add custom http headers if none are supplied" do
+    env = Rack::MockRequest.env_for("/cgi/test")
+    status, heads, _ = file(DOCROOT).call(env)
+
+    status.should.equal 200
+    heads['Cache-Control'].should.equal nil
+    heads['Access-Control-Allow-Origin'].should.equal nil
+  end
+
   should "only support GET and HEAD requests" do
-    req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT)))
+    req = Rack::MockRequest.new(file(DOCROOT))
 
-    forbidden = %w[post put delete]
+    forbidden = %w[post put patch delete]
     forbidden.each do |method|
 
       res = req.send(method, "/cgi/test")

data/test/spec_head.rb

@@ -1,30 +1,48 @@
+require 'enumerator'
 require 'rack/head'
+require 'rack/lint'
 require 'rack/mock'
 
 describe Rack::Head do
+
   def test_response(headers = {})
-    app = lambda { |env| [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]] }
+    body = StringIO.new "foo"
+    app = lambda do |env|
+      [200, {"Content-type" => "test/plain", "Content-length" => "3"}, body]
+    end
     request = Rack::MockRequest.env_for("/", headers)
-    response = Rack::Head.new(app).call(request)
+    response = Rack::Lint.new(Rack::Head.new(app)).call(request)
+
+    return response, body
+  end
 
-    return response
+  def enum
+    defined?(Enumerator) ? Enumerator : Enumerable::Enumerator
   end
 
   should "pass GET, POST, PUT, DELETE, OPTIONS, TRACE requests" do
     %w[GET POST PUT DELETE OPTIONS TRACE].each do |type|
-      resp = test_response("REQUEST_METHOD" => type)
+      resp, _ = test_response("REQUEST_METHOD" => type)
 
       resp[0].should.equal(200)
       resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"})
-      resp[2].should.equal(["foo"])
+      enum.new(resp[2]).to_a.should.equal(["foo"])
     end
   end
 
   should "remove body from HEAD requests" do
-    resp = test_response("REQUEST_METHOD" => "HEAD")
+    resp, _ = test_response("REQUEST_METHOD" => "HEAD")
+
+    resp[0].should.equal(200)
+    resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"})
+    enum.new(resp[2]).to_a.should.equal([])
+  end
 
+  should "close the body when it is removed" do
+    resp, body = test_response("REQUEST_METHOD" => "HEAD")
     resp[0].should.equal(200)
     resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"})
-    resp[2].should.equal([])
+    enum.new(resp[2]).to_a.should.equal([])
+    body.should.be.closed
   end
 end

data/test/spec_lobster.rb

@@ -1,28 +1,43 @@
 require 'rack/lobster'
+require 'rack/lint'
 require 'rack/mock'
 
+module LobsterHelpers
+  def lobster
+    Rack::MockRequest.new Rack::Lint.new(Rack::Lobster.new)
+  end
+
+  def lambda_lobster
+    Rack::MockRequest.new Rack::Lint.new(Rack::Lobster::LambdaLobster)
+  end
+end
+
 describe Rack::Lobster::LambdaLobster do
+  extend LobsterHelpers
+  
   should "be a single lambda" do
     Rack::Lobster::LambdaLobster.should.be.kind_of Proc
   end
 
   should "look like a lobster" do
-    res = Rack::MockRequest.new(Rack::Lobster::LambdaLobster).get("/")
+    res = lambda_lobster.get("/")
     res.should.be.ok
     res.body.should.include "(,(,,(,,,("
     res.body.should.include "?flip"
   end
 
   should "be flippable" do
-    res = Rack::MockRequest.new(Rack::Lobster::LambdaLobster).get("/?flip")
+    res = lambda_lobster.get("/?flip")
     res.should.be.ok
     res.body.should.include "(,,,(,,(,("
   end
 end
 
 describe Rack::Lobster do
+  extend LobsterHelpers
+  
   should "look like a lobster" do
-    res = Rack::MockRequest.new(Rack::Lobster.new).get("/")
+    res = lobster.get("/")
     res.should.be.ok
     res.body.should.include "(,(,,(,,,("
     res.body.should.include "?flip"
@@ -30,14 +45,14 @@ describe Rack::Lobster do
   end
 
   should "be flippable" do
-    res = Rack::MockRequest.new(Rack::Lobster.new).get("/?flip=left")
+    res = lobster.get("/?flip=left")
     res.should.be.ok
     res.body.should.include "(,,,(,,(,("
   end
 
   should "provide crashing for testing purposes" do
     lambda {
-      Rack::MockRequest.new(Rack::Lobster.new).get("/?flip=crash")
+      lobster.get("/?flip=crash")
     }.should.raise
   end
 end

data/test/spec_lock.rb

@@ -1,3 +1,5 @@
+require 'enumerator'
+require 'rack/lint'
 require 'rack/lock'
 require 'rack/mock'
 
@@ -22,10 +24,26 @@ class Lock
   end
 end
 
+module LockHelpers
+  def lock_app(app, lock = Lock.new)
+    app = if lock
+      Rack::Lock.new app, lock
+    else
+      Rack::Lock.new app
+    end
+    Rack::Lint.new app
+  end
+end
+
 describe Rack::Lock do
+  ::Enumerator = ::Enumerable::Enumerator unless Object.const_defined?(:Enumerator)
+  
+  extend LockHelpers
+  
   describe 'Proxy' do
+    extend LockHelpers
+    
     should 'delegate each' do
-      lock     = Lock.new
       env      = Rack::MockRequest.env_for("/")
       response = Class.new {
         attr_accessor :close_called
@@ -33,7 +51,7 @@ describe Rack::Lock do
         def each; %w{ hi mom }.each { |x| yield x }; end
       }.new
 
-      app = Rack::Lock.new(lambda { |inner_env| [200, {}, response] }, lock)
+      app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] })
       response = app.call(env)[2]
       list = []
       response.each { |x| list << x }
@@ -47,7 +65,7 @@ describe Rack::Lock do
       res = ['Hello World']
       def res.to_path ; "/tmp/hello.txt" ; end
 
-      app = Rack::Lock.new(lambda { |inner_env| [200, {}, res] }, lock)
+      app = Rack::Lock.new(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, res] }, lock)
       body = app.call(env)[2]
 
       body.should.respond_to :to_path
@@ -55,12 +73,11 @@ describe Rack::Lock do
     end
 
     should 'not delegate to_path if body does not implement it' do
-      lock = Lock.new
       env  = Rack::MockRequest.env_for("/")
 
       res = ['Hello World']
 
-      app = Rack::Lock.new(lambda { |inner_env| [200, {}, res] }, lock)
+      app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, res] })
       body = app.call(env)[2]
 
       body.should.not.respond_to :to_path
@@ -68,7 +85,6 @@ describe Rack::Lock do
   end
 
   should 'call super on close' do
-    lock     = Lock.new
     env      = Rack::MockRequest.env_for("/")
     response = Class.new {
       attr_accessor :close_called
@@ -76,7 +92,7 @@ describe Rack::Lock do
       def close; @close_called = true; end
     }.new
 
-    app = Rack::Lock.new(lambda { |inner_env| [200, {}, response] }, lock)
+    app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] })
     app.call(env)
     response.close_called.should.equal false
     response.close
@@ -87,7 +103,7 @@ describe Rack::Lock do
     lock     = Lock.new
     env      = Rack::MockRequest.env_for("/")
     response = Object.new
-    app      = Rack::Lock.new(lambda { |inner_env| [200, {}, response] }, lock)
+    app      = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] }, lock)
     lock.synchronized.should.equal false
     response = app.call(env)[2]
     lock.synchronized.should.equal true
@@ -96,19 +112,20 @@ describe Rack::Lock do
   end
 
   should "return value from app" do
-    lock = Lock.new
     env  = Rack::MockRequest.env_for("/")
-    body = [200, {}, %w{ hi mom }]
-    app  = Rack::Lock.new(lambda { |inner_env| body }, lock)
-    app.call(env).should.equal body
+    body = [200, {"Content-Type" => "text/plain"}, %w{ hi mom }]
+    app  = lock_app(lambda { |inner_env| body })
+    
+    res = app.call(env)
+    res[0].should.equal body[0]
+    res[1].should.equal body[1]
+    Enumerator.new(res[2]).to_a.should.equal ["hi", "mom"]
   end
 
   should "call synchronize on lock" do
     lock = Lock.new
     env = Rack::MockRequest.env_for("/")
-    app = Rack::Lock.new(lambda { |inner_env|
-      [200, {}, %w{ a b c }]
-    }, lock)
+    app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, %w{ a b c }] }, lock)
     lock.synchronized.should.equal false
     app.call(env)
     lock.synchronized.should.equal true
@@ -117,16 +134,24 @@ describe Rack::Lock do
   should "unlock if the app raises" do
     lock = Lock.new
     env = Rack::MockRequest.env_for("/")
-    app = Rack::Lock.new(lambda { raise Exception }, lock)
+    app = lock_app(lambda { raise Exception }, lock)
     lambda { app.call(env) }.should.raise(Exception)
     lock.synchronized.should.equal false
   end
 
+  should "unlock if the app throws" do
+    lock = Lock.new
+    env = Rack::MockRequest.env_for("/")
+    app = lock_app(lambda {|env| throw :bacon }, lock)
+    lambda { app.call(env) }.should.throw(:bacon)
+    lock.synchronized.should.equal false
+  end
+
   should "set multithread flag to false" do
-    app = Rack::Lock.new(lambda { |env|
+    app = lock_app(lambda { |env|
       env['rack.multithread'].should.equal false
-      [200, {}, %w{ a b c }]
-    })
+      [200, {"Content-Type" => "text/plain"}, %w{ a b c }]
+    }, false)
     app.call(Rack::MockRequest.env_for("/"))
   end
 
@@ -136,7 +161,7 @@ describe Rack::Lock do
         env['rack.multithread'].should.equal true
         super
       end
-    }.new(lambda { |env| [200, {}, %w{ a b c }] })
-    app.call(Rack::MockRequest.env_for("/"))
+    }.new(lambda { |env| [200, {"Content-Type" => "text/plain"}, %w{ a b c }] })
+    Rack::Lint.new(app).call(Rack::MockRequest.env_for("/"))
   end
 end

data/test/spec_logger.rb

@@ -1,5 +1,7 @@
 require 'stringio'
+require 'rack/lint'
 require 'rack/logger'
+require 'rack/mock'
 
 describe Rack::Logger do
   app = lambda { |env|
@@ -11,13 +13,6 @@ describe Rack::Logger do
     [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]]
   }
 
-  should "log to rack.errors" do
-    errors = StringIO.new
-    Rack::Logger.new(app).call('rack.errors' => errors)
-    errors.string.should.match(/INFO -- : Program started/)
-    errors.string.should.match(/WARN -- : Nothing to do/)
-  end
-
   should "conform to Rack::Lint" do
     errors = StringIO.new
     a = Rack::Lint.new(Rack::Logger.new(app))