double_write_cache_stores 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5dbec8739b2952e40813ae8355317815e4ac6769
-  data.tar.gz: 7f17258222ba0e1211ee777e69193def91723fc4
+  metadata.gz: 2f2e06c115f9f6f2c93e70bd217a9f0d2277e4b8
+  data.tar.gz: 026266132650bcfe4a9b11f8a7ea78cbaeaaceeb
 SHA512:
-  metadata.gz: 1c84a1e5255940a10299a068298666a82138f99e9623d737256f20f572bc6f792be8bc90ea5a93ac2fc8eef76ed0b1e1fdfd778fb865e08e3d1d186b1ef6d3c8
-  data.tar.gz: bc644b50386794570dc390a7e40af9bc4a86e6bb1f527df621a7da213f89bb8d6936714f2deecf1c423b42d9b58c242c58de9dabb64e8d06f295e810ed908fd0
+  metadata.gz: 7abdfd76502de8e42de745dbdd1ab4c729a126e3154e0572383720c70a27d06cd6e0e5e072963c57aaa8e1ca9833c81a4686278a489535e0b28d12e93735d2d7
+  data.tar.gz: 4ffd5deef56bd569014e711abf799c39217f2ae484c0ebc612d8868626a9f2152be6ac62c12f6a62f32c948c133ed24f7ac23788a681d8f47d6507efae24868b

data/README.md

@@ -39,6 +39,25 @@ write_only_cache_store = ActiveSupport::Cache.lookup_store :dalli_store, 'localh
 set :cache, DoubleWriteCacheStores::Client.new(read_and_write_cache_store, write_only_cache_store)
 ````
 
+### Rails4
+
+`config/application.rb`
+
+```ruby
+read_and_write_cache_store = ActiveSupport::Cache.lookup_store :mem_cache_store, 'localhost:11211'
+write_only_cache_store = ActiveSupport::Cache.lookup_store :mem_cache_store, 'localhost:21211'
+
+config.cache_store = DoubleWriteCacheStores::Client.new(read_and_write_cache_store, write_only_cache_store)
+```
+
+#### in application
+
+```ruby
+Rails.cache.fetch("key") do
+  "value"
+end
+```
+
 ## Contributing
 
 1. Fork it ( http://github.com/hirocaster/double_write_cache_stores/fork )

data/lib/dalli_store_patch.rb

@@ -0,0 +1,41 @@
+# monky patch
+# support cas interface for ActiveSupport::Cache::DalliStore
+module DalliStorePatch
+  def read_cas(name, options=nil)
+    options ||= {}
+    name = namespaced_key(name, options)
+
+    instrument(:get_cas, name) do |payload|
+      with { |c| c.get_cas(name) }
+    end
+  rescue Dalli::DalliError => e
+    logger.error("DalliError: #{e.message}") if logger
+    raise if raise_errors?
+    false
+  end
+
+  def write_cas(name, value, options=nil)
+    options ||= {}
+    name = namespaced_key(name, options)
+    expires_in = options[:expires_in]
+
+    instrument(:set_cas, name, value) do |payload|
+      cas = options.delete(:cas) || 0
+      expires_in = options.delete(:expires_in)
+      with { |c| c.set_cas(name, value, cas, expires_in, options) }
+    end
+  rescue Dalli::DalliError => e
+    logger.error("DalliError: #{e.message}") if logger
+    raise if raise_errors?
+    false
+  end
+end
+
+
+begin
+  require "active_support"
+  require "active_support/cache/dalli_store"
+
+  ActiveSupport::Cache::DalliStore.send(:include, DalliStorePatch)
+rescue => exception
+end

data/lib/double_write_cache_stores.rb

@@ -1,4 +1,6 @@
 require "double_write_cache_stores/version"
 require "double_write_cache_stores/client"
+require "double_write_cache_stores/base_exception"
+require "dalli_store_patch"
 module DoubleWriteCacheStores
 end

data/lib/double_write_cache_stores/base_exception.rb

@@ -0,0 +1,4 @@
+module DoubleWriteCacheStores
+  class BaseException < StandardError; end
+  class UnSupportException < StandardError; end
+end

data/lib/double_write_cache_stores/client.rb

@@ -17,12 +17,26 @@ class DoubleWriteCacheStores::Client
     get_or_read_method_call key
   end
 
+  def get_multi(*keys)
+    get_multi_or_read_multi_method_call *keys
+  end
+
   def get_cas(key)
-    @read_and_write_store.get_cas key
+    if @read_and_write_store.respond_to? :get_cas
+      @read_and_write_store.get_cas key
+    elsif @read_and_write_store.respond_to? :read_cas
+      @read_and_write_store.read_cas key
+    end
   end
 
-  def set_cas(key, value, cas, options = nil)
-    cas_unique = @read_and_write_store.set_cas key, value, cas, options
+  def set_cas(key, value, cas=0, options=nil)
+    cas_unique = if @read_and_write_store.respond_to? :set_cas
+                   @read_and_write_store.set_cas key, value, cas, options
+                 elsif @read_and_write_store.respond_to? :read_cas
+                   options ||= {}
+                   options[:cas] = cas
+                   @read_and_write_store.write_cas key, value, options
+                 end
 
     if @write_only_store && cas_unique
       set_or_write_method_call @write_only_store, key, value, options
@@ -35,6 +49,10 @@ class DoubleWriteCacheStores::Client
     get_or_read_method_call key
   end
 
+  def read_multi(*keys)
+    get_multi_or_read_multi_method_call *keys
+  end
+
   def delete(key)
     @read_and_write_store.delete key
     @write_only_store.delete key if @write_only_store
@@ -52,12 +70,16 @@ class DoubleWriteCacheStores::Client
     write_cache_store key, value, options
   end
 
-  def touch(key)
+  def touch(key, ttl=nil)
     result = false
-    read_and_write_backend = @read_and_write_store.instance_variable_get('@backend') || @read_and_write_store.instance_variable_get('@data')
-    if read_and_write_backend && read_and_write_backend.respond_to?(:touch)
-      result = read_and_write_backend.touch key
-      write_only_store_touch key
+    if defined?(Dalli) && @read_and_write_store.is_a?(Dalli::Client)
+      result = @read_and_write_store.touch key, ttl
+    else
+      read_and_write_backend = @read_and_write_store.instance_variable_get('@backend') || @read_and_write_store.instance_variable_get('@data')
+      if read_and_write_backend && read_and_write_backend.respond_to?(:touch)
+        result = read_and_write_backend.touch key, ttl
+        write_only_store_touch key, ttl
+      end
     end
     result
   end
@@ -70,6 +92,33 @@ class DoubleWriteCacheStores::Client
     end
   end
 
+  def fetch(name, options = nil)
+    if @read_and_write_store.respond_to?(:fetch) ||
+        (@write_only_store && @write_only_store.respond_to?(:fetch))
+      if block_given?
+        result = @read_and_write_store.fetch(name, options = nil) { yield }
+        @write_only_store.fetch(name, options = nil) { yield } if @write_only_store
+        result
+      else
+        result = @read_and_write_store.fetch(name, options = nil)
+        @write_only_store.fetch(name, options = nil) if @write_only_store
+        result
+      end
+    else
+      raise UnSupportException.new "Unsupported #fetch from client object."
+    end
+  end
+
+  def increment(key, amount = 1, options = {})
+    increment_cache_store key, amount, options
+  end
+  alias_method :incr, :increment
+
+  def decrement(key, amount = 1, options = {})
+    decrement_cache_store key, amount, options
+  end
+  alias_method :decr, :decrement
+  
   private
 
   def write_cache_store(key, value, options = nil)
@@ -79,7 +128,12 @@ class DoubleWriteCacheStores::Client
 
   def set_or_write_method_call cache_store, key, value, options
     if cache_store.respond_to? :set
-      cache_store.set key, value, options
+      if defined?(Dalli) && cache_store.is_a?(Dalli::Client)
+        ttl = options[:expires_in] if options
+        cache_store.set key, value, ttl, options
+      else
+        cache_store.set key, value, options
+      end
     elsif cache_store.respond_to? :write
       cache_store.write key, value, options
     end
@@ -93,6 +147,50 @@ class DoubleWriteCacheStores::Client
     end
   end
 
+  def get_multi_or_read_multi_method_call(*keys)
+    if @read_and_write_store.respond_to? :get_multi
+      @read_and_write_store.get_multi *keys
+    elsif @read_and_write_store.respond_to? :read_multi
+      @read_and_write_store.read_multi *keys
+    else
+      raise UnSupportException.new "Unsupported multi keys get or read from client object."
+    end
+  end
+
+  def increment_cache_store(key, amount, options)
+    rw_store_value = incr_or_increment_method_call @read_and_write_store, key, amount, options
+    return rw_store_value unless @write_only_store
+    incr_or_increment_method_call @write_only_store, key, amount, options
+  end
+
+  def decrement_cache_store(key, amount, options)
+    rw_store_value = decr_or_decrement_method_call @read_and_write_store, key, amount, options
+    return rw_store_value unless @write_only_store
+    decr_or_decrement_method_call @write_only_store, key, amount, options
+  end
+
+  def incr_or_increment_method_call(cache_store, key, amount, options)
+    if defined?(Dalli) && cache_store.is_a?(Dalli::Client)
+      ttl = options[:expires_in] if options
+      default = options.has_key?(:initial) ? options[:initial] : amount
+      cache_store.incr key, amount, ttl, default
+    elsif cache_store.respond_to? :increment
+      options[:initial] = amount unless options.has_key?(:initial)
+      cache_store.increment key, amount, options
+    end
+  end
+
+  def decr_or_decrement_method_call(cache_store, key, amount, options)
+    if defined?(Dalli) && cache_store.is_a?(Dalli::Client)
+      ttl = options[:expires_in] if options
+      default = options.has_key?(:initial) ? options[:initial] : 0
+      cache_store.decr key, amount, ttl, default
+    elsif cache_store.respond_to? :decrement
+      options[:initial] = 0 unless options.has_key?(:initial)
+      cache_store.decrement key, amount, options
+    end
+  end
+
   def flush_cache_store(method = :flush)
     if @read_and_write_store.respond_to? method
       if @write_only_store && @write_only_store.respond_to?(method)
@@ -104,11 +202,15 @@ class DoubleWriteCacheStores::Client
     end
   end
 
-  def write_only_store_touch(key)
+  def write_only_store_touch(key, ttl)
     if @write_only_store
-      write_only_backend = @write_only_store.instance_variable_get('@backend') || @write_only_store.instance_variable_get('@data')
-      if write_only_backend
-        write_only_backend.touch key if write_only_backend.respond_to?(:touch)
+      if defined?(Dalli) && @write_only_store.is_a?(Dalli::Client)
+        @write_only_store.touch key, ttl
+      else
+        write_only_backend = @write_only_store.instance_variable_get('@backend') || @write_only_store.instance_variable_get('@data')
+        if write_only_backend
+          write_only_backend.touch(key, ttl) if write_only_backend.respond_to?(:touch)
+        end
       end
     end
   end

data/lib/double_write_cache_stores/version.rb

@@ -1,3 +1,3 @@
 module DoubleWriteCacheStores
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/spec/double_write_cache_stores/client_spec.rb

@@ -11,7 +11,7 @@ describe DoubleWriteCacheStores::Client do
 
   describe '#initialize' do
     it 'different cache store instance' do
-      expect{ subject.new read_and_write_store, 'bad instance object' }.to raise_error
+      expect{ DoubleWriteCacheStores::Client.new read_and_write_store, 'bad instance object' }.to raise_error RuntimeError
     end
   end
 
@@ -19,6 +19,10 @@ describe DoubleWriteCacheStores::Client do
     DoubleWriteCacheStores::Client.new read_and_write_store, write_only_store
   end
 
+  let :one_cache_store do
+    DoubleWriteCacheStores::Client.new read_and_write_store, nil
+  end
+
   describe '#write' do
     before do
       copy_cache_store.write 'key', 'example-value', :expires_in => 1.day
@@ -29,181 +33,270 @@ describe DoubleWriteCacheStores::Client do
     end
   end
 
-  describe 'set #[]=(key, value) and get #[](key)' do
-    it 'set value and get value' do
-      copy_cache_store['key'] = 'example-value'
-      expect(copy_cache_store['key']).to eq 'example-value'
-    end
-  end
+  shared_examples "cache store example" do |cache_store|
+    describe '#read_multi' do
+      before do
+        cache_store.write 'key-a', 'example-value-a', :expires_in => 1.day
+        cache_store.write 'key-b', 'example-value-b', :expires_in => 1.day
+      end
 
-  describe '#delete' do
-    before do
-      copy_cache_store.write 'will-delete-key', 'example-will-delete-value', :expires_in => 1.day
-    end
-    it 'delete key-value' do
-      expect(read_and_write_store.read 'will-delete-key').to eq 'example-will-delete-value'
-      expect(write_only_store.read 'will-delete-key').to eq 'example-will-delete-value'
+      after { cache_store.flush }
 
-      copy_cache_store.delete 'will-delete-key'
+      it 'get multi-keys values from multi store' do
+        results = cache_store.read_multi('key-a', 'key-b', 'key-c')
+        expect(results['key-a']).to eq 'example-value-a'
+        expect(results['key-b']).to eq 'example-value-b'
+        expect(results['key-c']).to eq nil
+      end
 
-      expect(read_and_write_store.read 'will-delete-key').to be_nil
-      expect(write_only_store.read 'will-delete-key').to be_nil
+      it 'returns values equal #get_multi' do
+        expect(cache_store.read_multi('key-a', 'key-b')).to eq cache_store.get_multi('key-a', 'key-b')
+      end
     end
-  end
 
-  describe '#touch' do
-    let :options do
-      { :namespace => "app_v1", :compress => true }
-    end
-    let :support_touch_read_and_write_store do
-      Padrino::Cache::Store::Memcache.new(::Dalli::Client.new('localhost:11211', options))
-    end
-    let :support_touch_write_only_store do
-      Padrino::Cache::Store::Memcache.new(::Dalli::Client.new('localhost:21211', options))
-    end
-    let :support_touch_copy_cache_store do
-      DoubleWriteCacheStores::Client.new support_touch_read_and_write_store, support_touch_write_only_store
-    end
-    before do
-      support_touch_copy_cache_store.set 'touch-key', 'touch-value', :expires_in => 1.day
-    end
+    describe '#fetch' do
+      before do
+        cache_store.write 'key-a', 'example-value-a', :expires_in => 1.day
+      end
 
-    context 'Dalli::Client' do
-      it 'example' do
-        expect(support_touch_copy_cache_store.touch 'touch-key').to be true
-        expect(support_touch_copy_cache_store.touch 'non-set-key').to be nil
+      after { cache_store.flush }
+
+      it 'returns value' do
+        expect(cache_store.fetch('key-a')).to eq 'example-value-a'
+        expect(cache_store.fetch('key-nil')).to eq nil
       end
-    end
 
-    context 'ActiveSupport::Cache::DalliStore' do
-      let :double_write_dalli_store do
-        DoubleWriteCacheStores::Client.new ActiveSupport::Cache::DalliStore.new('localhost:11211', options), ActiveSupport::Cache::DalliStore.new('localhost:21211', options)
+      it 'get value and set value, block in args' do
+        expect(cache_store.fetch('key-b')).to eq nil
+
+        cache_store.fetch('key-b') do
+          'block-value-b'
+        end
+
+        expect(cache_store.fetch('key-b')).to eq 'block-value-b'
+        expect(cache_store.get('key-b')).to eq 'block-value-b'
+
+        result = cache_store.fetch('key-b') do
+          'not-overwrite-value'
+        end
+        expect(cache_store.fetch('key-b')).to eq 'block-value-b'
+        expect(cache_store.get('key-b')).to eq 'block-value-b'
       end
+    end
 
+    describe '#delete' do
       before do
-        double_write_dalli_store.set 'touch-key', 'touch-valule', :expires_in => 1.day
+        copy_cache_store.write 'will-delete-key', 'example-will-delete-value', :expires_in => 1.day
       end
+      it 'delete key-value' do
+        expect(read_and_write_store.read 'will-delete-key').to eq 'example-will-delete-value'
+        expect(write_only_store.read 'will-delete-key').to eq 'example-will-delete-value'
 
-      it 'example' do
-        expect(double_write_dalli_store.touch 'touch-key').to be true
-        expect(double_write_dalli_store.touch 'non-set-key').to be nil
+        copy_cache_store.delete 'will-delete-key'
+
+        expect(read_and_write_store.read 'will-delete-key').to be_nil
+        expect(write_only_store.read 'will-delete-key').to be_nil
       end
     end
-  end
 
-  describe '#read' do
-    context 'when standard case' do
+    describe '#touch' do
+      let(:expire_ttl) { 1 }
+
       before do
-        copy_cache_store.write 'key', 'example-read-value', :expires_in => 1.day
+        cache_store.set 'touch-key', 'touch-value', :expires_in => expire_ttl
       end
-      it 'get read key value from multi store' do
-        expect(copy_cache_store.read 'key').to eq 'example-read-value'
+
+      it 'expired value, not touched' do
+        sleep expire_ttl
+        expect(cache_store.read 'touch-key').to eq nil
       end
-      it 'not get no set key-value' do
-        expect(copy_cache_store.read 'not-set-key').to be_nil
+
+      it 'expired value, touched expired' do
+        expect(cache_store.touch 'touch-key', expire_ttl).to be true
+        sleep expire_ttl
+        expect(cache_store.read 'touch-key').to eq nil
       end
-    end
-    context 'when not set copy cache store' do
-      let :not_copy_cache_store do
-        DoubleWriteCacheStores::Client.new read_and_write_store
+
+      it 'returns value, before touched key' do
+        expect(cache_store.touch 'touch-key').to be true
+        sleep expire_ttl
+        expect(cache_store.read  'touch-key').to eq 'touch-value'
       end
+    end
+
+    describe '#read' do
       before do
-        not_copy_cache_store.write 'no-copy-key', 'example-read-value', :expires_in => 1.day
+        cache_store.write 'key', 'example-read-value', :expires_in => 1.day
       end
-      it 'not sync cache store' do
-        expect(read_and_write_store.read 'no-copy-key').to eq 'example-read-value'
-        expect(write_only_store.read 'no-copy-key').to be_nil
+      it 'returns writed value' do
+        expect(cache_store.read 'key').to eq 'example-read-value'
+      end
+      it 'returns nil, not writed value' do
+        expect(cache_store.read 'not-set-key').to eq nil
       end
     end
-  end
 
-  describe '#flush' do
-    context 'when not support flush method in cache store' do
+    describe '#flush' do
       before do
         copy_cache_store.write 'will-flush-key', 'will-flush-value', :expires_in => 1.day
       end
       it 'example' do
+        expect(copy_cache_store.read 'will-flush-key').to eq 'will-flush-value'
         expect(copy_cache_store.flush).to eq true
-        expect(copy_cache_store.read 'will-flush-key').to be_nil
+        expect(copy_cache_store.read 'will-flush-key').to eq nil
       end
     end
-    context 'when support flush method in backend cache store' do
-      let :options do
-        { :namespace => "app_v1", :compress => true }
-      end
-      let :support_flash_read_and_write_store do
-        Padrino::Cache::Store::Memcache.new(::Dalli::Client.new('localhost:11211', options))
-      end
-      let :support_flash_write_only_store do
-        Padrino::Cache::Store::Memcache.new(::Dalli::Client.new('localhost:21211', options))
-      end
-      let :support_flash_copy_cache_store do
-        DoubleWriteCacheStores::Client.new support_flash_read_and_write_store, support_flash_write_only_store
+
+    shared_examples 'read cache after increment or decrement example' do
+      before { cache_store.set(key, 10, raw: true) }
+      it { expect((cache_store.read key).to_i).to eq expected_value }
+    end
+
+    describe '#increment' do
+      let(:key) { 'key-increment' }
+      after     { cache_store.flush }
+
+      it_behaves_like 'read cache after increment or decrement example' do
+        let!(:expected_value) { cache_store.increment key }
       end
-      before do
-        support_flash_copy_cache_store.set 'will-flush-key',  'will-flush-value', :expires_in => 1.day
+
+      context 'when options[:initial] does not exist' do
+        context 'when value exists' do
+          before { cache_store.set(key, 0, raw: true) }
+          context 'when amount does not exist' do
+            it { expect(cache_store.increment key).to eq 1 }
+          end
+          context 'when amount exists' do
+            it { expect(cache_store.increment key, 2).to eq 2 }
+          end
+        end
+        context 'when value does not exist' do
+          context 'when amount does not exist' do
+            it { expect(cache_store.increment key).to eq 1 }
+          end
+          context 'when amount exists' do
+            it { expect(cache_store.increment key, 2).to eq 2 }
+          end
+        end
       end
-      it 'example' do
-        expect(support_flash_copy_cache_store.get 'will-flush-key').to eq 'will-flush-value'
-        expect(support_flash_copy_cache_store.flush).to be true
-        expect(support_flash_copy_cache_store.get 'will-flush-key').to be_nil
+
+      context 'when options[:initial] exists' do
+        let(:opt) { { initial: 12345678 } }
+        context 'when value exists' do
+          before { cache_store.set(key, 0, raw: true) }
+          it { expect(cache_store.increment key, 1, opt).to eq 1 }
+        end
+        context 'when value does not exist' do
+          it { expect(cache_store.increment key, 1, opt).to eq opt[:initial] }
+        end
       end
     end
-  end
 
-  describe "#get_cas" do
-    context "when support get_cas method in backend cache store" do
-      let :support_get_cas_cache_store do
-        read_and_write = ::Dalli::Client.new(['localhost:11211'])
-        write_only = ::Dalli::Client.new(['localhost:21211'])
-        DoubleWriteCacheStores::Client.new read_and_write, write_only
+    describe '#decrement' do
+      let(:key) { 'key-decrement' }
+      after     { cache_store.flush }
+
+      it_behaves_like 'read cache after increment or decrement example' do
+        let!(:expected_value) { cache_store.decrement key }
       end
 
-      before do
-        support_get_cas_cache_store.set 'cas-dalli-key', 'cas-dalli-value'
+      context 'when options[:initial] does not exist' do
+        context 'when value exists' do
+          before { cache_store.set(key, 101, raw: true) }
+          context 'when amount does not exist' do
+            it { expect(cache_store.decrement key).to eq 100 }
+          end
+          context 'when amount exists' do
+            it { expect(cache_store.decrement key, 2).to eq 99 }
+          end
+        end
+        context 'when value does not exist' do
+          context 'when amount does not exist' do
+            it { expect(cache_store.decrement key).to eq 0 }
+          end
+          context 'when amount exists' do
+            it { expect(cache_store.decrement key, 2).to eq 0 }
+          end
+        end
       end
 
-      it 'example' do
-        expect(support_get_cas_cache_store.get_cas('cas-dalli-key')[0]).to eq 'cas-dalli-value'
-        expect(support_get_cas_cache_store.get_cas('cas-dalli-key')[1]).to be_kind_of(Integer)
+      context 'when options[:initial] exists' do
+        let(:opt) { { initial: 12345678 } }
+        context 'when value exists' do
+          before { cache_store.set(key, 101, raw: true) }
+          it { expect(cache_store.decrement key, 1, opt).to eq 100 }
+        end
+        context 'when value does not exist' do
+          it { expect(cache_store.decrement key, 1, opt).to eq opt[:initial] }
+        end
       end
     end
 
-    context "when doesn't support get_cas method in backend cache store" do
-      let :not_support_get_cas_cache_store do
-        DoubleWriteCacheStores::Client.new ActiveSupport::Cache::DalliStore.new('localhost:11211'), ActiveSupport::Cache::DalliStore.new('localhost:21211')
+    describe '#[]=(key,value) and get #[](key)' do
+      it 'set value and get value' do
+        cache_store['key'] = 'example-value'
+        expect(cache_store['key']).to eq 'example-value'
       end
+    end
 
-      it 'should raise NoMethodError' do
-        expect{ not_support_get_cas_cache_store.get_cas 'cas-key' }.to raise_error(NoMethodError)
+    describe 'cas' do
+      describe '#get_cas' do
+        before do
+          cache_store.set_cas 'get-cas-key', 'get-cas-value'
+        end
+
+        it 'example' do
+          expect(cache_store.get_cas('get-cas-key')[0]).to eq 'get-cas-value'
+          expect(cache_store.get_cas('get-cas-key')[1]).to be_kind_of(Integer)
+        end
+      end
+
+      describe '#set_cas' do
+        let :cas_unique do
+          cache_store.set_cas('set-cas-key', 'set-cas-value')
+          cache_store.get_cas('set-cas-key')[1]
+        end
+
+        it 'example' do
+          expect(cache_store.set_cas('set-cas-key', 'set-cas-value', cas_unique)).to be_kind_of(Integer)
+        end
+
+        it 'returns false, not set cache because different cas_unique' do
+          expect(cache_store.set_cas('set-cas-key', 'set-cas-value', cas_unique - 1)).to eq false
+        end
       end
     end
   end
 
-  describe "#set_cas" do
-    context "when support set_cas method in backend cache store" do
-      let :support_set_cas_cache_store do
-        read_and_write = ::Dalli::Client.new(['localhost:11211'])
-        write_only = ::Dalli::Client.new(['localhost:21211'])
-        DoubleWriteCacheStores::Client.new read_and_write, write_only
-      end
-      let :cas_unique do
-        support_set_cas_cache_store.set('cas-dalli-key', 'cas-value')
-        support_set_cas_cache_store.get_cas('cas-dalli-key')[1]
+  describe "shard example" do
+    context "ActiveSupport :dalli_store" do
+      read_and_write_store = ActiveSupport::Cache.lookup_store :dalli_store, 'localhost:11211'
+      write_only_store = ActiveSupport::Cache.lookup_store :dalli_store, 'localhost:21211'
+
+      context "double cache store" do
+        copy_cache_store = DoubleWriteCacheStores::Client.new(read_and_write_store, write_only_store)
+        it_behaves_like "cache store example", copy_cache_store
       end
 
-      it 'example' do
-        expect(support_set_cas_cache_store.set_cas('cas-dalli-key', 'cas-dalli-value', cas_unique)).to be_kind_of(Integer)
+      context "one cache store object" do
+        one_cache_store = DoubleWriteCacheStores::Client.new(read_and_write_store, nil)
+        it_behaves_like "cache store example", one_cache_store
       end
     end
 
-    context "when doesn't support set_cas method in backend cache store" do
-      let :not_support_set_cas_cache_store do
-        DoubleWriteCacheStores::Client.new ActiveSupport::Cache::DalliStore.new('localhost:11211'), ActiveSupport::Cache::DalliStore.new('localhost:21211')
+    context "Dalli::Client" do
+      options = { :namespace => "app_v1", :compress => true }
+      read_and_write_store = Dalli::Client.new('localhost:11211', options)
+      write_only_store = Dalli::Client.new('localhost:21211', options)
+
+      context "double cache store" do
+        copy_cache_store = DoubleWriteCacheStores::Client.new(read_and_write_store, write_only_store)
+        it_behaves_like "cache store example", copy_cache_store
       end
 
-      it 'should raise NoMethodError' do
-        expect{ not_support_set_cas_cache_store.set_cas('cas-key', 'cas-value', 1) }.to raise_error(NoMethodError)
+      context "one cache store" do
+        one_cache_store = DoubleWriteCacheStores::Client.new(read_and_write_store)
+        it_behaves_like "cache store example", one_cache_store
       end
     end
   end

data/spec/double_write_cache_stores_spec.rb

@@ -2,6 +2,6 @@ require 'spec_helper'
 
 describe DoubleWriteCacheStores do
   it 'should have a version number' do
-    DoubleWriteCacheStores::VERSION.should_not be_nil
+    expect(DoubleWriteCacheStores::VERSION).not_to be_nil
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: double_write_cache_stores
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - hirocaster
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-09 00:00:00.000000000 Z
+date: 2015-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -138,7 +138,9 @@ files:
 - README.md
 - Rakefile
 - double_write_cache_stores.gemspec
+- lib/dalli_store_patch.rb
 - lib/double_write_cache_stores.rb
+- lib/double_write_cache_stores/base_exception.rb
 - lib/double_write_cache_stores/client.rb
 - lib/double_write_cache_stores/version.rb
 - spec/double_write_cache_stores/client_spec.rb
@@ -164,7 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Double write cache stores wrapper.