qoobaa-rack 1.0.0.1

data/test/spec_rack_response.rb

@@ -0,0 +1,218 @@
+require 'test/spec'
+require 'set'
+
+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 set secure cookies" do
+    response = Rack::Response.new
+    response.set_cookie "foo", {:value => "bar", :secure => true}
+    response["Set-Cookie"].should.equal "foo=bar; secure"
+  end
+
+  specify "can set http only cookies" do
+    response = Rack::Response.new
+    response.set_cookie "foo", {:value => "bar", :httponly => true}
+    response["Set-Cookie"].should.equal "foo=bar; HttpOnly"
+  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 "can do redirects" do
+    response = Rack::Response.new
+    response.redirect "/foo"
+    status, header, body = response.finish
+
+    status.should.equal 302
+    header["Location"].should.equal "/foo"
+
+    response = Rack::Response.new
+    response.redirect "/foo", 307
+    status, header, body = response.finish
+
+    status.should.equal 307
+  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"].to_set)
+    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
+
+  specify "does not add or change Content-Length when #finish()ing" do
+    res = Rack::Response.new
+    res.status = 200
+    res.finish
+    res.headers["Content-Length"].should.be.nil
+
+    res = Rack::Response.new
+    res.status = 200
+    res.headers["Content-Length"] = "10"
+    res.finish
+    res.headers["Content-Length"].should.equal "10"
+  end
+
+  specify "updates Content-Length when body appended to using #write" do
+    res = Rack::Response.new
+    res.status = 200
+    res.headers["Content-Length"].should.be.nil
+    res.write "Hi"
+    res.headers["Content-Length"].should.equal "2"
+    res.write " there"
+    res.headers["Content-Length"].should.equal "8"
+  end
+
+end

data/test/spec_rack_rewindable_input.rb

@@ -0,0 +1,118 @@
+require 'test/spec'
+require 'stringio'
+require 'rack/rewindable_input'
+
+shared_context "a rewindable IO object" do
+  setup do
+    @rio = Rack::RewindableInput.new(@io)
+  end
+  
+  teardown do
+    @rio.close
+  end
+  
+  specify "should be able to handle to read()" do
+    @rio.read.should.equal "hello world"
+  end
+  
+  specify "should be able to handle to read(nil)" do
+    @rio.read(nil).should.equal "hello world"
+  end
+  
+  specify "should be able to handle to read(length)" do
+    @rio.read(1).should.equal "h"
+  end
+  
+  specify "should be able to handle to read(length, buffer)" do
+    buffer = ""
+    result = @rio.read(1, buffer)
+    result.should.equal "h"
+    result.object_id.should.equal buffer.object_id
+  end
+  
+  specify "should be able to handle to read(nil, buffer)" do
+    buffer = ""
+    result = @rio.read(nil, buffer)
+    result.should.equal "hello world"
+    result.object_id.should.equal buffer.object_id
+  end
+  
+  specify "should rewind to the beginning when #rewind is called" do
+    @rio.read(1)
+    @rio.rewind
+    @rio.read.should.equal "hello world"
+  end
+  
+  specify "should be able to handle gets" do
+    @rio.gets.should == "hello world"
+  end
+  
+  specify "should be able to handle each" do
+    array = []
+    @rio.each do |data|
+      array << data
+    end
+    array.should.equal(["hello world"])
+  end
+  
+  specify "should not buffer into a Tempfile if no data has been read yet" do
+    @rio.instance_variable_get(:@rewindable_io).should.be.nil
+  end
+  
+  specify "should buffer into a Tempfile when data has been consumed for the first time" do
+    @rio.read(1)
+    tempfile = @rio.instance_variable_get(:@rewindable_io)
+    tempfile.should.not.be.nil
+    @rio.read(1)
+    tempfile2 = @rio.instance_variable_get(:@rewindable_io)
+    tempfile2.should.equal tempfile
+  end
+  
+  specify "should close the underlying tempfile upon calling #close" do
+    @rio.read(1)
+    tempfile = @rio.instance_variable_get(:@rewindable_io)
+    @rio.close
+    tempfile.should.be.closed
+  end
+  
+  specify "should be possibel to call #close when no data has been buffered yet" do
+    @rio.close
+  end
+  
+  specify "should be possible to call #close multiple times" do
+    @rio.close
+    @rio.close
+  end
+end
+
+context "Rack::RewindableInput" do
+  context "given an IO object that is already rewindable" do
+    setup do
+      @io = StringIO.new("hello world")
+    end
+    
+    it_should_behave_like "a rewindable IO object"
+  end
+  
+  context "given an IO object that is not rewindable" do
+    setup do
+      @io = StringIO.new("hello world")
+      @io.instance_eval do
+        undef :rewind
+      end
+    end
+    
+    it_should_behave_like "a rewindable IO object"
+  end
+  
+  context "given an IO object whose rewind method raises Errno::ESPIPE" do
+    setup do
+      @io = StringIO.new("hello world")
+      def @io.rewind
+        raise Errno::ESPIPE, "You can't rewind this!"
+      end
+    end
+    
+    it_should_behave_like "a rewindable IO object"
+  end
+end

data/test/spec_rack_session_cookie.rb

@@ -0,0 +1,82 @@
+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
+  
+  specify "creates a new cookie with integrity hash" do
+    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).get("/")
+    if RUBY_VERSION < "1.9"
+      res["Set-Cookie"].should.match("rack.session=BAh7BiIMY291bnRlcmkG%0A--1439b4d37b9d4b04c603848382f712d6fcd31088")
+    else
+      res["Set-Cookie"].should.match("rack.session=BAh7BkkiDGNvdW50ZXIGOg1lbmNvZGluZyINVVMtQVNDSUlpBg%3D%3D%0A--d7a6637b94d2728194a96c18484e1f7ed9074a83")
+    end
+  end
+  
+  specify "loads from a cookie wih integrity hash" do
+    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).get("/")
+    cookie = res["Set-Cookie"]
+    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).
+      get("/", "HTTP_COOKIE" => cookie)
+    res.body.should.equal '{"counter"=>2}'
+    cookie = res["Set-Cookie"]
+    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).
+      get("/", "HTTP_COOKIE" => cookie)
+    res.body.should.equal '{"counter"=>3}'
+  end
+  
+  specify "ignores tampered with session cookies" do
+    app = Rack::Session::Cookie.new(incrementor, :secret => 'test')
+    response1 = Rack::MockRequest.new(app).get("/")
+    _, digest = response1["Set-Cookie"].split("--")
+    tampered_with_cookie = "hackerman-was-here" + "--" + digest
+    response2 = Rack::MockRequest.new(app).get("/", "HTTP_COOKIE" =>
+                                               tampered_with_cookie)
+    
+    # The tampered-with cookie is ignored, so we get back an identical Set-Cookie
+    response2["Set-Cookie"].should.equal(response1["Set-Cookie"])
+  end
+end

data/test/spec_rack_session_memcache.rb

@@ -0,0 +1,250 @@
+require 'test/spec'
+
+begin
+  require 'rack/session/memcache'
+  require 'rack/mock'
+  require 'rack/response'
+  require 'thread'
+
+  pool = Rack::Session::Memcache.new(lambda {})
+
+  context "Rack::Session::Memcache" do
+    session_key = Rack::Session::Memcache::DEFAULT_OPTIONS[:key]
+    session_match = /#{session_key}=[0-9a-fA-F]+;/
+    incrementor = lambda do |env|
+      env["rack.session"]["counter"] ||= 0
+      env["rack.session"]["counter"] += 1
+      Rack::Response.new(env["rack.session"].inspect).to_a
+    end
+    drop_session = proc do |env|
+      env['rack.session.options'][:drop] = true
+      incrementor.call(env)
+    end
+    renew_session = proc do |env|
+      env['rack.session.options'][:renew] = true
+      incrementor.call(env)
+    end
+    defer_session = proc do |env|
+      env['rack.session.options'][:defer] = true
+      incrementor.call(env)
+    end
+
+    specify "MemCache can connect to existing server" do
+      test_pool = MemCache.new :namespace => 'test:rack:session'
+    end
+
+    specify "faults on no connection" do
+      if RUBY_VERSION < "1.9"
+        lambda do
+          Rack::Session::Memcache.new(incrementor, :memcache_server => '')
+        end.should.raise
+      else
+        lambda do
+          Rack::Session::Memcache.new(incrementor, :memcache_server => '')
+        end.should.raise ArgumentError
+      end
+    end
+
+    specify "creates a new cookie" do
+      pool = Rack::Session::Memcache.new(incrementor)
+      res = Rack::MockRequest.new(pool).get("/")
+      res["Set-Cookie"].should.match("#{session_key}=")
+      res.body.should.equal '{"counter"=>1}'
+    end
+
+    specify "determines session from a cookie" do
+      pool = Rack::Session::Memcache.new(incrementor)
+      req = Rack::MockRequest.new(pool)
+      res = req.get("/")
+      cookie = res["Set-Cookie"]
+      req.get("/", "HTTP_COOKIE" => cookie).
+        body.should.equal '{"counter"=>2}'
+      req.get("/", "HTTP_COOKIE" => cookie).
+        body.should.equal '{"counter"=>3}'
+    end
+
+    specify "survives nonexistant cookies" do
+      bad_cookie = "rack.session=blarghfasel"
+      pool = Rack::Session::Memcache.new(incrementor)
+      res = Rack::MockRequest.new(pool).
+        get("/", "HTTP_COOKIE" => bad_cookie)
+      res.body.should.equal '{"counter"=>1}'
+      cookie = res["Set-Cookie"][session_match]
+      cookie.should.not.match(/#{bad_cookie}/)
+    end
+
+    specify "maintains freshness" do
+      pool = Rack::Session::Memcache.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'
+      puts 'Sleeping to expire session' if $DEBUG
+      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 "deletes cookies with :drop option" do
+      pool = Rack::Session::Memcache.new(incrementor)
+      req = Rack::MockRequest.new(pool)
+      drop = Rack::Utils::Context.new(pool, drop_session)
+      dreq = Rack::MockRequest.new(drop)
+
+      res0 = req.get("/")
+      session = (cookie = res0["Set-Cookie"])[session_match]
+      res0.body.should.equal '{"counter"=>1}'
+
+      res1 = req.get("/", "HTTP_COOKIE" => cookie)
+      res1["Set-Cookie"][session_match].should.equal session
+      res1.body.should.equal '{"counter"=>2}'
+
+      res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
+      res2["Set-Cookie"].should.equal nil
+      res2.body.should.equal '{"counter"=>3}'
+
+      res3 = req.get("/", "HTTP_COOKIE" => cookie)
+      res3["Set-Cookie"][session_match].should.not.equal session
+      res3.body.should.equal '{"counter"=>1}'
+    end
+
+    specify "provides new session id with :renew option" do
+      pool = Rack::Session::Memcache.new(incrementor)
+      req = Rack::MockRequest.new(pool)
+      renew = Rack::Utils::Context.new(pool, renew_session)
+      rreq = Rack::MockRequest.new(renew)
+
+      res0 = req.get("/")
+      session = (cookie = res0["Set-Cookie"])[session_match]
+      res0.body.should.equal '{"counter"=>1}'
+
+      res1 = req.get("/", "HTTP_COOKIE" => cookie)
+      res1["Set-Cookie"][session_match].should.equal session
+      res1.body.should.equal '{"counter"=>2}'
+
+      res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
+      new_cookie = res2["Set-Cookie"]
+      new_session = new_cookie[session_match]
+      new_session.should.not.equal session
+      res2.body.should.equal '{"counter"=>3}'
+
+      res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
+      res3["Set-Cookie"][session_match].should.equal new_session
+      res3.body.should.equal '{"counter"=>4}'
+    end
+
+    specify "omits cookie with :defer option" do
+      pool = Rack::Session::Memcache.new(incrementor)
+      req = Rack::MockRequest.new(pool)
+      defer = Rack::Utils::Context.new(pool, defer_session)
+      dreq = Rack::MockRequest.new(defer)
+
+      res0 = req.get("/")
+      session = (cookie = res0["Set-Cookie"])[session_match]
+      res0.body.should.equal '{"counter"=>1}'
+
+      res1 = req.get("/", "HTTP_COOKIE" => cookie)
+      res1["Set-Cookie"][session_match].should.equal session
+      res1.body.should.equal '{"counter"=>2}'
+
+      res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
+      res2["Set-Cookie"].should.equal nil
+      res2.body.should.equal '{"counter"=>3}'
+
+      res3 = req.get("/", "HTTP_COOKIE" => cookie)
+      res3["Set-Cookie"][session_match].should.equal session
+      res3.body.should.equal '{"counter"=>4}'
+    end
+
+    # anyone know how to do this better?
+    specify "multithread: should cleanly merge sessions" do
+      next unless $DEBUG
+      warn 'Running multithread test for Session::Memcache'
+      pool = Rack::Session::Memcache.new(incrementor)
+      req = Rack::MockRequest.new(pool)
+
+      res = req.get('/')
+      res.body.should.equal '{"counter"=>1}'
+      cookie = res["Set-Cookie"]
+      sess_id = cookie[/#{pool.key}=([^,;]+)/,1]
+
+      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
+      tses = Rack::Utils::Context.new pool, delta_incrementor
+      treq = Rack::MockRequest.new(tses)
+      tnum = rand(7).to_i+5
+      r = Array.new(tnum) do
+        Thread.new(treq) do |run|
+          run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+        end
+      end.reverse.map{|t| t.run.join.value }
+      r.each do |request|
+        request['Set-Cookie'].should.equal cookie
+        request.body.should.include '"counter"=>2'
+      end
+
+      session = pool.pool.get(sess_id)
+      session.size.should.be tnum+1 # counter
+      session['counter'].should.be 2 # meeeh
+
+      tnum = rand(7).to_i+5
+      r = Array.new(tnum) do |i|
+        delta_time = proc do |env|
+          env['rack.session'][i]  = Time.now
+          Thread.stop
+          env['rack.session']     = env['rack.session'].dup
+          env['rack.session'][i] -= Time.now
+          incrementor.call(env)
+        end
+        app = Rack::Utils::Context.new pool, time_delta
+        req = Rack::MockRequest.new app
+        Thread.new(req) do |run|
+          run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+        end
+      end.reverse.map{|t| t.run.join.value }
+      r.each do |request|
+        request['Set-Cookie'].should.equal cookie
+        request.body.should.include '"counter"=>3'
+      end
+
+      session = pool.pool.get(sess_id)
+      session.size.should.be tnum+1
+      session['counter'].should.be 3
+
+      drop_counter = proc do |env|
+        env['rack.session'].delete 'counter'
+        env['rack.session']['foo'] = 'bar'
+        [200, {'Content-Type'=>'text/plain'}, env['rack.session'].inspect]
+      end
+      tses = Rack::Utils::Context.new pool, drop_counter
+      treq = Rack::MockRequest.new(tses)
+      tnum = rand(7).to_i+5
+      r = Array.new(tnum) do
+        Thread.new(treq) do |run|
+          run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+        end
+      end.reverse.map{|t| t.run.join.value }
+      r.each do |request|
+        request['Set-Cookie'].should.equal cookie
+        request.body.should.include '"foo"=>"bar"'
+      end
+
+      session = pool.pool.get(sess_id)
+      session.size.should.be r.size+1
+      session['counter'].should.be.nil?
+      session['foo'].should.equal 'bar'
+    end
+  end
+rescue RuntimeError
+  $stderr.puts "Skipping Rack::Session::Memcache tests. Start memcached and try again."
+rescue LoadError
+  $stderr.puts "Skipping Rack::Session::Memcache tests (Memcache is required). `gem install memcache-client` and try again."
+end