RubyGems - edgar-rack - Versions diffs - 1.2.1 - Mend

edgar-rack 1.2.1

Files changed (138) hide show

data/COPYING +18 -0
data/KNOWN-ISSUES +21 -0
data/README +401 -0
data/Rakefile +101 -0
data/SPEC +171 -0
data/bin/rackup +4 -0
data/contrib/rack_logo.svg +111 -0
data/example/lobster.ru +4 -0
data/example/protectedlobster.rb +14 -0
data/example/protectedlobster.ru +8 -0
data/lib/rack.rb +81 -0
data/lib/rack/auth/abstract/handler.rb +37 -0
data/lib/rack/auth/abstract/request.rb +43 -0
data/lib/rack/auth/basic.rb +58 -0
data/lib/rack/auth/digest/md5.rb +124 -0
data/lib/rack/auth/digest/nonce.rb +51 -0
data/lib/rack/auth/digest/params.rb +53 -0
data/lib/rack/auth/digest/request.rb +40 -0
data/lib/rack/builder.rb +80 -0
data/lib/rack/cascade.rb +41 -0
data/lib/rack/chunked.rb +52 -0
data/lib/rack/commonlogger.rb +49 -0
data/lib/rack/conditionalget.rb +63 -0
data/lib/rack/config.rb +15 -0
data/lib/rack/content_length.rb +29 -0
data/lib/rack/content_type.rb +23 -0
data/lib/rack/deflater.rb +96 -0
data/lib/rack/directory.rb +157 -0
data/lib/rack/etag.rb +59 -0
data/lib/rack/file.rb +118 -0
data/lib/rack/handler.rb +88 -0
data/lib/rack/handler/cgi.rb +61 -0
data/lib/rack/handler/evented_mongrel.rb +8 -0
data/lib/rack/handler/fastcgi.rb +90 -0
data/lib/rack/handler/lsws.rb +61 -0
data/lib/rack/handler/mongrel.rb +90 -0
data/lib/rack/handler/scgi.rb +59 -0
data/lib/rack/handler/swiftiplied_mongrel.rb +8 -0
data/lib/rack/handler/thin.rb +17 -0
data/lib/rack/handler/webrick.rb +73 -0
data/lib/rack/head.rb +19 -0
data/lib/rack/lint.rb +567 -0
data/lib/rack/lobster.rb +65 -0
data/lib/rack/lock.rb +44 -0
data/lib/rack/logger.rb +18 -0
data/lib/rack/methodoverride.rb +27 -0
data/lib/rack/mime.rb +210 -0
data/lib/rack/mock.rb +185 -0
data/lib/rack/nulllogger.rb +18 -0
data/lib/rack/recursive.rb +61 -0
data/lib/rack/reloader.rb +109 -0
data/lib/rack/request.rb +307 -0
data/lib/rack/response.rb +151 -0
data/lib/rack/rewindable_input.rb +104 -0
data/lib/rack/runtime.rb +27 -0
data/lib/rack/sendfile.rb +139 -0
data/lib/rack/server.rb +289 -0
data/lib/rack/session/abstract/id.rb +348 -0
data/lib/rack/session/cookie.rb +152 -0
data/lib/rack/session/memcache.rb +93 -0
data/lib/rack/session/pool.rb +79 -0
data/lib/rack/showexceptions.rb +378 -0
data/lib/rack/showstatus.rb +113 -0
data/lib/rack/static.rb +53 -0
data/lib/rack/urlmap.rb +55 -0
data/lib/rack/utils.rb +698 -0
data/rack.gemspec +39 -0
data/test/cgi/lighttpd.conf +25 -0
data/test/cgi/rackup_stub.rb +6 -0
data/test/cgi/sample_rackup.ru +5 -0
data/test/cgi/test +9 -0
data/test/cgi/test.fcgi +8 -0
data/test/cgi/test.ru +5 -0
data/test/gemloader.rb +6 -0
data/test/multipart/bad_robots +259 -0
data/test/multipart/binary +0 -0
data/test/multipart/empty +10 -0
data/test/multipart/fail_16384_nofile +814 -0
data/test/multipart/file1.txt +1 -0
data/test/multipart/filename_and_modification_param +7 -0
data/test/multipart/filename_with_escaped_quotes +6 -0
data/test/multipart/filename_with_escaped_quotes_and_modification_param +7 -0
data/test/multipart/filename_with_percent_escaped_quotes +6 -0
data/test/multipart/filename_with_unescaped_quotes +6 -0
data/test/multipart/ie +6 -0
data/test/multipart/nested +10 -0
data/test/multipart/none +9 -0
data/test/multipart/semicolon +6 -0
data/test/multipart/text +15 -0
data/test/rackup/config.ru +31 -0
data/test/spec_auth_basic.rb +70 -0
data/test/spec_auth_digest.rb +241 -0
data/test/spec_builder.rb +123 -0
data/test/spec_cascade.rb +45 -0
data/test/spec_cgi.rb +102 -0
data/test/spec_chunked.rb +60 -0
data/test/spec_commonlogger.rb +56 -0
data/test/spec_conditionalget.rb +86 -0
data/test/spec_config.rb +23 -0
data/test/spec_content_length.rb +36 -0
data/test/spec_content_type.rb +29 -0
data/test/spec_deflater.rb +125 -0
data/test/spec_directory.rb +57 -0
data/test/spec_etag.rb +75 -0
data/test/spec_fastcgi.rb +107 -0
data/test/spec_file.rb +92 -0
data/test/spec_handler.rb +49 -0
data/test/spec_head.rb +30 -0
data/test/spec_lint.rb +515 -0
data/test/spec_lobster.rb +43 -0
data/test/spec_lock.rb +142 -0
data/test/spec_logger.rb +28 -0
data/test/spec_methodoverride.rb +58 -0
data/test/spec_mock.rb +241 -0
data/test/spec_mongrel.rb +182 -0
data/test/spec_nulllogger.rb +12 -0
data/test/spec_recursive.rb +69 -0
data/test/spec_request.rb +774 -0
data/test/spec_response.rb +245 -0
data/test/spec_rewindable_input.rb +118 -0
data/test/spec_runtime.rb +39 -0
data/test/spec_sendfile.rb +83 -0
data/test/spec_server.rb +8 -0
data/test/spec_session_abstract_id.rb +43 -0
data/test/spec_session_cookie.rb +171 -0
data/test/spec_session_memcache.rb +289 -0
data/test/spec_session_pool.rb +200 -0
data/test/spec_showexceptions.rb +87 -0
data/test/spec_showstatus.rb +79 -0
data/test/spec_static.rb +48 -0
data/test/spec_thin.rb +86 -0
data/test/spec_urlmap.rb +213 -0
data/test/spec_utils.rb +678 -0
data/test/spec_webrick.rb +141 -0
data/test/testrequest.rb +78 -0
data/test/unregistered_handler/rack/handler/unregistered.rb +7 -0
data/test/unregistered_handler/rack/handler/unregistered_long_one.rb +7 -0
metadata +329 -0

@@ -0,0 +1,57 @@
+require 'rack/directory'
+require 'rack/mock'
+describe Rack::Directory do
+  DOCROOT = File.expand_path(File.dirname(__FILE__)) unless defined? DOCROOT
+  FILE_CATCH = proc{|env| [200, {'Content-Type'=>'text/plain', "Content-Length" => "7"}, ['passed!']] }
+  app = Rack::Directory.new DOCROOT, FILE_CATCH
+  should "serve directory indices" do
+    res = Rack::MockRequest.new(Rack::Lint.new(app)).
+      get("/cgi/")
+    res.should.be.ok
+    res.should =~ /<html><head>/
+  end
+  should "pass to app if file found" do
+    res = Rack::MockRequest.new(Rack::Lint.new(app)).
+      get("/cgi/test")
+    res.should.be.ok
+    res.should =~ /passed!/
+  end
+  should "serve uri with URL encoded filenames" do
+    res = Rack::MockRequest.new(Rack::Lint.new(app)).
+      get("/%63%67%69/") # "/cgi/test"
+    res.should.be.ok
+    res.should =~ /<html><head>/
+    res = Rack::MockRequest.new(Rack::Lint.new(app)).
+      get("/cgi/%74%65%73%74") # "/cgi/test"
+    res.should.be.ok
+    res.should =~ /passed!/
+  end
+  should "not allow directory traversal" do
+    res = Rack::MockRequest.new(Rack::Lint.new(app)).
+      get("/cgi/../test")
+    res.should.be.forbidden
+    res = Rack::MockRequest.new(Rack::Lint.new(app)).
+      get("/cgi/%2E%2E/test")
+    res.should.be.forbidden
+  end
+  should "404 if it can't find the file" do
+    res = Rack::MockRequest.new(Rack::Lint.new(app)).
+      get("/cgi/blubb")
+    res.should.be.not_found
+  end
+end

data/test/spec_etag.rb ADDED

@@ -0,0 +1,75 @@
+require 'rack/etag'
+describe Rack::ETag do
+  def sendfile_body
+    res = ['Hello World']
+    def res.to_path ; "/tmp/hello.txt" ; end
+    res
+  end
+  should "set ETag if none is set if status is 200" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
+    response = Rack::ETag.new(app).call({})
+    response[1]['ETag'].should.equal "\"65a8e27d8879283831b664bd8b7f0ad4\""
+  end
+  should "set ETag if none is set if status is 201" do
+    app = lambda { |env| [201, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
+    response = Rack::ETag.new(app).call({})
+    response[1]['ETag'].should.equal "\"65a8e27d8879283831b664bd8b7f0ad4\""
+  end
+  should "set Cache-Control to 'max-age=0, private, must-revalidate' (default) if none is set" do
+    app = lambda { |env| [201, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
+    response = Rack::ETag.new(app).call({})
+    response[1]['Cache-Control'].should.equal 'max-age=0, private, must-revalidate'
+  end
+  should "set Cache-Control to chosen one if none is set" do
+    app = lambda { |env| [201, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
+    response = Rack::ETag.new(app, nil, 'public').call({})
+    response[1]['Cache-Control'].should.equal 'public'
+  end
+  should "set a given Cache-Control even if digest could not be calculated" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, []] }
+    response = Rack::ETag.new(app, 'no-cache').call({})
+    response[1]['Cache-Control'].should.equal 'no-cache'
+  end
+  should "not set Cache-Control if it is already set" do
+    app = lambda { |env| [201, {'Content-Type' => 'text/plain', 'Cache-Control' => 'public'}, ["Hello, World!"]] }
+    response = Rack::ETag.new(app).call({})
+    response[1]['Cache-Control'].should.equal 'public'
+  end
+  should "not change ETag if it is already set" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'ETag' => '"abc"'}, ["Hello, World!"]] }
+    response = Rack::ETag.new(app).call({})
+    response[1]['ETag'].should.equal "\"abc\""
+  end
+  should "not set ETag if body is empty" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'Last-Modified' => Time.now.httpdate}, []] }
+    response = Rack::ETag.new(app).call({})
+    response[1]['ETag'].should.be.nil
+  end
+  should "not set ETag if Last-Modified is set" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'Last-Modified' => Time.now.httpdate}, ["Hello, World!"]] }
+    response = Rack::ETag.new(app).call({})
+    response[1]['ETag'].should.be.nil
+  end
+  should "not set ETag if a sendfile_body is given" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, sendfile_body] }
+    response = Rack::ETag.new(app).call({})
+    response[1]['ETag'].should.be.nil
+  end
+  should "not set ETag if a status is not 200 or 201" do
+    app = lambda { |env| [401, {'Content-Type' => 'text/plain'}, ['Access denied.']] }
+    response = Rack::ETag.new(app).call({})
+    response[1]['ETag'].should.be.nil
+  end
+end

data/test/spec_fastcgi.rb ADDED

@@ -0,0 +1,107 @@
+begin
+require File.expand_path('../testrequest', __FILE__)
+require 'rack/handler/fastcgi'
+describe Rack::Handler::FastCGI do
+  extend TestRequest::Helpers
+  @host = '0.0.0.0'
+  @port = 9203
+  if `which lighttpd` && !$?.success?
+    raise "lighttpd not found"
+  end
+  # Keep this first.
+  $pid = fork {
+    ENV['RACK_ENV'] = 'deployment'
+    ENV['RUBYLIB'] = [
+      File.expand_path('../../lib', __FILE__),
+      ENV['RUBYLIB'],
+    ].compact.join(':')
+    Dir.chdir(File.expand_path("../cgi", __FILE__)) do
+      exec "lighttpd -D -f lighttpd.conf"
+    end
+  }
+  should "respond" do
+    sleep 1
+    GET("/test")
+    response.should.not.be.nil
+  end
+  should "respond via rackup server" do
+    GET("/sample_rackup.ru")
+    status.should.equal 200
+  end
+  should "be a lighttpd" do
+    GET("/test.fcgi")
+    status.should.equal 200
+    response["SERVER_SOFTWARE"].should =~ /lighttpd/
+    response["HTTP_VERSION"].should.equal "HTTP/1.1"
+    response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
+    response["SERVER_PORT"].should.equal @port.to_s
+    response["SERVER_NAME"].should.equal @host
+  end
+  should "have rack headers" do
+    GET("/test.fcgi")
+    response["rack.version"].should.equal [1,1]
+    response["rack.multithread"].should.be.false
+    response["rack.multiprocess"].should.be.true
+    response["rack.run_once"].should.be.false
+  end
+  should "have CGI headers on GET" do
+    GET("/test.fcgi")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["SCRIPT_NAME"].should.equal "/test.fcgi"
+    response["REQUEST_PATH"].should.equal "/"
+    response["PATH_INFO"].should.equal ""
+    response["QUERY_STRING"].should.equal ""
+    response["test.postdata"].should.equal ""
+    GET("/test.fcgi/foo?quux=1")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["SCRIPT_NAME"].should.equal "/test.fcgi"
+    response["REQUEST_PATH"].should.equal "/"
+    response["PATH_INFO"].should.equal "/foo"
+    response["QUERY_STRING"].should.equal "quux=1"
+  end
+  should "have CGI headers on POST" do
+    POST("/test.fcgi", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
+    status.should.equal 200
+    response["REQUEST_METHOD"].should.equal "POST"
+    response["SCRIPT_NAME"].should.equal "/test.fcgi"
+    response["REQUEST_PATH"].should.equal "/"
+    response["QUERY_STRING"].should.equal ""
+    response["HTTP_X_TEST_HEADER"].should.equal "42"
+    response["test.postdata"].should.equal "rack-form-data=23"
+  end
+  should "support HTTP auth" do
+    GET("/test.fcgi", {:user => "ruth", :passwd => "secret"})
+    response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
+  end
+  should "set status" do
+    GET("/test.fcgi?secret")
+    status.should.equal 403
+    response["rack.url_scheme"].should.equal "http"
+  end
+  # Keep this last.
+  should "shutdown" do
+    Process.kill 15, $pid
+    Process.wait($pid).should.equal $pid
+  end
+end
+rescue RuntimeError
+  $stderr.puts "Skipping Rack::Handler::FastCGI tests (lighttpd is required). Install lighttpd and try again."
+rescue LoadError
+  $stderr.puts "Skipping Rack::Handler::FastCGI tests (FCGI is required). `gem install fcgi` and try again."
+end

data/test/spec_file.rb ADDED

@@ -0,0 +1,92 @@
+require 'rack/file'
+require 'rack/mock'
+describe Rack::File do
+  DOCROOT = File.expand_path(File.dirname(__FILE__)) unless defined? DOCROOT
+  should "serve files" do
+    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(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")
+    path = File.join(DOCROOT, "/cgi/test")
+    res.should.be.ok
+    res["Last-Modified"].should.equal File.mtime(path).httpdate
+  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.should.be.ok
+    res.should =~ /ruby/
+  end
+  should "not allow directory traversal" do
+    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
+      get("/cgi/../test")
+    res.should.be.forbidden
+  end
+  should "not allow directory traversal with encoded periods" do
+    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
+      get("/%2E%2E/README")
+    res.should.be.forbidden
+  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.should.be.not_found
+  end
+  should "detect SystemCallErrors" do
+    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(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(*Rack::File.new(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(*Rack::File.new(DOCROOT).call(env))
+    res.status.should.equal 416
+    res["Content-Range"].should.equal "bytes */193"
+  end
+end

data/test/spec_handler.rb ADDED

@@ -0,0 +1,49 @@
+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 NameError if handler doesn't exist" do
+    lambda {
+      Rack::Handler.get('boom')
+    }.should.raise(NameError)
+  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(NameError)
+      Rack::Handler.get('UnregisteredLongOne').should.equal Rack::Handler::UnregisteredLongOne
+    ensure
+      $LOAD_PATH.delete File.expand_path('../unregistered_handler', __FILE__)
+    end
+  end
+end

data/test/spec_head.rb ADDED

@@ -0,0 +1,30 @@
+require 'rack/head'
+require 'rack/mock'
+describe Rack::Head do
+  def test_response(headers = {})
+    app = lambda { |env| [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]] }
+    request = Rack::MockRequest.env_for("/", headers)
+    response = Rack::Head.new(app).call(request)
+    return response
+  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].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].should.equal([])
+  end
+end

data/test/spec_lint.rb ADDED

@@ -0,0 +1,515 @@
+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)
+  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|
+      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, 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