dalli 2.7.2 → 3.0.0

data/test/test_failover.rb

@@ -1,128 +0,0 @@
-require 'helper'
-
-describe 'failover' do
-
-  describe 'timeouts' do
-    it 'not lead to corrupt sockets' do
-      memcached(29125) do
-        dc = Dalli::Client.new ['localhost:29125']
-        begin
-          Timeout.timeout 0.01 do
-            1_000.times do
-              dc.set("test_123", {:test => "123"})
-            end
-            flunk("Did not timeout")
-          end
-        rescue Timeout::Error
-        end
-
-        assert_equal({:test => '123'}, dc.get("test_123"))
-      end
-    end
-  end
-
-
-  describe 'assuming some bad servers' do
-
-    it 'silently reconnect if server hiccups' do
-      memcached(29125) do
-        dc = Dalli::Client.new ['localhost:29125']
-        dc.set 'foo', 'bar'
-        foo = dc.get 'foo'
-        assert_equal foo, 'bar'
-
-        memcached_kill(29125)
-        memcached(29125) do
-
-          foo = dc.get 'foo'
-          assert_nil foo
-
-          memcached_kill(29125)
-        end
-      end
-    end
-
-    it 'handle graceful failover' do
-      memcached(29125) do
-        memcached(29126) do
-          dc = Dalli::Client.new ['localhost:29125', 'localhost:29126']
-          dc.set 'foo', 'bar'
-          foo = dc.get 'foo'
-          assert_equal foo, 'bar'
-
-          memcached_kill(29125)
-
-          dc.set 'foo', 'bar'
-          foo = dc.get 'foo'
-          assert_equal foo, 'bar'
-
-          memcached_kill(29126)
-
-          assert_raises Dalli::RingError, :message => "No server available" do
-            dc.set 'foo', 'bar'
-          end
-        end
-      end
-    end
-
-    it 'handle them gracefully in get_multi' do
-      memcached(29125) do
-        memcached(29126) do
-          dc = Dalli::Client.new ['localhost:29125', 'localhost:29126']
-          dc.set 'a', 'a1'
-          result = dc.get_multi ['a']
-          assert_equal result, {'a' => 'a1'}
-
-          memcached_kill(29125)
-
-          result = dc.get_multi ['a']
-          assert_equal result, {'a' => 'a1'}
-        end
-      end
-    end
-
-    it 'handle graceful failover in get_multi' do
-      memcached(29125) do
-        memcached(29126) do
-          dc = Dalli::Client.new ['localhost:29125', 'localhost:29126']
-          dc.set 'foo', 'foo1'
-          dc.set 'bar', 'bar1'
-          result = dc.get_multi ['foo', 'bar']
-          assert_equal result, {'foo' => 'foo1', 'bar' => 'bar1'}
-
-          memcached_kill(29125)
-
-          dc.set 'foo', 'foo1'
-          dc.set 'bar', 'bar1'
-          result = dc.get_multi ['foo', 'bar']
-          assert_equal result, {'foo' => 'foo1', 'bar' => 'bar1'}
-
-          memcached_kill(29126)
-
-          result = dc.get_multi ['foo', 'bar']
-          assert_equal result, {}
-        end
-      end
-    end
-
-    it 'stats it still properly report' do
-      memcached(29125) do
-        memcached(29126) do
-          dc = Dalli::Client.new ['localhost:29125', 'localhost:29126']
-          result = dc.stats
-          assert_instance_of Hash, result['localhost:29125']
-          assert_instance_of Hash, result['localhost:29126']
-
-          memcached_kill(29125)
-
-          dc = Dalli::Client.new ['localhost:29125', 'localhost:29126']
-          result = dc.stats
-          assert_instance_of NilClass, result['localhost:29125']
-          assert_instance_of Hash, result['localhost:29126']
-
-          memcached_kill(29126)
-        end
-      end
-    end
-  end
-end

data/test/test_network.rb

@@ -1,54 +0,0 @@
-require 'helper'
-
-describe 'Network' do
-
-  describe 'assuming a bad network' do
-
-    it 'handle no server available' do
-      assert_raises Dalli::RingError, :message => "No server available" do
-        dc = Dalli::Client.new 'localhost:19333'
-        dc.get 'foo'
-      end
-    end
-
-    describe 'with a fake server' do
-      it 'handle connection reset' do
-        memcached_mock(lambda {|sock| sock.close }) do
-          assert_raises Dalli::RingError, :message => "No server available" do
-            dc = Dalli::Client.new('localhost:19123')
-            dc.get('abc')
-          end
-        end
-      end
-
-      it 'handle malformed response' do
-        memcached_mock(lambda {|sock| sock.write('123') }) do
-          assert_raises Dalli::RingError, :message => "No server available" do
-            dc = Dalli::Client.new('localhost:19123')
-            dc.get('abc')
-          end
-        end
-      end
-
-      it 'handle connect timeouts' do
-        memcached_mock(lambda {|sock| sleep(0.6); sock.close }, :delayed_start) do
-          assert_raises Dalli::RingError, :message => "No server available" do
-            dc = Dalli::Client.new('localhost:19123')
-            dc.get('abc')
-          end
-        end
-      end
-
-      it 'handle read timeouts' do
-        memcached_mock(lambda {|sock| sleep(0.6); sock.write('giraffe') }) do
-          assert_raises Dalli::RingError, :message => "No server available" do
-            dc = Dalli::Client.new('localhost:19123')
-            dc.get('abc')
-          end
-        end
-      end
-
-    end
-
-  end
-end

data/test/test_rack_session.rb

@@ -1,341 +0,0 @@
-require 'helper'
-
-require 'rack/session/dalli'
-require 'rack/lint'
-require 'rack/mock'
-require 'thread'
-
-describe Rack::Session::Dalli do
-  Rack::Session::Dalli::DEFAULT_OPTIONS[:memcache_server] = 'localhost:19129'
-
-  before do
-    memcached(19129) do
-    end
-
-    # test memcache connection
-    Rack::Session::Dalli.new(incrementor)
-  end
-
-  let(:session_key) { Rack::Session::Dalli::DEFAULT_OPTIONS[:key] }
-  let(:session_match) do
-    /#{session_key}=([0-9a-fA-F]+);/
-  end
-  let(:incrementor_proc) do
-    lambda do |env|
-      env["rack.session"]["counter"] ||= 0
-      env["rack.session"]["counter"] += 1
-      Rack::Response.new(env["rack.session"].inspect).to_a
-    end
-  end
-  let(:drop_session) do
-    Rack::Lint.new(proc do |env|
-        env['rack.session.options'][:drop] = true
-        incrementor_proc.call(env)
-      end)
-  end
-  let(:renew_session) do
-    Rack::Lint.new(proc do |env|
-        env['rack.session.options'][:renew] = true
-        incrementor_proc.call(env)
-      end)
-  end
-  let(:defer_session) do
-    Rack::Lint.new(proc do |env|
-        env['rack.session.options'][:defer] = true
-        incrementor_proc.call(env)
-      end)
-  end
-  let(:skip_session) do
-    Rack::Lint.new(proc do |env|
-        env['rack.session.options'][:skip] = true
-        incrementor_proc.call(env)
-      end)
-  end
-  let(:incrementor) { Rack::Lint.new(incrementor_proc) }
-
-  it "faults on no connection" do
-    assert_raises Dalli::RingError do
-      Rack::Session::Dalli.new(incrementor, :memcache_server => 'nosuchserver')
-    end
-  end
-
-  it "connects to existing server" do
-    assert_silent do
-      rsd = Rack::Session::Dalli.new(incrementor, :namespace => 'test:rack:session')
-      rsd.pool.set('ping', '')
-    end
-  end
-
-  it "passes options to MemCache" do
-    rsd = Rack::Session::Dalli.new(incrementor, :namespace => 'test:rack:session')
-    assert_equal('test:rack:session', rsd.pool.instance_eval { @options[:namespace] })
-  end
-
-  it "creates a new cookie" do
-    rsd = Rack::Session::Dalli.new(incrementor)
-    res = Rack::MockRequest.new(rsd).get("/")
-    assert res["Set-Cookie"].include?("#{session_key}=")
-    assert_equal '{"counter"=>1}', res.body
-  end
-
-  it "determines session from a cookie" do
-    rsd = Rack::Session::Dalli.new(incrementor)
-    req = Rack::MockRequest.new(rsd)
-    res = req.get("/")
-    cookie = res["Set-Cookie"]
-    assert_equal '{"counter"=>2}', req.get("/", "HTTP_COOKIE" => cookie).body
-    assert_equal '{"counter"=>3}', req.get("/", "HTTP_COOKIE" => cookie).body
-  end
-
-  it "determines session only from a cookie by default" do
-    rsd = Rack::Session::Dalli.new(incrementor)
-    req = Rack::MockRequest.new(rsd)
-    res = req.get("/")
-    sid = res["Set-Cookie"][session_match, 1]
-    assert_equal '{"counter"=>1}', req.get("/?rack.session=#{sid}").body
-    assert_equal '{"counter"=>1}', req.get("/?rack.session=#{sid}").body
-  end
-
-  it "determines session from params" do
-    rsd = Rack::Session::Dalli.new(incrementor, :cookie_only => false)
-    req = Rack::MockRequest.new(rsd)
-    res = req.get("/")
-    sid = res["Set-Cookie"][session_match, 1]
-    assert_equal '{"counter"=>2}', req.get("/?rack.session=#{sid}").body
-    assert_equal '{"counter"=>3}', req.get("/?rack.session=#{sid}").body
-  end
-
-  it "survives nonexistant cookies" do
-    bad_cookie = "rack.session=blarghfasel"
-    rsd = Rack::Session::Dalli.new(incrementor)
-    res = Rack::MockRequest.new(rsd).
-      get("/", "HTTP_COOKIE" => bad_cookie)
-    assert_equal '{"counter"=>1}', res.body
-    cookie = res["Set-Cookie"][session_match]
-    refute_match(/#{bad_cookie}/, cookie)
-  end
-
-  it "survives nonexistant blank cookies" do
-    bad_cookie = "rack.session="
-    rsd = Rack::Session::Dalli.new(incrementor)
-    res = Rack::MockRequest.new(rsd).
-      get("/", "HTTP_COOKIE" => bad_cookie)
-    cookie = res["Set-Cookie"][session_match]
-    refute_match(/#{bad_cookie}$/, cookie)
-  end
-
-  it "maintains freshness" do
-    rsd = Rack::Session::Dalli.new(incrementor, :expire_after => 3)
-    res = Rack::MockRequest.new(rsd).get('/')
-    assert res.body.include?('"counter"=>1')
-    cookie = res["Set-Cookie"]
-    res = Rack::MockRequest.new(rsd).get('/', "HTTP_COOKIE" => cookie)
-    assert_equal cookie, res["Set-Cookie"]
-    assert res.body.include?('"counter"=>2')
-    puts 'Sleeping to expire session' if $DEBUG
-    sleep 4
-    res = Rack::MockRequest.new(rsd).get('/', "HTTP_COOKIE" => cookie)
-    refute_equal cookie, res["Set-Cookie"]
-    assert res.body.include?('"counter"=>1')
-  end
-
-  it "does not send the same session id if it did not change" do
-    rsd = Rack::Session::Dalli.new(incrementor)
-    req = Rack::MockRequest.new(rsd)
-
-    res0 = req.get("/")
-    cookie = res0["Set-Cookie"][session_match]
-    assert_equal '{"counter"=>1}', res0.body
-
-    res1 = req.get("/", "HTTP_COOKIE" => cookie)
-    assert_nil res1["Set-Cookie"]
-    assert_equal '{"counter"=>2}', res1.body
-
-    res2 = req.get("/", "HTTP_COOKIE" => cookie)
-    assert_nil res2["Set-Cookie"]
-    assert_equal '{"counter"=>3}', res2.body
-  end
-
-  it "deletes cookies with :drop option" do
-    rsd = Rack::Session::Dalli.new(incrementor)
-    req = Rack::MockRequest.new(rsd)
-    drop = Rack::Utils::Context.new(rsd, drop_session)
-    dreq = Rack::MockRequest.new(drop)
-
-    res1 = req.get("/")
-    session = (cookie = res1["Set-Cookie"])[session_match]
-    assert_equal '{"counter"=>1}', res1.body
-
-    res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
-    assert_nil res2["Set-Cookie"]
-    assert_equal '{"counter"=>2}', res2.body
-
-    res3 = req.get("/", "HTTP_COOKIE" => cookie)
-    refute_equal session, res3["Set-Cookie"][session_match]
-    assert_equal '{"counter"=>1}', res3.body
-  end
-
-  it "provides new session id with :renew option" do
-    rsd = Rack::Session::Dalli.new(incrementor)
-    req = Rack::MockRequest.new(rsd)
-    renew = Rack::Utils::Context.new(rsd, renew_session)
-    rreq = Rack::MockRequest.new(renew)
-
-    res1 = req.get("/")
-    session = (cookie = res1["Set-Cookie"])[session_match]
-    assert_equal '{"counter"=>1}', res1.body
-
-    res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
-    new_cookie = res2["Set-Cookie"]
-    new_session = new_cookie[session_match]
-    refute_equal session, new_session
-    assert_equal '{"counter"=>2}', res2.body
-
-    res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
-    assert_equal '{"counter"=>3}', res3.body
-
-    # Old cookie was deleted
-    res4 = req.get("/", "HTTP_COOKIE" => cookie)
-    assert_equal '{"counter"=>1}', res4.body
-  end
-
-  it "omits cookie with :defer option but still updates the state" do
-    rsd = Rack::Session::Dalli.new(incrementor)
-    count = Rack::Utils::Context.new(rsd, incrementor)
-    defer = Rack::Utils::Context.new(rsd, defer_session)
-    dreq = Rack::MockRequest.new(defer)
-    creq = Rack::MockRequest.new(count)
-
-    res0 = dreq.get("/")
-    assert_nil res0["Set-Cookie"]
-    assert_equal '{"counter"=>1}', res0.body
-
-    res0 = creq.get("/")
-    res1 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
-    assert_equal '{"counter"=>2}', res1.body
-    res2 = dreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
-    assert_equal '{"counter"=>3}', res2.body
-  end
-
-  it "omits cookie and state update with :skip option" do
-    rsd = Rack::Session::Dalli.new(incrementor)
-    count = Rack::Utils::Context.new(rsd, incrementor)
-    skip = Rack::Utils::Context.new(rsd, skip_session)
-    sreq = Rack::MockRequest.new(skip)
-    creq = Rack::MockRequest.new(count)
-
-    res0 = sreq.get("/")
-    assert_nil res0["Set-Cookie"]
-    assert_equal '{"counter"=>1}', res0.body
-
-    res0 = creq.get("/")
-    res1 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
-    assert_equal '{"counter"=>2}', res1.body
-    res2 = sreq.get("/", "HTTP_COOKIE" => res0["Set-Cookie"])
-    assert_equal '{"counter"=>2}', res2.body
-  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
-    rsd = Rack::Session::Dalli.new(hash_check)
-    req = Rack::MockRequest.new(rsd)
-
-    res0 = req.get("/")
-    session_id = (cookie = res0["Set-Cookie"])[session_match, 1]
-    ses0 = rsd.pool.get(session_id, true)
-
-    req.get("/", "HTTP_COOKIE" => cookie)
-    ses1 = rsd.pool.get(session_id, true)
-
-    refute_equal ses0, ses1
-  end
-
-  # anyone know how to do this better?
-  it "cleanly merges sessions when multithreaded" do
-    unless $DEBUG
-      assert_equal 1, 1 # fake assertion to appease the mighty bacon
-      next
-    end
-    warn 'Running multithread test for Session::Dalli'
-    rsd = Rack::Session::Dalli.new(incrementor)
-    req = Rack::MockRequest.new(rsd)
-
-    res = req.get('/')
-    assert_equal '{"counter"=>1}', res.body
-    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 rsd, 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|
-      assert_equal cookie, request['Set-Cookie']
-      assert request.body.include?('"counter"=>2')
-    end
-
-    session = rsd.pool.get(session_id)
-    assert_equal tnum+1, session.size  # counter
-    assert_equal 2, session['counter'] # meeeh
-
-    tnum = rand(7).to_i+5
-    r = Array.new(tnum) do |i|
-      app = Rack::Utils::Context.new rsd, 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|
-      assert_equal cookie, request['Set-Cookie']
-      assert request.body.include?('"counter"=>3')
-    end
-
-    session = rsd.pool.get(session_id)
-    assert_equal tnum+1, session.size
-    assert_equal 3, session['counter']
-
-    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 rsd, 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|
-      assert_equal cookie, request['Set-Cookie']
-      assert request.body.include?('"foo"=>"bar"')
-    end
-
-    session = rsd.pool.get(session_id)
-    assert_equal r.size+1, session.size
-    assert_nil session['counter']
-    assert_equal 'bar', session['foo']
-  end
-end

data/test/test_ring.rb

@@ -1,85 +0,0 @@
-require 'helper'
-
-describe 'Ring' do
-
-  describe 'a ring of servers' do
-
-    it "have the continuum sorted by value" do
-      servers = [stub(:hostname => "localhost", :port => "11211", :weight => 1),
-                 stub(:hostname => "localhost", :port => "9500", :weight => 1)]
-      ring = Dalli::Ring.new(servers, {})
-      previous_value = 0
-      ring.continuum.each do |entry|
-        assert entry.value > previous_value
-        previous_value = entry.value
-      end
-    end
-
-    it 'raise when no servers are available/defined' do
-      ring = Dalli::Ring.new([], {})
-      assert_raises Dalli::RingError, :message => "No server available" do
-        ring.server_for_key('test')
-      end
-    end
-
-    describe 'containing only a single server' do
-      it "raise correctly when it's not alive" do
-        servers = [
-          Dalli::Server.new("localhost:12345"),
-        ]
-        ring = Dalli::Ring.new(servers, {})
-        assert_raises Dalli::RingError, :message => "No server available" do
-          ring.server_for_key('test')
-        end
-      end
-
-      it "return the server when it's alive" do
-        servers = [
-          Dalli::Server.new("localhost:19191"),
-        ]
-        ring = Dalli::Ring.new(servers, {})
-        memcached(19191) do |mc|
-          ring = mc.send(:ring)
-          assert_equal ring.servers.first.port, ring.server_for_key('test').port
-        end
-      end
-    end
-
-    describe 'containing multiple servers' do
-      it "raise correctly when no server is alive" do
-        servers = [
-          Dalli::Server.new("localhost:12345"),
-          Dalli::Server.new("localhost:12346"),
-        ]
-        ring = Dalli::Ring.new(servers, {})
-        assert_raises Dalli::RingError, :message => "No server available" do
-          ring.server_for_key('test')
-        end
-      end
-
-      it "return an alive server when at least one is alive" do
-        servers = [
-          Dalli::Server.new("localhost:12346"),
-          Dalli::Server.new("localhost:19191"),
-        ]
-        ring = Dalli::Ring.new(servers, {})
-        memcached(19191) do |mc|
-          ring = mc.send(:ring)
-          assert_equal ring.servers.first.port, ring.server_for_key('test').port
-        end
-      end
-    end
-
-    it 'detect when a dead server is up again' do
-      memcached(19997) do
-        down_retry_delay = 0.5
-        dc = Dalli::Client.new(['localhost:19997', 'localhost:19998'], :down_retry_delay => down_retry_delay)
-        assert_equal 1, dc.stats.values.compact.count
-
-        memcached(19998) do
-          assert_equal 2, dc.stats.values.compact.count
-        end
-      end
-    end
-  end
-end