dalli 0.9.0 → 0.9.1

data/test/helper.rb

@@ -1,10 +1,18 @@
 require 'rubygems'
+
+# require 'simplecov-html'
+# SimpleCov.start
+
 require 'test/unit'
 require 'shoulda'
+require 'memcached_mock'
+require 'mocha'
 
 require 'dalli'
 
 class Test::Unit::TestCase
+  include MemcachedMock::Helper
+
   def assert_error(error, regexp=nil, &block)
     ex = assert_raise(error, &block)
     assert_match(regexp, ex.message, "#{ex.class.name}: #{ex.message}\n#{ex.backtrace.join("\n\t")}")

data/test/memcached_mock.rb

@@ -1,16 +1,15 @@
 require "socket"
 
 module MemcachedMock
-  def self.start(port=22122, &block)
+  def self.start(port=19123, &block)
     server = TCPServer.new("localhost", port)
     session = server.accept
     block.call session
   end
 
-  def self.delayed_start(port=22122, wait=1, &block)
+  def self.delayed_start(port=19123, wait=1, &block)
     server = TCPServer.new("localhost", port)
     sleep wait
-#    session = server.accept
     block.call server
   end
 
@@ -41,5 +40,52 @@ module MemcachedMock
         end
       end
     end
+
+    PATHS = %w(
+      /usr/local/bin/
+      /opt/local/bin/
+      /usr/bin/
+    )
+
+    def find_memcached
+      output = `memcached -h | head -1`.strip
+      if output && output =~ /^memcached (\d.\d.\d+)/ && $1 > '1.4'
+        return (puts "Found #{output} in PATH"; '')
+      end
+      PATHS.each do |path|
+        output = `memcached -h | head -1`.strip
+        if output && output =~ /^memcached (\d\.\d\.\d+)/ && $1 > '1.4'
+          return (puts "Found #{output} in #{path}"; path)
+        end
+      end
+
+      raise Errno::ENOENT, "Unable to find memcached 1.4+ locally"
+      nil
+    end
+
+    def memcached(port=19122, args='')
+      Memcached.path ||= find_memcached
+      cmd = "#{Memcached.path}memcached #{args} -p #{port}"
+#      puts "Starting: #{cmd}..."
+      pid = IO.popen(cmd).pid
+      begin
+        sleep 0.3
+        yield Dalli::Client.new(["localhost:#{port}", "127.0.0.1:#{port}"])
+      ensure
+        begin
+          Process.kill("TERM", pid)
+          Process.wait(pid)
+        rescue Errno::ECHILD
+          # the memcached_mock forks will try to run this at_exit block also
+          # but since they are not the parent process, will get an ECHILD error.
+        end
+      end
+    end
+  end
+end
+
+module Memcached
+  class << self
+    attr_accessor :path
   end
 end

data/test/test_active_support.rb

@@ -4,70 +4,83 @@ require 'active_support/cache/dalli_store'
 
 class TestDalli < Test::Unit::TestCase
   context 'activesupport caching' do
-    setup do
-      @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:11211', :expires_in => 10.seconds)
-      @mc = ActiveSupport::Cache.lookup_store(:mem_cache_store, 'localhost:11211', :expires_in => 10.seconds, :namespace => 'a')
-      @dalli.clear
-    end
 
     should 'support fetch' do
-      dvalue = @mc.fetch('some key with spaces', :expires_in => 1.second) { 123 }
-      mvalue = @dalli.fetch('some other key with spaces', :expires_in => 1.second) { 123 }
-      assert_equal mvalue, dvalue
+      memcached do
+        connect
+        dvalue = @mc.fetch('some key with spaces', :expires_in => 1.second) { 123 }
+        mvalue = @dalli.fetch('some other key with spaces', :expires_in => 1.second) { 123 }
+        assert_equal mvalue, dvalue
 
-      o = Object.new
-      o.instance_variable_set :@foo, 'bar'
-      dvalue = @mc.fetch(rand_key, :raw => true) { o }
-      mvalue = @dalli.fetch(rand_key, :raw => true) { o }
-      assert_equal mvalue, dvalue
-      assert_equal o, dvalue
+        o = Object.new
+        o.instance_variable_set :@foo, 'bar'
+        dvalue = @mc.fetch(rand_key, :raw => true) { o }
+        mvalue = @dalli.fetch(rand_key, :raw => true) { o }
+        assert_equal mvalue, dvalue
+        assert_equal o, dvalue
 
-      dvalue = @mc.fetch(rand_key) { o }
-      mvalue = @dalli.fetch(rand_key) { o }
-      assert_equal mvalue, dvalue
-      assert_equal o, dvalue
+        dvalue = @mc.fetch(rand_key) { o }
+        mvalue = @dalli.fetch(rand_key) { o }
+        assert_equal mvalue, dvalue
+        assert_equal o, dvalue
+      end
     end
 
     should 'support read_multi' do
-      x = rand_key
-      y = rand_key
-      assert_equal({}, @mc.read_multi(x, y))
-      assert_equal({}, @dalli.read_multi(x, y))
-      @dalli.write(x, '123')
-      @dalli.write(y, 123)
-      @mc.write(x, '123')
-      @mc.write(y, 123)
-      assert_equal({ x => '123', y => 123 }, @dalli.read_multi(x, y))
-      assert_equal({ x => '123', y => 123 }, @mc.read_multi(x, y))
+      memcached do
+        connect
+        x = rand_key
+        y = rand_key
+        assert_equal({}, @mc.read_multi(x, y))
+        assert_equal({}, @dalli.read_multi(x, y))
+        @dalli.write(x, '123')
+        @dalli.write(y, 123)
+        @mc.write(x, '123')
+        @mc.write(y, 123)
+        assert_equal({ x => '123', y => 123 }, @dalli.read_multi(x, y))
+        assert_equal({ x => '123', y => 123 }, @mc.read_multi(x, y))
+      end
     end
 
     should 'support read, write and delete' do
-      x = rand_key
-      y = rand_key
-      assert_nil @mc.read(x)
-      assert_nil @dalli.read(y)
-      mres = @mc.write(x, 123)
-      dres = @dalli.write(y, 123)
-      assert_equal mres, dres
+      memcached do
+        connect
+        x = rand_key
+        y = rand_key
+        assert_nil @mc.read(x)
+        assert_nil @dalli.read(y)
+        mres = @mc.write(x, 123)
+        dres = @dalli.write(y, 123)
+        assert_equal mres, dres
 
-      mres = @mc.read(x)
-      dres = @dalli.read(y)
-      assert_equal mres, dres
-      assert_equal 123, dres
+        mres = @mc.read(x)
+        dres = @dalli.read(y)
+        assert_equal mres, dres
+        assert_equal 123, dres
       
-      mres = @mc.delete(x)
-      dres = @dalli.delete(y)
-      assert_equal mres, dres
-      assert_equal true, dres
+        mres = @mc.delete(x)
+        dres = @dalli.delete(y)
+        assert_equal mres, dres
+        assert_equal true, dres
+      end
     end
     
     should 'support other esoteric commands' do
-      ms = @mc.stats
-      ds = @dalli.stats
-      assert_equal ms.keys.sort, ds.keys.sort
-      assert_equal ms[ms.keys.first].keys.sort, ds[ds.keys.first].keys.sort
+      memcached do
+        connect
+        ms = @mc.stats
+        ds = @dalli.stats
+        assert_equal ms.keys.sort, ds.keys.sort
+        assert_equal ms[ms.keys.first].keys.sort, ds[ds.keys.first].keys.sort
+      end
     end
   end
+  
+  def connect
+    @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:19122', :expires_in => 10.seconds)
+    @mc = ActiveSupport::Cache.lookup_store(:mem_cache_store, 'localhost:19122', :expires_in => 10.seconds, :namespace => 'a')
+    @dalli.clear
+  end
 
   def rand_key
     rand(1_000_000_000)

data/test/test_benchmark.rb

@@ -10,7 +10,7 @@ class TestBenchmark < Test::Unit::TestCase
     @value = []
     @marshalled = Marshal.dump(@value)
 
-    @servers = ['127.0.0.1:11211', 'localhost:11211']
+    @servers = ['127.0.0.1:19122', 'localhost:19122']
     @key1 = "Short"
     @key2 = "Sym1-2-3::45"*8
     @key3 = "Long"*40
@@ -21,97 +21,100 @@ class TestBenchmark < Test::Unit::TestCase
   end
   
   def test_benchmark
-    Benchmark.bm(31) do |x|
+    memcached do
+    
+      Benchmark.bm(31) do |x|
 
-      n = 2500
+        n = 2500
 
-      @m = Dalli::Client.new(@servers, :marshal => false)
-      x.report("set:plain:dalli") do
-        n.times do
-          @m.set @key1, @marshalled
-          @m.set @key2, @marshalled
-          @m.set @key3, @marshalled
-          @m.set @key1, @marshalled
-          @m.set @key2, @marshalled
-          @m.set @key3, @marshalled
+        @m = Dalli::Client.new(@servers, :marshal => false)
+        x.report("set:plain:dalli") do
+          n.times do
+            @m.set @key1, @marshalled
+            @m.set @key2, @marshalled
+            @m.set @key3, @marshalled
+            @m.set @key1, @marshalled
+            @m.set @key2, @marshalled
+            @m.set @key3, @marshalled
+          end
         end
-      end
 
-      @m = Dalli::Client.new(@servers)
-      x.report("set:ruby:dalli") do
-        n.times do
-          @m.set @key1, @value
-          @m.set @key2, @value
-          @m.set @key3, @value
-          @m.set @key1, @value
-          @m.set @key2, @value
-          @m.set @key3, @value
+        @m = Dalli::Client.new(@servers)
+        x.report("set:ruby:dalli") do
+          n.times do
+            @m.set @key1, @value
+            @m.set @key2, @value
+            @m.set @key3, @value
+            @m.set @key1, @value
+            @m.set @key2, @value
+            @m.set @key3, @value
+          end
         end
-      end
 
-      @m = Dalli::Client.new(@servers, :marshal => false)
-      x.report("get:plain:dalli") do
-        n.times do
-          @m.get @key1
-          @m.get @key2
-          @m.get @key3
-          @m.get @key1
-          @m.get @key2
-          @m.get @key3
+        @m = Dalli::Client.new(@servers, :marshal => false)
+        x.report("get:plain:dalli") do
+          n.times do
+            @m.get @key1
+            @m.get @key2
+            @m.get @key3
+            @m.get @key1
+            @m.get @key2
+            @m.get @key3
+          end
         end
-      end
 
-      @m = Dalli::Client.new(@servers)
-      x.report("get:ruby:dalli") do
-        n.times do
-          @m.get @key1
-          @m.get @key2
-          @m.get @key3
-          @m.get @key1
-          @m.get @key2
-          @m.get @key3
+        @m = Dalli::Client.new(@servers)
+        x.report("get:ruby:dalli") do
+          n.times do
+            @m.get @key1
+            @m.get @key2
+            @m.get @key3
+            @m.get @key1
+            @m.get @key2
+            @m.get @key3
+          end
         end
-      end
 
-      @m = Dalli::Client.new(@servers)
-      x.report("multiget:ruby:dalli") do
-        n.times do
-          # We don't use the keys array because splat is slow
-          @m.get_multi @key1, @key2, @key3, @key4, @key5, @key6
+        @m = Dalli::Client.new(@servers)
+        x.report("multiget:ruby:dalli") do
+          n.times do
+            # We don't use the keys array because splat is slow
+            @m.get_multi @key1, @key2, @key3, @key4, @key5, @key6
+          end
         end
-      end
 
-      @m = Dalli::Client.new(@servers)
-      x.report("missing:ruby:dalli") do
-        n.times do
-          begin @m.delete @key1; rescue; end
-          begin @m.get @key1; rescue; end
-          begin @m.delete @key2; rescue; end
-          begin @m.get @key2; rescue; end
-          begin @m.delete @key3; rescue; end
-          begin @m.get @key3; rescue; end
+        @m = Dalli::Client.new(@servers)
+        x.report("missing:ruby:dalli") do
+          n.times do
+            begin @m.delete @key1; rescue; end
+            begin @m.get @key1; rescue; end
+            begin @m.delete @key2; rescue; end
+            begin @m.get @key2; rescue; end
+            begin @m.delete @key3; rescue; end
+            begin @m.get @key3; rescue; end
+          end
         end
-      end
 
-      @m = Dalli::Client.new(@servers)
-      x.report("mixed:ruby:dalli") do
-        n.times do
-          @m.set @key1, @value
-          @m.set @key2, @value
-          @m.set @key3, @value
-          @m.get @key1
-          @m.get @key2
-          @m.get @key3
-          @m.set @key1, @value
-          @m.get @key1
-          @m.set @key2, @value
-          @m.get @key2
-          @m.set @key3, @value
-          @m.get @key3
+        @m = Dalli::Client.new(@servers)
+        x.report("mixed:ruby:dalli") do
+          n.times do
+            @m.set @key1, @value
+            @m.set @key2, @value
+            @m.set @key3, @value
+            @m.get @key1
+            @m.get @key2
+            @m.get @key3
+            @m.set @key1, @value
+            @m.get @key1
+            @m.set @key2, @value
+            @m.get @key2
+            @m.set @key3, @value
+            @m.get @key3
+          end
         end
-      end
 
-      assert true
+        assert true
+      end
     end
 
   end

data/test/test_dalli.rb

@@ -1,97 +1,258 @@
 require 'helper'
+require 'memcached_mock'
 
 class TestDalli < Test::Unit::TestCase
   context 'using a live server' do
-    setup do
-      begin
-        TCPSocket.new('localhost', 11211)
-      rescue => ex
-        $skip = true
-        puts "Skipping live test as memcached is not running at localhost:11211.  Start it with 'memcached -d'"
-      end
-    end
 
     should "support huge get/set" do
-      return if $skip
-      dc = Dalli::Client.new('localhost:11211')
-      dc.flush
+      memcached do |dc|
+        dc.flush
 
-      val1 = "1234567890"*105000
-      assert_error Dalli::DalliError, /too large/ do
+        val1 = "1234567890"*105000
+        assert_error Dalli::DalliError, /too large/ do
+          dc.set('a', val1)
+          val2 = dc.get('a')
+          assert_equal val1, val2
+        end
+
+        val1 = "1234567890"*100000
         dc.set('a', val1)
         val2 = dc.get('a')
         assert_equal val1, val2
       end
+    end
+
+    should "support the fetch operation" do
+      memcached do |dc|
+        dc.flush
+
+        expected = { 'blah' => 'blerg!' }
+        executed = false
+        value = dc.fetch('fetch_key') do
+          executed = true
+          expected
+        end
+        assert_equal expected, value
+        assert_equal true, executed
+
+        executed = false
+        value = dc.fetch('fetch_key') do
+          executed = true
+          expected
+        end
+        assert_equal expected, value
+        assert_equal false, executed
+      end
+    end
+
+    should "support the cas operation" do
+      memcached do |dc|
+        dc.flush
+
+        expected = { 'blah' => 'blerg!' }
 
-      val1 = "1234567890"*100000
-      dc.set('a', val1)
-      val2 = dc.get('a')
-      assert_equal val1, val2
+        resp = dc.cas('cas_key') do |value|
+          fail('Value should not exist')
+        end
+        assert_nil resp
+
+        mutated = { 'blah' => 'foo!' }
+        dc.set('cas_key', expected)
+        resp = dc.cas('cas_key') do |value|
+          assert_equal expected, value
+          mutated
+        end
+        assert_equal true, resp
+        
+        resp = dc.get('cas_key')
+        assert_equal mutated, resp
+        
+        # TODO Need to verify failure when value is mutated between get and add.
+      end
     end
 
     should "support multi-get" do
-      return if $skip
-      dc = Dalli::Client.new(['localhost:11211', '127.0.0.1'])
-      dc.flush
-      resp = dc.get_multi(%w(a b c d e f))
-      assert_equal({}, resp)
-
-      dc.set('a', 'foo')
-      dc.set('b', 123)
-      dc.set('c', %w(a b c))
-      resp = dc.get_multi(%w(a b c d e f))
-      assert_equal({ 'a' => 'foo', 'b' => 123, 'c' => %w(a b c) }, resp)
+      memcached do |dc|
+        dc.flush
+        resp = dc.get_multi(%w(a b c d e f))
+        assert_equal({}, resp)
+
+        dc.set('a', 'foo')
+        dc.set('b', 123)
+        dc.set('c', %w(a b c))
+        resp = dc.get_multi(%w(a b c d e f))
+        assert_equal({ 'a' => 'foo', 'b' => 123, 'c' => %w(a b c) }, resp)
+      end
     end
 
-    should "pass a simple smoke test" do
-      return if $skip
-      
-      dc = Dalli::Client.new('localhost:11211')
-      resp = dc.flush
-      assert_not_nil resp
-      assert_equal [true], resp
-      
-      resp = dc.get('123')
-      assert_equal nil, resp
-      
-      resp = dc.set('123', 'xyz')
-      assert_equal true, resp
-      
-      resp = dc.get('123')
-      assert_equal 'xyz', resp
-      
-      resp = dc.set('123', 'abc')
-      assert_equal true, resp
-
-      assert_raises Dalli::DalliError do
-        dc.prepend('123', '0')
+    should "support incr/decr operations" do
+      memcached do |dc|
+        dc.flush
+
+        resp = dc.decr('counter', 100, 5, 0)
+        assert_equal 0, resp
+
+        resp = dc.decr('counter', 10)
+        assert_equal 0, resp
+
+        resp = dc.incr('counter', 10)
+        assert_equal 10, resp
+
+        current = 10
+        100.times do |x|
+          resp = dc.incr('counter', 10)
+          assert_equal current + ((x+1)*10), resp
+        end
+
+        resp = dc.decr('10billion', 0, 5, 10)
+        # go over the 32-bit mark to verify proper (un)packing
+        resp = dc.incr('10billion', 10_000_000_000)
+        assert_equal 10_000_000_010, resp
+
+        resp = dc.decr('10billion', 1)
+        assert_equal 10_000_000_009, resp
+
+        resp = dc.decr('10billion', 0)
+        assert_equal 10_000_000_009, resp
+
+        resp = dc.incr('10billion', 0)
+        assert_equal 10_000_000_009, resp
+
+        assert_nil dc.incr('DNE', 10)
+        assert_nil dc.decr('DNE', 10)
+
+        resp = dc.incr('big', 100, 5, 0xFFFFFFFFFFFFFFFE)
+        assert_equal 0xFFFFFFFFFFFFFFFE, resp
+        resp = dc.incr('big', 1)
+        assert_equal 0xFFFFFFFFFFFFFFFF, resp
+
+        # rollover the 64-bit value, we'll get something undefined.
+        resp = dc.incr('big', 1)
+        assert_not_equal 0x10000000000000000, resp
       end
+    end
+
+    should "pass a simple smoke test" do
+      memcached do |dc|
+        resp = dc.flush
+        assert_not_nil resp
+        assert_equal [true, true], resp
+
+        resp = dc.get('123')
+        assert_equal nil, resp
+
+        resp = dc.set('123', 'xyz')
+        assert_equal true, resp
+
+        resp = dc.get('123')
+        assert_equal 'xyz', resp
+
+        resp = dc.set('123', 'abc')
+        assert_equal true, resp
+
+        assert_raises Dalli::DalliError do
+          dc.prepend('123', '0')
+        end
+
+        assert_raises Dalli::DalliError do
+          dc.append('123', '0')
+        end
+
+        resp = dc.get('123')
+        assert_equal 'abc', resp
+        dc.close
+        dc = nil
+
+        dc = Dalli::Client.new('localhost:19122', :marshal => false)
+
+        resp = dc.set('456', 'xyz')
+        assert_equal true, resp
+
+        resp = dc.prepend '456', '0'
+        assert_equal true, resp
 
-      assert_raises Dalli::DalliError do
-        dc.append('123', '0')
+        resp = dc.append '456', '9'
+        assert_equal true, resp
+
+        resp = dc.get('456')
+        assert_equal '0xyz9', resp
+
+        resp = dc.stats
+        assert_equal Hash, resp.class
       end
+    end
+    
+    should "support multithreaded access" do
+      memcached(11211) do |cache|
+        cache.flush
+        workers = []
 
-      resp = dc.get('123')
-      assert_equal 'abc', resp
-      dc.close
-      dc = nil
+        cache.set('f', 'zzz')
+        assert_equal true, (cache.cas('f') do |value|
+          value << 'z'
+        end)
+        assert_equal 'zzzz', cache.get('f')
 
-      dc = Dalli::Client.new('localhost:11211', :marshal => false)
+        # Have a bunch of threads perform a bunch of operations at the same time.
+        # Verify the result of each operation to ensure the request and response
+        # are not intermingled between threads.
+        10.times do
+          workers << Thread.new do
+            100.times do
+              cache.set('a', 9)
+              cache.set('b', 11)
+              inc = cache.incr('cat', 10, 0, 10)
+              cache.set('f', 'zzz')
+              assert_not_nil(cache.cas('f') do |value|
+                value << 'z'
+              end)
+              assert_equal false, cache.add('a', 11)
+              assert_equal({ 'a' => 9, 'b' => 11 }, cache.get_multi(['a', 'b']))
+              inc = cache.incr('cat', 10)
+              assert_equal 0, inc % 5
+              dec = cache.decr('cat', 5)
+              assert_equal 11, cache.get('b')
+            end
+          end
+        end
 
-      resp = dc.set('456', 'xyz')
-      assert_equal true, resp
-      
-      resp = dc.prepend '456', '0'
-      assert_equal true, resp
+        workers.each { |w| w.join }
+        cache.flush
+      end
+    end
 
-      resp = dc.append '456', '9'
-      assert_equal true, resp
+    should 'gracefully handle authentication failures' do
+      memcached(19122, '-S') do |dc|
+        assert_raise Dalli::DalliError, /32/ do
+          dc.set('abc', 123)
+        end
+      end
+    end
 
-      resp = dc.get('456')
-      assert_equal '0xyz9', resp
-      
-      resp = dc.stats
-      assert_equal Hash, resp.class
+    # 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 'support SASL authentication' do
+        memcached(19121, '-S') do |dc|
+          assert_equal true, dc.set('abc', 123)
+          assert_equal 123, dc.get('abc')
+          assert_equal({"localhost:19121"=>{}}, dc.stats)
+        end
+      end
     end
+
   end
 end