dalli 1.1.4 → 2.7.11

data/test/test_encoding.rb

@@ -1,43 +0,0 @@
-# encoding: utf-8
-require 'helper'
-require 'memcached_mock'
-
-class TestEncoding < Test::Unit::TestCase
-
-  context 'using a live server' do
-    should 'support i18n content' do
-      memcached do |dc|
-        key = 'foo'
-        bad_key = utf8 = 'ƒ©åÍÎ'
-
-        assert dc.set(key, utf8)
-        assert_equal utf8, dc.get(key)
-
-        # keys must be ASCII
-        assert_raise ArgumentError, /illegal character/ do
-          dc.set(bad_key, utf8)
-        end
-      end
-    end
-
-    should 'support content expiry' do
-      memcached do |dc|
-        key = 'foo'
-        assert dc.set(key, 'bar', 1)
-        assert_equal 'bar', dc.get(key)
-        sleep 2
-        assert_equal nil, dc.get(key)
-      end
-    end
-
-    should 'not allow non-ASCII keys' do
-      memcached do |dc|
-        key = 'fooƒ'
-        assert_raise ArgumentError do
-          dc.set(key, 'bar')
-        end
-      end
-    end
-
-  end
-end

data/test/test_failover.rb

@@ -1,107 +0,0 @@
-require 'helper'
-
-class TestFailover < Test::Unit::TestCase
-  context 'assuming some bad servers' do
-
-    should '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
-
-    should '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_raise Dalli::RingError, :message => "No server available" do
-            dc.set 'foo', 'bar'
-          end
-        end
-      end
-    end
-
-    should '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
-
-    should '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
-
-    should 'stats should 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'
-
-class TestNetwork < Test::Unit::TestCase
-
-  context 'assuming a bad network' do
-
-    should 'handle no server available' do
-      assert_raise Dalli::RingError, :message => "No server available" do
-        dc = Dalli::Client.new 'localhost:19333'
-        dc.get 'foo'
-      end
-    end
-
-    context 'with a fake server' do
-      should 'handle connection reset' do
-        memcached_mock(lambda {|sock| sock.close }) do
-          assert_raise Dalli::RingError, :message => "No server available" do
-            dc = Dalli::Client.new('localhost:19123')
-            dc.get('abc')
-          end
-        end
-      end
-
-      should 'handle malformed response' do
-        memcached_mock(lambda {|sock| sock.write('123') }) do
-          assert_raise Dalli::RingError, :message => "No server available" do
-            dc = Dalli::Client.new('localhost:19123')
-            dc.get('abc')
-          end
-        end
-      end
-
-      should 'handle connect timeouts' do
-        memcached_mock(lambda {|sock| sleep(0.6); sock.close }, :delayed_start) do
-          assert_raise Dalli::RingError, :message => "No server available" do
-            dc = Dalli::Client.new('localhost:19123')
-            dc.get('abc')
-          end
-        end
-      end
-
-      should 'handle read timeouts' do
-        memcached_mock(lambda {|sock| sleep(0.6); sock.write('giraffe') }) do
-          assert_raise 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_ring.rb

@@ -1,85 +0,0 @@
-require 'helper'
-
-class TestRing < Test::Unit::TestCase
-
-  context 'a ring of servers' do
-
-    should "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
-
-    should 'raise when no servers are available/defined' do
-      ring = Dalli::Ring.new([], {})
-      assert_raise Dalli::RingError, :message => "No server available" do
-        ring.server_for_key('test')
-      end
-    end
-
-    context 'containing only a single server' do
-      should "raise correctly when it's not alive" do
-        servers = [
-          Dalli::Server.new("localhost:12345"),
-        ]
-        ring = Dalli::Ring.new(servers, {})
-        assert_raise Dalli::RingError, :message => "No server available" do
-          ring.server_for_key('test')
-        end
-      end
-
-      should "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
-
-    context 'containing multiple servers' do
-      should "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_raise Dalli::RingError, :message => "No server available" do
-          ring.server_for_key('test')
-        end
-      end
-
-      should "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
-
-    should 'detect when a dead server is up again' do
-      memcached(29125) do
-        down_retry_delay = 0.5
-        dc = Dalli::Client.new(['localhost:29125', 'localhost:29126'], :down_retry_delay => down_retry_delay)
-        assert_equal 1, dc.stats.values.compact.count
-
-        memcached(29126) do
-          assert_equal 2, dc.stats.values.compact.count
-        end
-      end
-    end
-  end
-end

data/test/test_sasl.rb

@@ -1,83 +0,0 @@
-require 'helper'
-
-class TestSasl < Test::Unit::TestCase
-
-  context 'a server requiring authentication' do
-
-    context 'without authentication credentials' do
-      setup do
-        ENV['MEMCACHE_USERNAME'] = 'foo'
-        ENV['MEMCACHE_PASSWORD'] = 'wrongpwd'
-      end
-
-      teardown do
-        ENV['MEMCACHE_USERNAME'] = nil
-        ENV['MEMCACHE_PASSWORD'] = nil
-      end
-
-      should 'provide one test that passes' do
-        assert true
-      end
-
-      should_eventually 'gracefully handle authentication failures' do
-        memcached(19124, '-S') do |dc|
-          assert_raise Dalli::DalliError, /32/ do
-            dc.set('abc', 123)
-          end
-        end
-      end
-    end
-
-    should_eventually 'fail SASL authentication with wrong options' do
-      memcached(19124, '-S') do |dc|
-        dc = Dalli::Client.new('localhost:19124', :username => 'foo', :password => 'wrongpwd')
-        assert_raise Dalli::DalliError, /32/ do
-          dc.set('abc', 123)
-        end
-      end
-    end
-
-    # OSX: Create a SASL user for the memcached application like so:
-    #
-    # saslpasswd2 -a memcached -c testuser
-    #
-    # with password 'testtest'
-    context 'in an authenticated environment' do
-      setup do
-        ENV['MEMCACHE_USERNAME'] = 'testuser'
-        ENV['MEMCACHE_PASSWORD'] = 'testtest'
-      end
-
-      teardown do
-        ENV['MEMCACHE_USERNAME'] = nil
-        ENV['MEMCACHE_PASSWORD'] = nil
-      end
-
-      should_eventually 'pass SASL authentication' do
-        memcached(19124, '-S') do |dc|
-          # I get "Dalli::DalliError: Error authenticating: 32" in OSX
-          # but SASL works on Heroku servers. YMMV.
-          assert_equal true, dc.set('abc', 123)
-          assert_equal 123, dc.get('abc')
-          results = dc.stats
-          assert_equal 1, results.size
-          assert_equal 38, results.values.first.size
-        end
-      end
-    end
-
-    should_eventually 'pass SASL authentication with options' do
-      memcached(19124, '-S') do |dc|
-        dc = Dalli::Client.new('localhost:19124', :username => 'testuser', :password => 'testtest')
-        # I get "Dalli::DalliError: Error authenticating: 32" in OSX
-        # but SASL works on Heroku servers. YMMV.
-        assert_equal true, dc.set('abc', 123)
-        assert_equal 123, dc.get('abc')
-        results = dc.stats
-        assert_equal 1, results.size
-        assert_equal 38, results.values.first.size
-      end
-    end
-
-  end
-end

data/test/test_session_store.rb

@@ -1,225 +0,0 @@
-require 'helper'
-require 'abstract_unit'
-require 'action_dispatch/middleware/session/dalli_store'
-
-class Foo
-  def initialize(bar='baz')
-    @bar = bar
-  end
-  def inspect
-    "#<#{self.class} bar:#{@bar.inspect}>"
-  end
-end
-
-class TestSessionStore < ActionController::IntegrationTest
-  class TestController < ActionController::Base
-    def no_session_access
-      head :ok
-    end
-
-    def set_session_value
-      session[:foo] = "bar"
-      head :ok
-    end
-
-    def set_serialized_session_value
-      session[:foo] = Foo.new
-      head :ok
-    end
-
-    def get_session_value
-      render :text => "foo: #{session[:foo].inspect}"
-    end
-
-    def get_session_id
-      render :text => "#{request.session_options[:id]}"
-    end
-
-    def call_reset_session
-      session[:bar]
-      reset_session
-      session[:bar] = "baz"
-      head :ok
-    end
-
-    def rescue_action(e) raise end
-  end
-
-  begin
-    require 'dalli'
-    memcache = Dalli::Client.new('127.0.0.1:11211')
-    memcache.set('ping', '')
-
-    def test_setting_and_getting_session_value
-      with_test_route_set do
-        get '/set_session_value'
-        assert_response :success
-        assert cookies['_session_id']
-
-        get '/get_session_value'
-        assert_response :success
-        assert_equal 'foo: "bar"', response.body
-      end
-    end
-
-    def test_getting_nil_session_value
-      with_test_route_set do
-        get '/get_session_value'
-        assert_response :success
-        assert_equal 'foo: nil', response.body
-      end
-    end
-
-    def test_getting_session_value_after_session_reset
-      with_test_route_set do
-        get '/set_session_value'
-        assert_response :success
-        assert cookies['_session_id']
-        session_cookie = cookies.send(:hash_for)['_session_id']
-
-        get '/call_reset_session'
-        assert_response :success
-        assert_not_equal [], headers['Set-Cookie']
-
-        cookies << session_cookie # replace our new session_id with our old, pre-reset session_id
-
-        get '/get_session_value'
-        assert_response :success
-        assert_equal 'foo: nil', response.body, "data for this session should have been obliterated from memcached"
-      end
-    end
-
-    def test_getting_from_nonexistent_session
-      with_test_route_set do
-        get '/get_session_value'
-        assert_response :success
-        assert_equal 'foo: nil', response.body
-        assert_nil cookies['_session_id'], "should only create session on write, not read"
-      end
-    end
-
-    def test_setting_session_value_after_session_reset
-      with_test_route_set do
-        get '/set_session_value'
-        assert_response :success
-        assert cookies['_session_id']
-        session_id = cookies['_session_id']
-
-        get '/call_reset_session'
-        assert_response :success
-        assert_not_equal [], headers['Set-Cookie']
-
-        get '/get_session_value'
-        assert_response :success
-        assert_equal 'foo: nil', response.body
-
-        get '/get_session_id'
-        assert_response :success
-        assert_not_equal session_id, response.body
-      end
-    end
-
-    def test_getting_session_id
-      with_test_route_set do
-        get '/set_session_value'
-        assert_response :success
-        assert cookies['_session_id']
-        session_id = cookies['_session_id']
-
-        get '/get_session_id'
-        assert_response :success
-        assert_equal session_id, response.body, "should be able to read session id without accessing the session hash"
-      end
-    end
-
-    def test_deserializes_unloaded_class
-      with_test_route_set do
-        with_autoload_path "session_autoload_test" do
-          get '/set_serialized_session_value'
-          assert_response :success
-          assert cookies['_session_id']
-        end
-        with_autoload_path "session_autoload_test" do
-          get '/get_session_id'
-          assert_response :success
-        end
-        with_autoload_path "session_autoload_test" do
-          get '/get_session_value'
-          assert_response :success
-          assert_equal 'foo: #<Foo bar:"baz">', response.body, "should auto-load unloaded class"
-        end
-      end
-    end
-
-    def test_doesnt_write_session_cookie_if_session_id_is_already_exists
-      with_test_route_set do
-        get '/set_session_value'
-        assert_response :success
-        assert cookies['_session_id']
-
-        get '/get_session_value'
-        assert_response :success
-        assert_equal nil, headers['Set-Cookie'], "should not resend the cookie again if session_id cookie is already exists"
-      end
-    end
-
-    def test_prevents_session_fixation
-      with_test_route_set do
-        get '/get_session_value'
-        assert_response :success
-        assert_equal 'foo: nil', response.body
-        session_id = cookies['_session_id']
-
-        reset!
-
-        get '/set_session_value', :_session_id => session_id
-        assert_response :success
-        assert_not_equal session_id, cookies['_session_id']
-      end
-    end
-
-    def test_expire_after
-      with_test_route_set(:expire_after => 1) do
-        get '/set_session_value'
-        assert_match /expires/, @response.headers['Set-Cookie']
-
-        sleep(1)
-
-        get '/get_session_value'
-        assert_equal 'foo: nil', response.body
-      end
-    end
-
-    def test_expires_in
-      with_test_route_set(:expires_in => 1) do
-        get '/set_session_value'
-        assert_no_match /expires/, @response.headers['Set-Cookie']
-
-        sleep(1)
-
-        get '/get_session_value'
-        assert_equal 'foo: nil', response.body
-      end
-    end
-  rescue LoadError, RuntimeError
-    $stderr.puts "Skipping SessionStore tests. Start memcached and try again: #{$!.message}"
-  end
-
-  private
-
-  def with_test_route_set(options = {})
-    options = {:key => '_session_id', :memcache_server => '127.0.0.1:11211'}.merge(options)
-    with_routing do |set|
-      set.draw do
-        match ':action', :to => ::TestSessionStore::TestController
-      end
-
-      @app = self.class.build_app(set) do |middleware|
-        middleware.use ActionDispatch::Session::DalliStore, options
-        middleware.delete "ActionDispatch::ShowExceptions"
-      end
-
-      yield
-    end
-  end
-end