RubyGems - eac-rack - Versions diffs - 1.1.1 - Mend

eac-rack 1.1.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 (111) hide show

data/COPYING +18 -0
data/KNOWN-ISSUES +21 -0
data/README +399 -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 +92 -0
data/lib/rack/adapter/camping.rb +22 -0
data/lib/rack/auth/abstract/handler.rb +37 -0
data/lib/rack/auth/abstract/request.rb +37 -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 +55 -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 +49 -0
data/lib/rack/commonlogger.rb +49 -0
data/lib/rack/conditionalget.rb +47 -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 +23 -0
data/lib/rack/file.rb +90 -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 +89 -0
data/lib/rack/handler/lsws.rb +63 -0
data/lib/rack/handler/mongrel.rb +90 -0
data/lib/rack/handler/scgi.rb +62 -0
data/lib/rack/handler/swiftiplied_mongrel.rb +8 -0
data/lib/rack/handler/thin.rb +18 -0
data/lib/rack/handler/webrick.rb +69 -0
data/lib/rack/head.rb +19 -0
data/lib/rack/lint.rb +575 -0
data/lib/rack/lobster.rb +65 -0
data/lib/rack/lock.rb +16 -0
data/lib/rack/logger.rb +20 -0
data/lib/rack/methodoverride.rb +27 -0
data/lib/rack/mime.rb +206 -0
data/lib/rack/mock.rb +189 -0
data/lib/rack/nulllogger.rb +18 -0
data/lib/rack/recursive.rb +57 -0
data/lib/rack/reloader.rb +109 -0
data/lib/rack/request.rb +271 -0
data/lib/rack/response.rb +149 -0
data/lib/rack/rewindable_input.rb +100 -0
data/lib/rack/runtime.rb +27 -0
data/lib/rack/sendfile.rb +142 -0
data/lib/rack/server.rb +212 -0
data/lib/rack/session/abstract/id.rb +140 -0
data/lib/rack/session/cookie.rb +90 -0
data/lib/rack/session/memcache.rb +119 -0
data/lib/rack/session/pool.rb +100 -0
data/lib/rack/showexceptions.rb +349 -0
data/lib/rack/showstatus.rb +106 -0
data/lib/rack/static.rb +38 -0
data/lib/rack/urlmap.rb +56 -0
data/lib/rack/utils.rb +614 -0
data/rack.gemspec +38 -0
data/test/spec_rack_auth_basic.rb +73 -0
data/test/spec_rack_auth_digest.rb +226 -0
data/test/spec_rack_builder.rb +84 -0
data/test/spec_rack_camping.rb +51 -0
data/test/spec_rack_cascade.rb +48 -0
data/test/spec_rack_cgi.rb +89 -0
data/test/spec_rack_chunked.rb +62 -0
data/test/spec_rack_commonlogger.rb +61 -0
data/test/spec_rack_conditionalget.rb +41 -0
data/test/spec_rack_config.rb +24 -0
data/test/spec_rack_content_length.rb +43 -0
data/test/spec_rack_content_type.rb +30 -0
data/test/spec_rack_deflater.rb +127 -0
data/test/spec_rack_directory.rb +61 -0
data/test/spec_rack_etag.rb +17 -0
data/test/spec_rack_fastcgi.rb +89 -0
data/test/spec_rack_file.rb +75 -0
data/test/spec_rack_handler.rb +43 -0
data/test/spec_rack_head.rb +30 -0
data/test/spec_rack_lint.rb +528 -0
data/test/spec_rack_lobster.rb +45 -0
data/test/spec_rack_lock.rb +38 -0
data/test/spec_rack_logger.rb +21 -0
data/test/spec_rack_methodoverride.rb +60 -0
data/test/spec_rack_mock.rb +243 -0
data/test/spec_rack_mongrel.rb +189 -0
data/test/spec_rack_nulllogger.rb +13 -0
data/test/spec_rack_recursive.rb +77 -0
data/test/spec_rack_request.rb +545 -0
data/test/spec_rack_response.rb +221 -0
data/test/spec_rack_rewindable_input.rb +118 -0
data/test/spec_rack_runtime.rb +35 -0
data/test/spec_rack_sendfile.rb +86 -0
data/test/spec_rack_session_cookie.rb +73 -0
data/test/spec_rack_session_memcache.rb +273 -0
data/test/spec_rack_session_pool.rb +172 -0
data/test/spec_rack_showexceptions.rb +21 -0
data/test/spec_rack_showstatus.rb +72 -0
data/test/spec_rack_static.rb +37 -0
data/test/spec_rack_thin.rb +91 -0
data/test/spec_rack_urlmap.rb +215 -0
data/test/spec_rack_utils.rb +554 -0
data/test/spec_rack_webrick.rb +130 -0
data/test/spec_rackup.rb +154 -0
metadata +311 -0

data/test/spec_rack_directory.rb ADDED

@@ -0,0 +1,61 @@
+require 'test/spec'
+require 'rack/directory'
+require 'rack/lint'
+require 'rack/mock'
+context "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
+  specify "serves directory indices" do
+    res = Rack::MockRequest.new(Rack::Lint.new(app)).
+      get("/cgi/")
+    res.should.be.ok
+    res.should =~ /<html><head>/
+  end
+  specify "passes 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
+  specify "serves 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
+  specify "does 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
+  specify "404s 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_rack_etag.rb ADDED

@@ -0,0 +1,17 @@
+require 'test/spec'
+require 'rack/mock'
+require 'rack/etag'
+context "Rack::ETag" do
+  specify "sets ETag if none is set" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
+    response = Rack::ETag.new(app).call({})
+    response[1]['ETag'].should.equal "\"65a8e27d8879283831b664bd8b7f0ad4\""
+  end
+  specify "does 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
+end

data/test/spec_rack_fastcgi.rb ADDED

@@ -0,0 +1,89 @@
+require 'test/spec'
+require 'testrequest'
+context "Rack::Handler::FastCGI" do
+  include TestRequest::Helpers
+  setup do
+    @host = '0.0.0.0'
+    @port = 9203
+  end
+  # Keep this first.
+  specify "startup" do
+    $pid = fork {
+      Dir.chdir(File.join(File.dirname(__FILE__), "..", "test", "cgi"))
+      exec "lighttpd -D -f lighttpd.conf"
+    }
+  end
+  specify "should respond" do
+    sleep 1
+    lambda {
+      GET("/test.fcgi")
+    }.should.not.raise
+  end
+  specify "should be a lighttpd" do
+    GET("/test.fcgi")
+    status.should.be 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 =~ @host
+  end
+  specify "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
+  specify "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
+  specify "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
+  specify "should support HTTP auth" do
+    GET("/test.fcgi", {:user => "ruth", :passwd => "secret"})
+    response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
+  end
+  specify "should set status" do
+    GET("/test.fcgi?secret")
+    status.should.equal 403
+    response["rack.url_scheme"].should.equal "http"
+  end
+  # Keep this last.
+  specify "shutdown" do
+    Process.kill 15, $pid
+    Process.wait($pid).should.equal $pid
+  end
+end

data/test/spec_rack_file.rb ADDED

@@ -0,0 +1,75 @@
+require 'test/spec'
+require 'rack/file'
+require 'rack/lint'
+require 'rack/mock'
+context "Rack::File" do
+  DOCROOT = File.expand_path(File.dirname(__FILE__)) unless defined? DOCROOT
+  specify "serves files" do
+    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
+      get("/cgi/test")
+    res.should.be.ok
+    res.should =~ /ruby/
+  end
+  specify "sets 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
+  specify "serves 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
+  specify "does not allow directory traversal" do
+    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
+      get("/cgi/../test")
+    res.should.be.forbidden
+  end
+  specify "does 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
+  specify "404s 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
+  specify "detects SystemCallErrors" do
+    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
+      get("/cgi")
+    res.should.be.not_found
+  end
+  specify "returns bodies that respond to #to_path" do
+    env = Rack::MockRequest.env_for("/cgi/test")
+    status, headers, 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
+end

data/test/spec_rack_handler.rb ADDED

@@ -0,0 +1,43 @@
+require 'test/spec'
+require 'rack/handler'
+class Rack::Handler::Lobster; end
+class RockLobster; end
+context "Rack::Handler" do
+  specify "has registered default handlers" do
+    Rack::Handler.get('cgi').should.equal Rack::Handler::CGI
+    Rack::Handler.get('fastcgi').should.equal Rack::Handler::FastCGI
+    Rack::Handler.get('mongrel').should.equal Rack::Handler::Mongrel
+    Rack::Handler.get('webrick').should.equal Rack::Handler::WEBrick
+  end
+  specify "handler that doesn't exist should raise a NameError" do
+    lambda {
+      Rack::Handler.get('boom')
+    }.should.raise(NameError)
+  end
+  specify "should get unregistered, but already required, handler by name" do
+    Rack::Handler.get('Lobster').should.equal Rack::Handler::Lobster
+  end
+  specify "should register custom handler" do
+    Rack::Handler.register('rock_lobster', 'RockLobster')
+    Rack::Handler.get('rock_lobster').should.equal RockLobster
+  end
+  specify "should not need registration for properly coded handlers even if not already required" do
+    begin
+      $:.push "test/unregistered_handler"
+      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
+      $:.delete "test/unregistered_handler"
+    end
+  end
+end

data/test/spec_rack_head.rb ADDED

@@ -0,0 +1,30 @@
+require 'rack/head'
+require 'rack/mock'
+context "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
+  specify "passes 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
+  specify "removes 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_rack_lint.rb ADDED

@@ -0,0 +1,528 @@
+require 'test/spec'
+require 'stringio'
+require 'rack/lint'
+require 'rack/mock'
+context "Rack::Lint" do
+  def env(*args)
+    Rack::MockRequest.env_for("/", *args)
+  end
+  specify "passes valid request" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]]
+                     }).call(env({}))
+    }.should.not.raise
+  end
+  specify "notices fatal errors" do
+    lambda { Rack::Lint.new(nil).call }.should.raise(Rack::Lint::LintError).
+      message.should.match(/No env given/)
+  end
+  specify "notices environment errors" do
+    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
+  specify "notices 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
+  specify "notices error errors" do
+    lambda {
+      Rack::Lint.new(nil).call(env("rack.errors" => ""))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/does not respond to #puts/)
+  end
+  specify "notices status errors" do
+    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
+  specify "notices 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
+  specify "notices 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
+  specify "notices 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({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/Content-Length header was 1, but should be 0/)
+  end
+  specify "notices body errors" do
+    lambda {
+      status, header, body = Rack::Lint.new(lambda { |env|
+                               [200, {"Content-type" => "text/plain","Content-length" => "3"}, [1,2,3]]
+                             }).call(env({}))
+      body.each { |part| }
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/yielded non-string/)
+  end
+  specify "notices 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
+  specify "notices 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
+  specify "notices 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"}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/body was given for HEAD/)
+  end
+  specify "passes 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
+context "Rack::Lint::InputWrapper" do
+  specify "delegates :size to underlying IO object" do
+    class IOMock
+      def size
+        101
+      end
+    end
+    wrapper = Rack::Lint::InputWrapper.new(IOMock.new)
+    wrapper.size.should == 101
+  end
+  specify "delegates :rewind to underlying IO object" do
+    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