technomancy-rack 0.3.0

data/test/spec_rack_response.rb

@@ -0,0 +1,167 @@
+require 'test/spec'
+
+require 'rack/response'
+
+context "Rack::Response" do
+  specify "has sensible default values" do
+    response = Rack::Response.new
+    status, header, body = response.finish
+    status.should.equal 200
+    header.should.equal "Content-Type" => "text/html"
+    body.each { |part|
+      part.should.equal ""
+    }
+
+    response = Rack::Response.new
+    status, header, body = *response
+    status.should.equal 200
+    header.should.equal "Content-Type" => "text/html"
+    body.each { |part|
+      part.should.equal ""
+    }
+  end
+
+  specify "can be written to" do
+    response = Rack::Response.new
+
+    status, header, body = response.finish do
+      response.write "foo"
+      response.write "bar"
+      response.write "baz"
+    end
+    
+    parts = []
+    body.each { |part| parts << part }
+    
+    parts.should.equal ["foo", "bar", "baz"]
+  end
+
+  specify "can set and read headers" do
+    response = Rack::Response.new
+    response["Content-Type"].should.equal "text/html"
+    response["Content-Type"] = "text/plain"
+    response["Content-Type"].should.equal "text/plain"
+  end
+
+  specify "can set cookies" do
+    response = Rack::Response.new
+    
+    response.set_cookie "foo", "bar"
+    response["Set-Cookie"].should.equal "foo=bar"
+    response.set_cookie "foo2", "bar2"
+    response["Set-Cookie"].should.equal ["foo=bar", "foo2=bar2"]
+    response.set_cookie "foo3", "bar3"
+    response["Set-Cookie"].should.equal ["foo=bar", "foo2=bar2", "foo3=bar3"]
+  end
+
+  specify "formats the Cookie expiration date accordingly to RFC 2109" do
+    response = Rack::Response.new
+    
+    response.set_cookie "foo", {:value => "bar", :expires => Time.now+10}
+    response["Set-Cookie"].should.match(
+      /expires=..., \d\d-...-\d\d\d\d \d\d:\d\d:\d\d .../)
+  end
+
+  specify "can delete cookies" do
+    response = Rack::Response.new
+    response.set_cookie "foo", "bar"
+    response.set_cookie "foo2", "bar2"
+    response.delete_cookie "foo"
+    response["Set-Cookie"].should.equal ["foo2=bar2",
+                                  "foo=; expires=Thu, 01-Jan-1970 00:00:00 GMT"]
+  end
+
+  specify "has a useful constructor" do
+    r = Rack::Response.new("foo")
+    status, header, body = r.finish
+    str = ""; body.each { |part| str << part }
+    str.should.equal "foo"
+
+    r = Rack::Response.new(["foo", "bar"])
+    status, header, body = r.finish
+    str = ""; body.each { |part| str << part }
+    str.should.equal "foobar"
+
+    r = Rack::Response.new({"foo", "bar"})
+    r.write "foo"
+    status, header, body = r.finish
+    str = ""; body.each { |part| str << part }
+    str.should.equal "foobarfoo"
+
+    r = Rack::Response.new([], 500)
+    r.status.should.equal 500
+  end
+
+  specify "has a constructor that can take a block" do
+    r = Rack::Response.new { |res|
+      res.status = 404
+      res.write "foo"
+    }
+    status, header, body = r.finish
+    str = ""; body.each { |part| str << part }
+    str.should.equal "foo"
+    status.should.equal 404
+  end
+ 
+  specify "doesn't return invalid responses" do
+    r = Rack::Response.new(["foo", "bar"], 204)
+    status, header, body = r.finish
+    str = ""; body.each { |part| str << part }
+    str.should.be.empty
+    header["Content-Type"].should.equal nil
+
+    lambda {
+      Rack::Response.new(Object.new)
+    }.should.raise(TypeError).
+      message.should =~ /stringable or iterable required/
+  end
+
+  specify "knows if it's empty" do
+    r = Rack::Response.new
+    r.should.be.empty
+    r.write "foo"
+    r.should.not.be.empty
+
+    r = Rack::Response.new
+    r.should.be.empty
+    r.finish
+    r.should.be.empty
+
+    r = Rack::Response.new
+    r.should.be.empty
+    r.finish { }
+    r.should.not.be.empty
+  end
+
+  specify "should provide access to the HTTP status" do
+    res = Rack::Response.new
+    res.status = 200
+    res.should.be.successful
+    res.should.be.ok
+
+    res.status = 404
+    res.should.not.be.successful
+    res.should.be.client_error
+    res.should.be.not_found
+
+    res.status = 501
+    res.should.not.be.successful
+    res.should.be.server_error
+
+    res.status = 307
+    res.should.be.redirect
+  end
+
+  specify "should provide access to the HTTP headers" do
+    res = Rack::Response.new
+    res["Content-Type"] = "text/yaml"
+
+    res.should.include "Content-Type"
+    res.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.nil
+    res.location.should.be.nil
+  end
+
+end

data/test/spec_rack_session_cookie.rb

@@ -0,0 +1,49 @@
+require 'test/spec'
+
+require 'rack/session/cookie'
+require 'rack/mock'
+require 'rack/response'
+
+context "Rack::Session::Cookie" do
+  incrementor = lambda { |env|
+    env["rack.session"]["counter"] ||= 0
+    env["rack.session"]["counter"] += 1
+    Rack::Response.new(env["rack.session"].inspect).to_a
+  }
+
+  specify "creates a new cookie" do
+    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).get("/")
+    res["Set-Cookie"].should.match("rack.session=")
+    res.body.should.equal '{"counter"=>1}'
+  end
+
+  specify "loads from a cookie" do
+    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).get("/")
+    cookie = res["Set-Cookie"]
+    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).
+      get("/", "HTTP_COOKIE" => cookie)
+    res.body.should.equal '{"counter"=>2}'
+    cookie = res["Set-Cookie"]
+    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).
+      get("/", "HTTP_COOKIE" => cookie)
+    res.body.should.equal '{"counter"=>3}'
+  end
+
+  specify "survives broken cookies" do
+    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).
+      get("/", "HTTP_COOKIE" => "rack.session=blarghfasel")
+    res.body.should.equal '{"counter"=>1}'
+  end
+
+  bigcookie = lambda { |env|
+    env["rack.session"]["cookie"] = "big" * 3000
+    Rack::Response.new(env["rack.session"].inspect).to_a
+  }
+
+  specify "barks on too big cookies" do
+    lambda {
+      Rack::MockRequest.new(Rack::Session::Cookie.new(bigcookie)).
+        get("/", :fatal => true)
+    }.should.raise(Rack::MockRequest::FatalWarning)
+  end
+end

data/test/spec_rack_session_memcache.rb

@@ -0,0 +1,100 @@
+require 'test/spec'
+
+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
+  }
+
+  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'
+    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.reverse.map{|t| t.join.value }
+
+    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
+end

data/test/spec_rack_session_pool.rb

@@ -0,0 +1,84 @@
+require 'test/spec'
+
+require 'rack/session/pool'
+require 'rack/mock'
+require 'rack/response'
+require 'thread'
+
+context "Rack::Session::Pool" do
+  incrementor = lambda { |env|
+    env["rack.session"]["counter"] ||= 0
+    env["rack.session"]["counter"] += 1
+    Rack::Response.new(env["rack.session"].inspect).to_a
+  }
+
+  specify "creates a new cookie" do
+    pool = Rack::Session::Pool.new(incrementor)
+    res = Rack::MockRequest.new(pool).get("/")
+    res["Set-Cookie"].should.match("rack.session=")
+    res.body.should.equal '{"counter"=>1}'
+  end
+
+  specify "determines session from a cookie" do
+    pool = Rack::Session::Pool.new(incrementor)
+    res = Rack::MockRequest.new(pool).get("/")
+    cookie = res["Set-Cookie"]
+    res = Rack::MockRequest.new(pool).get("/", "HTTP_COOKIE" => cookie)
+    res.body.should.equal '{"counter"=>2}'
+    res = Rack::MockRequest.new(pool).get("/", "HTTP_COOKIE" => cookie)
+    res.body.should.equal '{"counter"=>3}'
+  end
+
+  specify "survives broken cookies" do
+    pool = Rack::Session::Pool.new(incrementor)
+    res = Rack::MockRequest.new(pool).
+      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_showexceptions.rb

@@ -0,0 +1,21 @@
+require 'test/spec'
+
+require 'rack/showexceptions'
+require 'rack/mock'
+
+context "Rack::ShowExceptions" do
+  specify "catches exceptions" do
+    res = nil
+    req = Rack::MockRequest.new(Rack::ShowExceptions.new(lambda { |env|
+                                                           raise RuntimeError
+                                                         }))
+    lambda {
+      res = req.get("/")
+    }.should.not.raise
+    res.should.be.a.server_error
+    res.status.should.equal 500
+
+    res.should =~ /RuntimeError/
+    res.should =~ /ShowExceptions/
+  end
+end

data/test/spec_rack_showstatus.rb

@@ -0,0 +1,71 @@
+require 'test/spec'
+
+require 'rack/showstatus'
+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"}, []]
+                                                     }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+    res.should.be.not.empty
+
+    res["Content-Type"].should.equal("text/html")
+    res.should =~ /404/
+    res.should =~ /Not Found/
+  end
+
+  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"}, []]
+                                                     }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+    res.should.be.not.empty
+
+    res["Content-Type"].should.equal("text/html")
+    res.should =~ /404/
+    res.should =~ /Not Found/
+    res.should =~ /too meta/
+  end
+
+  specify "should not replace existing messages" do
+    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
+                                                       [404, {"Content-Type" => "text/plain"}, ["foo!"]]
+                                                     }))
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+
+    res.body.should == "foo!"
+  end
+
+  specify "should pass on original headers" do
+    headers = {"WWW-Authenticate" => "Basic blah"}
+
+    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env| [401, headers, []] }))
+    res = req.get("/", :lint => true)
+
+    res["WWW-Authenticate"].should.equal("Basic blah")
+  end
+
+  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!"]]
+                                                     }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+    res.should.be.not.empty
+
+    res["Content-Type"].should.equal("text/html")
+    res.should =~ /404/
+    res.should =~ /too meta/
+    res.body.should.not =~ /foo/
+  end
+end