sinatra 0.2.1 → 0.2.2

data/vendor/rack/test/spec_rack_builder.rb

@@ -0,0 +1,50 @@
+require 'test/spec'
+
+require 'rack/builder'
+require 'rack/mock'
+
+context "Rack::Builder" do
+  specify "chains apps by default" do
+    app = Rack::Builder.new do
+      use Rack::ShowExceptions
+      run lambda { |env| raise "bzzzt" }
+    end.to_app
+
+    Rack::MockRequest.new(app).get("/").should.be.server_error
+    Rack::MockRequest.new(app).get("/").should.be.server_error
+    Rack::MockRequest.new(app).get("/").should.be.server_error
+  end
+
+  specify "has implicit #to_app" do
+    app = Rack::Builder.new do
+      use Rack::ShowExceptions
+      run lambda { |env| raise "bzzzt" }
+    end
+
+    Rack::MockRequest.new(app).get("/").should.be.server_error
+    Rack::MockRequest.new(app).get("/").should.be.server_error
+    Rack::MockRequest.new(app).get("/").should.be.server_error
+  end
+
+  specify "supports blocks on use" do
+    app = Rack::Builder.new do
+      use Rack::ShowExceptions
+      use Rack::Auth::Basic do |username, password|
+        'secret' == password
+      end
+
+      run lambda { |env| [200, {}, 'Hi Boss'] }
+    end
+
+    response = Rack::MockRequest.new(app).get("/")
+    response.should.be.client_error
+    response.status.should.equal 401
+
+    # with auth...
+    response = Rack::MockRequest.new(app).get("/", 
+        'HTTP_AUTHORIZATION' => 'Basic ' + ["joe:secret"].pack("m*"))
+    response.status.should.equal 200
+    response.body.to_s.should.equal 'Hi Boss'
+  end
+
+end

data/vendor/rack/test/spec_rack_camping.rb

@@ -0,0 +1,47 @@
+require 'test/spec'
+require 'stringio'
+require 'uri'
+
+require 'rack/mock'
+
+$-w, w = nil, $-w               # yuck
+require 'camping'
+require 'rack/adapter/camping'
+
+Camping.goes :CampApp
+module CampApp
+  module Controllers
+    class HW < R('/')
+      def get
+        @headers["X-Served-By"] = URI("http://rack.rubyforge.org")
+        "Camping works!"
+      end
+
+      def post
+        "Data: #{input.foo}"
+      end
+    end
+  end
+end
+$-w = w
+
+context "Rack::Adapter::Camping" do
+  specify "works with GET" do
+    res = Rack::MockRequest.new(Rack::Adapter::Camping.new(CampApp)).
+      get("/")
+
+    res.should.be.ok
+    res["Content-Type"].should.equal "text/html"
+    res["X-Served-By"].should.equal "http://rack.rubyforge.org"
+
+    res.body.should.equal "Camping works!"
+  end
+
+  specify "works with POST" do
+    res = Rack::MockRequest.new(Rack::Adapter::Camping.new(CampApp)).
+      post("/", :input => "foo=bar")
+
+    res.should.be.ok
+    res.body.should.equal "Data: bar"
+  end
+end

data/vendor/rack/test/spec_rack_cascade.rb

@@ -0,0 +1,50 @@
+require 'test/spec'
+
+require 'rack/cascade'
+require 'rack/mock'
+
+require 'rack/urlmap'
+require 'rack/file'
+
+context "Rack::Cascade" do
+  docroot = File.expand_path(File.dirname(__FILE__))
+  app1 = Rack::File.new(docroot)
+
+  app2 = Rack::URLMap.new("/crash" => lambda { |env| raise "boom" })
+
+  app3 = Rack::URLMap.new("/foo" => lambda { |env|
+                            [200, { "Content-Type" => "text/plain"}, [""]]})
+
+  specify "should dispatch onward on 404 by default" do
+    cascade = Rack::Cascade.new([app1, app2, app3])
+    Rack::MockRequest.new(cascade).get("/cgi/test").should.be.ok
+    Rack::MockRequest.new(cascade).get("/foo").should.be.ok
+    Rack::MockRequest.new(cascade).get("/toobad").should.be.not_found
+    Rack::MockRequest.new(cascade).get("/cgi/../bla").should.be.forbidden
+  end
+
+  specify "should dispatch onward on whatever is passed" do
+    cascade = Rack::Cascade.new([app1, app2, app3], [404, 403])
+    Rack::MockRequest.new(cascade).get("/cgi/../bla").should.be.not_found
+  end
+
+  specify "should fail if empty" do
+    lambda { Rack::MockRequest.new(Rack::Cascade.new([])).get("/") }.
+      should.raise(ArgumentError)
+  end
+
+  specify "should append new app" do
+    cascade = Rack::Cascade.new([], [404, 403])
+    lambda { Rack::MockRequest.new(cascade).get('/cgi/test') }.
+      should.raise(ArgumentError)
+    cascade << app2
+    Rack::MockRequest.new(cascade).get('/cgi/test').should.be.not_found
+    Rack::MockRequest.new(cascade).get('/cgi/../bla').should.be.not_found
+    cascade << app1
+    Rack::MockRequest.new(cascade).get('/cgi/test').should.be.ok
+    Rack::MockRequest.new(cascade).get('/cgi/../bla').should.be.forbidden
+    Rack::MockRequest.new(cascade).get('/foo').should.be.not_found
+    cascade << app3
+    Rack::MockRequest.new(cascade).get('/foo').should.be.ok
+  end
+end

data/vendor/rack/test/spec_rack_cgi.rb

@@ -0,0 +1,91 @@
+require 'test/spec'
+require 'testrequest'
+
+context "Rack::Handler::CGI" do
+  include TestRequest::Helpers
+  
+  setup do
+    @host = '0.0.0.0'
+    @port = 9203
+  end
+
+  # Keep this first.
+  specify "startup" do
+    $pid = fork {
+      rack_home = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+      ENV['RUBYLIB'] = File.join(rack_home, "lib")
+      Dir.chdir(File.join(rack_home, "test", "cgi"))
+      exec "lighttpd -D -f lighttpd.conf"
+    }
+  end
+
+  specify "should respond" do
+    sleep 1
+    lambda {
+      GET("/test")
+    }.should.not.raise
+  end
+
+  specify "should be a lighttpd" do
+    GET("/test")
+    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")
+    response["rack.version"].should.equal [0,1]
+    response["rack.multithread"].should.be false
+    response["rack.multiprocess"].should.be true
+    response["rack.run_once"].should.be true
+  end
+
+  specify "should have CGI headers on GET" do
+    GET("/test")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["SCRIPT_NAME"].should.equal "/test"
+    response["REQUEST_PATH"].should.equal "/"
+    response["PATH_INFO"].should.be.nil
+    response["QUERY_STRING"].should.equal ""
+    response["test.postdata"].should.equal ""
+
+    GET("/test/foo?quux=1")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["SCRIPT_NAME"].should.equal "/test"
+    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", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
+    status.should.equal 200
+    response["REQUEST_METHOD"].should.equal "POST"
+    response["SCRIPT_NAME"].should.equal "/test"
+    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", {:user => "ruth", :passwd => "secret"})
+    response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
+  end
+
+  specify "should set status" do
+    GET("/test?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/vendor/rack/test/spec_rack_commonlogger.rb

@@ -0,0 +1,32 @@
+require 'test/spec'
+require 'stringio'
+
+require 'rack/commonlogger'
+require 'rack/lobster'
+require 'rack/mock'
+
+context "Rack::CommonLogger" do
+  app = lambda { |env|
+    [200,
+     {"Content-Type" => "text/html"},
+     ["foo"]]}
+
+  specify "should log to rack.errors by default" do
+    log = StringIO.new
+    res = Rack::MockRequest.new(Rack::CommonLogger.new(app)).get("/")
+
+    res.errors.should.not.be.empty
+    res.errors.should =~ /GET /
+    res.errors.should =~ / 200 / # status
+    res.errors.should =~ / 3 /   # length
+  end
+
+  specify "should log to anything with <<" do
+    log = ""
+    res = Rack::MockRequest.new(Rack::CommonLogger.new(app, log)).get("/")
+
+    log.should =~ /GET /
+    log.should =~ / 200 / # status
+    log.should =~ / 3 / # length
+  end
+end

data/vendor/rack/test/spec_rack_fastcgi.rb

@@ -0,0 +1,91 @@
+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 {
+      rack_home = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+      ENV['RUBYLIB'] = File.join(rack_home, "lib")
+      Dir.chdir(File.join(rack_home, "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 [0,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.be.nil
+    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/vendor/rack/test/spec_rack_file.rb

@@ -0,0 +1,40 @@
+require 'test/spec'
+
+require 'rack/file'
+require 'rack/lint'
+
+require 'rack/mock'
+
+context "Rack::File" do
+  DOCROOT = File.expand_path(File.dirname(__FILE__))
+
+  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 "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 "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
+end

data/vendor/rack/test/spec_rack_lint.rb

@@ -0,0 +1,317 @@
+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"}, "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("REQUEST_METHOD" => "FUCKUP"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/REQUEST_METHOD unknown/)
+
+    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/)
+  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.match(/should respond to #each/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {true=>false}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/header key must be a string/)
+
+    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.match(/invalid header/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Foo" => Object.new}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must respond to #each/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Foo" => [1,2,3]}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must consist of Strings/)
+
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Foo-Bar" => "text\000plain"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/invalid header/)
+  end
+
+  specify "notices content-type errors" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/No Content-Type/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [204, {"Content-Type" => "text/plain"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/Content-Type header found/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [204, {"Content-type" => "text/plain"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/Content-Type header found/)
+  end
+
+  specify "notices body errors" do
+    lambda {
+      status, header, body = Rack::Lint.new(lambda { |env|
+                               [200, {"Content-type" => "text/plain"}, [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"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/gets called with arguments/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read("foo")
+                       [201, {"Content-type" => "text/plain"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/read called with non-integer argument/)
+
+    weirdio = Object.new
+    class << weirdio
+      def gets
+        42
+      end
+
+      def read
+        23
+      end
+
+      def each
+        yield 23
+        yield 42
+      end
+    end
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].gets
+                       [201, {"Content-type" => "text/plain"}, ""]
+                     }).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"}, ""]
+                     }).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"}, ""]
+                     }).call(env("rack.input" => weirdio))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/read didn't return a String/)
+
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].close
+                       [201, {"Content-type" => "text/plain"}, ""]
+                     }).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"}, ""]
+                     }).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"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/close must not be called/)
+  end
+
+end