rack 1.1.6 → 1.6.9

data/test/{spec_rack_lint.rb → spec_lint.rb}

@@ -1,15 +1,14 @@
-require 'test/spec'
 require 'stringio'
-
+require 'tempfile'
 require 'rack/lint'
 require 'rack/mock'
 
-context "Rack::Lint" do
+describe Rack::Lint do
   def env(*args)
     Rack::MockRequest.env_for("/", *args)
   end
 
-  specify "passes valid request" do
+  should "pass valid request" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]]
@@ -17,12 +16,12 @@ context "Rack::Lint" do
     }.should.not.raise
   end
 
-  specify "notices fatal errors" do
+  should "notice fatal errors" do
     lambda { Rack::Lint.new(nil).call }.should.raise(Rack::Lint::LintError).
       message.should.match(/No env given/)
   end
 
-  specify "notices environment errors" do
+  should "notice environment errors" do
     lambda { Rack::Lint.new(nil).call 5 }.should.raise(Rack::Lint::LintError).
       message.should.match(/not a Hash/)
 
@@ -76,6 +75,23 @@ context "Rack::Lint" do
     }.should.raise(Rack::Lint::LintError).
       message.should.equal("logger [] must respond to info")
 
+    lambda {
+      Rack::Lint.new(nil).call(env("rack.multipart.buffer_size" => 0))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.equal("rack.multipart.buffer_size must be an Integer > 0 if specified")
+
+    lambda {
+      Rack::Lint.new(nil).call(env("rack.multipart.tempfile_factory" => Tempfile))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.equal("rack.multipart.tempfile_factory must respond to #call")
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+        env['rack.multipart.tempfile_factory'].call("testfile", "text/plain")
+      }).call(env("rack.multipart.tempfile_factory" => lambda { |filename, content_type| Object.new }))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.equal("rack.multipart.tempfile_factory return value must respond to #<<")
+
     lambda {
       Rack::Lint.new(nil).call(env("REQUEST_METHOD" => "FUCKUP?"))
     }.should.raise(Rack::Lint::LintError).
@@ -110,7 +126,7 @@ context "Rack::Lint" do
       message.should.match(/cannot be .* make it ''/)
   end
 
-  specify "notices input errors" do
+  should "notice input errors" do
     lambda {
       Rack::Lint.new(nil).call(env("rack.input" => ""))
     }.should.raise(Rack::Lint::LintError).
@@ -139,14 +155,14 @@ context "Rack::Lint" do
       message.should.match(/does not have ASCII-8BIT as its external encoding/)
   end
 
-  specify "notices error errors" do
+  should "notice error errors" do
     lambda {
       Rack::Lint.new(nil).call(env("rack.errors" => ""))
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/does not respond to #puts/)
   end
 
-  specify "notices status errors" do
+  should "notice status errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        ["cc", {}, ""]
@@ -162,7 +178,7 @@ context "Rack::Lint" do
       message.should.match(/must be >=100 seen as integer/)
   end
 
-  specify "notices header errors" do
+  should "notice header errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, Object.new, []]
@@ -184,26 +200,36 @@ context "Rack::Lint" do
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/must not contain Status/)
 
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       [200, {"Content-Type:" => "text/plain"}, []]
-                     }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/must not contain :/)
-
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       [200, {"Content-" => "text/plain"}, []]
-                     }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/must not end/)
-
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       [200, {"..%%quark%%.." => "text/plain"}, []]
-                     }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.equal("invalid header name: ..%%quark%%..")
+    # From RFC 7230:<F24><F25>
+    # Most HTTP header field values are defined using common syntax
+    # components (token, quoted-string, and comment) separated by
+    # whitespace or specific delimiting characters.  Delimiters are chosen
+    # from the set of US-ASCII visual characters not allowed in a token
+    # (DQUOTE and "(),/:;<=>?@[\]{}").
+    # 
+    #   token          = 1*tchar
+    # 
+    #   tchar          = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+    #                 / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+    #                 / DIGIT / ALPHA
+    #                 ; any VCHAR, except delimiters
+    invalid_headers = 0.upto(31).map(&:chr) + %W<( ) , / : ; < = > ? @ [ \\ ] { } \x7F>
+    invalid_headers.each do |invalid_header|
+      lambda {
+        Rack::Lint.new(lambda { |env|
+          [200, {invalid_header => "text/plain"}, []]
+        }).call(env({}))
+      }.should.raise(Rack::Lint::LintError, "on invalid header: #{invalid_header}").
+      message.should.equal("invalid header name: #{invalid_header}")
+    end
+    valid_headers = 0.upto(127).map(&:chr) - invalid_headers
+    valid_headers.each do |valid_header|
+      lambda {
+        Rack::Lint.new(lambda { |env|
+          [200, {valid_header => "text/plain"}, []]
+        }).call(env({}))
+      }.should.not.raise(Rack::Lint::LintError, "on valid header: #{valid_header}")
+    end
 
     lambda {
       Rack::Lint.new(lambda { |env|
@@ -233,17 +259,24 @@ context "Rack::Lint" do
                        [200, {"Foo-Bar" => "one\ntwo\nthree", "Content-Length" => "0", "Content-Type" => "text/plain" }, []]
                      }).call(env({}))
     }.should.not.raise(Rack::Lint::LintError)
-  end
 
-  specify "notices content-type errors" do
+    # non-Hash header responses should be allowed
     lambda {
       Rack::Lint.new(lambda { |env|
-                       [200, {"Content-length" => "0"}, []]
+                       [200, [%w(Content-Type text/plain), %w(Content-Length 0)], []]
                      }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/No Content-Type/)
+    }.should.not.raise(TypeError)
+  end
+
+  should "notice content-type errors" do
+    # lambda {
+    #   Rack::Lint.new(lambda { |env|
+    #                    [200, {"Content-length" => "0"}, []]
+    #                  }).call(env({}))
+    # }.should.raise(Rack::Lint::LintError).
+    #   message.should.match(/No Content-Type/)
 
-    [100, 101, 204, 304].each do |status|
+    [100, 101, 204, 205, 304].each do |status|
       lambda {
         Rack::Lint.new(lambda { |env|
                          [status, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
@@ -253,8 +286,8 @@ context "Rack::Lint" do
     end
   end
 
-  specify "notices content-length errors" do
-    [100, 101, 204, 304].each do |status|
+  should "notice content-length errors" do
+    [100, 101, 204, 205, 304].each do |status|
       lambda {
         Rack::Lint.new(lambda { |env|
                          [status, {"Content-length" => "0"}, []]
@@ -266,22 +299,22 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Content-type" => "text/plain", "Content-Length" => "1"}, []]
-                     }).call(env({}))
+                     }).call(env({}))[2].each { }
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/Content-Length header was 1, but should be 0/)
   end
 
-  specify "notices body errors" do
+  should "notice body errors" do
     lambda {
-      status, header, body = Rack::Lint.new(lambda { |env|
+      body = Rack::Lint.new(lambda { |env|
                                [200, {"Content-type" => "text/plain","Content-length" => "3"}, [1,2,3]]
-                             }).call(env({}))
+                             }).call(env({}))[2]
       body.each { |part| }
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/yielded non-string/)
   end
 
-  specify "notices input handling errors" do
+  should "notice input handling errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].gets("\r\n")
@@ -425,7 +458,7 @@ context "Rack::Lint" do
       message.should.match(/close must not be called/)
   end
 
-  specify "notices error handling errors" do
+  should "notice error handling errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.errors"].write(42)
@@ -443,7 +476,7 @@ context "Rack::Lint" do
       message.should.match(/close must not be called/)
   end
 
-  specify "notices HEAD errors" do
+  should "notice HEAD errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Content-type" => "test/plain", "Content-length" => "3"}, []]
@@ -453,12 +486,12 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]]
-                     }).call(env({"REQUEST_METHOD" => "HEAD"}))
+                     }).call(env({"REQUEST_METHOD" => "HEAD"}))[2].each { }
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/body was given for HEAD/)
   end
 
-  specify "passes valid read calls" do
+  should "pass valid read calls" do
     hello_str = "hello world"
     hello_str.force_encoding("ASCII-8BIT") if hello_str.respond_to? :force_encoding
     lambda {
@@ -505,19 +538,8 @@ context "Rack::Lint" do
   end
 end
 
-context "Rack::Lint::InputWrapper" do
-  specify "delegates :size to underlying IO object" do
-    class IOMock
-      def size
-        101
-      end
-    end
-
-    wrapper = Rack::Lint::InputWrapper.new(IOMock.new)
-    wrapper.size.should == 101
-  end
-
-  specify "delegates :rewind to underlying IO object" do
+describe "Rack::Lint::InputWrapper" do
+  should "delegate :rewind to underlying IO object" do
     io = StringIO.new("123")
     wrapper = Rack::Lint::InputWrapper.new(io)
     wrapper.read.should.equal "123"

data/test/spec_lobster.rb

@@ -0,0 +1,58 @@
+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 = lambda_lobster.get("/")
+    res.should.be.ok
+    res.body.should.include "(,(,,(,,,("
+    res.body.should.include "?flip"
+  end
+
+  should "be flippable" do
+    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 = lobster.get("/")
+    res.should.be.ok
+    res.body.should.include "(,(,,(,,,("
+    res.body.should.include "?flip"
+    res.body.should.include "crash"
+  end
+
+  should "be flippable" do
+    res = lobster.get("/?flip=left")
+    res.should.be.ok
+    res.body.should.include "),,,),,),)"
+  end
+
+  should "provide crashing for testing purposes" do
+    lambda {
+      lobster.get("/?flip=crash")
+    }.should.raise
+  end
+end

data/test/spec_lock.rb

@@ -0,0 +1,164 @@
+require 'rack/lint'
+require 'rack/lock'
+require 'rack/mock'
+
+class Lock
+  attr_reader :synchronized
+
+  def initialize
+    @synchronized = false
+  end
+
+  def synchronize
+    @synchronized = true
+    yield
+  end
+
+  def lock
+    @synchronized = true
+  end
+
+  def unlock
+    @synchronized = false
+  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
+  extend LockHelpers
+
+  describe 'Proxy' do
+    extend LockHelpers
+
+    should 'delegate each' do
+      env      = Rack::MockRequest.env_for("/")
+      response = Class.new {
+        attr_accessor :close_called
+        def initialize; @close_called = false; end
+        def each; %w{ hi mom }.each { |x| yield x }; end
+      }.new
+
+      app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] })
+      response = app.call(env)[2]
+      list = []
+      response.each { |x| list << x }
+      list.should.equal %w{ hi mom }
+    end
+
+    should 'delegate to_path' do
+      lock = Lock.new
+      env  = Rack::MockRequest.env_for("/")
+
+      res = ['Hello World']
+      def res.to_path ; "/tmp/hello.txt" ; end
+
+      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
+      body.to_path.should.equal "/tmp/hello.txt"
+    end
+
+    should 'not delegate to_path if body does not implement it' do
+      env  = Rack::MockRequest.env_for("/")
+
+      res = ['Hello World']
+
+      app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, res] })
+      body = app.call(env)[2]
+
+      body.should.not.respond_to :to_path
+    end
+  end
+
+  should 'call super on close' do
+    env      = Rack::MockRequest.env_for("/")
+    response = Class.new {
+      attr_accessor :close_called
+      def initialize; @close_called = false; end
+      def close; @close_called = true; end
+    }.new
+
+    app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] })
+    app.call(env)
+    response.close_called.should.equal false
+    response.close
+    response.close_called.should.equal true
+  end
+
+  should "not unlock until body is closed" do
+    lock     = Lock.new
+    env      = Rack::MockRequest.env_for("/")
+    response = Object.new
+    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
+    response.close
+    lock.synchronized.should.equal false
+  end
+
+  should "return value from app" do
+    env  = Rack::MockRequest.env_for("/")
+    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]
+    res[2].to_enum.to_a.should.equal ["hi", "mom"]
+  end
+
+  should "call synchronize on lock" do
+    lock = Lock.new
+    env = Rack::MockRequest.env_for("/")
+    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
+  end
+
+  should "unlock if the app raises" do
+    lock = Lock.new
+    env = Rack::MockRequest.env_for("/")
+    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 {|_| throw :bacon }, lock)
+    lambda { app.call(env) }.should.throw(:bacon)
+    lock.synchronized.should.equal false
+  end
+
+  should "set multithread flag to false" do
+    app = lock_app(lambda { |env|
+      env['rack.multithread'].should.equal false
+      [200, {"Content-Type" => "text/plain"}, %w{ a b c }]
+    }, false)
+    app.call(Rack::MockRequest.env_for("/"))
+  end
+
+  should "reset original multithread flag when exiting lock" do
+    app = Class.new(Rack::Lock) {
+      def call(env)
+        env['rack.multithread'].should.equal true
+        super
+      end
+    }.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

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

data/test/spec_methodoverride.rb

@@ -0,0 +1,95 @@
+require 'stringio'
+require 'rack/methodoverride'
+require 'rack/mock'
+
+describe Rack::MethodOverride do
+  def app
+    Rack::Lint.new(Rack::MethodOverride.new(lambda {|e|
+      [200, {"Content-Type" => "text/plain"}, []]
+    }))
+  end
+  
+  should "not affect GET requests" do
+    env = Rack::MockRequest.env_for("/?_method=delete", :method => "GET")
+    app.call env
+
+    env["REQUEST_METHOD"].should.equal "GET"
+  end
+
+  should "modify REQUEST_METHOD for POST requests when _method parameter is set" do
+    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=put")
+    app.call env
+
+    env["REQUEST_METHOD"].should.equal "PUT"
+  end
+
+  should "modify REQUEST_METHOD for POST requests when X-HTTP-Method-Override is set" do
+    env = Rack::MockRequest.env_for("/",
+            :method => "POST",
+            "HTTP_X_HTTP_METHOD_OVERRIDE" => "PATCH"
+          )
+    app.call env
+
+    env["REQUEST_METHOD"].should.equal "PATCH"
+  end
+
+  should "not modify REQUEST_METHOD if the method is unknown" do
+    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=foo")
+    app.call env
+
+    env["REQUEST_METHOD"].should.equal "POST"
+  end
+
+  should "not modify REQUEST_METHOD when _method is nil" do
+    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "foo=bar")
+    app.call env
+
+    env["REQUEST_METHOD"].should.equal "POST"
+  end
+
+  should "store the original REQUEST_METHOD prior to overriding" do
+    env = Rack::MockRequest.env_for("/",
+            :method => "POST",
+            :input  => "_method=options")
+    app.call env
+
+    env["rack.methodoverride.original_method"].should.equal "POST"
+  end
+
+  should "not modify REQUEST_METHOD when given invalid multipart form data" do
+    input = <<EOF
+--AaB03x\r
+content-disposition: form-data; name="huge"; filename="huge"\r
+EOF
+    env = Rack::MockRequest.env_for("/",
+                      "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x",
+                      "CONTENT_LENGTH" => input.size.to_s,
+                      :method => "POST", :input => input)
+    app.call env
+
+    env["REQUEST_METHOD"].should.equal "POST"
+  end
+
+  should "write error to RACK_ERRORS when given invalid multipart form data" do
+    input = <<EOF
+--AaB03x\r
+content-disposition: form-data; name="huge"; filename="huge"\r
+EOF
+    env = Rack::MockRequest.env_for("/",
+                      "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x",
+                      "CONTENT_LENGTH" => input.size.to_s,
+                      "rack.errors" => StringIO.new,
+                      :method => "POST", :input => input)
+    Rack::MethodOverride.new(proc { [200, {"Content-Type" => "text/plain"}, []] }).call env
+
+    env["rack.errors"].rewind
+    env["rack.errors"].read.should =~ /Bad request content body/
+  end
+
+  should "not modify REQUEST_METHOD for POST requests when the params are unparseable" do
+    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "(%bad-params%)")
+    app.call env
+
+    env["REQUEST_METHOD"].should.equal "POST"
+  end
+end

data/test/spec_mime.rb

@@ -0,0 +1,51 @@
+require 'rack/mime'
+
+describe Rack::Mime do
+
+  it "should return the fallback mime-type for files with no extension" do
+    fallback = 'image/jpg'
+    Rack::Mime.mime_type(File.extname('no_ext'), fallback).should.equal fallback
+  end
+
+  it "should always return 'application/octet-stream' for unknown file extensions" do
+    unknown_ext = File.extname('unknown_ext.abcdefg')
+    Rack::Mime.mime_type(unknown_ext).should.equal 'application/octet-stream'
+  end
+
+  it "should return the mime-type for a given extension" do
+    # sanity check. it would be infeasible test every single mime-type.
+    Rack::Mime.mime_type(File.extname('image.jpg')).should.equal 'image/jpeg'
+  end
+
+  it "should support null fallbacks" do
+    Rack::Mime.mime_type('.nothing', nil).should.equal nil
+  end
+
+  it "should match exact mimes" do
+    Rack::Mime.match?('text/html', 'text/html').should.equal true
+    Rack::Mime.match?('text/html', 'text/meme').should.equal false
+    Rack::Mime.match?('text', 'text').should.equal true
+    Rack::Mime.match?('text', 'binary').should.equal false
+  end
+
+  it "should match class wildcard mimes" do
+    Rack::Mime.match?('text/html', 'text/*').should.equal true
+    Rack::Mime.match?('text/plain', 'text/*').should.equal true
+    Rack::Mime.match?('application/json', 'text/*').should.equal false
+    Rack::Mime.match?('text/html', 'text').should.equal true
+  end
+
+  it "should match full wildcards" do
+    Rack::Mime.match?('text/html', '*').should.equal true
+    Rack::Mime.match?('text/plain', '*').should.equal true
+    Rack::Mime.match?('text/html', '*/*').should.equal true
+    Rack::Mime.match?('text/plain', '*/*').should.equal true
+  end
+
+  it "should match type wildcard mimes" do
+    Rack::Mime.match?('text/html', '*/html').should.equal true
+    Rack::Mime.match?('text/plain', '*/plain').should.equal true
+  end
+
+end
+