dalli 2.7.2 → 2.7.3

data/lib/dalli/socket.rb

@@ -13,17 +13,6 @@ begin
       IO.select(nil, [self], nil, options[:socket_timeout]) || raise(Timeout::Error, "IO timeout")
     end
 
-    def self.open(host, port, server, options = {})
-      addr = Socket.pack_sockaddr_in(port, host)
-      sock = start(addr)
-      sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
-      sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true) if options[:keepalive]
-      sock.options = options
-      sock.server = server
-      sock.kgio_wait_writable
-      sock
-    end
-
     alias :write :kgio_write
 
     def readfull(count)
@@ -50,7 +39,30 @@ begin
       end
       value
     end
+  end
+
+  class Dalli::Server::KSocket::TCP < Dalli::Server::KSocket
+    def self.open(host, port, server, options = {})
+      addr = Socket.pack_sockaddr_in(port, host)
+      sock = start(addr)
+      sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
+      sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true) if options[:keepalive]
+      sock.options = options
+      sock.server = server
+      sock.kgio_wait_writable
+      sock
+    end
+  end
 
+  class Dalli::Server::KSocket::UNIX < Dalli::Server::KSocket
+    def self.open(path, server, options = {})
+      addr = Socket.pack_sockaddr_un(path)
+      sock = start(addr)
+      sock.options = options
+      sock.server = server
+      sock.kgio_wait_writable
+      sock
+    end
   end
 
   if ::Kgio.respond_to?(:wait_readable=)
@@ -61,48 +73,70 @@ begin
 rescue LoadError
 
   puts "Using standard socket IO (#{RUBY_DESCRIPTION})" if defined?($TESTING) && $TESTING
-  class Dalli::Server::KSocket < TCPSocket
-    attr_accessor :options, :server
+  module Dalli::Server::KSocket
+    module InstanceMethods
+      def readfull(count)
+        value = ''
+        begin
+          loop do
+            value << read_nonblock(count - value.bytesize)
+            break if value.bytesize == count
+          end
+        rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+          if IO.select([self], nil, nil, options[:socket_timeout])
+            retry
+          else
+            raise Timeout::Error, "IO timeout: #{options.inspect}"
+          end
+        end
+        value
+      end
+
+      def read_available
+        value = ''
+        loop do
+          begin
+            value << read_nonblock(8196)
+          rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+            break
+          end
+        end
+        value
+      end
+    end
+
+    def self.included(receiver)
+      receiver.send(:attr_accessor, :options, :server)
+      receiver.send(:include, InstanceMethods)
+    end
+  end
+
+  class Dalli::Server::KSocket::TCP < TCPSocket
+    include Dalli::Server::KSocket
 
     def self.open(host, port, server, options = {})
       Timeout.timeout(options[:socket_timeout]) do
         sock = new(host, port)
         sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true)
         sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true) if options[:keepalive]
-        sock.options = { :host => host, :port => port }.merge(options)
+        sock.options = {:host => host, :port => port}.merge(options)
         sock.server = server
         sock
       end
     end
+  end
 
-    def readfull(count)
-      value = ''
-      begin
-        loop do
-          value << read_nonblock(count - value.bytesize)
-          break if value.bytesize == count
-        end
-      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
-        if IO.select([self], nil, nil, options[:socket_timeout])
-          retry
-        else
-          raise Timeout::Error, "IO timeout: #{options.inspect}"
-        end
-      end
-      value
-    end
+  class Dalli::Server::KSocket::UNIX < UNIXSocket
+    include Dalli::Server::KSocket
 
-    def read_available
-      value = ''
-      loop do
-        begin
-          value << read_nonblock(8196)
-        rescue Errno::EAGAIN, Errno::EWOULDBLOCK
-          break
-        end
+    def self.open(path, server, options = {})
+      Timeout.timeout(options[:socket_timeout]) do
+        sock = new(path)
+        sock.options = {:path => path}.merge(options)
+        sock.server = server
+        sock
       end
-      value
     end
-
   end
+
 end

data/lib/dalli/version.rb

@@ -1,3 +1,3 @@
 module Dalli
-  VERSION = '2.7.2'
+  VERSION = '2.7.3'
 end

data/test/benchmark_test.rb

@@ -10,7 +10,8 @@ describe 'performance' do
     @value = []
     @marshalled = Marshal.dump(@value)
 
-    @servers = ['127.0.0.1:19122', 'localhost:19122']
+    @port = 23417
+    @servers = ["127.0.0.1:#{@port}", "localhost:#{@port}"]
     @key1 = "Short"
     @key2 = "Sym1-2-3::45"*8
     @key3 = "Long"*40
@@ -22,7 +23,7 @@ describe 'performance' do
   end
 
   it 'runs benchmarks' do
-    memcached do
+    memcached(@port) do
 
       Benchmark.bm(37) do |x|
 

data/test/helper.rb

@@ -2,12 +2,13 @@ $TESTING = true
 require 'rubygems'
 # require 'simplecov'
 # SimpleCov.start
-require 'minitest/pride'
+require 'minitest/pride' unless RUBY_ENGINE == 'rbx'
 require 'minitest/autorun'
 require 'mocha/setup'
 require 'memcached_mock'
 
-ENV['MEMCACHED_SASL_PWDB'] = "#{File.dirname(__FILE__)}/sasldb"
+ENV['MEMCACHED_SASL_PWDB'] = "#{File.dirname(__FILE__)}/sasl/sasldb"
+ENV['SASL_CONF_PATH'] = "#{File.dirname(__FILE__)}/sasl/memcached.conf"
 
 WANT_RAILS_VERSION = ENV['RAILS_VERSION'] || '>= 3.0.0'
 gem 'rails', WANT_RAILS_VERSION

data/test/memcached_mock.rb

@@ -1,18 +1,31 @@
 require "socket"
+require "tempfile"
 
 $started = {}
 
 module MemcachedMock
-  def self.start(port=19123, &block)
+  UNIX_SOCKET_PATH = (f = Tempfile.new('dalli_test'); f.close; f.path)
+
+  def self.start(port=19123)
     server = TCPServer.new("localhost", port)
     session = server.accept
-    block.call session
+    yield(session)
+  end
+
+  def self.start_unix(path=UNIX_SOCKET_PATH)
+    begin
+      File.delete(path)
+    rescue Errno::ENOENT
+    end
+    server = UNIXServer.new(path)
+    session = server.accept
+    yield(session)
   end
 
-  def self.delayed_start(port=19123, wait=1, &block)
+  def self.delayed_start(port=19123, wait=1)
     server = TCPServer.new("localhost", port)
     sleep wait
-    block.call server
+    yield(server)
   end
 
   module Helper
@@ -23,13 +36,13 @@ module MemcachedMock
     #       assert_equal "PONG", Dalli::Client.new('localhost:22122').get('abc')
     #     end
     #
-    def memcached_mock(proc, meth = :start)
+    def memcached_mock(proc, meth=:start, meth_args=[])
       return unless supports_fork?
       begin
         pid = fork do
           trap("TERM") { exit }
 
-          MemcachedMock.send(meth) do |*args|
+          MemcachedMock.send(meth, *meth_args) do |*args|
             proc.call(*args)
           end
         end
@@ -65,24 +78,89 @@ module MemcachedMock
       raise Errno::ENOENT, "Unable to find memcached 1.4+ locally"
     end
 
-    def memcached(port=19122, args='', options={})
-      memcached_server(port, args)
-      yield Dalli::Client.new(["localhost:#{port}", "127.0.0.1:#{port}"], options)
+    def memcached_persistent(port=21345)
+      dc = start_and_flush_with_retry(port, '', {})
+      yield dc, port if block_given?
     end
 
-    def memcached_cas(port=19122, args='', options={})
-      memcached_server(port, args)
+    def sasl_credentials
+      { :username => 'testuser', :password => 'testtest' }
+    end
+
+    def sasl_env
+      {
+        'MEMCACHED_SASL_PWDB' => "#{File.dirname(__FILE__)}/sasl/sasldb",
+        'SASL_CONF_PATH' => "#{File.dirname(__FILE__)}/sasl/memcached.conf"
+      }
+    end
+
+    def memcached_sasl_persistent(port=21397)
+      dc = start_and_flush_with_retry(port, '-S', sasl_credentials)
+      yield dc, port if block_given?
+    end
+
+    def memcached_cas_persistent(port = 25662)
       require 'dalli/cas/client'
-      yield Dalli::Client.new(["localhost:#{port}", "127.0.0.1:#{port}"], options)
+      dc = start_and_flush_with_retry(port)
+      yield dc, port if block_given?
+    end
+
+
+    def memcached_low_mem_persistent(port = 19128)
+      dc = start_and_flush_with_retry(port, '-m 1 -M')
+      yield dc, port if block_given?
+    end
+
+    def start_and_flush_with_retry(port, args = '', client_options = {})
+      dc = nil
+      retry_count = 0
+      while dc.nil? do
+        begin
+          dc = start_and_flush(port, args, client_options, (retry_count == 0))
+        rescue StandardError => e
+          $started[port] = nil
+          retry_count += 1
+          raise e if retry_count >= 3
+        end
+      end
+      dc
     end
 
-    def memcached_server(port=19122, args='')
+    def start_and_flush(port, args = '', client_options = {}, flush = true)
+      memcached_server(port, args)
+      if "#{port}" =~ /\A\//
+        # unix socket
+        dc = Dalli::Client.new(port, client_options)
+      else
+        dc = Dalli::Client.new(["localhost:#{port}", "127.0.0.1:#{port}"], client_options)
+      end
+      dc.flush_all if flush
+      dc
+    end
+
+    def memcached(port, args='', client_options={})
+      dc = start_and_flush_with_retry(port, args, client_options)
+      yield dc, port if block_given?
+      memcached_kill(port)
+    end
+
+    def memcached_server(port, args='')
       Memcached.path ||= find_memcached
+      if "#{port}" =~ /\A\//
+        # unix socket
+        port_socket_arg = '-s'
+        begin
+          File.delete(port)
+        rescue Errno::ENOENT
+        end
+      else
+        port_socket_arg = '-p'
+        port = port.to_i
+      end
 
-      cmd = "#{Memcached.path}memcached #{args} -p #{port}"
+      cmd = "#{Memcached.path}memcached #{args} #{port_socket_arg} #{port}"
 
       $started[port] ||= begin
-        #puts "Starting: #{cmd}..."
         pid = IO.popen(cmd).pid
         at_exit do
           begin
@@ -91,7 +169,8 @@ module MemcachedMock
           rescue Errno::ECHILD, Errno::ESRCH
           end
         end
-        sleep 0.1
+        wait_time = (args && args =~ /\-S/) ? 0.1 : 0.1
+        sleep wait_time
         pid
       end
     end
@@ -106,7 +185,8 @@ module MemcachedMock
         begin
           Process.kill("TERM", pid)
           Process.wait(pid)
-        rescue Errno::ECHILD, Errno::ESRCH
+        rescue Errno::ECHILD, Errno::ESRCH => e
+          puts e.inspect
         end
       end
     end

data/test/sasl/memcached.conf

@@ -0,0 +1 @@
+mech_list: plain

data/test/test_active_support.rb

@@ -9,40 +9,48 @@ class MockUser
 end
 
 describe 'ActiveSupport' do
+  before do
+    @port = 19987
+  end
+
   describe 'active_support caching' do
 
     it 'has accessible options' do
-      @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:19122', :expires_in => 5.minutes, :frob => 'baz')
+      @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, "localhost:#{@port}", :expires_in => 5.minutes, :frob => 'baz')
       assert_equal 'baz', @dalli.options[:frob]
     end
 
     it 'allow mute and silence' do
-      @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:19122')
-      @dalli.mute do
-        assert op_addset_succeeds(@dalli.write('foo', 'bar', nil))
-        assert_equal 'bar', @dalli.read('foo', nil)
+      memcached_persistent(@port) do
+        @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, "localhost:#{@port}")
+        @dalli.mute do
+          assert op_addset_succeeds(@dalli.write('foo', 'bar', nil))
+          assert_equal 'bar', @dalli.read('foo', nil)
+        end
+        refute @dalli.silence?
+        @dalli.silence!
+        assert_equal true, @dalli.silence?
       end
-      refute @dalli.silence?
-      @dalli.silence!
-      assert_equal true, @dalli.silence?
     end
 
     it 'handle nil options' do
-      @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:19122')
-      assert op_addset_succeeds(@dalli.write('foo', 'bar', nil))
-      assert_equal 'bar', @dalli.read('foo', nil)
-      assert_equal 18, @dalli.fetch('lkjsadlfk', nil) { 18 }
-      assert_equal 18, @dalli.fetch('lkjsadlfk', nil) { 18 }
-      assert_equal 1, @dalli.increment('lkjsa', 1, nil)
-      assert_equal 2, @dalli.increment('lkjsa', 1, nil)
-      assert_equal 1, @dalli.decrement('lkjsa', 1, nil)
-      assert_equal true, @dalli.delete('lkjsa')
+      memcached_persistent(@port) do
+        @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, "localhost:#{@port}")
+        assert op_addset_succeeds(@dalli.write('foo', 'bar', nil))
+        assert_equal 'bar', @dalli.read('foo', nil)
+        assert_equal 18, @dalli.fetch('lkjsadlfk', nil) { 18 }
+        assert_equal 18, @dalli.fetch('lkjsadlfk', nil) { 18 }
+        assert_equal 1, @dalli.increment('lkjsa', 1, nil)
+        assert_equal 2, @dalli.increment('lkjsa', 1, nil)
+        assert_equal 1, @dalli.decrement('lkjsa', 1, nil)
+        assert_equal true, @dalli.delete('lkjsa')
+      end
     end
 
     it 'support fetch' do
       with_activesupport do
-        memcached do
-          connect
+        memcached_persistent(@port) do
+          connect(@port)
           dvalue = @dalli.fetch('someotherkeywithoutspaces', :expires_in => 1.second) { 123 }
           assert_equal 123, dvalue
 
@@ -68,8 +76,8 @@ describe 'ActiveSupport' do
 
     it 'support keys with spaces on Rails3' do
       with_activesupport do
-        memcached do
-          connect
+        memcached_persistent(@port) do
+          connect(@port)
           dvalue = @dalli.fetch('some key with spaces', :expires_in => 1.second) { 123 }
           assert_equal 123, dvalue
         end
@@ -78,8 +86,8 @@ describe 'ActiveSupport' do
 
     it 'support read_multi' do
       with_activesupport do
-        memcached do
-          connect
+        memcached_persistent(@port) do
+          connect(@port)
           x = rand_key
           y = rand_key
           assert_equal({}, @dalli.read_multi(x, y))
@@ -92,8 +100,8 @@ describe 'ActiveSupport' do
 
     it 'support read_multi with an array' do
       with_activesupport do
-        memcached do
-          connect
+        memcached_persistent(@port) do
+          connect(@port)
           x = rand_key
           y = rand_key
           assert_equal({}, @dalli.read_multi([x, y]))
@@ -106,10 +114,19 @@ describe 'ActiveSupport' do
       end
     end
 
+    it 'support read_multi with an empty array' do
+      with_activesupport do
+        memcached_persistent(@port) do
+          connect(@port)
+          assert_equal({}, @dalli.read_multi([]))
+        end
+      end
+    end
+
     it 'support raw read_multi' do
       with_activesupport do
-        memcached do
-          connect
+        memcached_persistent(@port) do
+          connect(@port)
           @dalli.write("abc", 5, :raw => true)
           @dalli.write("cba", 5, :raw => true)
           assert_equal({'abc' => '5', 'cba' => '5' }, @dalli.read_multi("abc", "cba"))
@@ -119,8 +136,8 @@ describe 'ActiveSupport' do
 
     it 'support read_multi with LocalCache' do
       with_activesupport do
-        memcached do
-          connect
+        memcached_persistent(@port) do
+          connect(@port)
           x = rand_key
           y = rand_key
           assert_equal({}, @dalli.read_multi(x, y))
@@ -150,8 +167,8 @@ describe 'ActiveSupport' do
 
     it 'supports fetch_multi' do
       with_activesupport do
-        memcached do
-          connect
+        memcached_persistent(@port) do
+          connect(@port)
 
           x = rand_key.to_s
           y = rand_key
@@ -170,8 +187,8 @@ describe 'ActiveSupport' do
 
     it 'support read, write and delete' do
       with_activesupport do
-        memcached do
-          connect
+        memcached_persistent(@port) do
+          connect(@port)
           y = rand_key
           assert_nil @dalli.read(y)
           dres = @dalli.write(y, 123)
@@ -193,6 +210,11 @@ describe 'ActiveSupport' do
           dres = @dalli.delete(user)
           assert_equal true, dres
 
+          dres = @dalli.write(:false_value, false)
+          assert op_addset_succeeds(dres)
+          dres = @dalli.read(:false_value)
+          assert_equal false, dres
+
           bigkey = '１２３４５６７８９０１２３４５６７８９０１２３４５６７８９０'
           @dalli.write(bigkey, 'double width')
           assert_equal 'double width', @dalli.read(bigkey)
@@ -201,10 +223,55 @@ describe 'ActiveSupport' do
       end
     end
 
+    it 'support read, write and delete with local namespace' do
+      with_activesupport do
+        memcached_persistent(@port) do
+          connect(@port, '')
+          key = 'key_with_namespace'
+          namespace_value = @dalli.fetch(key, :namespace => 'namespace') { 123 }
+          assert_equal 123, namespace_value
+
+          res = @dalli.read(key, :namespace => 'namespace')
+          assert_equal 123, res
+
+          res = @dalli.delete(key, :namespace => 'namespace')
+          assert_equal true, res
+
+          res = @dalli.write(key, "foo", :namespace => 'namespace')
+          assert op_addset_succeeds(res)
+
+          res = @dalli.read(key, :namespace => 'namespace')
+          assert_equal "foo", res
+        end
+      end
+    end
+
+    it 'support multi_read and multi_fetch with local namespace' do
+      with_activesupport do
+        memcached_persistent(@port) do
+          connect(@port, '')
+          x         = rand_key.to_s
+          y         = rand_key
+          namespace = 'namespace'
+          hash      = { x => 'ABC', y => 'DEF' }
+
+          results = @dalli.fetch_multi(x, y, :namespace => namespace) { |key| hash[key] }
+
+          assert_equal({ x => 'ABC', y => 'DEF' }, results)
+          assert_equal('ABC', @dalli.read(x, :namespace => namespace))
+          assert_equal('DEF', @dalli.read(y, :namespace => namespace))
+
+          @dalli.write("abc", 5, :namespace => 'namespace')
+          @dalli.write("cba", 5, :namespace => 'namespace')
+          assert_equal({'abc' => 5, 'cba' => 5 }, @dalli.read_multi("abc", "cba", :namespace => 'namespace'))
+        end
+      end
+    end
+
     it 'support read, write and delete with LocalCache' do
       with_activesupport do
-        memcached do
-          connect
+        memcached_persistent(@port) do
+          connect(@port)
           y = rand_key.to_s
           @dalli.with_local_cache do
             Dalli::Client.any_instance.expects(:get).with(y, {}).once.returns(123)
@@ -231,8 +298,8 @@ describe 'ActiveSupport' do
 
     it 'support unless_exist with LocalCache' do
       with_activesupport do
-        memcached do
-          connect
+        memcached_persistent(@port) do
+          connect(@port)
           y = rand_key.to_s
           @dalli.with_local_cache do
             Dalli::Client.any_instance.expects(:add).with(y, 123, nil, {:unless_exist => true}).once.returns(true)
@@ -255,8 +322,8 @@ describe 'ActiveSupport' do
 
     it 'support increment/decrement commands' do
       with_activesupport do
-        memcached do
-          connect
+        memcached_persistent(@port) do
+          connect(@port)
           assert op_addset_succeeds(@dalli.write('counter', 0, :raw => true))
           assert_equal 1, @dalli.increment('counter')
           assert_equal 2, @dalli.increment('counter')
@@ -293,8 +360,8 @@ describe 'ActiveSupport' do
 
     it 'support exist command' do
       with_activesupport do
-        memcached do
-          connect
+        memcached_persistent(@port) do
+          connect(@port)
           @dalli.write(:foo, 'a')
           @dalli.write(:false_value, false)
 
@@ -312,8 +379,8 @@ describe 'ActiveSupport' do
 
     it 'support other esoteric commands' do
       with_activesupport do
-        memcached do
-          connect
+        memcached_persistent(@port) do
+          connect(@port)
           ds = @dalli.stats
           assert_equal 1, ds.keys.size
           assert ds[ds.keys.first].keys.size > 0
@@ -325,16 +392,17 @@ describe 'ActiveSupport' do
 
     it 'respect "raise_errors" option' do
       with_activesupport do
-        memcached(29125) do
-          @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:29125')
+        new_port = 29333
+        memcached_persistent(new_port) do
+          @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, "localhost:#{new_port}")
           @dalli.write 'foo', 'bar'
           assert_equal @dalli.read('foo'), 'bar'
 
-          memcached_kill(29125)
+          memcached_kill(new_port)
 
           assert_equal @dalli.read('foo'), nil
 
-          @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:29125', :raise_errors => true)
+          @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, "localhost:#{new_port}", :raise_errors => true)
 
           exception = [Dalli::RingError, { :message => "No server available" }]
 
@@ -351,12 +419,46 @@ describe 'ActiveSupport' do
         end
       end
     end
+
+    describe 'instruments' do
+      it 'payload hits' do
+        with_activesupport do
+          memcached_persistent(@port) do
+            connect(@port)
+
+            payload = {}
+            dres = @dalli.write('false', false)
+            assert op_addset_succeeds(dres)
+            foo = @dalli.fetch('burrito') do 'tacos' end
+            assert 'tacos', foo
+
+            # NOTE: mocha stubbing for yields
+            #       makes the result of the block nil in all cases
+            #       there was a ticket about this:
+            #       http://floehopper.lighthouseapp.com/projects/22289/tickets/14-8687-blocks-return-value-is-dropped-on-stubbed-yielding-methods
+            @dalli.stubs(:instrument).yields payload
+
+            @dalli.read('false')
+            assert_equal true, payload.delete(:hit)
+
+
+            foo = @dalli.fetch('unset_key') do 'tacos' end
+            assert_equal false, payload.delete(:hit)
+
+            @dalli.fetch('burrito') do 'tacos' end
+            assert_equal true, payload.delete(:hit)
+
+            @dalli.unstub(:instrument)
+          end
+        end
+      end
+    end
   end
 
   it 'handle crazy characters from far-away lands' do
     with_activesupport do
-      memcached do
-        connect
+      memcached_persistent(@port) do
+        connect(@port)
         key = "fooƒ"
         value = 'bafƒ'
         assert op_addset_succeeds(@dalli.write(key, value))
@@ -367,18 +469,18 @@ describe 'ActiveSupport' do
 
   it 'normalize options as expected' do
     with_activesupport do
-      memcached do
-        @dalli = ActiveSupport::Cache::DalliStore.new('localhost:19122', :expires_in => 1, :namespace => 'foo', :compress => true)
+      memcached_persistent(@port) do
+        @dalli = ActiveSupport::Cache::DalliStore.new("localhost:#{@port}", :expires_in => 1, :namespace => 'foo', :compress => true)
         assert_equal 1, @dalli.instance_variable_get(:@data).instance_variable_get(:@options)[:expires_in]
         assert_equal 'foo', @dalli.instance_variable_get(:@data).instance_variable_get(:@options)[:namespace]
-        assert_equal ["localhost:19122"], @dalli.instance_variable_get(:@data).instance_variable_get(:@servers)
+        assert_equal ["localhost:#{@port}"], @dalli.instance_variable_get(:@data).instance_variable_get(:@servers)
       end
     end
   end
 
   it 'handles nil server with additional options' do
     with_activesupport do
-      memcached do
+      memcached_persistent(@port) do
         @dalli = ActiveSupport::Cache::DalliStore.new(nil, :expires_in => 1, :namespace => 'foo', :compress => true)
         assert_equal 1, @dalli.instance_variable_get(:@data).instance_variable_get(:@options)[:expires_in]
         assert_equal 'foo', @dalli.instance_variable_get(:@data).instance_variable_get(:@options)[:namespace]
@@ -389,8 +491,8 @@ describe 'ActiveSupport' do
 
   it 'supports connection pooling' do
     with_activesupport do
-      memcached do
-        @dalli = ActiveSupport::Cache::DalliStore.new('localhost:19122', :expires_in => 1, :namespace => 'foo', :compress => true, :pool_size => 3)
+      memcached_persistent(@port) do
+        @dalli = ActiveSupport::Cache::DalliStore.new("localhost:#{@port}", :expires_in => 1, :namespace => 'foo', :compress => true, :pool_size => 3)
         assert_equal nil, @dalli.read('foo')
         assert @dalli.write('foo', 1)
         assert_equal 1, @dalli.fetch('foo') { raise 'boom' }
@@ -406,8 +508,8 @@ describe 'ActiveSupport' do
 
   it 'allow keys to be frozen' do
     with_activesupport do
-      memcached do
-        connect
+      memcached_persistent(@port) do
+        connect(@port)
         key = "foo"
         key.freeze
         assert op_addset_succeeds(@dalli.write(key, "value"))
@@ -417,8 +519,8 @@ describe 'ActiveSupport' do
 
   it 'allow keys from a hash' do
     with_activesupport do
-      memcached do
-        connect
+      memcached_persistent(@port) do
+        connect(@port)
         map = { "one" => "one", "two" => "two" }
         map.each_pair do |k, v|
           assert op_addset_succeeds(@dalli.write(k, v))
@@ -428,8 +530,8 @@ describe 'ActiveSupport' do
     end
   end
 
-  def connect
-    @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:19122', :expires_in => 10.seconds, :namespace => lambda{33.to_s(36)})
+  def connect(port = 19122, namespace = lambda{33.to_s(36)})
+    @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, "localhost:#{port}", :expires_in => 10.seconds, :namespace => namespace)
     @dalli.clear
   end