mob-dalli 1.1.4

data/test/test_encoding.rb

@@ -0,0 +1,51 @@
+# 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
+
+    should 'allow non-ASCII keys when desired' do
+      memcached(19122,'',:nonascii => true) do |dc|
+        key = 'fooƒ'
+        assert dc.set(key, 'bar')
+        assert_equal 'bar', dc.get(key)
+      end
+    end
+
+  end
+end

data/test/test_failover.rb

@@ -0,0 +1,107 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,225 @@
+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