rack 1.1.6 → 1.2.0

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 "Program started"
-    errors.string.should.match "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)

data/{test/spec_rack_mongrel.rb → spec/spec_mongrel.rb}

@@ -1,37 +1,32 @@
-require 'test/spec'
-
 begin
+require 'rack'
 require 'rack/handler/mongrel'
-require 'rack/urlmap'
-require 'rack/lint'
-require 'testrequest'
+require File.expand_path('../testrequest', __FILE__)
 require 'timeout'
 
 Thread.abort_on_exception = true
 $tcp_defer_accept_opts = nil
 $tcp_cork_opts = nil
 
-context "Rack::Handler::Mongrel" do
-  include TestRequest::Helpers
+describe Rack::Handler::Mongrel do
+  extend TestRequest::Helpers
 
-  setup do
-    server = Mongrel::HttpServer.new(@host='0.0.0.0', @port=9201)
-    server.register('/test',
-                    Rack::Handler::Mongrel.new(Rack::Lint.new(TestRequest.new)))
-    server.register('/stream',
-                    Rack::Handler::Mongrel.new(Rack::Lint.new(StreamingRequest)))
-    @acc = server.run
-  end
+  @server = Mongrel::HttpServer.new(@host='0.0.0.0', @port=9201)
+  @server.register('/test',
+                  Rack::Handler::Mongrel.new(Rack::Lint.new(TestRequest.new)))
+  @server.register('/stream',
+                  Rack::Handler::Mongrel.new(Rack::Lint.new(StreamingRequest)))
+  @acc = @server.run
 
-  specify "should respond" do
+  should "respond" do
     lambda {
       GET("/test")
     }.should.not.raise
   end
 
-  specify "should be a Mongrel" do
+  should "be a Mongrel" do
     GET("/test")
-    status.should.be 200
+    status.should.equal 200
     response["SERVER_SOFTWARE"].should =~ /Mongrel/
     response["HTTP_VERSION"].should.equal "HTTP/1.1"
     response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
@@ -39,15 +34,15 @@ context "Rack::Handler::Mongrel" do
     response["SERVER_NAME"].should.equal "0.0.0.0"
   end
 
-  specify "should have rack headers" do
+  should "have rack headers" do
     GET("/test")
     response["rack.version"].should.equal [1,1]
-    response["rack.multithread"].should.be true
-    response["rack.multiprocess"].should.be false
-    response["rack.run_once"].should.be false
+    response["rack.multithread"].should.be.true
+    response["rack.multiprocess"].should.be.false
+    response["rack.run_once"].should.be.false
   end
 
-  specify "should have CGI headers on GET" do
+  should "have CGI headers on GET" do
     GET("/test")
     response["REQUEST_METHOD"].should.equal "GET"
     response["SCRIPT_NAME"].should.equal "/test"
@@ -64,7 +59,7 @@ context "Rack::Handler::Mongrel" do
     response["QUERY_STRING"].should.equal "quux=1"
   end
 
-  specify "should have CGI headers on POST" do
+  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"
@@ -75,18 +70,18 @@ context "Rack::Handler::Mongrel" do
     response["test.postdata"].should.equal "rack-form-data=23"
   end
 
-  specify "should support HTTP auth" do
+  should "support HTTP auth" do
     GET("/test", {:user => "ruth", :passwd => "secret"})
     response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
   end
 
-  specify "should set status" do
+  should "set status" do
     GET("/test?secret")
     status.should.equal 403
     response["rack.url_scheme"].should.equal "http"
   end
 
-  specify "should provide a .run" do
+  should "provide a .run" do
     block_ran = false
     Thread.new {
       Rack::Handler::Mongrel.run(lambda {}, {:Port => 9211}) { |server|
@@ -95,16 +90,16 @@ context "Rack::Handler::Mongrel" do
       }
     }
     sleep 1
-    block_ran.should.be true
+    block_ran.should.be.true
   end
 
-  specify "should provide a .run that maps a hash" do
+  should "provide a .run that maps a hash" do
     block_ran = false
     Thread.new {
       map = {'/'=>lambda{},'/foo'=>lambda{}}
       Rack::Handler::Mongrel.run(map, :map => true, :Port => 9221) { |server|
         server.should.be.kind_of Mongrel::HttpServer
-        server.classifier.uris.size.should.be 2
+        server.classifier.uris.size.should.equal 2
         server.classifier.uris.should.not.include '/arf'
         server.classifier.uris.should.include '/'
         server.classifier.uris.should.include '/foo'
@@ -112,16 +107,16 @@ context "Rack::Handler::Mongrel" do
       }
     }
     sleep 1
-    block_ran.should.be true
+    block_ran.should.be.true
   end
 
-  specify "should provide a .run that maps a urlmap" do
+  should "provide a .run that maps a urlmap" do
     block_ran = false
     Thread.new {
       map = Rack::URLMap.new({'/'=>lambda{},'/bar'=>lambda{}})
       Rack::Handler::Mongrel.run(map, {:map => true, :Port => 9231}) { |server|
         server.should.be.kind_of Mongrel::HttpServer
-        server.classifier.uris.size.should.be 2
+        server.classifier.uris.size.should.equal 2
         server.classifier.uris.should.not.include '/arf'
         server.classifier.uris.should.include '/'
         server.classifier.uris.should.include '/bar'
@@ -129,10 +124,10 @@ context "Rack::Handler::Mongrel" do
       }
     }
     sleep 1
-    block_ran.should.be true
+    block_ran.should.be.true
   end
 
-  specify "should provide a .run that maps a urlmap restricting by host" do
+  should "provide a .run that maps a urlmap restricting by host" do
     block_ran = false
     Thread.new {
       map = Rack::URLMap.new({
@@ -148,22 +143,22 @@ context "Rack::Handler::Mongrel" do
       Rack::Handler::Mongrel.run(map, opt) { |server|
         server.should.be.kind_of Mongrel::HttpServer
         server.classifier.uris.should.include '/'
-        server.classifier.handler_map['/'].size.should.be 2
+        server.classifier.handler_map['/'].size.should.equal 2
         server.classifier.uris.should.include '/foo'
-        server.classifier.handler_map['/foo'].size.should.be 1
+        server.classifier.handler_map['/foo'].size.should.equal 1
         server.classifier.uris.should.include '/bar'
-        server.classifier.handler_map['/bar'].size.should.be 2
+        server.classifier.handler_map['/bar'].size.should.equal 2
         server.classifier.uris.should.not.include '/qux'
         server.classifier.uris.should.not.include '/arf'
-        server.classifier.uris.size.should.be 3
+        server.classifier.uris.size.should.equal 3
         block_ran = true
       }
     }
     sleep 1
-    block_ran.should.be true
+    block_ran.should.be.true
   end
 
-  specify "should stream #each part of the response" do
+  should "stream #each part of the response" do
     body = ''
     begin
       Timeout.timeout(1) do
@@ -179,11 +174,10 @@ context "Rack::Handler::Mongrel" do
     body.should.not.be.empty
   end
 
-  teardown do
-    @acc.raise Mongrel::StopServer
-  end
+  @acc.raise Mongrel::StopServer
 end
 
-rescue LoadError
-  $stderr.puts "Skipping Rack::Handler::Mongrel tests (Mongrel is required). `gem install mongrel` and try again."
+rescue LoadError => ex
+  warn ex
+  warn "Skipping Rack::Handler::Mongrel tests (Mongrel is required). `gem install mongrel` and try again."
 end