lack 2.0.0

data/test/spec_chunked.rb

@@ -0,0 +1,101 @@
+require 'rack/chunked'
+require 'rack/lint'
+require 'rack/mock'
+
+describe Rack::Chunked do
+  def chunked(app)
+    proc do |env|
+      app = Rack::Chunked.new(app)
+      response = Rack::Lint.new(app).call(env)
+      # we want to use body like an array, but it only has #each
+      response[2] = response[2].to_enum.to_a
+      response
+    end
+  end
+
+  before do
+    @env = Rack::MockRequest.
+      env_for('/', 'HTTP_VERSION' => '1.1', 'REQUEST_METHOD' => 'GET')
+  end
+
+  should 'chunk responses with no Content-Length' do
+    app = lambda { |env| [200, {"Content-Type" => "text/plain"}, ['Hello', ' ', 'World!']] }
+    response = Rack::MockResponse.new(*chunked(app).call(@env))
+    response.headers.should.not.include 'Content-Length'
+    response.headers['Transfer-Encoding'].should.equal 'chunked'
+    response.body.should.equal "5\r\nHello\r\n1\r\n \r\n6\r\nWorld!\r\n0\r\n\r\n"
+  end
+
+  should 'chunks empty bodies properly' do
+    app = lambda { |env| [200, {"Content-Type" => "text/plain"}, []] }
+    response = Rack::MockResponse.new(*chunked(app).call(@env))
+    response.headers.should.not.include 'Content-Length'
+    response.headers['Transfer-Encoding'].should.equal 'chunked'
+    response.body.should.equal "0\r\n\r\n"
+  end
+
+  should 'chunks encoded bodies properly' do
+    body = ["\uFFFEHello", " ", "World"].map {|t| t.encode("UTF-16LE") }
+    app  = lambda { |env| [200, {"Content-Type" => "text/plain"}, body] }
+    response = Rack::MockResponse.new(*chunked(app).call(@env))
+    response.headers.should.not.include 'Content-Length'
+    response.headers['Transfer-Encoding'].should.equal 'chunked'
+    response.body.encoding.to_s.should.equal "ASCII-8BIT"
+    response.body.should.equal "c\r\n\xFE\xFFH\x00e\x00l\x00l\x00o\x00\r\n2\r\n \x00\r\na\r\nW\x00o\x00r\x00l\x00d\x00\r\n0\r\n\r\n".force_encoding("BINARY")
+  end if RUBY_VERSION >= "1.9"
+
+  should 'not modify response when Content-Length header present' do
+    app = lambda { |env|
+      [200, {"Content-Type" => "text/plain", 'Content-Length'=>'12'}, ['Hello', ' ', 'World!']]
+    }
+    status, headers, body = chunked(app).call(@env)
+    status.should.equal 200
+    headers.should.not.include 'Transfer-Encoding'
+    headers.should.include 'Content-Length'
+    body.join.should.equal 'Hello World!'
+  end
+
+  should 'not modify response when client is HTTP/1.0' do
+    app = lambda { |env| [200, {"Content-Type" => "text/plain"}, ['Hello', ' ', 'World!']] }
+    @env['HTTP_VERSION'] = 'HTTP/1.0'
+    status, headers, body = chunked(app).call(@env)
+    status.should.equal 200
+    headers.should.not.include 'Transfer-Encoding'
+    body.join.should.equal 'Hello World!'
+  end
+
+  should 'not modify response when client is ancient, pre-HTTP/1.0' do
+    app = lambda { |env| [200, {"Content-Type" => "text/plain"}, ['Hello', ' ', 'World!']] }
+    check = lambda do
+      status, headers, body = chunked(app).call(@env.dup)
+      status.should.equal 200
+      headers.should.not.include 'Transfer-Encoding'
+      body.join.should.equal 'Hello World!'
+    end
+
+    @env.delete('HTTP_VERSION') # unicorn will do this on pre-HTTP/1.0 requests
+    check.call
+
+    @env['HTTP_VERSION'] = 'HTTP/0.9' # not sure if this happens in practice
+    check.call
+  end
+
+  should 'not modify response when Transfer-Encoding header already present' do
+    app = lambda { |env|
+      [200, {"Content-Type" => "text/plain", 'Transfer-Encoding' => 'identity'}, ['Hello', ' ', 'World!']]
+    }
+    status, headers, body = chunked(app).call(@env)
+    status.should.equal 200
+    headers['Transfer-Encoding'].should.equal 'identity'
+    body.join.should.equal 'Hello World!'
+  end
+
+  [100, 204, 205, 304].each do |status_code|
+    should "not modify response when status code is #{status_code}" do
+      app = lambda { |env| [status_code, {}, []] }
+      status, headers, _ = chunked(app).call(@env)
+      status.should.equal status_code
+      headers.should.not.include 'Transfer-Encoding'
+    end
+  end
+end

data/test/spec_file.rb

@@ -0,0 +1,221 @@
+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(file(DOCROOT)).get("/cgi/test")
+
+    res.should.be.ok
+    res.should =~ /ruby/
+  end
+
+  should "set Last-Modified header" do
+    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/test")
+
+    path = File.join(DOCROOT, "/cgi/test")
+
+    res.should.be.ok
+    res["Last-Modified"].should.equal File.mtime(path).httpdate
+  end
+
+  should "return 304 if file isn't modified since last serve" do
+    path = File.join(DOCROOT, "/cgi/test")
+    res = Rack::MockRequest.new(file(DOCROOT)).
+      get("/cgi/test", 'HTTP_IF_MODIFIED_SINCE' => File.mtime(path).httpdate)
+
+    res.status.should.equal 304
+    res.body.should.be.empty
+  end
+
+  should "return the file if it's modified since last serve" do
+    path = File.join(DOCROOT, "/cgi/test")
+    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(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(file(DOCROOT))
+
+    res = req.get('/cgi/../cgi/test')
+    res.should.be.successful
+
+    res = req.get('.')
+    res.should.be.not_found
+
+    res = req.get("test/..")
+    res.should.be.not_found
+  end
+
+  should "not allow unsafe directory traversal" do
+    req = Rack::MockRequest.new(file(DOCROOT))
+
+    res = req.get("/../README.rdoc")
+    res.should.be.client_error
+
+    res = req.get("../test/spec_file.rb")
+    res.should.be.client_error
+
+    res = req.get("../README.rdoc")
+    res.should.be.client_error
+
+    res.should.be.not_found
+  end
+
+  should "allow files with .. in their name" do
+    req = Rack::MockRequest.new(file(DOCROOT))
+    res = req.get("/cgi/..test")
+    res.should.be.not_found
+
+    res = req.get("/cgi/test..")
+    res.should.be.not_found
+
+    res = req.get("/cgi../test..")
+    res.should.be.not_found
+  end
+
+  should "not allow unsafe directory traversal with encoded periods" do
+    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(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(file(DOCROOT)).get("/cgi/blubb")
+
+    res.should.be.not_found
+  end
+
+  should "detect SystemCallErrors" do
+    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi")
+
+    res.should.be.not_found
+  end
+
+  should "return bodies that respond to #to_path" do
+    env = Rack::MockRequest.env_for("/cgi/test")
+    status, _, body = Rack::File.new(DOCROOT).call(env)
+
+    path = File.join(DOCROOT, "/cgi/test")
+
+    status.should.equal 200
+    body.should.respond_to :to_path
+    body.to_path.should.equal path
+  end
+
+  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(*file(DOCROOT).call(env))
+
+    res.status.should.equal 206
+    res["Content-Length"].should.equal "12"
+    res["Content-Range"].should.equal "bytes 22-33/193"
+    res.body.should.equal "-*- ruby -*-"
+  end
+
+  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(*file(DOCROOT).call(env))
+
+    res.status.should.equal 416
+    res["Content-Range"].should.equal "bytes */193"
+  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, HEAD, and OPTIONS requests" do
+    req = Rack::MockRequest.new(file(DOCROOT))
+
+    forbidden = %w[post put patch delete]
+    forbidden.each do |method|
+      res = req.send(method, "/cgi/test")
+      res.should.be.client_error
+      res.should.be.method_not_allowed
+      res.headers['Allow'].split(/, */).sort.should == %w(GET HEAD OPTIONS)
+    end
+
+    allowed = %w[get head options]
+    allowed.each do |method|
+      res = req.send(method, "/cgi/test")
+      res.should.be.successful
+    end
+  end
+
+  should "set Allow correctly for OPTIONS requests" do
+    req = Rack::MockRequest.new(file(DOCROOT))
+    res = req.options('/cgi/test')
+    res.should.be.successful
+    res.headers['Allow'].should.not.equal nil
+    res.headers['Allow'].split(/, */).sort.should == %w(GET HEAD OPTIONS)
+  end
+
+  should "set Content-Length correctly for HEAD requests" do
+    req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT)))
+    res = req.head "/cgi/test"
+    res.should.be.successful
+    res['Content-Length'].should.equal "193"
+  end
+
+  should "default to a mime type of text/plain" do
+    req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT)))
+    res = req.get "/cgi/test"
+    res.should.be.successful
+    res['Content-Type'].should.equal "text/plain"
+  end
+
+  should "allow the default mime type to be set" do
+    req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT, nil, 'application/octet-stream')))
+    res = req.get "/cgi/test"
+    res.should.be.successful
+    res['Content-Type'].should.equal "application/octet-stream"
+  end
+
+  should "not set Content-Type if the mime type is not set" do
+    req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT, nil, nil)))
+    res = req.get "/cgi/test"
+    res.should.be.successful
+    res['Content-Type'].should.equal nil
+  end
+
+end

data/test/spec_handler.rb

@@ -0,0 +1,59 @@
+require 'rack/handler'
+
+class Rack::Handler::Lobster; end
+class RockLobster; end
+
+describe Rack::Handler do
+  it "has registered default handlers" do
+    Rack::Handler.get('cgi').should.equal Rack::Handler::CGI
+    Rack::Handler.get('webrick').should.equal Rack::Handler::WEBrick
+
+    begin
+      Rack::Handler.get('fastcgi').should.equal Rack::Handler::FastCGI
+    rescue LoadError
+    end
+
+    begin
+      Rack::Handler.get('mongrel').should.equal Rack::Handler::Mongrel
+    rescue LoadError
+    end
+  end
+
+  should "raise LoadError if handler doesn't exist" do
+    lambda {
+      Rack::Handler.get('boom')
+    }.should.raise(LoadError)
+  end
+
+  should "get unregistered, but already required, handler by name" do
+    Rack::Handler.get('Lobster').should.equal Rack::Handler::Lobster
+  end
+
+  should "register custom handler" do
+    Rack::Handler.register('rock_lobster', 'RockLobster')
+    Rack::Handler.get('rock_lobster').should.equal RockLobster
+  end
+
+  should "not need registration for properly coded handlers even if not already required" do
+    begin
+      $LOAD_PATH.push File.expand_path('../unregistered_handler', __FILE__)
+      Rack::Handler.get('Unregistered').should.equal Rack::Handler::Unregistered
+      lambda {
+        Rack::Handler.get('UnRegistered')
+      }.should.raise LoadError
+      Rack::Handler.get('UnregisteredLongOne').should.equal Rack::Handler::UnregisteredLongOne
+    ensure
+      $LOAD_PATH.delete File.expand_path('../unregistered_handler', __FILE__)
+    end
+  end
+
+  should "allow autoloaded handlers to be registered properly while being loaded" do
+    path = File.expand_path('../registering_handler', __FILE__)
+    begin
+      $LOAD_PATH.push path
+      Rack::Handler.get('registering_myself').should.equal Rack::Handler::RegisteringMyself
+    ensure
+      $LOAD_PATH.delete path
+    end
+  end
+end

data/test/spec_head.rb

@@ -0,0 +1,45 @@
+require 'rack/head'
+require 'rack/lint'
+require 'rack/mock'
+
+describe Rack::Head do
+
+  def test_response(headers = {})
+    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::Lint.new(Rack::Head.new(app)).call(request)
+
+    return response, body
+  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[0].should.equal(200)
+      resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"})
+      resp[2].to_enum.to_a.should.equal(["foo"])
+    end
+  end
+
+  should "remove body from HEAD requests" do
+    resp, _ = test_response("REQUEST_METHOD" => "HEAD")
+
+    resp[0].should.equal(200)
+    resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"})
+    resp[2].to_enum.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].to_enum.to_a.should.equal([])
+    body.should.not.be.closed
+    resp[2].close
+    body.should.be.closed
+  end
+end

data/test/spec_lint.rb

@@ -0,0 +1,522 @@
+require 'stringio'
+require 'rack/lint'
+require 'rack/mock'
+
+describe Rack::Lint do
+  def env(*args)
+    Rack::MockRequest.env_for("/", *args)
+  end
+
+  should "pass valid request" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]]
+                     }).call(env({}))
+    }.should.not.raise
+  end
+
+  should "notice fatal errors" do
+    lambda { Rack::Lint.new(nil).call }.should.raise(Rack::Lint::LintError).
+      message.should.match(/No env given/)
+  end
+
+  should "notice environment errors" do
+    lambda { Rack::Lint.new(nil).call 5 }.should.raise(Rack::Lint::LintError).
+      message.should.match(/not a Hash/)
+
+    lambda {
+      e = env
+      e.delete("REQUEST_METHOD")
+      Rack::Lint.new(nil).call(e)
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/missing required key REQUEST_METHOD/)
+
+    lambda {
+      e = env
+      e.delete("SERVER_NAME")
+      Rack::Lint.new(nil).call(e)
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/missing required key SERVER_NAME/)
+
+
+    lambda {
+      Rack::Lint.new(nil).call(env("HTTP_CONTENT_TYPE" => "text/plain"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/contains HTTP_CONTENT_TYPE/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("HTTP_CONTENT_LENGTH" => "42"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/contains HTTP_CONTENT_LENGTH/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("FOO" => Object.new))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/non-string value/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("rack.version" => "0.2"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must be an Array/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("rack.url_scheme" => "gopher"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/url_scheme unknown/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("rack.session" => []))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.equal("session [] must respond to store and []=")
+
+    lambda {
+      Rack::Lint.new(nil).call(env("rack.logger" => []))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.equal("logger [] must respond to info")
+
+    lambda {
+      Rack::Lint.new(nil).call(env("REQUEST_METHOD" => "FUCKUP?"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/REQUEST_METHOD/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("SCRIPT_NAME" => "howdy"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must start with/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("PATH_INFO" => "../foo"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must start with/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("CONTENT_LENGTH" => "xcii"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/Invalid CONTENT_LENGTH/)
+
+    lambda {
+      e = env
+      e.delete("PATH_INFO")
+      e.delete("SCRIPT_NAME")
+      Rack::Lint.new(nil).call(e)
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/One of .* must be set/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("SCRIPT_NAME" => "/"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/cannot be .* make it ''/)
+  end
+
+  should "notice input errors" do
+    lambda {
+      Rack::Lint.new(nil).call(env("rack.input" => ""))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/does not respond to #gets/)
+
+    lambda {
+      input = Object.new
+      def input.binmode?
+        false
+      end
+      Rack::Lint.new(nil).call(env("rack.input" => input))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/is not opened in binary mode/)
+
+    lambda {
+      input = Object.new
+      def input.external_encoding
+        result = Object.new
+        def result.name
+          "US-ASCII"
+        end
+        result
+      end
+      Rack::Lint.new(nil).call(env("rack.input" => input))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/does not have ASCII-8BIT as its external encoding/)
+  end
+
+  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
+
+  should "notice status errors" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       ["cc", {}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must be >=100 seen as integer/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [42, {}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must be >=100 seen as integer/)
+  end
+
+  should "notice header errors" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, Object.new, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.equal("headers object should respond to #each, but doesn't (got Object as headers)")
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {true=>false}, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.equal("header key must be a string, was TrueClass")
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Status" => "404"}, []]
+                     }).call(env({}))
+    }.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%%..")
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Foo" => Object.new}, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.equal("a header value must be a String, but the value of 'Foo' is a Object")
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Foo" => [1, 2, 3]}, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.equal("a header value must be a String, but the value of 'Foo' is a Array")
+
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Foo-Bar" => "text\000plain"}, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/invalid header/)
+
+    # line ends (010) should be allowed in header values.
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Foo-Bar" => "one\ntwo\nthree", "Content-Length" => "0", "Content-Type" => "text/plain" }, []]
+                     }).call(env({}))
+    }.should.not.raise(Rack::Lint::LintError)
+
+    # non-Hash header responses should be allowed
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, [%w(Content-Type text/plain), %w(Content-Length 0)], []]
+                     }).call(env({}))
+    }.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, 205, 304].each do |status|
+      lambda {
+        Rack::Lint.new(lambda { |env|
+                         [status, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                       }).call(env({}))
+      }.should.raise(Rack::Lint::LintError).
+        message.should.match(/Content-Type header found/)
+    end
+  end
+
+  should "notice content-length errors" do
+    [100, 101, 204, 205, 304].each do |status|
+      lambda {
+        Rack::Lint.new(lambda { |env|
+                         [status, {"Content-length" => "0"}, []]
+                       }).call(env({}))
+      }.should.raise(Rack::Lint::LintError).
+        message.should.match(/Content-Length header found/)
+    end
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Content-type" => "text/plain", "Content-Length" => "1"}, []]
+                     }).call(env({}))[2].each { }
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/Content-Length header was 1, but should be 0/)
+  end
+
+  should "notice body errors" do
+    lambda {
+      body = Rack::Lint.new(lambda { |env|
+                               [200, {"Content-type" => "text/plain","Content-length" => "3"}, [1,2,3]]
+                             }).call(env({}))[2]
+      body.each { |part| }
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/yielded non-string/)
+  end
+
+  should "notice input handling errors" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].gets("\r\n")
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/gets called with arguments/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read(1, 2, 3)
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/read called with too many arguments/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read("foo")
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/read called with non-integer and non-nil length/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read(-1)
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/read called with a negative length/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read(nil, nil)
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/read called with non-String buffer/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read(nil, 1)
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/read called with non-String buffer/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].rewind(0)
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/rewind called with arguments/)
+
+    weirdio = Object.new
+    class << weirdio
+      def gets
+        42
+      end
+
+      def read
+        23
+      end
+
+      def each
+        yield 23
+        yield 42
+      end
+
+      def rewind
+        raise Errno::ESPIPE, "Errno::ESPIPE"
+      end
+    end
+
+    eof_weirdio = Object.new
+    class << eof_weirdio
+      def gets
+        nil
+      end
+
+      def read(*args)
+        nil
+      end
+
+      def each
+      end
+
+      def rewind
+      end
+    end
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].gets
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env("rack.input" => weirdio))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/gets didn't return a String/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].each { |x| }
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env("rack.input" => weirdio))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/each didn't yield a String/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env("rack.input" => weirdio))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/read didn't return nil or a String/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env("rack.input" => eof_weirdio))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/read\(nil\) returned nil on EOF/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].rewind
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env("rack.input" => weirdio))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/rewind raised Errno::ESPIPE/)
+
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].close
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/close must not be called/)
+  end
+
+  should "notice error handling errors" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.errors"].write(42)
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/write not called with a String/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.errors"].close
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/close must not be called/)
+  end
+
+  should "notice HEAD errors" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Content-type" => "test/plain", "Content-length" => "3"}, []]
+                     }).call(env({"REQUEST_METHOD" => "HEAD"}))
+    }.should.not.raise
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]]
+                     }).call(env({"REQUEST_METHOD" => "HEAD"}))[2].each { }
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/body was given for HEAD/)
+  end
+
+  should "pass valid read calls" do
+    hello_str = "hello world"
+    hello_str.force_encoding("ASCII-8BIT") if hello_str.respond_to? :force_encoding
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({"rack.input" => StringIO.new(hello_str)}))
+    }.should.not.raise(Rack::Lint::LintError)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read(0)
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({"rack.input" => StringIO.new(hello_str)}))
+    }.should.not.raise(Rack::Lint::LintError)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read(1)
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({"rack.input" => StringIO.new(hello_str)}))
+    }.should.not.raise(Rack::Lint::LintError)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read(nil)
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({"rack.input" => StringIO.new(hello_str)}))
+    }.should.not.raise(Rack::Lint::LintError)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read(nil, '')
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({"rack.input" => StringIO.new(hello_str)}))
+    }.should.not.raise(Rack::Lint::LintError)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read(1, '')
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
+                     }).call(env({"rack.input" => StringIO.new(hello_str)}))
+    }.should.not.raise(Rack::Lint::LintError)
+  end
+end
+
+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"
+    wrapper.read.should.equal ""
+    wrapper.rewind
+    wrapper.read.should.equal "123"
+  end
+end