memcache-client-activerecord 0.1.0

data/spec/database.yml.example

@@ -0,0 +1,18 @@
+sqlite3:
+  adapter: sqlite3
+  database: spec/database.sqlite3
+
+mysql:
+  adapter: mysql
+  database: memcache_client_activerecord_test
+  username: root
+  password:
+  socket: /var/lib/mysql/mysql.sock
+  encoding: utf8
+
+postgresql:
+  adapter: postgresql
+  database: memcache_client_activerecord_test
+  username: memcache_client_activerecord_test
+  password:
+  encoding: unicode

data/spec/memcache/activerecord_spec.rb

@@ -0,0 +1,550 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'erb'
+require 'yaml'
+require 'rubygems'
+gem 'memcache-client'; require 'memcache'
+gem 'activerecord'; require 'active_record'
+
+
+### start memcached
+
+MEMCACHED_HOST   = 'localhost'
+MEMCACHED_PORT   = '31121'
+MEMCACHED_SERVER = "#{MEMCACHED_HOST}:#{MEMCACHED_PORT}"
+
+if MEMCACHED_HOST == 'localhost'
+  memcached_pid = fork do
+    exec 'memcached', '-p', MEMCACHED_PORT
+  end
+
+  END {
+    Process.kill(:SIGINT, memcached_pid)
+  }
+
+  sleep 1
+end
+
+
+### initializing
+
+ROOT_DIR      = File.dirname(__FILE__) + '/../..'
+DATABASE_YAML = ROOT_DIR + '/spec/database.yml'
+MIGRATION     = ROOT_DIR + '/generators/cache_model/templates/migration.rb'
+TABLE_NAME    = 'caches'
+
+ActiveRecord::Base.configurations = YAML.load_file(DATABASE_YAML)
+ActiveRecord::Base.logger = Logger.new($stdout) if ENV['LOG']
+
+migration_name = 'CreateCaches'
+table_name     = TABLE_NAME
+eval(ERB.new(File.read(MIGRATION)).result(binding))
+
+def new_cache_class(adapter)
+  cache_class = Class.new(ActiveRecord::Base)
+  Object.const_set('Cache' + rand.to_s[2..-1], cache_class)
+  cache_class.set_table_name(TABLE_NAME)
+  cache_class.establish_connection(adapter)
+  cache_class
+end
+
+def new_dbcache(adapter, options)
+  MemCache::ActiveRecord.new(new_cache_class(adapter), options)
+end
+
+class Caches
+  def initialize(memcache, dbcache)
+    @memcache = memcache
+    @dbcache  = dbcache
+  end
+
+  def same(*args, &block)
+    convert = args.first.is_a?(Symbol) ? lambda {|m| m } : args.shift
+
+    begin
+      memcache_result = @memcache.send(*args, &block)
+    rescue Exception => memcache_error
+    end
+
+    if memcache_error
+      begin
+        dbcache_result = @dbcache.send(*args, &block)
+      rescue Exception => dbcache_error
+      end
+
+      dbcache_error.class.should   == memcache_error.class
+      dbcache_error.message.should == memcache_error.message
+
+    else
+      dbcache_result = @dbcache.send(*args, &block)
+      dbcache_result.should == convert.call(memcache_result)
+    end
+
+    dbcache_result
+  end
+
+  private
+    def method_missing(name, *args)
+      if @dbcache.respond_to?(name)
+        @dbcache.send(name, *args)
+        @memcache.send(name, *args)
+      else
+        super
+      end
+    end
+end
+
+
+### specs
+
+mem_flusher = MemCache.new(MEMCACHED_SERVER)
+mem_flusher.flush_all
+
+ActiveRecord::Base.configurations.each_key do |adapter|
+  ActiveRecord::Base.establish_connection(adapter)
+  CreateCaches.down rescue nil
+  CreateCaches.up
+  ActiveRecord::Base.clear_all_connections!
+  ActiveRecord::Base.remove_connection
+
+  cache_class = new_cache_class(adapter)
+
+  db_flusher = MemCache::ActiveRecord.new(cache_class)
+  db_flusher.flush_all
+
+  flushers = Caches.new(mem_flusher, db_flusher)
+
+describe "#{adapter}:" do
+  after do
+    flushers.flush_all
+  end
+
+  [
+    {},
+    { :namespace => 'ns' },
+    { :no_reply  => true },
+  ].each do |options|
+    memcache = MemCache.new(MEMCACHED_SERVER, options)
+    dbcache  = MemCache::ActiveRecord.new(cache_class, options)
+    caches   = Caches.new(memcache, dbcache)
+
+    describe MemCache::ActiveRecord, " when options are #{options.inspect}" do
+      if options.empty?
+        it 'should be case-sensitive' do
+          caches.same(:set, 'foo', 1)
+          caches.same(:set, 'FOO', 2)
+
+          caches.same(:get, 'foo').should == 1
+          caches.same(:get, 'FOO').should == 2
+        end
+
+        unless ENV['LOG']
+          it 'should behave like MemCache with over 64KB value' do
+            value = 'a' * (2 ** 16 + 1)
+            caches.same(:set, 'foo', value, 0, true)
+            caches.same(:get, 'foo', true).should == value
+          end
+
+          it 'should behave like MemCache with over 1MB value' do
+            value = 'a' * (2 ** 20 + 1)
+            caches.same(:set, 'foo', value, 0, true)
+            caches.same(:get, 'foo', true).should be_nil
+          end
+        end
+
+        unless ENV['WITHOUT_SLEEP']
+          it 'should be able to collect garbage' do
+            dbcache.set('foo', 1)
+            dbcache.set('bar', 1, 1)
+            dbcache.set('baz', 1, 2)
+
+            cache_class.count.should == 3
+
+            sleep 1
+            dbcache.garbage_collection!
+
+            cache_class.count.should == 2
+          end
+        end
+      end
+
+      describe '#get' do
+        it 'should behave like MemCache#get' do
+          caches.same(:get, 'foo')
+        end
+
+        if options.empty?
+          unless ENV['WITHOUT_SLEEP']
+            it 'should behave like MemCache#get with expiry' do
+              3.times do |expiry|
+                if expiry > 0
+                  caches.same(:delete, 'foo')
+                end
+
+                caches.same(:set, 'foo', 1, expiry)
+
+                3.times do |i|
+                  sleep 1 if i > 0
+                  caches.same(:get, 'foo')
+                end
+              end
+            end
+          end
+        end
+      end
+
+      describe '#fetch' do
+        it 'should behave like MemCache#fetch' do
+          caches.same(:fetch, 'foo') { 1 }.should == 1
+          caches.same(:fetch, 'foo') { 2 }.should == 1
+          caches.same(:fetch, 'foo')      .should == 1
+        end
+      end
+
+      describe '#get_multi' do
+        it 'should behave like MemCache#get_multi' do
+          caches.same(:get_multi, 'foo', 'bar', 'baz')
+
+          caches.same(:set, 'foo', 1)
+          caches.same(:set, 'bar', nil)
+
+          caches.same(:get_multi, 'foo', 'bar', 'baz')
+        end
+      end
+
+      describe '#set' do
+        it 'should behave like MemCache#set' do
+          caches.same(:set, 'foo', 1)
+          caches.same(:get, 'foo').should == 1
+
+          caches.same(:set, 'foo', 2)
+          caches.same(:get, 'foo').should == 2
+        end
+
+        it 'should work in multithread' do
+          thread = Thread.new do
+            dbcache2 = new_dbcache(adapter, options)
+            def dbcache2.insert(*args)
+              sleep 0.2
+              super
+            end
+            dbcache2.set('foo', 2)
+          end
+
+          sleep 0.1
+          dbcache.set('foo', 1)
+
+          thread.join
+
+          dbcache.get('foo').should == 1
+        end
+
+        if options.empty?
+          it 'should behave like MemCache#set with negative expiry' do
+            caches.same(:set, 'foo', 1, -1)
+            caches.same(:get, 'foo').should be_nil
+          end
+        end
+      end
+
+      describe '#cas' do
+        it 'should behave like MemCache#cas' do
+          caches.same(:cas, 'foo') {|v| v + 1 }
+          caches.same(:get, 'foo').should be_nil
+
+          caches.same(:set, 'foo', 1)
+          caches.same(:cas, 'foo') {|v| v + 1 }
+          caches.same(:get, 'foo').should == 2
+        end
+
+        it 'should behave like MemCache#cas without block' do
+          caches.same(:cas, 'foo')
+        end
+
+        it 'should work in multithread' do
+          dbcache.set('foo', 0)
+
+          thread = Thread.new do
+            dbcache2 = new_dbcache(adapter, options)
+            dbcache2.cas('foo') {|v| sleep 0.2; v + 1 }.should(
+              options[:no_reply] ? be_nil : eql(MemCache::ActiveRecord::EXISTS))
+          end
+
+          sleep 0.1
+          dbcache.set('foo', 2)
+
+          thread.join
+
+          dbcache.get('foo').should == 2
+        end
+      end
+
+      describe '#add' do
+        it 'should behave like MemCache#add' do
+          caches.same(:add, 'foo', 1)
+          caches.same(:get, 'foo').should == 1
+
+          caches.same(:add, 'foo', 2)
+          caches.same(:get, 'foo').should == 1
+        end
+      end
+
+      describe '#replace' do
+        it 'should behave like MemCache#replace' do
+          caches.same(:replace, 'foo', 1)
+          caches.same(:get, 'foo').should be_nil
+
+          caches.same(:set, 'foo', 1)
+          caches.same(:replace, 'foo', 2)
+          caches.same(:get, 'foo').should == 2
+        end
+
+        it 'should work in multithread' do
+          dbcache.set('foo', 0)
+
+          thread = Thread.new do
+            dbcache2 = new_dbcache(adapter, options)
+            def dbcache2.update(*args)
+              sleep 0.2
+              super
+            end
+            dbcache2.replace('foo', 2)
+          end
+
+          sleep 0.1
+          dbcache.delete('foo')
+
+          thread.join
+
+          dbcache.get('foo').should be_nil
+        end
+
+        if options.empty?
+          unless ENV['WITHOUT_SLEEP']
+            it 'should behave like MemCache#replace with expiry' do
+              caches.same(:set, 'foo', 1, 1)
+              sleep 2
+              caches.same(:replace, 'foo', 2)
+              caches.same(:get, 'foo').should be_nil
+            end
+          end
+        end
+      end
+
+      describe '#append' do
+        it 'should behave like MemCache#append' do
+          caches.same(:append, 'foo', 1)
+          caches.same(:get, 'foo', true).should be_nil
+
+          caches.same(:set, 'foo', 0, 0, true)
+          caches.same(:append, 'foo', 1)
+          caches.same(:get, 'foo', true).should == '01'
+        end
+      end
+
+      describe '#prepend' do
+        it 'should behave like MemCache#prepend' do
+          caches.same(:prepend, 'foo', 1)
+          caches.same(:get, 'foo', true).should be_nil
+
+          caches.same(:set, 'foo', 0, 0, true)
+          caches.same(:prepend, 'foo', 1)
+          caches.same(:get, 'foo', true).should == '10'
+        end
+      end
+
+      describe '#incr' do
+        it 'should behave like MemCache#incr' do
+          caches.same(:incr, 'foo').should be_nil
+          caches.same(:get, 'foo', true).should be_nil
+
+          caches.same(:set, 'foo', 1, 0, true)
+          caches.same(:incr, 'foo').should(options[:no_reply] ? be_nil : eql(2))
+          caches.same(:get, 'foo', true).should == '2'
+
+          caches.same(:incr, 'foo', 0).should(options[:no_reply] ? be_nil : eql(2))
+          caches.same(:get, 'foo', true).should == '2'
+
+          caches.same(:incr, 'foo', 2).should(options[:no_reply] ? be_nil : eql(4))
+          caches.same(:get, 'foo', true).should == '4'
+        end
+
+        it 'should work in multithread' do
+          dbcache.set('foo', 1, 0, true)
+
+          thread = Thread.new do
+            dbcache2 = new_dbcache(adapter, options)
+            5.times { dbcache2.incr('foo') }
+          end
+
+          5.times { dbcache.incr('foo') }
+
+          thread.join
+
+          dbcache.get('foo', true).should == '11'
+        end
+
+        if options.empty?
+          it 'should behave like MemCache#incr with string amount' do
+            caches.same(:set, 'foo', ' 1 ', 0, true)
+            caches.same(:incr, 'foo', '1')
+            caches.same(lambda {|m| m.sub(/  \z/, '') }, :get, 'foo', true)
+
+            caches.same(:incr, 'foo', '1 ')
+            caches.same(lambda {|m| m.sub(/  \z/, '') }, :get, 'foo', true)
+
+            caches.same(:incr, 'foo', ' 1')
+            caches.same(lambda {|m| m.sub(/  \z/, '') }, :get, 'foo', true)
+
+            caches.same(:incr, 'foo', ' 1 ')
+            caches.same(lambda {|m| m.sub(/  \z/, '') }, :get, 'foo', true)
+          end
+
+          it 'should behave like MemCache#incr with non-raw value' do
+            caches.same(:set, 'foo', 1)
+            caches.same(:incr, 'foo')
+          end
+
+          it 'should behave like MemCache#incr with non-numeric value' do
+            [1.5, -1, 'qux'].each do |value|
+              caches.same(:set, 'foo', value, 0, true)
+              caches.same(:incr, 'foo')
+            end
+          end
+
+          it 'should behave like MemCache#incr with invalid numeric delta argument' do
+            caches.same(:set, 'foo', 1, 0, true)
+            [1.5, -1, 'qux'].each do |amount|
+              caches.same(:incr, 'foo', amount)
+            end
+          end
+
+          unless ENV['WITHOUT_SLEEP']
+            it 'should behave like MemCache#incr with expiry' do
+              caches.same(:set, 'foo', 1, 1, true)
+              caches.same(:incr, 'foo')
+              sleep 2
+              caches.same(:get, 'foo', true)
+
+              caches.same(:set, 'foo', 1, 1, true)
+              sleep 2
+              caches.same(:incr, 'foo')
+              caches.same(:get, 'foo', true)
+            end
+          end
+        end
+      end
+
+      describe '#decr' do
+        it 'should behave like MemCache#decr' do
+          caches.same(:decr, 'foo')
+          caches.same(:get, 'foo', true)
+
+          caches.same(:set, 'foo', 9, 0, true)
+          caches.same(:decr, 'foo')
+          caches.same(:get, 'foo', true)
+
+          caches.same(:decr, 'foo', 0)
+          caches.same(:get, 'foo', true)
+
+          caches.same(:decr, 'foo', 2)
+          caches.same(:get, 'foo', true)
+        end
+
+        if options.empty?
+          it 'should behave like MemCache#decr (1 - 2 => 0)' do
+            caches.same(:set, 'foo', 1, 0, true)
+            caches.same(:decr, 'foo', 2)
+            caches.same(:get, 'foo', true)
+          end
+
+          it 'should behave like MemCache#decr with decrement digit' do
+            caches.same(:set, 'foo', 10, 0, true)
+            caches.same(:decr, 'foo')
+            caches.same(lambda {|m| m.sub(/ \z/, '') }, :get, 'foo', true)
+          end
+
+          it 'should behave like MemCache#decr with non-raw value' do
+            caches.same(:set, 'foo', 1)
+            caches.same(:decr, 'foo')
+          end
+
+          it 'should behave like MemCache#decr with non-numeric value' do
+            [1.5, -1, 'qux'].each do |value|
+              caches.same(:set, 'foo', value, 0, true)
+              caches.same(:decr, 'foo')
+            end
+          end
+
+          it 'should behave like MemCache#decr with invalid numeric delta argument' do
+            caches.same(:set, 'foo', 1, 0, true)
+
+            [1.5, -1, 'qux'].each do |amount|
+              caches.same(:decr, 'foo', amount)
+            end
+          end
+        end
+      end
+
+      describe '#delete' do
+        it 'should behave like MemCache#delete' do
+          caches.same(:set, 'foo', 1)
+          caches.same(:get, 'foo')
+
+          caches.same(:delete, 'foo')
+          caches.same(:get, 'foo')
+        end
+      end
+
+      if options.empty?
+        describe '#flush_all' do
+          it 'should behave like MemCache#delete' do
+            caches.same(:set, 'foo', 1)
+            caches.same(:get, 'foo')
+
+            # don't use same, because MemCache#flush_all returns @servers.
+            caches.flush_all
+
+            caches.same(:get, 'foo')
+          end
+        end
+      end
+    end
+  end
+
+  [
+    {},
+    { :namespace => 'n' },
+  ].each do |options|
+    options.update(:autofix_keys => true)
+
+    memcache = MemCache.new(MEMCACHED_SERVER, options)
+    dbcache  = MemCache::ActiveRecord.new(cache_class, options)
+    caches   = Caches.new(memcache, dbcache)
+
+    describe MemCache::ActiveRecord, " when options are #{options.inspect}" do
+      it 'should behave like MemCache' do
+        (248..251).each do |length|
+          caches.same(:set, 'a' * length, length)
+          caches.same(:get, 'a' * length)
+        end
+      end
+    end
+  end
+
+  [
+    { :readonly => true },
+  ].each do |options|
+    memcache = MemCache.new(MEMCACHED_SERVER, options)
+    dbcache  = MemCache::ActiveRecord.new(cache_class, options)
+    caches   = Caches.new(memcache, dbcache)
+
+    describe MemCache::ActiveRecord, " when options are #{options.inspect}" do
+      it 'should behave like MemCache' do
+        caches.same(:set, 'foo', 1)
+      end
+    end
+  end
+
+end
+end