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

edgar-rack 1.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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

data/test/spec_directory.rb ADDED

@@ -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