rack 1.1.0 → 1.2.0

data/{test/spec_rack_lint.rb → spec/spec_lint.rb}

@@ -1,15 +1,13 @@
-require 'test/spec'
 require 'stringio'
-
 require 'rack/lint'
 require 'rack/mock'
 
-context "Rack::Lint" do
+describe Rack::Lint do
   def env(*args)
     Rack::MockRequest.env_for("/", *args)
   end
 
-  specify "passes valid request" do
+  should "pass valid request" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]]
@@ -17,12 +15,12 @@ context "Rack::Lint" do
     }.should.not.raise
   end
 
-  specify "notices fatal errors" do
+  should "notice 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
+  should "notice environment errors" do
     lambda { Rack::Lint.new(nil).call 5 }.should.raise(Rack::Lint::LintError).
       message.should.match(/not a Hash/)
 
@@ -110,7 +108,7 @@ context "Rack::Lint" do
       message.should.match(/cannot be .* make it ''/)
   end
 
-  specify "notices input errors" do
+  should "notice input errors" do
     lambda {
       Rack::Lint.new(nil).call(env("rack.input" => ""))
     }.should.raise(Rack::Lint::LintError).
@@ -139,14 +137,14 @@ context "Rack::Lint" do
       message.should.match(/does not have ASCII-8BIT as its external encoding/)
   end
 
-  specify "notices error errors" do
+  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
 
-  specify "notices status errors" do
+  should "notice status errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        ["cc", {}, ""]
@@ -162,7 +160,7 @@ context "Rack::Lint" do
       message.should.match(/must be >=100 seen as integer/)
   end
 
-  specify "notices header errors" do
+  should "notice header errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, Object.new, []]
@@ -235,7 +233,7 @@ context "Rack::Lint" do
     }.should.not.raise(Rack::Lint::LintError)
   end
 
-  specify "notices content-type errors" do
+  should "notice content-type errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Content-length" => "0"}, []]
@@ -253,7 +251,7 @@ context "Rack::Lint" do
     end
   end
 
-  specify "notices content-length errors" do
+  should "notice content-length errors" do
     [100, 101, 204, 304].each do |status|
       lambda {
         Rack::Lint.new(lambda { |env|
@@ -266,12 +264,12 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Content-type" => "text/plain", "Content-Length" => "1"}, []]
-                     }).call(env({}))
+                     }).call(env({}))[2].each { }
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/Content-Length header was 1, but should be 0/)
   end
 
-  specify "notices body errors" do
+  should "notice body errors" do
     lambda {
       status, header, body = Rack::Lint.new(lambda { |env|
                                [200, {"Content-type" => "text/plain","Content-length" => "3"}, [1,2,3]]
@@ -281,7 +279,7 @@ context "Rack::Lint" do
       message.should.match(/yielded non-string/)
   end
 
-  specify "notices input handling errors" do
+  should "notice input handling errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].gets("\r\n")
@@ -425,7 +423,7 @@ context "Rack::Lint" do
       message.should.match(/close must not be called/)
   end
 
-  specify "notices error handling errors" do
+  should "notice error handling errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.errors"].write(42)
@@ -443,7 +441,7 @@ context "Rack::Lint" do
       message.should.match(/close must not be called/)
   end
 
-  specify "notices HEAD errors" do
+  should "notice HEAD errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Content-type" => "test/plain", "Content-length" => "3"}, []]
@@ -453,12 +451,12 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]]
-                     }).call(env({"REQUEST_METHOD" => "HEAD"}))
+                     }).call(env({"REQUEST_METHOD" => "HEAD"}))[2].each { }
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/body was given for HEAD/)
   end
 
-  specify "passes valid read calls" do
+  should "pass valid read calls" do
     hello_str = "hello world"
     hello_str.force_encoding("ASCII-8BIT") if hello_str.respond_to? :force_encoding
     lambda {
@@ -505,19 +503,8 @@ context "Rack::Lint" do
   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
+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"

data/{test/spec_rack_lobster.rb → spec/spec_lobster.rb}

@@ -1,29 +1,27 @@
-require 'test/spec'
-
 require 'rack/lobster'
 require 'rack/mock'
 
-context "Rack::Lobster::LambdaLobster" do
-  specify "should be a single lambda" do
+describe Rack::Lobster::LambdaLobster do
+  should "be a single lambda" do
     Rack::Lobster::LambdaLobster.should.be.kind_of Proc
   end
-  
-  specify "should look like a lobster" do
+
+  should "look like a lobster" do
     res = Rack::MockRequest.new(Rack::Lobster::LambdaLobster).get("/")
     res.should.be.ok
     res.body.should.include "(,(,,(,,,("
     res.body.should.include "?flip"
   end
 
-  specify "should be flippable" do
+  should "be flippable" do
     res = Rack::MockRequest.new(Rack::Lobster::LambdaLobster).get("/?flip")
     res.should.be.ok
     res.body.should.include "(,,,(,,(,("
   end
 end
 
-context "Rack::Lobster" do
-  specify "should look like a lobster" do
+describe Rack::Lobster do
+  should "look like a lobster" do
     res = Rack::MockRequest.new(Rack::Lobster.new).get("/")
     res.should.be.ok
     res.body.should.include "(,(,,(,,,("
@@ -31,13 +29,13 @@ context "Rack::Lobster" do
     res.body.should.include "crash"
   end
 
-  specify "should be flippable" do
+  should "be flippable" do
     res = Rack::MockRequest.new(Rack::Lobster.new).get("/?flip=left")
     res.should.be.ok
     res.body.should.include "(,,,(,,(,("
   end
 
-  specify "should provide crashing for testing purposes" do
+  should "provide crashing for testing purposes" do
     lambda {
       Rack::MockRequest.new(Rack::Lobster.new).get("/?flip=crash")
     }.should.raise

data/{test/spec_rack_lock.rb → spec/spec_lock.rb}

@@ -1,37 +1,35 @@
-require 'test/spec'
-
-require 'rack/mock'
 require 'rack/lock'
+require 'rack/mock'
 
-context "Rack::Lock" do
-  class Lock
-    attr_reader :synchronized
+class Lock
+  attr_reader :synchronized
 
-    def initialize
-      @synchronized = false
-    end
+  def initialize
+    @synchronized = false
+  end
 
-    def synchronize
-      @synchronized = true
-      yield
-    end
+  def synchronize
+    @synchronized = true
+    yield
   end
+end
 
-  specify "should call synchronize on lock" do
+describe Rack::Lock do
+  should "call synchronize on lock" do
     lock = Lock.new
     env = Rack::MockRequest.env_for("/")
-    app = Rack::Lock.new(lambda { |env| }, lock)
+    app = Rack::Lock.new(lambda { |inner_env| }, lock)
     lock.synchronized.should.equal false
     app.call(env)
     lock.synchronized.should.equal true
   end
 
-  specify "should set multithread flag to false" do
+  should "set multithread flag to false" do
     app = Rack::Lock.new(lambda { |env| env['rack.multithread'] })
     app.call(Rack::MockRequest.env_for("/")).should.equal false
   end
 
-  specify "should reset original multithread flag when exiting lock" do
+  should "reset original multithread flag when exiting lock" do
     app = Rack::Lock.new(lambda { |env| env })
     app.call(Rack::MockRequest.env_for("/"))['rack.multithread'].should.equal true
   end

data/{test/spec_rack_logger.rb → spec/spec_logger.rb}

@@ -1,9 +1,8 @@
-require 'rack/logger'
-require 'rack/lint'
 require 'stringio'
+require 'rack/logger'
 
-context "Rack::Logger" do
-  specify "logs to rack.errors" do
+describe Rack::Logger do
+  should "log to rack.errors" do
     app = lambda { |env|
       log = env['rack.logger']
       log.debug("Created logger")
@@ -14,8 +13,8 @@ context "Rack::Logger" do
     }
 
     errors = StringIO.new
-    Rack::Logger.new(app).call({'rack.errors' => errors})
-    errors.string.should.match "INFO -- : Program started"
-    errors.string.should.match "WARN -- : Nothing to do"
+    Rack::Logger.new(app).call('rack.errors' => errors)
+    errors.string.should.match(/INFO -- : Program started/)
+    errors.string.should.match(/WARN -- : Nothing to do/)
   end
 end

data/{test/spec_rack_methodoverride.rb → spec/spec_methodoverride.rb}

@@ -1,58 +1,56 @@
-require 'test/spec'
-
-require 'rack/mock'
-require 'rack/methodoverride'
 require 'stringio'
+require 'rack/methodoverride'
+require 'rack/mock'
 
-context "Rack::MethodOverride" do
-  specify "should not affect GET requests" do
+describe Rack::MethodOverride do
+  should "not affect GET requests" do
     env = Rack::MockRequest.env_for("/?_method=delete", :method => "GET")
-    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
+    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
     req = app.call(env)
 
     req.env["REQUEST_METHOD"].should.equal "GET"
   end
 
-  specify "_method parameter should modify REQUEST_METHOD for POST requests" do
+  should "modify REQUEST_METHOD for POST requests when _method parameter is set" do
     env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=put")
-    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
+    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
     req = app.call(env)
 
     req.env["REQUEST_METHOD"].should.equal "PUT"
   end
 
-  specify "X-HTTP-Method-Override header should modify REQUEST_METHOD for POST requests" do
+  should "modify REQUEST_METHOD for POST requests when X-HTTP-Method-Override is set" do
     env = Rack::MockRequest.env_for("/",
             :method => "POST",
             "HTTP_X_HTTP_METHOD_OVERRIDE" => "PUT"
           )
-    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
+    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
     req = app.call(env)
 
     req.env["REQUEST_METHOD"].should.equal "PUT"
   end
 
-  specify "should not modify REQUEST_METHOD if the method is unknown" do
+  should "not modify REQUEST_METHOD if the method is unknown" do
     env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=foo")
-    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
+    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
     req = app.call(env)
 
     req.env["REQUEST_METHOD"].should.equal "POST"
   end
 
-  specify "should not modify REQUEST_METHOD when _method is nil" do
+  should "not modify REQUEST_METHOD when _method is nil" do
     env = Rack::MockRequest.env_for("/", :method => "POST", :input => "foo=bar")
-    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
+    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
     req = app.call(env)
 
     req.env["REQUEST_METHOD"].should.equal "POST"
   end
 
-  specify "should store the original REQUEST_METHOD prior to overriding" do
+  should "store the original REQUEST_METHOD prior to overriding" do
     env = Rack::MockRequest.env_for("/",
             :method => "POST",
             :input  => "_method=options")
-    app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) })
+    app = Rack::MethodOverride.new(lambda{|envx| Rack::Request.new(envx) })
     req = app.call(env)
 
     req.env["rack.methodoverride.original_method"].should.equal "POST"

data/{test/spec_rack_mock.rb → spec/spec_mock.rb}

@@ -1,35 +1,33 @@
 require 'yaml'
 require 'rack/mock'
-require 'rack/request'
-require 'rack/response'
 
 app = lambda { |env|
   req = Rack::Request.new(env)
-  
+
   env["mock.postdata"] = env["rack.input"].read
   if req.GET["error"]
     env["rack.errors"].puts req.GET["error"]
     env["rack.errors"].flush
   end
-  
+
   Rack::Response.new(env.to_yaml,
                      req.GET["status"] || 200,
                      "Content-Type" => "text/yaml").finish
 }
 
-context "Rack::MockRequest" do
-  specify "should return a MockResponse" do
+describe Rack::MockRequest do
+  should "return a MockResponse" do
     res = Rack::MockRequest.new(app).get("")
     res.should.be.kind_of Rack::MockResponse
   end
 
-  specify "should be able to only return the environment" do
+  should "be able to only return the environment" do
     env = Rack::MockRequest.env_for("")
     env.should.be.kind_of Hash
     env.should.include "rack.version"
   end
 
-  specify "should provide sensible defaults" do
+  should "provide sensible defaults" do
     res = Rack::MockRequest.new(app).request
 
     env = YAML.load(res.body)
@@ -43,7 +41,7 @@ context "Rack::MockRequest" do
     env["mock.postdata"].should.be.empty
   end
 
-  specify "should allow GET/POST/PUT/DELETE" do
+  should "allow GET/POST/PUT/DELETE" do
     res = Rack::MockRequest.new(app).get("", :input => "foo")
     env = YAML.load(res.body)
     env["REQUEST_METHOD"].should.equal "GET"
@@ -64,12 +62,12 @@ context "Rack::MockRequest" do
       should.equal "OPTIONS"
   end
 
-  specify "should set content length" do
+  should "set content length" do
     env = Rack::MockRequest.env_for("/", :input => "foo")
     env["CONTENT_LENGTH"].should.equal "3"
   end
 
-  specify "should allow posting" do
+  should "allow posting" do
     res = Rack::MockRequest.new(app).get("", :input => "foo")
     env = YAML.load(res.body)
     env["mock.postdata"].should.equal "foo"
@@ -79,7 +77,7 @@ context "Rack::MockRequest" do
     env["mock.postdata"].should.equal "foo"
   end
 
-  specify "should use all parts of an URL" do
+  should "use all parts of an URL" do
     res = Rack::MockRequest.new(app).
       get("https://bla.example.org:9292/meh/foo?bar")
     res.should.be.kind_of Rack::MockResponse
@@ -93,7 +91,7 @@ context "Rack::MockRequest" do
     env["rack.url_scheme"].should.equal "https"
   end
 
-  specify "should set SSL port and HTTP flag on when using https" do
+  should "set SSL port and HTTP flag on when using https" do
     res = Rack::MockRequest.new(app).
       get("https://example.org/foo")
     res.should.be.kind_of Rack::MockResponse
@@ -108,7 +106,7 @@ context "Rack::MockRequest" do
     env["HTTPS"].should.equal "on"
   end
 
-  specify "should prepend slash to uri path" do
+  should "prepend slash to uri path" do
     res = Rack::MockRequest.new(app).
       get("foo")
     res.should.be.kind_of Rack::MockResponse
@@ -122,33 +120,33 @@ context "Rack::MockRequest" do
     env["rack.url_scheme"].should.equal "http"
   end
 
-  specify "should properly convert method name to an uppercase string" do
+  should "properly convert method name to an uppercase string" do
     res = Rack::MockRequest.new(app).request(:get)
     env = YAML.load(res.body)
     env["REQUEST_METHOD"].should.equal "GET"
   end
 
-  specify "should accept params and build query string for GET requests" do
+  should "accept params and build query string for GET requests" do
     res = Rack::MockRequest.new(app).get("/foo?baz=2", :params => {:foo => {:bar => "1"}})
     env = YAML.load(res.body)
     env["REQUEST_METHOD"].should.equal "GET"
-    env["QUERY_STRING"].should.match "baz=2"
-    env["QUERY_STRING"].should.match "foo[bar]=1"
+    env["QUERY_STRING"].should.include "baz=2"
+    env["QUERY_STRING"].should.include "foo[bar]=1"
     env["PATH_INFO"].should.equal "/foo"
     env["mock.postdata"].should.equal ""
   end
 
-  specify "should accept raw input in params for GET requests" do
+  should "accept raw input in params for GET requests" do
     res = Rack::MockRequest.new(app).get("/foo?baz=2", :params => "foo[bar]=1")
     env = YAML.load(res.body)
     env["REQUEST_METHOD"].should.equal "GET"
-    env["QUERY_STRING"].should.match "baz=2"
-    env["QUERY_STRING"].should.match "foo[bar]=1"
+    env["QUERY_STRING"].should.include "baz=2"
+    env["QUERY_STRING"].should.include "foo[bar]=1"
     env["PATH_INFO"].should.equal "/foo"
     env["mock.postdata"].should.equal ""
   end
 
-  specify "should accept params and build url encoded params for POST requests" do
+  should "accept params and build url encoded params for POST requests" do
     res = Rack::MockRequest.new(app).post("/foo", :params => {:foo => {:bar => "1"}})
     env = YAML.load(res.body)
     env["REQUEST_METHOD"].should.equal "POST"
@@ -158,7 +156,7 @@ context "Rack::MockRequest" do
     env["mock.postdata"].should.equal "foo[bar]=1"
   end
 
-  specify "should accept raw input in params for POST requests" do
+  should "accept raw input in params for POST requests" do
     res = Rack::MockRequest.new(app).post("/foo", :params => "foo[bar]=1")
     env = YAML.load(res.body)
     env["REQUEST_METHOD"].should.equal "POST"
@@ -168,7 +166,7 @@ context "Rack::MockRequest" do
     env["mock.postdata"].should.equal "foo[bar]=1"
   end
 
-  specify "should accept params and build multipart encoded params for POST requests" do
+  should "accept params and build multipart encoded params for POST requests" do
     files = Rack::Utils::Multipart::UploadedFile.new(File.join(File.dirname(__FILE__), "multipart", "file1.txt"))
     res = Rack::MockRequest.new(app).post("/foo", :params => { "submit-name" => "Larry", "files" => files })
     env = YAML.load(res.body)
@@ -179,7 +177,7 @@ context "Rack::MockRequest" do
     env["mock.postdata"].length.should.equal 206
   end
 
-  specify "should behave valid according to the Rack spec" do
+  should "behave valid according to the Rack spec" do
     lambda {
       res = Rack::MockRequest.new(app).
         get("https://bla.example.org:9292/meh/foo?bar", :lint => true)
@@ -187,8 +185,8 @@ context "Rack::MockRequest" do
   end
 end
 
-context "Rack::MockResponse" do
-  specify "should provide access to the HTTP status" do
+describe Rack::MockResponse do
+  should "provide access to the HTTP status" do
     res = Rack::MockRequest.new(app).get("")
     res.should.be.successful
     res.should.be.ok
@@ -209,18 +207,18 @@ context "Rack::MockResponse" do
     res.should.be.empty
   end
 
-  specify "should provide access to the HTTP headers" do
+  should "provide access to the HTTP headers" do
     res = Rack::MockRequest.new(app).get("")
     res.should.include "Content-Type"
     res.headers["Content-Type"].should.equal "text/yaml"
     res.original_headers["Content-Type"].should.equal "text/yaml"
     res["Content-Type"].should.equal "text/yaml"
     res.content_type.should.equal "text/yaml"
-    res.content_length.should.be 414  # needs change often.
+    res.content_length.should.be > 0
     res.location.should.be.nil
   end
 
-  specify "should provide access to the HTTP body" do
+  should "provide access to the HTTP body" do
     res = Rack::MockRequest.new(app).get("")
     res.body.should =~ /rack/
     res.should =~ /rack/
@@ -228,14 +226,14 @@ context "Rack::MockResponse" do
     res.should.satisfy { |r| r.match(/rack/) }
   end
 
-  specify "should provide access to the Rack errors" do
+  should "provide access to the Rack errors" do
     res = Rack::MockRequest.new(app).get("/?error=foo", :lint => true)
     res.should.be.ok
     res.errors.should.not.be.empty
     res.errors.should.include "foo"
   end
 
-  specify "should optionally make Rack errors fatal" do
+  should "optionally make Rack errors fatal" do
     lambda {
       Rack::MockRequest.new(app).get("/?error=foo", :fatal => true)
     }.should.raise(Rack::MockRequest::FatalWarning)