mob-dalli 1.1.4

data/test/benchmark_test.rb

@@ -0,0 +1,170 @@
+require 'helper'
+require 'benchmark'
+
+class TestBenchmark < Test::Unit::TestCase
+
+  def setup
+    puts "Testing #{Dalli::VERSION} with #{RUBY_DESCRIPTION}"
+    # We'll use a simple @value to try to avoid spending time in Marshal,
+    # which is a constant penalty that both clients have to pay
+    @value = []
+    @marshalled = Marshal.dump(@value)
+
+    @servers = ['127.0.0.1:19122', 'localhost:19122']
+    @key1 = "Short"
+    @key2 = "Sym1-2-3::45"*8
+    @key3 = "Long"*40
+    @key4 = "Medium"*8
+    # 5 and 6 are only used for multiget miss test
+    @key5 = "Medium2"*8
+    @key6 = "Long3"*40
+    @counter = 'counter'
+  end
+
+  def test_benchmark
+    memcached do
+
+      Benchmark.bm(31) do |x|
+
+        n = 2500
+
+        @m = Dalli::Client.new(@servers)
+        x.report("set:plain:dalli") do
+          n.times do
+            @m.set @key1, @marshalled, 0, :raw => true
+            @m.set @key2, @marshalled, 0, :raw => true
+            @m.set @key3, @marshalled, 0, :raw => true
+            @m.set @key1, @marshalled, 0, :raw => true
+            @m.set @key2, @marshalled, 0, :raw => true
+            @m.set @key3, @marshalled, 0, :raw => true
+          end
+        end
+
+        @m = Dalli::Client.new(@servers)
+        x.report("setq:plain:dalli") do
+          @m.multi do
+            n.times do
+              @m.set @key1, @marshalled, 0, :raw => true
+              @m.set @key2, @marshalled, 0, :raw => true
+              @m.set @key3, @marshalled, 0, :raw => true
+              @m.set @key1, @marshalled, 0, :raw => true
+              @m.set @key2, @marshalled, 0, :raw => true
+              @m.set @key3, @marshalled, 0, :raw => true
+            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
+          end
+        end
+
+        @m = Dalli::Client.new(@servers)
+        x.report("get:plain:dalli") do
+          n.times do
+            @m.get @key1, :raw => true
+            @m.get @key2, :raw => true
+            @m.get @key3, :raw => true
+            @m.get @key1, :raw => true
+            @m.get @key2, :raw => true
+            @m.get @key3, :raw => true
+          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
+          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
+          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
+          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
+          end
+        end
+
+        @m = Dalli::Client.new(@servers)
+        x.report("mixedq:ruby:dalli") do
+          @m.multi 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.replace @key2, @value
+              @m.delete @key3
+              @m.add @key3, @value
+              @m.get @key2
+              @m.set @key3, @value
+              @m.get @key3
+            end
+          end
+        end
+
+        @m = Dalli::Client.new(@servers)
+        x.report("incr:ruby:dalli") do
+          n.times do
+            @m.incr @counter, 1, 0, 1
+          end
+          n.times do
+            @m.decr @counter, 1
+          end
+
+          assert_equal 0, @m.incr(@counter, 0)
+        end
+
+      end
+    end
+
+  end
+end

data/test/helper.rb

@@ -0,0 +1,39 @@
+$TESTING = true
+require 'rubygems'
+# require 'simplecov'
+# SimpleCov.start
+WANT_RAILS_VERSION = ENV['RAILS_VERSION'] || '>= 3.0.0'
+gem 'rails', WANT_RAILS_VERSION
+require 'rails'
+puts "Testing with 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 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
+    require 'active_support/all'
+    yield
+  end
+
+  def with_actionpack
+    require 'action_dispatch'
+    require 'action_controller'
+    yield
+  end
+end

data/test/memcached_mock.rb

@@ -0,0 +1,126 @@
+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
+
+  def self.tmp_socket_path
+    "#{Dir.pwd}/tmp.sock"
+  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)
+      return unless supports_fork?
+      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='', options={})
+      return unless supports_fork?
+      Memcached.path ||= find_memcached
+
+      cmd = if options[:unix]
+        "#{Memcached.path}memcached #{args} -s #{MemcachedMock.tmp_socket_path}"
+      else
+        "#{Memcached.path}memcached #{args} -p #{port}"
+      end
+
+      $started[port] ||= begin
+        #puts "Starting: #{cmd}..."
+        pid = IO.popen(cmd).pid
+        at_exit do
+          begin
+            Process.kill("TERM", pid)
+            Process.wait(pid)
+            File.delete(MemcachedMock.tmp_socket_path) if options[:unix]
+          rescue Errno::ECHILD, Errno::ESRCH
+          end
+        end
+        sleep 0.1
+        pid
+      end
+      if options[:unix]
+        yield Dalli::Client.new(MemcachedMock.tmp_socket_path)
+      else
+        yield Dalli::Client.new(["localhost:#{port}", "127.0.0.1:#{port}"], options)
+      end
+    end
+
+    def supports_fork?
+      !defined?(RUBY_ENGINE) || RUBY_ENGINE != 'jruby'
+    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,201 @@
+# encoding: utf-8
+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
+          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
+        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 read_multi with an array' 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({}, @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)
+          assert_equal({'abc' => '5', 'cba' => '5' }, @mc.read_multi("abc", "cba"))
+
+          @dalli.write("abc", 5, :raw => true)
+          @dalli.write("cba", 5, :raw => true)
+          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
+
+  should 'handle crazy characters from far-away lands' do
+    with_activesupport do
+      memcached do
+        connect
+        key = "fooƒ"
+        value = 'bafƒ'
+#        assert_equal true, @mc.write(key, value)
+        assert_equal true, @dalli.write(key, value)
+#        assert_equal true, @mc.read(key, value)
+        assert_equal value, @dalli.read(key)
+      end
+    end
+  end
+
+  should 'normalize options as expected' do
+    with_activesupport do
+      memcached do
+        @dalli = ActiveSupport::Cache::DalliStore.new('localhost:19122', :expires_in => 1, :race_condition_ttl => 1)
+        assert_equal 2, @dalli.instance_variable_get(:@data).instance_variable_get(:@options)[:expires_in]
+      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