moneta 0.6.0 → 0.7.0

data/spec/rack/cache_moneta_spec.rb

@@ -0,0 +1,355 @@
+require 'rack/cache/moneta'
+require 'rack/mock'
+require 'rack/cache'
+
+class Object
+  def sha_like?
+    length == 40 && self =~ /^[0-9a-z]+$/
+  end
+end
+
+describe Rack::Cache::MetaStore::Moneta do
+  before do
+    Rack::Cache::Moneta['meta'] = Moneta.new(:Memory, :expires => true)
+    Rack::Cache::Moneta['entity'] = Moneta.new(:Memory, :expires => true)
+    @store        = Rack::Cache::MetaStore::Moneta.resolve   uri('moneta://entity')
+    @entity_store = Rack::Cache::EntityStore::Moneta.resolve uri('moneta://meta')
+    @request  = mock_request('/', {})
+    @response = mock_response(200, {}, ['hello world'])
+  end
+
+  after do
+    Rack::Cache::Moneta['meta'].clear
+    Rack::Cache::Moneta['entity'].clear
+  end
+
+  it "has the class referenced by homonym constant" do
+    Rack::Cache::MetaStore::MONETA.should == Rack::Cache::MetaStore::Moneta
+  end
+
+  it "instantiates the store" do
+    @store.should be_kind_of(Rack::Cache::MetaStore::Moneta)
+  end
+
+  it "resolves the connection uri" do
+    Rack::Cache::MetaStore::Moneta.resolve(uri('moneta://Memory?expires=true')).should be_kind_of(Rack::Cache::MetaStore::Moneta)
+  end
+
+  # Low-level implementation methods ===========================================
+
+  it 'writes a list of negotation tuples with #write' do
+    # lambda {
+    @store.write('/test', [[{}, {}]])
+    # }.should_not raise Exception
+  end
+
+  it 'reads a list of negotation tuples with #read' do
+    @store.write('/test', [[{},{}],[{},{}]])
+    tuples = @store.read('/test')
+    tuples.should == [ [{},{}], [{},{}] ]
+  end
+
+  it 'reads an empty list with #read when nothing cached at key' do
+    @store.read('/nothing').should be_empty
+  end
+
+  it 'removes entries for key with #purge' do
+    @store.write('/test', [[{},{}]])
+    @store.read('/test').should_not be_empty
+
+    @store.purge('/test')
+    @store.read('/test').should be_empty
+  end
+
+  it 'succeeds when purging non-existing entries' do
+    @store.read('/test').should be_empty
+    @store.purge('/test')
+  end
+
+  it 'returns nil from #purge' do
+    @store.write('/test', [[{},{}]])
+    @store.purge('/test').should be_nil
+    @store.read('/test').should == []
+  end
+
+  %w[/test http://example.com:8080/ /test?x=y /test?x=y&p=q].each do |key|
+    it "can read and write key: '#{key}'" do
+      # lambda {
+      @store.write(key, [[{},{}]])
+      # }.should_not raise Exception
+      @store.read(key).should == [[{},{}]]
+    end
+  end
+
+  it "can read and write fairly large keys" do
+    key = "b" * 4096
+    # lambda {
+    @store.write(key, [[{},{}]])
+    # }.should_not raise Exception
+    @store.read(key).should == [[{},{}]]
+  end
+
+  it "allows custom cache keys from block" do
+    request = mock_request('/test', {})
+    request.env['rack-cache.cache_key'] =
+      lambda { |request| request.path_info.reverse }
+    @store.cache_key(request).should == 'tset/'
+  end
+
+  it "allows custom cache keys from class" do
+    request = mock_request('/test', {})
+    request.env['rack-cache.cache_key'] = Class.new do
+      def self.call(request); request.path_info.reverse end
+    end
+    @store.cache_key(request).should == 'tset/'
+  end
+
+  it 'does not blow up when given a non-marhsalable object with an ALL_CAPS key' do
+    store_simple_entry('/bad', { 'SOME_THING' => Proc.new {} })
+  end
+
+  # Abstract methods ===========================================================
+
+  it 'stores a cache entry' do
+    cache_key = store_simple_entry
+    @store.read(cache_key).should_not be_empty
+  end
+
+  it 'sets the X-Content-Digest response header before storing' do
+    cache_key = store_simple_entry
+    req, res = @store.read(cache_key).first
+    res['X-Content-Digest'].should == 'a94a8fe5ccb19ba61c4c0873d391e987982fbbd3'
+  end
+
+  it 'finds a stored entry with #lookup' do
+    store_simple_entry
+    response = @store.lookup(@request, @entity_store)
+    response.should_not be_nil
+    response.should be_kind_of(Rack::Cache::Response)
+  end
+
+  it 'does not find an entry with #lookup when none exists' do
+    req = mock_request('/test', {'HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'})
+    @store.lookup(req, @entity_store).should be_nil
+  end
+
+  it "canonizes urls for cache keys" do
+    store_simple_entry(path='/test?x=y&p=q')
+
+    hits_req = mock_request(path, {})
+    miss_req = mock_request('/test?p=x', {})
+
+    @store.lookup(hits_req, @entity_store).should_not be_nil
+    @store.lookup(miss_req, @entity_store).should be_nil
+  end
+
+  it 'does not find an entry with #lookup when the body does not exist' do
+    store_simple_entry
+    @response.headers['X-Content-Digest'].should_not be_nil
+    @entity_store.purge(@response.headers['X-Content-Digest'])
+    @store.lookup(@request, @entity_store).should be_nil
+  end
+
+  it 'restores response headers properly with #lookup' do
+    store_simple_entry
+    response = @store.lookup(@request, @entity_store)
+    response.headers.should == @response.headers.merge('Content-Length' => '4')
+  end
+
+  it 'restores response body from entity store with #lookup' do
+    store_simple_entry
+    response = @store.lookup(@request, @entity_store)
+    body = '' ; response.body.each {|p| body << p}
+    body.should == 'test'
+  end
+
+  it 'invalidates meta and entity store entries with #invalidate' do
+    store_simple_entry
+    @store.invalidate(@request, @entity_store)
+    response = @store.lookup(@request, @entity_store)
+    response.should be_kind_of(Rack::Cache::Response)
+    response.should_not be :fresh?
+  end
+
+  it 'succeeds quietly when #invalidate called with no matching entries' do
+    req = mock_request('/test', {})
+    @store.invalidate(req, @entity_store)
+    @store.lookup(@request, @entity_store).should be_nil
+  end
+
+  # Vary =======================================================================
+
+  it 'does not return entries that Vary with #lookup' do
+    req1 = mock_request('/test', {'HTTP_FOO' => 'Foo', 'HTTP_BAR' => 'Bar'})
+    req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
+    res = mock_response(200, {'Vary' => 'Foo Bar'}, ['test'])
+    @store.store(req1, res, @entity_store)
+
+    @store.lookup(req2, @entity_store).should be_nil
+  end
+
+  it 'stores multiple responses for each Vary combination' do
+    req1 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
+    res1 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 1'])
+    key = @store.store(req1, res1, @entity_store)
+
+    req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
+    res2 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 2'])
+    @store.store(req2, res2, @entity_store)
+
+    req3 = mock_request('/test', {'HTTP_FOO' => 'Baz',   'HTTP_BAR' => 'Boom'})
+    res3 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 3'])
+    @store.store(req3, res3, @entity_store)
+
+    slurp(@store.lookup(req3, @entity_store).body).should == 'test 3'
+    slurp(@store.lookup(req1, @entity_store).body).should == 'test 1'
+    slurp(@store.lookup(req2, @entity_store).body).should == 'test 2'
+
+    @store.read(key).length.should == 3
+  end
+
+  it 'overwrites non-varying responses with #store' do
+    req1 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
+    res1 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 1'])
+    key = @store.store(req1, res1, @entity_store)
+    slurp(@store.lookup(req1, @entity_store).body).should == 'test 1'
+
+    req2 = mock_request('/test', {'HTTP_FOO' => 'Bling', 'HTTP_BAR' => 'Bam'})
+    res2 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 2'])
+    @store.store(req2, res2, @entity_store)
+    slurp(@store.lookup(req2, @entity_store).body).should == 'test 2'
+
+    req3 = mock_request('/test', {'HTTP_FOO' => 'Foo',   'HTTP_BAR' => 'Bar'})
+    res3 = mock_response(200, {'Vary' => 'Foo Bar'}, ['test 3'])
+    @store.store(req3, res3, @entity_store)
+    slurp(@store.lookup(req1, @entity_store).body).should == 'test 3'
+
+    @store.read(key).length.should == 2
+  end
+
+  private
+  def mock_request(uri, opts)
+    env = Rack::MockRequest.env_for(uri, opts || {})
+    Rack::Cache::Request.new(env)
+  end
+
+  def mock_response(status, headers, body)
+    headers ||= {}
+    body = Array(body).compact
+    Rack::Cache::Response.new(status, headers, body)
+  end
+
+  def slurp(body)
+    buf = ''
+    body.each { |part| buf << part }
+    buf
+  end
+
+  # Stores an entry for the given request args, returns a url encoded cache key
+  # for the request.
+  def store_simple_entry(*request_args)
+    path, headers = request_args
+    @request = mock_request(path || '/test', headers || {})
+    @response = mock_response(200, {'Cache-Control' => 'max-age=420'}, ['test'])
+    body = @response.body
+    cache_key = @store.store(@request, @response, @entity_store)
+    @response.body.should == body
+    cache_key
+  end
+
+  def uri(uri)
+    URI.parse uri
+  end
+end
+
+describe Rack::Cache::EntityStore::Moneta do
+  before do
+    @store = Rack::Cache::EntityStore::Moneta.resolve(uri('moneta://Memory?expires=true'))
+  end
+
+  it 'has the class referenced by homonym constant' do
+    Rack::Cache::EntityStore::MONETA.should == Rack::Cache::EntityStore::Moneta
+  end
+
+  it 'resolves the connection uri' do
+    Rack::Cache::EntityStore::Moneta.resolve(uri('moneta://Memory?expires=true')).should be_kind_of(Rack::Cache::EntityStore::Moneta)
+  end
+
+  it 'responds to all required messages' do
+    %w[read open write exist?].each do |message|
+      @store.should respond_to message
+    end
+  end
+
+  it 'stores bodies with #write' do
+    key, size = @store.write(['My wild love went riding,'])
+    key.should_not be_nil
+    key.should be_sha_like
+
+    data = @store.read(key)
+    data.should == 'My wild love went riding,'
+  end
+
+  it 'takes a ttl parameter for #write' do
+    key, size = @store.write(['My wild love went riding,'], 0)
+    key.should_not be_nil
+    key.should be_sha_like
+
+    data = @store.read(key)
+    data.should == 'My wild love went riding,'
+  end
+
+  it 'correctly determines whether cached body exists for key with #exist?' do
+    key, size = @store.write(['She rode to the devil,'])
+    @store.exist?(key).should be_true
+    @store.exist?('938jasddj83jasdh4438021ksdfjsdfjsdsf').should be_false
+  end
+
+  it 'can read data written with #write' do
+    key, size = @store.write(['And asked him to pay.'])
+    data = @store.read(key)
+    data.should == 'And asked him to pay.'
+  end
+
+  it 'gives a 40 character SHA1 hex digest from #write' do
+    key, size = @store.write(['she rode to the sea;'])
+    key.should_not be_nil
+    key.length.should == 40
+    key.should match(/^[0-9a-z]+$/)
+    key.should == '90a4c84d51a277f3dafc34693ca264531b9f51b6'
+  end
+
+  it 'returns the entire body as a String from #read' do
+    key, size = @store.write(['She gathered together'])
+    @store.read(key).should == 'She gathered together'
+  end
+
+  it 'returns nil from #read when key does not exist' do
+    @store.read('87fe0a1ae82a518592f6b12b0183e950b4541c62').should be_nil
+  end
+
+  it 'returns a Rack compatible body from #open' do
+    key, size = @store.write(['Some shells for her hair.'])
+    body = @store.open(key)
+    body.should respond_to :each
+    buf = ''
+    body.each { |part| buf << part }
+    buf.should == 'Some shells for her hair.'
+  end
+
+  it 'returns nil from #open when key does not exist' do
+    @store.open('87fe0a1ae82a518592f6b12b0183e950b4541c62').should be_nil
+  end
+
+  it 'deletes stored entries with #purge' do
+    key, size = @store.write(['My wild love went riding,'])
+    @store.purge(key).should be_nil
+    @store.read(key).should be_nil
+  end
+
+  private
+
+  def uri(uri)
+    URI.parse uri
+  end
+end

data/spec/rack/moneta_cookies_spec.rb

@@ -0,0 +1,81 @@
+require 'helper'
+require 'rack/mock'
+require 'rack/moneta_cookies'
+
+describe Rack::MonetaCookies do
+  def config(options={},&block)
+    @options = options
+    @block = block
+  end
+
+  def app(&block)
+    @app_block ||= block
+  end
+
+  def backend
+    Rack::MockRequest.new(Rack::MonetaCookies.new(lambda{|env|
+      @store = env['rack.request.cookie_hash']
+      app.call(env) if app
+      [200,{},[]]
+    }, @options || {}, &@block))
+  end
+
+  def get(cookies = {}, &block)
+    app(&block)
+    @response = backend.get('/','HTTP_COOKIE' => Rack::Utils.build_query(cookies))
+  end
+
+  it 'should be able to read a simple key' do
+    get 'key' => 'value' do
+      expect( @store['key'] ).to eql('value')
+    end
+  end
+
+  it 'should be able to set a simple key' do
+    get do
+      @store['key'] = 'value'
+    end
+    expect( @response['Set-Cookie'] ).to eql('key=value')
+  end
+
+  it 'should be able to remove a simple key' do
+    get 'key' => 'value' do
+      @store.delete('key')
+    end
+    expect( @response['Set-Cookie'] ).to eql('key=; expires=Thu, 01-Jan-1970 00:00:00 GMT')
+  end
+
+  it 'should accept a config block' do
+    config do
+      use :Transformer, :key => :prefix, :prefix => 'moneta.'
+      adapter :Cookie
+    end
+    get 'moneta.key' => 'right', 'key' => 'wrong' do
+      expect( @store['key'] ).to eql('right')
+    end
+  end
+
+  it 'should accept a :domain option' do
+    config :domain => 'example.com'
+    get do
+      @store['key'] = 'value'
+    end
+    expect(@response['Set-Cookie']).to eql('key=value; domain=example.com')
+  end
+
+  it 'should accept a :path option' do
+    config :path => '/path'
+    get do
+      @store['key'] = 'value'
+    end
+    expect(@response['Set-Cookie']).to eql('key=value; path=/path')
+  end
+
+  it 'should be accessible via Rack::Request' do
+    get 'key' => 'value' do |env|
+      req = Rack::Request.new(env)
+      expect(req.cookies['key']).to eql('value')
+    end
+  end
+
+end

data/spec/rack/session_moneta_spec.rb

@@ -0,0 +1,305 @@
+require 'rack/session/moneta'
+require 'rack/lint'
+require 'rack/mock'
+require 'thread'
+
+describe Rack::Session::Moneta do
+  session_key = Rack::Session::Moneta::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)
+
+  it 'supports different constructors' do
+    Rack::Session::Moneta.new(incrementor, :store => :Memory)
+    Rack::Session::Moneta.new(incrementor, :store => Moneta.new(:Memory, :expires => true))
+    Rack::Session::Moneta.new(incrementor) do
+      use :Expires
+      adapter :Memory
+    end
+  end
+
+  it "creates a new cookie" do
+    pool = Rack::Session::Moneta.new(incrementor, :store => :Memory)
+    res = Rack::MockRequest.new(pool).get("/")
+    res["Set-Cookie"].should include("#{session_key}=")
+    res.body.should == '{"counter"=>1}'
+  end
+
+  it "determines session from a cookie" do
+    pool = Rack::Session::Moneta.new(incrementor, :store => :Memory)
+    req = Rack::MockRequest.new(pool)
+    res = req.get("/")
+    cookie = res["Set-Cookie"]
+    req.get("/", "HTTP_COOKIE" => cookie).
+      body.should == '{"counter"=>2}'
+    req.get("/", "HTTP_COOKIE" => cookie).
+      body.should == '{"counter"=>3}'
+  end
+
+  it "determines session only from a cookie by default" do
+    pool = Rack::Session::Moneta.new(incrementor, :store => :Memory)
+    req = Rack::MockRequest.new(pool)
+    res = req.get("/")
+    sid = res["Set-Cookie"][session_match, 1]
+    req.get("/?rack.session=#{sid}").
+      body.should == '{"counter"=>1}'
+    req.get("/?rack.session=#{sid}").
+      body.should == '{"counter"=>1}'
+  end
+
+  it "determines session from params" do
+    pool = Rack::Session::Moneta.new(incrementor, :cookie_only => false, :store => :Memory)
+    req = Rack::MockRequest.new(pool)
+    res = req.get("/")
+    sid = res["Set-Cookie"][session_match, 1]
+    req.get("/?rack.session=#{sid}").
+      body.should == '{"counter"=>2}'
+    req.get("/?rack.session=#{sid}").
+      body.should == '{"counter"=>3}'
+  end
+
+  it "survives nonexistant cookies" do
+    bad_cookie = "rack.session=blarghfasel"
+    pool = Rack::Session::Moneta.new(incrementor, :store => :Memory)
+    res = Rack::MockRequest.new(pool).
+      get("/", "HTTP_COOKIE" => bad_cookie)
+    res.body.should == '{"counter"=>1}'
+    cookie = res["Set-Cookie"][session_match]
+    cookie.should_not match(/#{bad_cookie}/)
+  end
+
+  it "maintains freshness" do
+    pool = Rack::Session::Moneta.new(incrementor, :expire_after => 3, :store => :Memory)
+    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 == 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 == 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::Moneta.new(incrementor, :store => :Memory)
+    req = Rack::MockRequest.new(pool)
+
+    res0 = req.get("/")
+    cookie = res0["Set-Cookie"][session_match]
+    res0.body.should == '{"counter"=>1}'
+
+    res1 = req.get("/", "HTTP_COOKIE" => cookie)
+    res1["Set-Cookie"].should be_nil
+    res1.body.should == '{"counter"=>2}'
+
+    res2 = req.get("/", "HTTP_COOKIE" => cookie)
+    res2["Set-Cookie"].should be_nil
+    res2.body.should == '{"counter"=>3}'
+  end
+
+  it "deletes cookies with :drop option" do
+    pool = Rack::Session::Moneta.new(incrementor, :store => :Memory)
+    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 == '{"counter"=>1}'
+
+    res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
+    res2["Set-Cookie"].should == nil
+    res2.body.should == '{"counter"=>2}'
+
+    res3 = req.get("/", "HTTP_COOKIE" => cookie)
+    res3["Set-Cookie"][session_match].should_not == session
+    res3.body.should == '{"counter"=>1}'
+  end
+
+  it "provides new session id with :renew option" do
+    pool = Rack::Session::Moneta.new(incrementor, :store => :Memory)
+    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 == '{"counter"=>1}'
+
+    res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
+    new_cookie = res2["Set-Cookie"]
+    new_session = new_cookie[session_match]
+    new_session.should_not == session
+    res2.body.should == '{"counter"=>2}'
+
+    res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
+    res3.body.should == '{"counter"=>3}'
+
+    # Old cookie was deleted
+    res4 = req.get("/", "HTTP_COOKIE" => cookie)
+    res4.body.should == '{"counter"=>1}'
+  end
+
+  it "omits cookie with :defer option but still updates the state" do
+    pool = Rack::Session::Moneta.new(incrementor, :store => :Memory)
+    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 == nil
+    res0.body.should == '{"counter"=>1}'
+
+    res0 = creq.get("/")
+    res1 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
+    res1.body.should == '{"counter"=>2}'
+    res2 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
+    res2.body.should == '{"counter"=>3}'
+  end
+
+  it "omits cookie and state update with :skip option" do
+    pool = Rack::Session::Moneta.new(incrementor, :store => :Memory)
+    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 == nil
+    res0.body.should == '{"counter"=>1}'
+
+    res0 = creq.get("/")
+    res1 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
+    res1.body.should == '{"counter"=>2}'
+    res2 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
+    res2.body.should == '{"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::Moneta.new(hash_check, :store => :Memory)
+    req = Rack::MockRequest.new(pool)
+
+    res0 = req.get("/")
+    session_id = (cookie = res0["Set-Cookie"])[session_match, 1]
+    ses0 = pool.pool[session_id]
+
+    req.get("/", "HTTP_COOKIE" => cookie)
+    ses1 = pool.pool[session_id]
+
+    ses1.should_not == ses0
+  end
+
+  # anyone know how to do this better?
+  it "cleanly merges sessions when multithreaded" do
+    unless $DEBUG
+      1.should == 1 # fake assertion to appease the mighty bacon
+      next
+    end
+    warn 'Running multithread test for Session::Memcache'
+    pool = Rack::Session::Moneta.new(incrementor, :store => :Memory)
+    req = Rack::MockRequest.new(pool)
+
+    res = req.get('/')
+    res.body.should == '{"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 == cookie
+      request.body.should include '"counter"=>2'
+    end
+
+    session = pool.pool[session_id]
+    session.size.should == tnum+1 # counter
+    session['counter'].should == 2 # meeeh
+
+    tnum = rand(7).to_i+5
+    r = Array.new(tnum) do |i|
+      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 == cookie
+      request.body.should include '"counter"=>3'
+    end
+
+    session = pool.pool[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 == cookie
+      request.body.should include '"foo"=>"bar"'
+    end
+
+    session = pool.pool[session_id]
+    session.size.should.be r.size+1
+    session['counter'].should.be.nil?
+    session['foo'].should == 'bar'
+  end
+end