RubyGems - rack - Versions diffs - 0.3.0 → 0.4.0 - Mend

rack 0.3.0 → 0.4.0

Potentially problematic release.

This version of rack might be problematic. Click here for more details.

Files changed (50) hide show

data/AUTHORS +1 -0
data/RDOX +61 -3
data/README +94 -9
data/Rakefile +36 -32
data/SPEC +1 -7
data/bin/rackup +31 -13
data/lib/rack.rb +8 -19
data/lib/rack/auth/digest/params.rb +2 -2
data/lib/rack/auth/openid.rb +406 -80
data/lib/rack/builder.rb +1 -1
data/lib/rack/cascade.rb +10 -0
data/lib/rack/commonlogger.rb +6 -1
data/lib/rack/deflater.rb +63 -0
data/lib/rack/directory.rb +158 -0
data/lib/rack/file.rb +11 -5
data/lib/rack/handler.rb +44 -0
data/lib/rack/handler/evented_mongrel.rb +8 -0
data/lib/rack/handler/fastcgi.rb +1 -0
data/lib/rack/handler/mongrel.rb +21 -1
data/lib/rack/lint.rb +20 -13
data/lib/rack/mock.rb +1 -0
data/lib/rack/request.rb +69 -2
data/lib/rack/session/abstract/id.rb +140 -0
data/lib/rack/session/memcache.rb +97 -0
data/lib/rack/session/pool.rb +50 -59
data/lib/rack/showstatus.rb +3 -1
data/lib/rack/urlmap.rb +12 -12
data/lib/rack/utils.rb +88 -9
data/test/cgi/lighttpd.conf +1 -1
data/test/cgi/test.fcgi +1 -2
data/test/cgi/test.ru +2 -2
data/test/spec_rack_auth_openid.rb +137 -0
data/test/spec_rack_camping.rb +37 -33
data/test/spec_rack_cascade.rb +15 -0
data/test/spec_rack_cgi.rb +4 -3
data/test/spec_rack_deflater.rb +70 -0
data/test/spec_rack_directory.rb +56 -0
data/test/spec_rack_fastcgi.rb +4 -3
data/test/spec_rack_file.rb +11 -1
data/test/spec_rack_handler.rb +24 -0
data/test/spec_rack_lint.rb +19 -33
data/test/spec_rack_mongrel.rb +71 -0
data/test/spec_rack_request.rb +91 -1
data/test/spec_rack_session_memcache.rb +132 -0
data/test/spec_rack_session_pool.rb +48 -1
data/test/spec_rack_showstatus.rb +5 -4
data/test/spec_rack_urlmap.rb +60 -25
data/test/spec_rack_utils.rb +118 -1
data/test/testrequest.rb +3 -1
metadata +67 -44

@@ -12,12 +12,13 @@ context "Rack::Handler::CGI" do
   # Keep this first.
   specify "startup" do
     $pid = fork {
-      Dir.chdir File.join(File.dirname(__FILE__), 'cgi')
+      Dir.chdir(File.join(File.dirname(__FILE__), "..", "test", "cgi"))
       exec "lighttpd -D -f lighttpd.conf"
     }
   end
   specify "should respond" do
+    sleep 1
     lambda {
       GET("/test")
     }.should.not.raise
@@ -29,8 +30,8 @@ context "Rack::Handler::CGI" do
     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 "9203"
-    response["SERVER_NAME"].should =~ "0.0.0.0"
+    response["SERVER_PORT"].should.equal @port.to_s
+    response["SERVER_NAME"].should =~ @host
   end
   specify "should have rack headers" do

data/test/spec_rack_deflater.rb ADDED

@@ -0,0 +1,70 @@
+require 'test/spec'
+require 'rack/mock'
+require 'rack/deflater'
+require 'stringio'
+context "Rack::Deflater" do
+  def build_response(body, accept_encoding, headers = {})
+    app = lambda { |env| [200, {}, body] }
+    request = Rack::MockRequest.env_for("", headers.merge("HTTP_ACCEPT_ENCODING" => accept_encoding))
+    response = Rack::Deflater.new(app).call(request)
+    return response
+  end
+  specify "should be able to deflate bodies that respond to each" do
+    body = Object.new
+    class << body; def each; yield("foo"); yield("bar"); end; end
+    response = build_response(body, "deflate")
+    response[0].should.equal(200)
+    response[1].should.equal({ "Content-Encoding" => "deflate" })
+    response[2].to_s.should.equal("K\313\317OJ,\002\000")
+  end
+  # TODO: This is really just a special case of the above...
+  specify "should be able to deflate String bodies" do
+    response = build_response("Hello world!", "deflate")
+    response[0].should.equal(200)
+    response[1].should.equal({ "Content-Encoding" => "deflate" })
+    response[2].to_s.should.equal("\363H\315\311\311W(\317/\312IQ\004\000")
+  end
+  specify "should be able to gzip bodies that respond to each" do
+    body = Object.new
+    class << body; def each; yield("foo"); yield("bar"); end; end
+    response = build_response(body, "gzip")
+    response[0].should.equal(200)
+    response[1].should.equal({ "Content-Encoding" => "gzip" })
+    io = StringIO.new(response[2].to_s)
+    gz = Zlib::GzipReader.new(io)
+    gz.read.should.equal("foobar")
+    gz.close
+  end
+  specify "should be able to fallback to no deflation" do
+    response = build_response("Hello world!", "superzip")
+    response[0].should.equal(200)
+    response[1].should.equal({})
+    response[2].should.equal("Hello world!")
+  end
+  specify "should handle the lack of an acceptable encoding" do
+    response1 = build_response("Hello world!", "identity;q=0", "PATH_INFO" => "/")
+    response1[0].should.equal(406)
+    response1[1].should.equal({"Content-Type" => "text/plain"})
+    response1[2].should.equal("An acceptable encoding for the requested resource / could not be found.")
+    response2 = build_response("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[2].should.equal("An acceptable encoding for the requested resource /foo/bar could not be found.")
+  end
+end

data/test/spec_rack_directory.rb ADDED

@@ -0,0 +1,56 @@
+require 'test/spec'
+require 'rack/directory'
+require 'rack/lint'
+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!'] }
+  app = Rack::Directory.new DOCROOT, FILE_CATCH
+  specify "serves directory indices" do
+    res = Rack::MockRequest.new(Rack::Lint.new(app)).
+      get("/cgi/")
+    res.should.be.ok
+    res.should =~ /<html><head>/
+  end
+  specify "passes to app if file found" do
+    res = Rack::MockRequest.new(Rack::Lint.new(app)).
+      get("/cgi/test")
+    res.should.be.ok
+    res.should =~ /passed!/
+  end
+  specify "serves uri with URL encoded filenames" do
+    res = Rack::MockRequest.new(Rack::Lint.new(app)).
+      get("/%63%67%69/") # "/cgi/test"
+    res.should.be.ok
+    res.should =~ /<html><head>/
+    res = Rack::MockRequest.new(Rack::Lint.new(app)).
+      get("/cgi/%74%65%73%74") # "/cgi/test"
+    res.should.be.ok
+    res.should =~ /passed!/
+  end
+  specify "does not allow directory traversal" do
+    res = Rack::MockRequest.new(Rack::Lint.new(app)).
+      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(app)).
+      get("/cgi/blubb")
+    res.should.be.not_found
+  end
+end

data/test/spec_rack_fastcgi.rb CHANGED

@@ -12,12 +12,13 @@ context "Rack::Handler::FastCGI" do
   # Keep this first.
   specify "startup" do
     $pid = fork {
-      Dir.chdir File.join(File.dirname(__FILE__), 'cgi')
+      Dir.chdir(File.join(File.dirname(__FILE__), "..", "test", "cgi"))
       exec "lighttpd -D -f lighttpd.conf"
     }
   end
   specify "should respond" do
+    sleep 1
     lambda {
       GET("/test.fcgi")
     }.should.not.raise
@@ -29,8 +30,8 @@ context "Rack::Handler::FastCGI" do
     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 "9203"
-    response["SERVER_NAME"].should =~ "0.0.0.0"
+    response["SERVER_PORT"].should.equal @port.to_s
+    response["SERVER_NAME"].should =~ @host
   end
   specify "should have rack headers" do

data/test/spec_rack_file.rb CHANGED

@@ -15,7 +15,17 @@ context "Rack::File" do
     res.should.be.ok
     res.should =~ /ruby/
   end
+  specify "sets Last-Modified header" do
+    res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))).
+      get("/cgi/test")
+    path = File.join(DOCROOT, "/cgi/test")
+    res.should.be.ok
+    res["Last-Modified"].should.equal File.mtime(path).httpdate
+  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"

data/test/spec_rack_handler.rb ADDED

@@ -0,0 +1,24 @@
+require 'test/spec'
+require 'rack/handler'
+context "Rack::Handler" do
+  class Rack::Handler::Lobster; end
+  class RockLobster; end
+  specify "has registered default handlers" do
+    Rack::Handler.get('cgi').should.equal Rack::Handler::CGI
+    Rack::Handler.get('fastcgi').should.equal Rack::Handler::FastCGI
+    Rack::Handler.get('mongrel').should.equal Rack::Handler::Mongrel
+    Rack::Handler.get('webrick').should.equal Rack::Handler::WEBrick
+  end
+  specify "should get unregistered 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
+end

data/test/spec_rack_lint.rb CHANGED

@@ -8,11 +8,11 @@ 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"]
+                       [200, {"Content-type" => "test/plain", "Content-length" => "3"}, "foo"]
                      }).call(env({}))
     }.should.not.raise
   end
@@ -120,14 +120,14 @@ context "Rack::Lint" do
                        ["cc", {}, ""]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
-      message.should.match(/must be >100 seen as integer/)
+      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/)
+      message.should.match(/must be >=100 seen as integer/)
   end
   specify "notices header errors" do
@@ -136,14 +136,14 @@ context "Rack::Lint" do
                        [200, Object.new, ""]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
-      message.should.match(/should respond to #each/)
+      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}, ""]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
-      message.should.match(/header key must be a string/)
+      message.should.equal("header key must be a string, was TrueClass")
     lambda {
       Rack::Lint.new(lambda { |env|
@@ -171,21 +171,21 @@ context "Rack::Lint" do
                        [200, {"..%%quark%%.." => "text/plain"}, ""]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
-      message.should.match(/invalid header/)
+      message.should.equal("invalid header name: ..%%quark%%..")
     lambda {
       Rack::Lint.new(lambda { |env|
                        [200, {"Foo" => Object.new}, ""]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
-      message.should.match(/must respond to #each/)
+      message.should.equal("header values must respond to #each, but the value of 'Foo' doesn't (is Object)")
     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/)
+      message.should.equal("header values must consist of Strings, but 'Foo' also contains a Fixnum")
     lambda {
@@ -199,30 +199,16 @@ context "Rack::Lint" do
   specify "notices content-type errors" do
     lambda {
       Rack::Lint.new(lambda { |env|
-                       [200, {}, ""]
+                       [200, {"Content-length" => "0"}, ""]
                      }).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]]
+                               [200, {"Content-type" => "text/plain","Content-length" => "3"}, [1,2,3]]
                              }).call(env({}))
       body.each { |part| }
     }.should.raise(Rack::Lint::LintError).
@@ -233,7 +219,7 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].gets("\r\n")
-                       [201, {"Content-type" => "text/plain"}, ""]
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/gets called with arguments/)
@@ -241,7 +227,7 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].read("foo")
-                       [201, {"Content-type" => "text/plain"}, ""]
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/read called with non-integer argument/)
@@ -265,7 +251,7 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].gets
-                       [201, {"Content-type" => "text/plain"}, ""]
+                       [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/)
@@ -273,7 +259,7 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].each { |x| }
-                       [201, {"Content-type" => "text/plain"}, ""]
+                       [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/)
@@ -281,7 +267,7 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].read
-                       [201, {"Content-type" => "text/plain"}, ""]
+                       [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/)
@@ -290,7 +276,7 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.input"].close
-                       [201, {"Content-type" => "text/plain"}, ""]
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/close must not be called/)
@@ -300,7 +286,7 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.errors"].write(42)
-                       [201, {"Content-type" => "text/plain"}, ""]
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/write not called with a String/)
@@ -308,7 +294,7 @@ context "Rack::Lint" do
     lambda {
       Rack::Lint.new(lambda { |env|
                        env["rack.errors"].close
-                       [201, {"Content-type" => "text/plain"}, ""]
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
                      }).call(env({}))
     }.should.raise(Rack::Lint::LintError).
       message.should.match(/close must not be called/)

data/test/spec_rack_mongrel.rb CHANGED

@@ -1,6 +1,8 @@
 require 'test/spec'
+begin
 require 'rack/handler/mongrel'
+require 'rack/urlmap'
 require 'rack/lint'
 require 'testrequest'
@@ -93,7 +95,76 @@ context "Rack::Handler::Mongrel" do
     block_ran.should.be true
   end
+  specify "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.should.not.include '/arf'
+        server.classifier.uris.should.include '/'
+        server.classifier.uris.should.include '/foo'
+        block_ran = true
+      }
+    }
+    sleep 1
+    block_ran.should.be true
+  end
+  specify "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.should.not.include '/arf'
+        server.classifier.uris.should.include '/'
+        server.classifier.uris.should.include '/bar'
+        block_ran = true
+      }
+    }
+    sleep 1
+    block_ran.should.be true
+  end
+  specify "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://falsehost/arf' => lambda{},
+        'http://falsehost/qux' => lambda{}
+      })
+      opt = {:map => true, :Port => 9241, :Host => 'localhost'}
+      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.uris.should.include '/foo'
+        server.classifier.handler_map['/foo'].size.should.be 1
+        server.classifier.uris.should.include '/bar'
+        server.classifier.handler_map['/bar'].size.should.be 2
+        server.classifier.uris.should.not.include '/qux'
+        server.classifier.uris.should.not.include '/arf'
+        server.classifier.uris.size.should.be 3
+        block_ran = true
+      }
+    }
+    sleep 1
+    block_ran.should.be true
+  end
   teardown do
     @acc.raise Mongrel::StopServer
   end
 end
+rescue LoadError
+  $stderr.puts "Skipping Rack::Handler::Mongrel tests (Mongrel is required). `gem install mongrel` and try again."
+end