jashmenn-dalli 1.0.3

data/test/helper.rb

@@ -0,0 +1,54 @@
+$TESTING = true
+require 'rubygems'
+# require 'simplecov'
+# SimpleCov.start
+RAILS_VERSION = ENV['RAILS_VERSION'] || '~> 3.0.0'
+#puts "Testing with Rails #{RAILS_VERSION}"
+gem 'rails', RAILS_VERSION
+
+require 'test/unit'
+require 'shoulda'
+require 'memcached_mock'
+require 'mocha'
+
+require 'dalli'
+require 'logger'
+
+Dalli.logger = Logger.new(STDOUT)
+Dalli.logger.level = Logger::ERROR
+
+class Test::Unit::TestCase
+  include MemcachedMock::Helper
+
+  def rails3?
+    RAILS_VERSION =~ /3\.0\./
+  end
+
+  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")}")
+  end
+
+  def with_activesupport
+    case 
+    when rails3?
+      require 'active_support/all'
+    else
+      require 'active_support'
+      require 'active_support/cache/dalli_store23'
+    end
+    yield
+  end
+
+  def with_actionpack
+    case
+    when rails3?
+      require 'action_dispatch'
+      require 'action_controller'
+    # when '2.3.0'
+    #   raise NotImplementedError
+    end
+    yield
+  end
+
+end

data/test/memcached_mock.rb

@@ -0,0 +1,106 @@
+require "socket"
+
+$started = {}
+
+module MemcachedMock
+  def self.start(port=19123, &block)
+    server = TCPServer.new("localhost", port)
+    session = server.accept
+    block.call session
+  end
+
+  def self.delayed_start(port=19123, wait=1, &block)
+    server = TCPServer.new("localhost", port)
+    sleep wait
+    block.call server
+  end
+
+  module Helper
+    # Forks the current process and starts a new mock Memcached server on
+    # port 22122.
+    #
+    #     memcached_mock(lambda {|sock| socket.write('123') }) do
+    #       assert_equal "PONG", Dalli::Client.new('localhost:22122').get('abc')
+    #     end
+    #
+    def memcached_mock(proc, meth = :start)
+      begin
+        pid = fork do
+          trap("TERM") { exit }
+
+          MemcachedMock.send(meth) do |*args|
+            proc.call(*args)
+          end
+        end
+
+        sleep 0.3 # Give time for the socket to start listening.
+        yield
+      ensure
+        if pid
+          Process.kill("TERM", pid)
+          Process.wait(pid)
+        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}"
+      $started[port] ||= begin
+        #puts "Starting: #{cmd}..."
+        pid = IO.popen(cmd).pid
+        at_exit do
+          begin
+            Process.kill("TERM", pid)
+            Process.wait(pid)
+          rescue Errno::ECHILD, Errno::ESRCH
+          end
+        end
+        sleep 0.1
+        pid
+      end
+
+      yield Dalli::Client.new(["localhost:#{port}", "127.0.0.1:#{port}"])
+    end
+    
+    def memcached_kill(port)
+      pid = $started.delete(port)
+      if pid
+        begin
+          Process.kill("TERM", pid)
+          Process.wait(pid)
+        rescue Errno::ECHILD, Errno::ESRCH
+        end
+      end
+    end
+
+  end
+end
+
+module Memcached
+  class << self
+    attr_accessor :path
+  end
+end

data/test/test_active_support.rb

@@ -0,0 +1,177 @@
+require 'helper'
+
+class TestActiveSupport < Test::Unit::TestCase
+  context 'active_support caching' do
+
+    should 'support fetch' do
+      with_activesupport do
+        memcached do
+          connect
+          mvalue = @mc.fetch('somekeywithoutspaces', :expires_in => 1.second) { 123 }
+          dvalue = @dalli.fetch('someotherkeywithoutspaces', :expires_in => 1.second) { 123 }
+          assert_equal 123, dvalue
+          assert_equal mvalue, dvalue
+
+          o = Object.new
+          o.instance_variable_set :@foo, 'bar'
+          mvalue = @mc.fetch(rand_key, :raw => true) { o }
+          dvalue = @dalli.fetch(rand_key, :raw => true) { o }
+          assert_equal mvalue, dvalue
+          assert_equal o, mvalue
+
+          mvalue = @mc.fetch(rand_key) { o }
+          dvalue = @dalli.fetch(rand_key) { o }
+          assert_equal mvalue, dvalue
+          assert_equal o, dvalue
+        end
+      end
+    end
+
+    should 'support keys with spaces on Rails3' do
+      with_activesupport do
+        memcached do
+          connect
+          case 
+          when rails3?
+            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
+          else
+            assert_raises ArgumentError do
+              @mc.fetch('some key with spaces', :expires_in => 1.second) { 123 }
+            end
+            assert_raises ArgumentError do
+              @dalli.fetch('some other key with spaces', :expires_in => 1.second) { 123 }
+            end
+          end
+        end
+      end
+    end      
+
+    should 'support read_multi' do
+      with_activesupport do
+        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
+    end
+
+    should 'support raw read_multi' do
+      with_activesupport do
+        memcached do
+          connect
+          @mc.write("abc", 5, :raw => true)
+          @mc.write("cba", 5, :raw => true)
+          if RAILS_VERSION =~ /2\.3/
+            assert_raise ArgumentError do
+              @mc.read_multi("abc", "cba")
+            end
+          else
+            assert_equal({'abc' => '5', 'cba' => '5' }, @mc.read_multi("abc", "cba"))
+          end
+
+          @dalli.write("abc", 5, :raw => true)
+          @dalli.write("cba", 5, :raw => true)
+          # XXX: API difference between m-c and dalli.  Dalli is smarter about
+          # what it needs to unmarshal.
+          assert_equal({'abc' => '5', 'cba' => '5' }, @dalli.read_multi("abc", "cba"))
+        end
+      end
+    end
+
+    should 'support read, write and delete' do
+      with_activesupport do
+        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.delete(x)
+          dres = @dalli.delete(y)
+          assert_equal mres, dres
+          assert_equal true, dres
+        end
+      end
+    end
+    
+    should 'support increment/decrement commands' do
+      with_activesupport do
+        memcached do
+          connect
+          assert_equal true, @mc.write('counter', 0, :raw => true)
+          assert_equal 1, @mc.increment('counter')
+          assert_equal 2, @mc.increment('counter')
+          assert_equal 1, @mc.decrement('counter')
+          assert_equal "1", @mc.read('counter', :raw => true)
+
+          assert_equal true, @dalli.write('counter', 0, :raw => true)
+          assert_equal 1, @dalli.increment('counter')
+          assert_equal 2, @dalli.increment('counter')
+          assert_equal 1, @dalli.decrement('counter')
+          assert_equal "1", @dalli.read('counter', :raw => true)
+
+          assert_equal 0, @mc.increment('counterX')
+          assert_equal 0, @mc.increment('counterX')
+          assert_equal nil, @mc.read('counterX')
+
+          assert_equal 1, @dalli.increment('counterX')
+          assert_equal 2, @dalli.increment('counterX')
+          assert_equal 2, @dalli.read('counterX', :raw => true).to_i
+        end
+      end
+    end
+
+    should 'support other esoteric commands' do
+      with_activesupport do
+        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
+
+          assert_equal true, @dalli.write(:foo, 'a')
+          assert_equal true, @mc.write(:foo, 'a')
+
+          assert_equal true, @mc.exist?(:foo)
+          assert_equal true, @dalli.exist?(:foo)
+
+          assert_equal false, @mc.exist?(:bar)
+          assert_equal false, @dalli.exist?(:bar)
+
+          @dalli.reset
+        end
+      end
+    end
+  end
+  
+  def connect
+    @dalli = ActiveSupport::Cache.lookup_store(:dalli_store, 'localhost:19122', :expires_in => 10.seconds, :namespace => 'x')
+    @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)
+  end
+end

data/test/test_compatibility.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+class TestCompatibility < Test::Unit::TestCase
+
+  def setup
+    require 'dalli/memcache-client'
+  end
+
+  context 'dalli in memcache-client mode' do
+
+    should 'handle old raw flag to set/add/replace' do
+      memcached do |dc|
+        assert_equal "STORED\r\n", dc.set('abc', 123, 5, true)
+        assert_equal '123', dc.get('abc', true)
+
+        assert_equal "NOT_STORED\r\n", dc.add('abc', 456, 5, true)
+        assert_equal '123', dc.get('abc', true)
+
+        assert_equal "STORED\r\n", dc.replace('abc', 456, 5, false)
+        assert_equal 456, dc.get('abc', false)
+
+        assert_equal "DELETED\r\n", dc.delete('abc')
+        assert_equal "NOT_DELETED\r\n", dc.delete('abc')
+      end
+    end
+
+  end
+
+  def teardown
+    Dalli::Client.compatibility_mode = false
+  end
+
+end

data/test/test_dalli.rb

@@ -0,0 +1,398 @@
+require 'helper'
+require 'memcached_mock'
+
+class TestDalli < Test::Unit::TestCase
+
+  should "default to localhost:11211" do
+    dc = Dalli::Client.new
+    ring = dc.send(:ring)
+    s1 = ring.servers.first.hostname
+    assert_equal 1, ring.servers.size
+    dc.close
+
+    dc = Dalli::Client.new('localhost:11211')
+    ring = dc.send(:ring)
+    s2 = ring.servers.first.hostname
+    assert_equal 1, ring.servers.size
+    dc.close
+
+    dc = Dalli::Client.new(['localhost:11211'])
+    ring = dc.send(:ring)
+    s3 = ring.servers.first.hostname
+    assert_equal 1, ring.servers.size
+    dc.close
+
+    assert_equal s1, s2
+    assert_equal s2, s3
+  end
+
+  context 'using a live server' do
+
+    should "support get/set" do
+      memcached do |dc|
+        dc.flush
+
+        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
+        
+        assert_equal true, dc.set('a', nil)
+        assert_nil dc.get('a')
+      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!' }
+
+        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
+      memcached do |dc|
+        dc.close
+        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)
+
+        # Perform a huge multi-get with 10,000 elements.
+        arr = []
+        dc.multi do
+          10_000.times do |idx|
+            dc.set idx, idx
+            arr << idx
+          end
+        end
+
+        result = dc.get_multi(arr)
+        assert_equal(10_000, result.size)
+        assert_equal(1000, result['1000'])
+      end
+    end
+
+    should 'support raw incr/decr' do
+      memcached do |client|
+        client.flush
+
+        assert_equal true, client.set('fakecounter', 0, 0, :raw => true)
+        assert_equal 1, client.incr('fakecounter', 1)
+        assert_equal 2, client.incr('fakecounter', 1)
+        assert_equal 3, client.incr('fakecounter', 1)
+        assert_equal 1, client.decr('fakecounter', 2)
+        assert_equal "1", client.get('fakecounter', :raw => true)
+
+        resp = client.incr('mycounter', 0)
+        assert_nil resp
+
+        resp = client.incr('mycounter', 1, 0, 2)
+        assert_equal 2, resp
+        resp = client.incr('mycounter', 1)
+        assert_equal 3, resp
+
+        resp = client.set('rawcounter', 10, 0, :raw => true)
+        assert_equal true, resp
+
+        resp = client.get('rawcounter', :raw => true)
+        assert_equal '10', resp
+
+        resp = client.incr('rawcounter', 1)
+        assert_equal 11, resp
+      end
+    end
+
+    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
+        dc.reset
+      end
+    end
+
+    should 'support the append and prepend operations' do
+      memcached do |dc|
+        resp = dc.flush
+        assert_equal true, dc.set('456', 'xyz', 0, :raw => true)
+        assert_equal true, dc.prepend('456', '0')
+        assert_equal true, dc.append('456', '9')
+        assert_equal '0xyz9', dc.get('456', :raw => true)
+        assert_equal '0xyz9', dc.get('456')
+
+        assert_equal false, dc.append('nonexist', 'abc')
+        assert_equal false, dc.prepend('nonexist', 'abc')
+      end
+    end
+
+    should "pass a simple smoke test" do
+      memcached do |dc|
+        resp = dc.flush
+        assert_not_nil resp
+        assert_equal [true, true], resp
+
+        assert_equal true, dc.set(:foo, 'bar')
+        assert_equal 'bar', dc.get(:foo)
+
+        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
+
+        dc.prepend('123', '0')
+        dc.append('123', '0')
+
+        assert_raises Dalli::DalliError do
+          resp = dc.get('123')
+        end
+
+        dc.close
+        dc = nil
+
+        dc = Dalli::Client.new('localhost:19122')
+
+        resp = dc.set('456', 'xyz', 0, :raw => true)
+        assert_equal true, resp
+
+        resp = dc.prepend '456', '0'
+        assert_equal true, resp
+
+        resp = dc.append '456', '9'
+        assert_equal true, resp
+
+        resp = dc.get('456', :raw => true)
+        assert_equal '0xyz9', resp
+
+        resp = dc.stats
+        assert_equal Hash, resp.class
+
+        dc.close
+      end
+    end
+    
+    should "support multithreaded access" do
+      memcached do |cache|
+        cache.flush
+        workers = []
+
+        cache.set('f', 'zzz')
+        assert_equal true, (cache.cas('f') do |value|
+          value << 'z'
+        end)
+        assert_equal 'zzzz', cache.get('f')
+
+        # 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
+
+        workers.each { |w| w.join }
+        cache.flush
+      end
+    end
+
+    should "handle namespaced keys" do
+      memcached do |dc|
+        dc = Dalli::Client.new('localhost:19122', :namespace => 'a')
+        dc.set('namespaced', 1)
+        dc2 = Dalli::Client.new('localhost:19122', :namespace => 'b')
+        dc2.set('namespaced', 2)
+        assert_equal 1, dc.get('namespaced')
+        assert_equal 2, dc2.get('namespaced')
+      end
+    end
+
+    should "handle namespaced keys in multi_get" do
+      memcached do |dc|
+        dc = Dalli::Client.new('localhost:19122', :namespace => 'a')
+        dc.set('a', 1)
+        dc.set('b', 2)
+        assert_equal({'a' => 1, 'b' => 2}, dc.get_multi('a', 'b'))
+      end
+    end
+
+    should "handle application marshalling issues" do
+      memcached do |dc|
+        old = Dalli.logger
+        Dalli.logger = Logger.new(nil)
+        begin
+          assert_equal false, dc.set('a', Proc.new { true })
+        ensure
+          Dalli.logger = old
+        end
+      end
+    end
+
+    context 'with compression' do
+      should 'allow large values' do
+        memcached do |dc|
+          dalli = Dalli::Client.new(dc.instance_variable_get(:@servers), :compression => true)
+
+          value = "0"*1024*1024
+          assert_raise Dalli::DalliError, /too large/ do
+            dc.set('verylarge', value)
+          end
+          dalli.set('verylarge', value)
+        end
+      end
+    end
+
+    context 'in low memory conditions' do
+
+      should 'handle error response correctly' do
+        memcached(19125, '-m 1 -M') do |dc|
+          failed = false
+          value = "1234567890"*100
+          1_000.times do |idx|
+            begin
+              assert_equal true, dc.set(idx, value)
+            rescue Dalli::DalliError
+              failed = true
+              assert((800..900).include?(idx), "unexpected failure on iteration #{idx}")
+              break
+            end
+          end
+          assert failed, 'did not fail under low memory conditions'
+        end
+      end
+
+      should 'fit more values with compression' do
+        memcached(19126, '-m 1 -M') do |dc|
+          dalli = Dalli::Client.new('localhost:19126', :compression => true)
+          failed = false
+          value = "1234567890"*1000
+          10_000.times do |idx|
+            begin
+              assert_equal true, dalli.set(idx, value)
+            rescue Dalli::DalliError
+              failed = true
+              assert((6000..7000).include?(idx), "unexpected failure on iteration #{idx}")
+              break
+            end
+          end
+          assert failed, 'did not fail under low memory conditions'
+        end
+      end
+
+    end
+
+  end
+end