rack 0.9.1 → 1.0.0

data/test/spec_rack_conditionalget.rb

@@ -8,34 +8,34 @@ context "Rack::ConditionalGet" do
   specify "should set a 304 status and truncate body when If-Modified-Since hits" do
     timestamp = Time.now.httpdate
     app = Rack::ConditionalGet.new(lambda { |env|
-      [200, {'Last-Modified'=>timestamp}, 'TEST'] })
+      [200, {'Last-Modified'=>timestamp}, ['TEST']] })
 
     response = Rack::MockRequest.new(app).
       get("/", 'HTTP_IF_MODIFIED_SINCE' => timestamp)
 
-    response.status.should.be == 304
+    response.status.should.equal 304
     response.body.should.be.empty
   end
 
   specify "should set a 304 status and truncate body when If-None-Match hits" do
     app = Rack::ConditionalGet.new(lambda { |env|
-      [200, {'Etag'=>'1234'}, 'TEST'] })
+      [200, {'Etag'=>'1234'}, ['TEST']] })
 
     response = Rack::MockRequest.new(app).
       get("/", 'HTTP_IF_NONE_MATCH' => '1234')
 
-    response.status.should.be == 304
+    response.status.should.equal 304
     response.body.should.be.empty
   end
 
   specify "should not affect non-GET/HEAD requests" do
     app = Rack::ConditionalGet.new(lambda { |env|
-      [200, {'Etag'=>'1234'}, 'TEST'] })
+      [200, {'Etag'=>'1234'}, ['TEST']] })
 
     response = Rack::MockRequest.new(app).
       post("/", 'HTTP_IF_NONE_MATCH' => '1234')
 
-    response.status.should.be == 200
-    response.body.should.be == 'TEST'
+    response.status.should.equal 200
+    response.body.should.equal 'TEST'
   end
 end

data/test/spec_rack_content_type.rb

@@ -0,0 +1,30 @@
+require 'rack/mock'
+require 'rack/content_type'
+
+context "Rack::ContentType" do
+  specify "sets Content-Type to default text/html if none is set" do
+    app = lambda { |env| [200, {}, "Hello, World!"] }
+    status, headers, body = Rack::ContentType.new(app).call({})
+    headers['Content-Type'].should.equal 'text/html'
+  end
+
+  specify "sets Content-Type to chosen default if none is set" do
+    app = lambda { |env| [200, {}, "Hello, World!"] }
+    status, headers, body =
+      Rack::ContentType.new(app, 'application/octet-stream').call({})
+    headers['Content-Type'].should.equal 'application/octet-stream'
+  end
+
+  specify "does not change Content-Type if it is already set" do
+    app = lambda { |env| [200, {'Content-Type' => 'foo/bar'}, "Hello, World!"] }
+    status, headers, body = Rack::ContentType.new(app).call({})
+    headers['Content-Type'].should.equal 'foo/bar'
+  end
+
+  specify "case insensitive detection of Content-Type" do
+    app = lambda { |env| [200, {'CONTENT-Type' => 'foo/bar'}, "Hello, World!"] }
+    status, headers, body = Rack::ContentType.new(app).call({})
+    headers.to_a.select { |k,v| k.downcase == "content-type" }.
+      should.equal [["CONTENT-Type","foo/bar"]]
+  end
+end

data/test/spec_rack_deflater.rb

@@ -7,6 +7,7 @@ require 'time'  # for Time#httpdate
 
 context "Rack::Deflater" do
   def build_response(status, body, accept_encoding, headers = {})
+    body = [body]  if body.respond_to? :to_str
     app = lambda { |env| [status, {}, body] }
     request = Rack::MockRequest.env_for("", headers.merge("HTTP_ACCEPT_ENCODING" => accept_encoding))
     response = Rack::Deflater.new(app).call(request)
@@ -21,8 +22,13 @@ context "Rack::Deflater" do
     response = build_response(200, body, "deflate")
 
     response[0].should.equal(200)
-    response[1].should.equal({ "Content-Encoding" => "deflate", "Vary" => "Accept-Encoding" })
-    response[2].to_s.should.equal("K\313\317OJ,\002\000")
+    response[1].should.equal({
+      "Content-Encoding" => "deflate",
+      "Vary" => "Accept-Encoding"
+    })
+    buf = ''
+    response[2].each { |part| buf << part }
+    buf.should.equal("K\313\317OJ,\002\000")
   end
 
   # TODO: This is really just a special case of the above...
@@ -30,8 +36,13 @@ context "Rack::Deflater" do
     response = build_response(200, "Hello world!", "deflate")
 
     response[0].should.equal(200)
-    response[1].should.equal({ "Content-Encoding" => "deflate", "Vary" => "Accept-Encoding" })
-    response[2].to_s.should.equal("\363H\315\311\311W(\317/\312IQ\004\000")
+    response[1].should.equal({
+      "Content-Encoding" => "deflate",
+      "Vary" => "Accept-Encoding"
+    })
+    buf = ''
+    response[2].each { |part| buf << part }
+    buf.should.equal("\363H\315\311\311W(\317/\312IQ\004\000")
   end
 
   specify "should be able to gzip bodies that respond to each" do
@@ -41,9 +52,14 @@ context "Rack::Deflater" do
     response = build_response(200, body, "gzip")
 
     response[0].should.equal(200)
-    response[1].should.equal({ "Content-Encoding" => "gzip", "Vary" => "Accept-Encoding" })
-
-    io = StringIO.new(response[2].to_s)
+    response[1].should.equal({
+      "Content-Encoding" => "gzip",
+      "Vary" => "Accept-Encoding",
+    })
+
+    buf = ''
+    response[2].each { |part| buf << part }
+    io = StringIO.new(buf)
     gz = Zlib::GzipReader.new(io)
     gz.read.should.equal("foobar")
     gz.close
@@ -54,7 +70,7 @@ context "Rack::Deflater" do
 
     response[0].should.equal(200)
     response[1].should.equal({ "Vary" => "Accept-Encoding" })
-    response[2].should.equal("Hello world!")
+    response[2].should.equal(["Hello world!"])
   end
 
   specify "should be able to skip when there is no response entity body" do
@@ -68,26 +84,32 @@ context "Rack::Deflater" do
   specify "should handle the lack of an acceptable encoding" do
     response1 = build_response(200, "Hello world!", "identity;q=0", "PATH_INFO" => "/")
     response1[0].should.equal(406)
-    response1[1].should.equal({"Content-Type" => "text/plain"})
+    response1[1].should.equal({"Content-Type" => "text/plain", "Content-Length" => "71"})
     response1[2].should.equal(["An acceptable encoding for the requested resource / could not be found."])
 
     response2 = build_response(200, "Hello world!", "identity;q=0", "SCRIPT_NAME" => "/foo", "PATH_INFO" => "/bar")
     response2[0].should.equal(406)
-    response2[1].should.equal({"Content-Type" => "text/plain"})
+    response2[1].should.equal({"Content-Type" => "text/plain", "Content-Length" => "78"})
     response2[2].should.equal(["An acceptable encoding for the requested resource /foo/bar could not be found."])
   end
 
   specify "should handle gzip response with Last-Modified header" do
     last_modified = Time.now.httpdate
 
-    app = lambda { |env| [200, { "Last-Modified" => last_modified }, "Hello World!"] }
+    app = lambda { |env| [200, { "Last-Modified" => last_modified }, ["Hello World!"]] }
     request = Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => "gzip")
     response = Rack::Deflater.new(app).call(request)
 
     response[0].should.equal(200)
-    response[1].should.equal({ "Content-Encoding" => "gzip", "Vary" => "Accept-Encoding", "Last-Modified" => last_modified })
-
-    io = StringIO.new(response[2].to_s)
+    response[1].should.equal({
+      "Content-Encoding" => "gzip",
+      "Vary" => "Accept-Encoding",
+      "Last-Modified" => last_modified
+    })
+
+    buf = ''
+    response[2].each { |part| buf << part }
+    io = StringIO.new(buf)
     gz = Zlib::GzipReader.new(io)
     gz.read.should.equal("Hello World!")
     gz.close

data/test/spec_rack_directory.rb

@@ -7,7 +7,7 @@ require 'rack/mock'
 
 context "Rack::Directory" do
   DOCROOT = File.expand_path(File.dirname(__FILE__))
-  FILE_CATCH = proc{|env| [200, {'Content-Type'=>'text/plain', "Content-Length" => "7"}, 'passed!'] }
+  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

data/test/spec_rack_file.rb

@@ -61,4 +61,15 @@ context "Rack::File" do
 
     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

@@ -12,13 +12,32 @@ context "Rack::Handler" do
     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 handler by name" do
-    Rack::Handler.get('lobster').should.equal Rack::Handler::Lobster
+  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_lint.rb

@@ -12,7 +12,7 @@ context "Rack::Lint" do
   specify "passes valid request" do
     lambda {
       Rack::Lint.new(lambda { |env|
-                       [200, {"Content-type" => "test/plain", "Content-length" => "3"}, "foo"]
+                       [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]]
                      }).call(env({}))
     }.should.not.raise
   end
@@ -66,6 +66,11 @@ context "Rack::Lint" do
     }.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("REQUEST_METHOD" => "FUCKUP?"))
     }.should.raise(Rack::Lint::LintError).
@@ -133,73 +138,80 @@ context "Rack::Lint" do
   specify "notices header errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
-                       [200, Object.new, ""]
+                       [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}, ""]
+                       [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"}, ""]
+                       [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"}, ""]
+                       [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"}, ""]
+                       [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"}, ""]
+                       [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}, ""]
+                       [200, {"Foo" => Object.new}, []]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
-      message.should.equal("header values must respond to #each, but the value of 'Foo' doesn't (is Object)")
+      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]}, ""]
+                       [200, {"Foo" => [1, 2, 3]}, []]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
-      message.should.equal("header values must consist of Strings, but 'Foo' also contains a Fixnum")
+      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"}, ""]
+                       [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"}, ""]
+                       [200, {"Content-length" => "0"}, []]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/No Content-Type/)
@@ -207,7 +219,7 @@ context "Rack::Lint" do
     [100, 101, 204, 304].each do |status|
       lambda {
         Rack::Lint.new(lambda { |env|
-                         [status, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                         [status, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                        }).call(env({}))
       }.should.raise(Rack::Lint::LintError).
         message.should.match(/Content-Type header found/)
@@ -215,17 +227,10 @@ context "Rack::Lint" do
   end
 
   specify "notices content-length errors" do
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       [200, {"Content-type" => "text/plain"}, ""]
-                     }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/No Content-Length/)
-
     [100, 101, 204, 304].each do |status|
       lambda {
         Rack::Lint.new(lambda { |env|
-                         [status, {"Content-length" => "0"}, ""]
+                         [status, {"Content-length" => "0"}, []]
                        }).call(env({}))
       }.should.raise(Rack::Lint::LintError).
         message.should.match(/Content-Length header found/)
@@ -233,14 +238,7 @@ context "Rack::Lint" do
 
     lambda {
       Rack::Lint.new(lambda { |env|
-                       [200, {"Content-type" => "text/plain", "Content-Length" => "0", "Transfer-Encoding" => "chunked"}, ""]
-                     }).call(env({}))
-    }.should.raise(Rack::Lint::LintError).
-      message.should.match(/Content-Length header should not be used/)
-
-    lambda {
-      Rack::Lint.new(lambda { |env|
-                       [200, {"Content-type" => "text/plain", "Content-Length" => "1"}, ""]
+                       [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/)
@@ -260,18 +258,58 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].gets("\r\n")
-                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                       [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"}, ""]
+                       [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-integer argument/)
+      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
@@ -287,12 +325,33 @@ context "Rack::Lint" do
         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"}, ""]
+                       [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/)
@@ -300,7 +359,7 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].each { |x| }
-                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                       [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/)
@@ -308,16 +367,32 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].read
-                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                       [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 a String/)
+      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"}, ""]
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/close must not be called/)
@@ -327,7 +402,7 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.errors"].write(42)
-                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/write not called with a String/)
@@ -335,7 +410,7 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.errors"].close
-                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/close must not be called/)
@@ -350,11 +425,55 @@ context "Rack::Lint" do
 
     lambda {
       Rack::Lint.new(lambda { |env|
-                       [200, {"Content-type" => "test/plain", "Content-length" => "3"}, "foo"]
+                       [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
+    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 world")}))
+    }.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 world")}))
+    }.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 world")}))
+    }.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 world")}))
+    }.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 world")}))
+    }.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 world")}))
+    }.should.not.raise(Rack::Lint::LintError)
+  end
 end
 
 context "Rack::Lint::InputWrapper" do
@@ -372,9 +491,9 @@ context "Rack::Lint::InputWrapper" do
   specify "delegates :rewind to underlying IO object" do
     io = StringIO.new("123")
     wrapper = Rack::Lint::InputWrapper.new(io)
-    wrapper.read.should == "123"
-    wrapper.read.should == ""
+    wrapper.read.should.equal "123"
+    wrapper.read.should.equal ""
     wrapper.rewind
-    wrapper.read.should == "123"
+    wrapper.read.should.equal "123"
   end
 end