rack 0.3.0 → 0.4.0

data/test/spec_rack_request.rb

@@ -16,6 +16,7 @@ context "Rack::Request" do
     req.should.not.be.post
     req.should.not.be.put
     req.should.not.be.delete
+    req.should.not.be.head
 
     req.script_name.should.equal ""
     req.path_info.should.equal "/"
@@ -23,6 +24,9 @@ context "Rack::Request" do
 
     req.host.should.equal "example.com"
     req.port.should.equal 8080
+
+    req.content_length.should.be.nil
+    req.content_type.should.be.nil
   end
 
   specify "can figure out the correct host" do
@@ -46,12 +50,39 @@ context "Rack::Request" do
   specify "can parse POST data" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("/?foo=quux", :input => "foo=bar&quux=bla")
+    req.content_type.should.be.nil
+    req.media_type.should.be.nil
     req.query_string.should.equal "foo=quux"
     req.GET.should.equal "foo" => "quux"
     req.POST.should.equal "foo" => "bar", "quux" => "bla"
     req.params.should.equal "foo" => "bar", "quux" => "bla"
   end
 
+  specify "can parse POST data with explicit content type" do
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/",
+        "CONTENT_TYPE" => 'application/x-www-form-urlencoded;foo=bar',
+        :input => "foo=bar&quux=bla")
+    req.content_type.should.equal 'application/x-www-form-urlencoded;foo=bar'
+    req.media_type.should.equal 'application/x-www-form-urlencoded'
+    req.media_type_params['foo'].should.equal 'bar'
+    req.POST.should.equal "foo" => "bar", "quux" => "bla"
+    req.params.should.equal "foo" => "bar", "quux" => "bla"
+  end
+
+  specify "does not parse POST data when media type is not form-data" do
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/?foo=quux",
+        "CONTENT_TYPE" => 'text/plain;charset=utf-8',
+        :input => "foo=bar&quux=bla")
+    req.content_type.should.equal 'text/plain;charset=utf-8'
+    req.media_type.should.equal 'text/plain'
+    req.media_type_params['charset'].should.equal 'utf-8'
+    req.POST.should.be.empty
+    req.params.should.equal "foo" => "quux"
+    req.body.read.should.equal "foo=bar&quux=bla"
+  end
+
   specify "can get value by key from params with #[]" do
     req = Rack::Request.new \
       Rack::MockRequest.env_for("?foo=quux")
@@ -189,6 +220,20 @@ context "Rack::Request" do
       should.equal "/foo?foo"
   end
 
+  specify "can handle multiple media type parameters" do
+    req = Rack::Request.new \
+      Rack::MockRequest.env_for("/",
+        "CONTENT_TYPE" => 'text/plain; foo=BAR,baz=bizzle dizzle;BLING=bam')
+      req.should.not.be.form_data
+      req.media_type_params.should.include 'foo'
+      req.media_type_params['foo'].should.equal 'BAR'
+      req.media_type_params.should.include 'baz'
+      req.media_type_params['baz'].should.equal 'bizzle dizzle'
+      req.media_type_params.should.not.include 'BLING'
+      req.media_type_params.should.include 'bling'
+      req.media_type_params['bling'].should.equal 'bam'
+  end
+
   specify "can parse multipart form data" do
     # Adapted from RFC 1867.
     input = <<EOF
@@ -212,6 +257,12 @@ EOF
     req.POST.should.include "fileupload"
     req.POST.should.include "reply"
 
+    req.should.be.form_data
+    req.content_length.should.equal input.size
+    req.media_type.should.equal 'multipart/form-data'
+    req.media_type_params.should.include 'boundary'
+    req.media_type_params['boundary'].should.equal 'AaB03x'
+
     req.POST["reply"].should.equal "yes"
 
     f = req.POST["fileupload"]
@@ -283,10 +334,33 @@ EOF
     lambda { req.POST }.should.raise(EOFError)
   end
 
+  specify "should work around buggy 1.8.* Tempfile equality" do
+    input = <<EOF
+--AaB03x\r
+content-disposition: form-data; name="huge"; filename="huge"\r
+\r
+foo\r
+--AaB03x--
+EOF
+
+    rack_input = Tempfile.new("rackspec")
+    rack_input.write(input)
+    rack_input.rewind
+
+    req = Rack::Request.new Rack::MockRequest.env_for("/",
+                      "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x",
+                      "CONTENT_LENGTH" => input.size,
+                      :input => rack_input)
+
+    lambda {req.POST}.should.not.raise
+    lambda {req.POST}.should.blaming("input re-processed!").not.raise
+  end
+
   specify "does conform to the Rack spec" do
     app = lambda { |env|
       content = Rack::Request.new(env).POST["file"].inspect
-      [200, {"Content-Type" => "text/html"}, content]
+      size = content.respond_to?(:bytesize) ? content.bytesize : content.size
+      [200, {"Content-Type" => "text/html", "Content-Length" => size.to_s}, content]
     }
 
     input = <<EOF
@@ -308,4 +382,20 @@ EOF
 
     res.should.be.ok
   end
+
+  specify "should parse Accept-Encoding correctly" do
+    parser = lambda do |x|
+      Rack::Request.new(Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => x)).accept_encoding
+    end
+
+    parser.call(nil).should.equal([])
+
+    parser.call("compress, gzip").should.equal([["compress", 1.0], ["gzip", 1.0]])
+    parser.call("").should.equal([])
+    parser.call("*").should.equal([["*", 1.0]])
+    parser.call("compress;q=0.5, gzip;q=1.0").should.equal([["compress", 0.5], ["gzip", 1.0]])
+    parser.call("gzip;q=1.0, identity; q=0.5, *;q=0").should.equal([["gzip", 1.0], ["identity", 0.5], ["*", 0] ])
+
+    lambda { parser.call("gzip ; q=1.0") }.should.raise(RuntimeError)
+  end
 end

data/test/spec_rack_session_memcache.rb

@@ -0,0 +1,132 @@
+require 'test/spec'
+
+begin
+  require 'rack/session/memcache'
+  require 'rack/mock'
+  require 'rack/response'
+  require 'thread'
+
+  context "Rack::Session::Memcache" do
+    incrementor = lambda { |env|
+      env["rack.session"]["counter"] ||= 0
+      env["rack.session"]["counter"] += 1
+      Rack::Response.new(env["rack.session"].inspect).to_a
+    }
+
+    # Keep this first.
+    specify "startup" do
+      $pid = fork {
+        exec "memcached"
+      }
+      sleep 1
+    end
+
+    specify "faults on no connection" do
+      lambda do
+        Rack::Session::Memcache.new(incrementor, :memcache_server => '')
+      end.should.raise
+    end
+
+    specify "creates a new cookie" do
+      cache = Rack::Session::Memcache.new(incrementor)
+      res = Rack::MockRequest.new(cache).get("/")
+      res["Set-Cookie"].should.match("rack.session=")
+      res.body.should.equal '{"counter"=>1}'
+    end
+
+    specify "determines session from a cookie" do
+      cache = Rack::Session::Memcache.new(incrementor)
+      res = Rack::MockRequest.new(cache).get("/")
+      cookie = res["Set-Cookie"]
+      res = Rack::MockRequest.new(cache).get("/", "HTTP_COOKIE" => cookie)
+      res.body.should.equal '{"counter"=>2}'
+      res = Rack::MockRequest.new(cache).get("/", "HTTP_COOKIE" => cookie)
+      res.body.should.equal '{"counter"=>3}'
+    end
+
+    specify "survives broken cookies" do
+      cache = Rack::Session::Memcache.new(incrementor)
+      res = Rack::MockRequest.new(cache).
+        get("/", "HTTP_COOKIE" => "rack.session=blarghfasel")
+      res.body.should.equal '{"counter"=>1}'
+    end
+
+    specify "maintains freshness" do
+      cache = Rack::Session::Memcache.new(incrementor, :expire_after => 3)
+      res = Rack::MockRequest.new(cache).get('/')
+      res.body.should.include '"counter"=>1'
+      cookie = res["Set-Cookie"]
+      res = Rack::MockRequest.new(cache).get('/', "HTTP_COOKIE" => cookie)
+      res["Set-Cookie"].should.equal cookie
+      res.body.should.include '"counter"=>2'
+      puts 'Sleeping to expire session' if $DEBUG
+      sleep 4
+      res = Rack::MockRequest.new(cache).get('/', "HTTP_COOKIE" => cookie)
+      res["Set-Cookie"].should.not.equal cookie
+      res.body.should.include '"counter"=>1'
+    end
+
+    specify "multithread: should cleanly merge sessions" do
+      cache = Rack::Session::Memcache.new(incrementor)
+      drop_counter = Rack::Session::Memcache.new(proc do |env|
+        env['rack.session'].delete 'counter'
+        env['rack.session']['foo'] = 'bar'
+        [200, {'Content-Type'=>'text/plain'}, env['rack.session'].inspect]
+      end)
+
+      res = Rack::MockRequest.new(cache).get('/')
+      res.body.should.equal '{"counter"=>1}'
+      cookie = res["Set-Cookie"]
+      sess_id = cookie[/#{cache.key}=([^,;]+)/, 1]
+
+      res = Rack::MockRequest.new(cache).get('/', "HTTP_COOKIE" => cookie)
+      res.body.should.equal '{"counter"=>2}'
+
+      r = Array.new(rand(7).to_i+2) do |i|
+        app = proc do |env|
+          env['rack.session'][i]  = Time.now
+          sleep 2
+          env['rack.session']     = env['rack.session'].dup
+          env['rack.session'][i] -= Time.now
+          incrementor.call(env)
+        end
+        Thread.new(cache.context(app)) do |run|
+          Rack::MockRequest.new(run).
+            get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+        end
+      end
+
+      r.reverse!
+
+      r.map! do |t|
+        p t if $DEBUG
+        t.join.value
+      end
+
+      r.each do |res|
+        res['Set-Cookie'].should.equal cookie
+        res.body.should.include '"counter"=>3'
+      end
+
+      session = cache.pool[sess_id]
+      session.size.should.be r.size+1
+      session['counter'].should.be 3
+
+      res = Rack::MockRequest.new(drop_counter).get('/', "HTTP_COOKIE" => cookie)
+      res.body.should.include '"foo"=>"bar"'
+
+      session = cache.pool[sess_id]
+      session.size.should.be r.size+1
+      session['counter'].should.be.nil?
+      session['foo'].should.equal 'bar'
+    end
+
+    # Keep this last.
+    specify "shutdown" do
+      Process.kill 15, $pid
+      Process.wait($pid).should.equal $pid
+    end
+  end
+rescue LoadError
+  $stderr.puts "Skipping Rack::Session::Memcache tests (Memcache is required). `gem install memcache-client` and try again."
+end

data/test/spec_rack_session_pool.rb

@@ -3,6 +3,7 @@ require 'test/spec'
 require 'rack/session/pool'
 require 'rack/mock'
 require 'rack/response'
+require 'thread'
 
 context "Rack::Session::Pool" do
   incrementor = lambda { |env|
@@ -18,7 +19,7 @@ context "Rack::Session::Pool" do
     res.body.should.equal '{"counter"=>1}'
   end
 
-  specify "loads from a cookie" do
+  specify "determines session from a cookie" do
     pool = Rack::Session::Pool.new(incrementor)
     res = Rack::MockRequest.new(pool).get("/")
     cookie = res["Set-Cookie"]
@@ -34,4 +35,50 @@ context "Rack::Session::Pool" do
       get("/", "HTTP_COOKIE" => "rack.session=blarghfasel")
     res.body.should.equal '{"counter"=>1}'
   end
+
+  specify "maintains freshness" do
+    pool = Rack::Session::Pool.new(incrementor, :expire_after => 3)
+    res = Rack::MockRequest.new(pool).get('/')
+    res.body.should.include '"counter"=>1'
+    cookie = res["Set-Cookie"]
+    res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
+    res["Set-Cookie"].should.equal cookie
+    res.body.should.include '"counter"=>2'
+    sleep 4
+    res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
+    res["Set-Cookie"].should.not.equal cookie
+    res.body.should.include '"counter"=>1'
+  end
+
+  specify "multithread: should merge sessions" do
+    delta_incrementor = lambda do |env|
+      # emulate disconjoinment of threading
+      env['rack.session'] = env['rack.session'].dup
+      Thread.stop
+      env['rack.session'][(Time.now.usec*rand).to_i] = true
+      incrementor.call(env)
+    end
+    pool = Rack::Session::Pool.new(incrementor)
+    res = Rack::MockRequest.new(pool).get('/')
+    res.body.should.equal '{"counter"=>1}'
+    cookie = res["Set-Cookie"]
+    sess_id = cookie[/#{pool.key}=([^,;]+)/,1]
+
+    pool = pool.context(delta_incrementor)
+    r = Array.new(rand(7).to_i+3).
+      map! do
+        Thread.new do
+          Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
+        end
+      end.
+      reverse!.
+      map!{|t| t.run.join.value }
+    session = pool.for.pool[sess_id] # for is needed by Utils::Context
+    session.size.should.be r.size+1 # counter
+    session['counter'].should.be 2 # meeeh
+    r.each do |res|
+      res['Set-Cookie'].should.equal cookie
+      res.body.should.include '"counter"=>2'
+    end
+  end
 end

data/test/spec_rack_showstatus.rb

@@ -6,7 +6,7 @@ require 'rack/mock'
 context "Rack::ShowStatus" do
   specify "should provide a default status message" do
     req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
-                                                       [404, {"Content-Type" => "text/plain"}, []]
+                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
                                                      }))
 
     res = req.get("/", :lint => true)
@@ -21,7 +21,7 @@ context "Rack::ShowStatus" do
   specify "should let the app provide additional information" do
     req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
                                                        env["rack.showstatus.detail"] = "gone too meta."
-                                                       [404, {"Content-Type" => "text/plain"}, []]
+                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
                                                      }))
 
     res = req.get("/", :lint => true)
@@ -36,7 +36,7 @@ context "Rack::ShowStatus" do
 
   specify "should not replace existing messages" do
     req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
-                                                       [404, {"Content-Type" => "text/plain"}, ["foo!"]]
+                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
                                                      }))
     res = req.get("/", :lint => true)
     res.should.be.not_found
@@ -56,7 +56,7 @@ context "Rack::ShowStatus" do
   specify "should replace existing messages if there is detail" do
     req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
                                                        env["rack.showstatus.detail"] = "gone too meta."
-                                                       [404, {"Content-Type" => "text/plain"}, ["foo!"]]
+                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
                                                      }))
 
     res = req.get("/", :lint => true)
@@ -64,6 +64,7 @@ context "Rack::ShowStatus" do
     res.should.be.not.empty
 
     res["Content-Type"].should.equal("text/html")
+    res["Content-Length"].should.not.equal("4")
     res.should =~ /404/
     res.should =~ /too meta/
     res.body.should.not =~ /foo/

data/test/spec_rack_urlmap.rb

@@ -5,47 +5,62 @@ require 'rack/mock'
 
 context "Rack::URLMap" do
   specify "dispatches paths correctly" do
-    map = Rack::URLMap.new("/foo" => lambda { |env|
-                             [200,
-                              { "Content-Type" => "text/plain",
-                                "X-Position" => "/foo",
-                                "X-PathInfo" => env["PATH_INFO"],
-                              }, [""]]},
-
-                           "/bar" => lambda { |env|
-                             [200,
-                              { "Content-Type" => "text/plain",
-                                "X-Position" => "/bar",
-                                "X-PathInfo" => env["PATH_INFO"],
-                              }, [""]]}
-
-                           )
+    app = lambda { |env|
+      [200, {
+        'X-ScriptName' => env['SCRIPT_NAME'],
+        'X-PathInfo' => env['PATH_INFO'],
+        'Content-Type' => 'text/plain'
+      }, [""]]
+    }
+    map = Rack::URLMap.new({
+      'http://foo.org/bar' => app,
+      '/foo' => app,
+      '/foo/bar' => app
+    })
 
+    res = Rack::MockRequest.new(map).get("/")
+    res.should.be.not_found
 
-    Rack::MockRequest.new(map).get("/").should.be.not_found
+    res = Rack::MockRequest.new(map).get("/qux")
+    res.should.be.not_found
 
     res = Rack::MockRequest.new(map).get("/foo")
     res.should.be.ok
-    res["X-Position"].should.equal "/foo"
+    res["X-ScriptName"].should.equal "/foo"
+    res["X-PathInfo"].should.equal ""
+
+    res = Rack::MockRequest.new(map).get("/foo/")
+    res.should.be.ok
+    res["X-ScriptName"].should.equal "/foo"
     res["X-PathInfo"].should.equal "/"
 
+    res = Rack::MockRequest.new(map).get("/foo/bar")
+    res.should.be.ok
+    res["X-ScriptName"].should.equal "/foo/bar"
+    res["X-PathInfo"].should.equal ""
 
-    res = Rack::MockRequest.new(map).get("/bar")
+    res = Rack::MockRequest.new(map).get("/foo/bar/")
     res.should.be.ok
-    res["X-Position"].should.equal "/bar"
+    res["X-ScriptName"].should.equal "/foo/bar"
     res["X-PathInfo"].should.equal "/"
 
-    res = Rack::MockRequest.new(map).get("/foo/quux")
+    res = Rack::MockRequest.new(map).get("/foo/quux", "SCRIPT_NAME" => "/bleh")
     res.should.be.ok
-    res["X-Position"].should.equal "/foo"
+    res["X-ScriptName"].should.equal "/bleh/foo"
     res["X-PathInfo"].should.equal "/quux"
 
-    res = Rack::MockRequest.new(map).get("/foo/quux", "SCRIPT_NAME" => "/bleh")
+    res = Rack::MockRequest.new(map).get("/bar", 'HTTP_HOST' => 'foo.org')
     res.should.be.ok
-    res["X-Position"].should.equal "/foo"
-    res["X-PathInfo"].should.equal "/quux"
+    res["X-ScriptName"].should.equal "/bar"
+    res["X-PathInfo"].should.be.empty
+
+    res = Rack::MockRequest.new(map).get("/bar/", 'HTTP_HOST' => 'foo.org')
+    res.should.be.ok
+    res["X-ScriptName"].should.equal "/bar"
+    res["X-PathInfo"].should.equal '/'
   end
 
+
   specify "dispatches hosts correctly" do
     map = Rack::URLMap.new("http://foo.org/" => lambda { |env|
                              [200,
@@ -112,7 +127,7 @@ context "Rack::URLMap" do
     res = Rack::MockRequest.new(map).get("/foo/bar/quux")
     res.should.be.ok
     res["X-Position"].should.equal "/foo/bar/quux"
-    res["X-PathInfo"].should.equal "/"
+    res["X-PathInfo"].should.equal ""
     res["X-ScriptName"].should.equal "/foo/bar/quux"
   end
 
@@ -121,20 +136,40 @@ context "Rack::URLMap" do
                              [200,
                               { "Content-Type" => "text/plain",
                                 "X-Position" => "root",
+                                "X-PathInfo" => env["PATH_INFO"],
+                                "X-ScriptName" => env["SCRIPT_NAME"]
                               }, [""]]},
                            "/foo" => lambda { |env|
                              [200,
                               { "Content-Type" => "text/plain",
                                 "X-Position" => "foo",
+                                "X-PathInfo" => env["PATH_INFO"],
+                                "X-ScriptName" => env["SCRIPT_NAME"]
                               }, [""]]}
                            )
 
     res = Rack::MockRequest.new(map).get("/foo/bar")
     res.should.be.ok
     res["X-Position"].should.equal "foo"
+    res["X-PathInfo"].should.equal "/bar"
+    res["X-ScriptName"].should.equal "/foo"
+
+    res = Rack::MockRequest.new(map).get("/foo")
+    res.should.be.ok
+    res["X-Position"].should.equal "foo"
+    res["X-PathInfo"].should.equal ""
+    res["X-ScriptName"].should.equal "/foo"
 
     res = Rack::MockRequest.new(map).get("/bar")
     res.should.be.ok
     res["X-Position"].should.equal "root"
+    res["X-PathInfo"].should.equal "/bar"
+    res["X-ScriptName"].should.equal ""
+
+    res = Rack::MockRequest.new(map).get("")
+    res.should.be.ok
+    res["X-Position"].should.equal "root"
+    res["X-PathInfo"].should.equal "/"
+    res["X-ScriptName"].should.equal ""
   end
 end