rack 1.6.11 → 2.2.3

data/test/spec_session_memcache.rb

@@ -1,321 +0,0 @@
-begin
-  require 'rack/session/memcache'
-  require 'rack/lint'
-  require 'rack/mock'
-  require 'thread'
-
-  describe 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 = Rack::Lint.new(proc do |env|
-      env['rack.session.options'][:drop] = true
-      incrementor.call(env)
-    end)
-    renew_session = Rack::Lint.new(proc do |env|
-      env['rack.session.options'][:renew] = true
-      incrementor.call(env)
-    end)
-    defer_session = Rack::Lint.new(proc do |env|
-      env['rack.session.options'][:defer] = true
-      incrementor.call(env)
-    end)
-    skip_session = Rack::Lint.new(proc do |env|
-      env['rack.session.options'][:skip] = true
-      incrementor.call(env)
-    end)
-    incrementor = Rack::Lint.new(incrementor)
-
-    # test memcache connection
-    Rack::Session::Memcache.new(incrementor)
-
-    it "faults on no connection" do
-      lambda{
-        Rack::Session::Memcache.new(incrementor, :memcache_server => 'nosuchserver')
-      }.should.raise
-    end
-
-    it "connects to existing server" do
-      test_pool = MemCache.new(incrementor, :namespace => 'test:rack:session')
-      test_pool.namespace.should.equal 'test:rack:session'
-    end
-
-    it "passes options to MemCache" do
-      pool = Rack::Session::Memcache.new(incrementor, :namespace => 'test:rack:session')
-      pool.pool.namespace.should.equal 'test:rack:session'
-    end
-
-    it "creates a new cookie" do
-      pool = Rack::Session::Memcache.new(incrementor)
-      res = Rack::MockRequest.new(pool).get("/")
-      res["Set-Cookie"].should.include("#{session_key}=")
-      res.body.should.equal '{"counter"=>1}'
-    end
-
-    it "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
-
-    it "determines session only from a cookie by default" do
-      pool = Rack::Session::Memcache.new(incrementor)
-      req = Rack::MockRequest.new(pool)
-      res = req.get("/")
-      sid = res["Set-Cookie"][session_match, 1]
-      req.get("/?rack.session=#{sid}").
-        body.should.equal '{"counter"=>1}'
-      req.get("/?rack.session=#{sid}").
-        body.should.equal '{"counter"=>1}'
-    end
-
-    it "determines session from params" do
-      pool = Rack::Session::Memcache.new(incrementor, :cookie_only => false)
-      req = Rack::MockRequest.new(pool)
-      res = req.get("/")
-      sid = res["Set-Cookie"][session_match, 1]
-      req.get("/?rack.session=#{sid}").
-        body.should.equal '{"counter"=>2}'
-      req.get("/?rack.session=#{sid}").
-        body.should.equal '{"counter"=>3}'
-    end
-
-    it "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
-
-    it "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
-
-    it "does not send the same session id if it did not change" do
-      pool = Rack::Session::Memcache.new(incrementor)
-      req = Rack::MockRequest.new(pool)
-
-      res0 = req.get("/")
-      cookie = res0["Set-Cookie"][session_match]
-      res0.body.should.equal '{"counter"=>1}'
-
-      res1 = req.get("/", "HTTP_COOKIE" => cookie)
-      res1["Set-Cookie"].should.be.nil
-      res1.body.should.equal '{"counter"=>2}'
-
-      res2 = req.get("/", "HTTP_COOKIE" => cookie)
-      res2["Set-Cookie"].should.be.nil
-      res2.body.should.equal '{"counter"=>3}'
-    end
-
-    it "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)
-
-      res1 = req.get("/")
-      session = (cookie = res1["Set-Cookie"])[session_match]
-      res1.body.should.equal '{"counter"=>1}'
-
-      res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
-      res2["Set-Cookie"].should.equal nil
-      res2.body.should.equal '{"counter"=>2}'
-
-      res3 = req.get("/", "HTTP_COOKIE" => cookie)
-      res3["Set-Cookie"][session_match].should.not.equal session
-      res3.body.should.equal '{"counter"=>1}'
-    end
-
-    it "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)
-
-      res1 = req.get("/")
-      session = (cookie = res1["Set-Cookie"])[session_match]
-      res1.body.should.equal '{"counter"=>1}'
-
-      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"=>2}'
-
-      res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
-      res3.body.should.equal '{"counter"=>3}'
-
-      # Old cookie was deleted
-      res4 = req.get("/", "HTTP_COOKIE" => cookie)
-      res4.body.should.equal '{"counter"=>1}'
-    end
-
-    it "omits cookie with :defer option but still updates the state" do
-      pool = Rack::Session::Memcache.new(incrementor)
-      count = Rack::Utils::Context.new(pool, incrementor)
-      defer = Rack::Utils::Context.new(pool, defer_session)
-      dreq = Rack::MockRequest.new(defer)
-      creq = Rack::MockRequest.new(count)
-
-      res0 = dreq.get("/")
-      res0["Set-Cookie"].should.equal nil
-      res0.body.should.equal '{"counter"=>1}'
-
-      res0 = creq.get("/")
-      res1 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
-      res1.body.should.equal '{"counter"=>2}'
-      res2 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
-      res2.body.should.equal '{"counter"=>3}'
-    end
-
-    it "omits cookie and state update with :skip option" do
-      pool = Rack::Session::Memcache.new(incrementor)
-      count = Rack::Utils::Context.new(pool, incrementor)
-      skip = Rack::Utils::Context.new(pool, skip_session)
-      sreq = Rack::MockRequest.new(skip)
-      creq = Rack::MockRequest.new(count)
-
-      res0 = sreq.get("/")
-      res0["Set-Cookie"].should.equal nil
-      res0.body.should.equal '{"counter"=>1}'
-
-      res0 = creq.get("/")
-      res1 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
-      res1.body.should.equal '{"counter"=>2}'
-      res2 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
-      res2.body.should.equal '{"counter"=>2}'
-    end
-
-    it "updates deep hashes correctly" do
-      hash_check = proc do |env|
-        session = env['rack.session']
-        unless session.include? 'test'
-          session.update :a => :b, :c => { :d => :e },
-            :f => { :g => { :h => :i} }, 'test' => true
-        else
-          session[:f][:g][:h] = :j
-        end
-        [200, {}, [session.inspect]]
-      end
-      pool = Rack::Session::Memcache.new(hash_check)
-      req = Rack::MockRequest.new(pool)
-
-      res0 = req.get("/")
-      session_id = (cookie = res0["Set-Cookie"])[session_match, 1]
-      ses0 = pool.pool.get(session_id, true)
-
-      req.get("/", "HTTP_COOKIE" => cookie)
-      ses1 = pool.pool.get(session_id, true)
-
-      ses1.should.not.equal ses0
-    end
-
-    # anyone know how to do this better?
-    it "cleanly merges sessions when multithreaded" do
-      unless $DEBUG
-        1.should.equal 1 # fake assertion to appease the mighty bacon
-        next
-      end
-      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"]
-      session_id = cookie[session_match, 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(session_id)
-      session.size.should.equal tnum+1 # counter
-      session['counter'].should.equal 2 # meeeh
-
-      tnum = rand(7).to_i+5
-      r = Array.new(tnum) do
-        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(session_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(session_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

data/test/spec_session_pool.rb

@@ -1,209 +0,0 @@
-require 'thread'
-require 'rack/lint'
-require 'rack/mock'
-require 'rack/session/pool'
-
-describe Rack::Session::Pool do
-  session_key = Rack::Session::Pool::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
-
-  session_id = Rack::Lint.new(lambda do |env|
-    Rack::Response.new(env["rack.session"].inspect).to_a
-  end)
-
-  nothing = Rack::Lint.new(lambda do |env|
-    Rack::Response.new("Nothing").to_a
-  end)
-
-  drop_session = Rack::Lint.new(lambda do |env|
-    env['rack.session.options'][:drop] = true
-    incrementor.call(env)
-  end)
-
-  renew_session = Rack::Lint.new(lambda do |env|
-    env['rack.session.options'][:renew] = true
-    incrementor.call(env)
-  end)
-
-  defer_session = Rack::Lint.new(lambda do |env|
-    env['rack.session.options'][:defer] = true
-    incrementor.call(env)
-  end)
-  
-  incrementor = Rack::Lint.new(incrementor)
-
-  it "creates a new cookie" do
-    pool = Rack::Session::Pool.new(incrementor)
-    res = Rack::MockRequest.new(pool).get("/")
-    res["Set-Cookie"].should.match session_match
-    res.body.should.equal '{"counter"=>1}'
-  end
-
-  it "determines session from a cookie" do
-    pool = Rack::Session::Pool.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-    cookie = req.get("/")["Set-Cookie"]
-    req.get("/", "HTTP_COOKIE" => cookie).
-      body.should.equal '{"counter"=>2}'
-    req.get("/", "HTTP_COOKIE" => cookie).
-      body.should.equal '{"counter"=>3}'
-  end
-
-  it "survives nonexistant cookies" do
-    pool = Rack::Session::Pool.new(incrementor)
-    res = Rack::MockRequest.new(pool).
-      get("/", "HTTP_COOKIE" => "#{session_key}=blarghfasel")
-    res.body.should.equal '{"counter"=>1}'
-  end
-
-  it "does not send the same session id if it did not change" do
-    pool = Rack::Session::Pool.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-
-    res0 = req.get("/")
-    cookie = res0["Set-Cookie"][session_match]
-    res0.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.equal 1
-
-    res1 = req.get("/", "HTTP_COOKIE" => cookie)
-    res1["Set-Cookie"].should.be.nil
-    res1.body.should.equal '{"counter"=>2}'
-    pool.pool.size.should.equal 1
-
-    res2 = req.get("/", "HTTP_COOKIE" => cookie)
-    res2["Set-Cookie"].should.be.nil
-    res2.body.should.equal '{"counter"=>3}'
-    pool.pool.size.should.equal 1
-  end
-
-  it "deletes cookies with :drop option" do
-    pool = Rack::Session::Pool.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-    drop = Rack::Utils::Context.new(pool, drop_session)
-    dreq = Rack::MockRequest.new(drop)
-
-    res1 = req.get("/")
-    session = (cookie = res1["Set-Cookie"])[session_match]
-    res1.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.equal 1
-
-    res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
-    res2["Set-Cookie"].should.be.nil
-    res2.body.should.equal '{"counter"=>2}'
-    pool.pool.size.should.equal 0
-
-    res3 = req.get("/", "HTTP_COOKIE" => cookie)
-    res3["Set-Cookie"][session_match].should.not.equal session
-    res3.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.equal 1
-  end
-
-  it "provides new session id with :renew option" do
-    pool = Rack::Session::Pool.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-    renew = Rack::Utils::Context.new(pool, renew_session)
-    rreq = Rack::MockRequest.new(renew)
-
-    res1 = req.get("/")
-    session = (cookie = res1["Set-Cookie"])[session_match]
-    res1.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.equal 1
-
-    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"=>2}'
-    pool.pool.size.should.equal 1
-
-    res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
-    res3.body.should.equal '{"counter"=>3}'
-    pool.pool.size.should.equal 1
-
-    res4 = req.get("/", "HTTP_COOKIE" => cookie)
-    res4.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.equal 2
-  end
-
-  it "omits cookie with :defer option" do
-    pool = Rack::Session::Pool.new(incrementor)
-    defer = Rack::Utils::Context.new(pool, defer_session)
-    dreq = Rack::MockRequest.new(defer)
-
-    res1 = dreq.get("/")
-    res1["Set-Cookie"].should.equal nil
-    res1.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.equal 1
-  end
-
-  # anyone know how to do this better?
-  it "should merge sessions when multithreaded" do
-    unless $DEBUG
-      1.should.equal 1
-      next
-    end
-
-    warn 'Running multithread tests for Session::Pool'
-    pool = Rack::Session::Pool.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 |resp|
-      resp['Set-Cookie'].should.equal cookie
-      resp.body.should.include '"counter"=>2'
-    end
-
-    session = pool.pool[sess_id]
-    session.size.should.equal tnum+1 # counter
-    session['counter'].should.equal 2 # meeeh
-  end
-
-  it "does not return a cookie if cookie was not read/written" do
-    app = Rack::Session::Pool.new(nothing)
-    res = Rack::MockRequest.new(app).get("/")
-    res["Set-Cookie"].should.be.nil
-  end
-
-  it "does not return a cookie if cookie was not written (only read)" do
-    app = Rack::Session::Pool.new(session_id)
-    res = Rack::MockRequest.new(app).get("/")
-    res["Set-Cookie"].should.be.nil
-  end
-
-  it "returns even if not read/written if :expire_after is set" do
-    app = Rack::Session::Pool.new(nothing, :expire_after => 3600)
-    res = Rack::MockRequest.new(app).get("/", 'rack.session' => {'not' => 'empty'})
-    res["Set-Cookie"].should.not.be.nil
-  end
-
-  it "returns no cookie if no data was written and no session was created previously, even if :expire_after is set" do
-    app = Rack::Session::Pool.new(nothing, :expire_after => 3600)
-    res = Rack::MockRequest.new(app).get("/")
-    res["Set-Cookie"].should.be.nil
-  end
-end

data/test/spec_showexceptions.rb

@@ -1,98 +0,0 @@
-require 'rack/showexceptions'
-require 'rack/lint'
-require 'rack/mock'
-
-describe Rack::ShowExceptions do
-  def show_exceptions(app)
-    Rack::Lint.new Rack::ShowExceptions.new(app)
-  end
-  
-  it "catches exceptions" do
-    res = nil
-
-    req = Rack::MockRequest.new(
-      show_exceptions(
-        lambda{|env| raise RuntimeError }
-    ))
-
-    lambda{
-      res = req.get("/", "HTTP_ACCEPT" => "text/html")
-    }.should.not.raise
-
-    res.should.be.a.server_error
-    res.status.should.equal 500
-
-    res.should =~ /RuntimeError/
-    res.should =~ /ShowExceptions/
-  end
-
-  it "responds with HTML only to requests accepting HTML" do
-    res = nil
-
-    req = Rack::MockRequest.new(
-      show_exceptions(
-        lambda{|env| raise RuntimeError, "It was never supposed to work" }
-    ))
-
-    [
-      # Serve text/html when the client accepts text/html
-      ["text/html", ["/", {"HTTP_ACCEPT" => "text/html"}]],
-      ["text/html", ["/", {"HTTP_ACCEPT" => "*/*"}]],
-      # Serve text/plain when the client does not accept text/html
-      ["text/plain", ["/"]],
-      ["text/plain", ["/", {"HTTP_ACCEPT" => "application/json"}]]
-    ].each do |exmime, rargs|
-      lambda{
-        res = req.get(*rargs)
-      }.should.not.raise
-
-      res.should.be.a.server_error
-      res.status.should.equal 500
-
-      res.content_type.should.equal exmime
-
-      res.body.should.include "RuntimeError"
-      res.body.should.include "It was never supposed to work"
-
-      if exmime == "text/html"
-        res.body.should.include '</html>'
-      else
-        res.body.should.not.include '</html>'
-      end
-    end
-  end
-
-  it "handles exceptions without a backtrace" do
-    res = nil
-
-    req = Rack::MockRequest.new(
-      show_exceptions(
-        lambda{|env| raise RuntimeError, "", [] }
-      )
-    )
-
-    lambda{
-      res = req.get("/", "HTTP_ACCEPT" => "text/html")
-    }.should.not.raise
-
-    res.should.be.a.server_error
-    res.status.should.equal 500
-
-    res.should =~ /RuntimeError/
-    res.should =~ /ShowExceptions/
-    res.should =~ /unknown location/
-  end
-
-  it "knows to prefer plaintext for non-html" do
-    # We don't need an app for this
-    exc = Rack::ShowExceptions.new(nil)
-
-    [
-      [{ "HTTP_ACCEPT" => "text/plain" }, true],
-      [{ "HTTP_ACCEPT" => "text/foo" }, true],
-      [{ "HTTP_ACCEPT" => "text/html" }, false]
-    ].each do |env, expected|
-      assert_equal(expected, exc.prefers_plaintext?(env))
-    end
-  end
-end