rack 1.1.6 → 1.6.9

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

@@ -1,35 +1,44 @@
 require 'yaml'
+require 'rack/lint'
 require 'rack/mock'
-require 'rack/request'
-require 'rack/response'
+require 'stringio'
 
-app = lambda { |env|
+app = Rack::Lint.new(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,
+
+  body = req.head? ? "" : env.to_yaml
+  Rack::Response.new(body,
                      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 "return an environment with a path" do
+    env = Rack::MockRequest.env_for("http://www.example.com/parse?location[]=1&location[]=2&age_group[]=2")
+    env["QUERY_STRING"].should.equal "location[]=1&location[]=2&age_group[]=2"
+    env["PATH_INFO"].should.equal "/parse"
+    env.should.be.kind_of Hash
+    env.should.include "rack.version"
+  end
+
+  should "provide sensible defaults" do
     res = Rack::MockRequest.new(app).request
 
     env = YAML.load(res.body)
@@ -43,7 +52,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/HEAD" do
     res = Rack::MockRequest.new(app).get("", :input => "foo")
     env = YAML.load(res.body)
     env["REQUEST_METHOD"].should.equal "GET"
@@ -56,20 +65,27 @@ context "Rack::MockRequest" do
     env = YAML.load(res.body)
     env["REQUEST_METHOD"].should.equal "PUT"
 
+    res = Rack::MockRequest.new(app).patch("", :input => "foo")
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "PATCH"
+
     res = Rack::MockRequest.new(app).delete("", :input => "foo")
     env = YAML.load(res.body)
     env["REQUEST_METHOD"].should.equal "DELETE"
+    
+    Rack::MockRequest.env_for("/", :method => "HEAD")["REQUEST_METHOD"].
+      should.equal "HEAD"
 
     Rack::MockRequest.env_for("/", :method => "OPTIONS")["REQUEST_METHOD"].
       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 +95,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 +109,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 +124,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 +138,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 +174,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,27 +184,57 @@ 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
-    files = Rack::Utils::Multipart::UploadedFile.new(File.join(File.dirname(__FILE__), "multipart", "file1.txt"))
+  should "accept params and build multipart encoded params for POST requests" do
+    files = Rack::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)
     env["REQUEST_METHOD"].should.equal "POST"
     env["QUERY_STRING"].should.equal ""
     env["PATH_INFO"].should.equal "/foo"
     env["CONTENT_TYPE"].should.equal "multipart/form-data; boundary=AaB03x"
-    env["mock.postdata"].length.should.equal 206
+    # The gsub accounts for differences in YAMLs affect on the data.
+    env["mock.postdata"].gsub("\r", "").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).
+      Rack::MockRequest.new(app).
         get("https://bla.example.org:9292/meh/foo?bar", :lint => true)
     }.should.not.raise(Rack::Lint::LintError)
   end
+
+  should "call close on the original body object" do
+    called = false
+    body   = Rack::BodyProxy.new(['hi']) { called = true }
+    capp   = proc { |e| [200, {'Content-Type' => 'text/plain'}, body] }
+    called.should.equal false
+    Rack::MockRequest.new(capp).get('/', :lint => true)
+    called.should.equal true
+  end
+
+  if "<3".respond_to? :b
+    should "defaults encoding to ASCII 8BIT" do
+      req = Rack::MockRequest.env_for("/foo")
+
+      keys = [
+        Rack::REQUEST_METHOD,
+        "SERVER_NAME",
+        "SERVER_PORT",
+        Rack::QUERY_STRING,
+        Rack::PATH_INFO,
+        "rack.url_scheme",
+        "HTTPS"
+      ]
+
+      keys.each do |k|
+        req[k].encoding.should.equal Encoding::ASCII_8BIT
+      end
+    end
+  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 +255,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.not.equal 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 +274,22 @@ 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 "allow calling body.close afterwards" do
+    # this is exactly what rack-test does
+    body = StringIO.new("hi")
+    res = Rack::MockResponse.new(200, {}, body)
+    body.close if body.respond_to?(:close)
+    res.body.should == 'hi'
+  end
+
+  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_mongrel.rb}

@@ -1,53 +1,48 @@
-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='127.0.0.1', @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"
     response["SERVER_PORT"].should.equal "9201"
-    response["SERVER_NAME"].should.equal "0.0.0.0"
+    response["SERVER_NAME"].should.equal "127.0.0.1"
   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.version"].should.equal [1,3]
+    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,36 +70,36 @@ 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|
+      Rack::Handler::Mongrel.run(lambda {}, {:Host => '127.0.0.1', :Port => 9211}) { |server|
         server.should.be.kind_of Mongrel::HttpServer
         block_ran = true
       }
     }
     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|
+      Rack::Handler::Mongrel.run(map, :map => true, :Host => '127.0.0.1', :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|
+      Rack::Handler::Mongrel.run(map, {:map => true, :Host => '127.0.0.1', :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,41 +124,41 @@ 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({
         '/' => lambda{},
         '/foo' => lambda{},
         '/bar' => lambda{},
-        'http://localhost/' => lambda{},
-        'http://localhost/bar' => lambda{},
+        'http://127.0.0.1/' => lambda{},
+        'http://127.0.0.1/bar' => lambda{},
         'http://falsehost/arf' => lambda{},
         'http://falsehost/qux' => lambda{}
       })
-      opt = {:map => true, :Port => 9241, :Host => 'localhost'}
+      opt = {:map => true, :Port => 9241, :Host => '127.0.0.1'}
       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,9 @@ 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."
+  warn "Skipping Rack::Handler::Mongrel tests (Mongrel is required). `gem install mongrel` and try again."
 end