moneta 1.0.0 → 1.5.1

data/spec/active_support/cache_moneta_store_spec.rb

@@ -2,19 +2,7 @@ require 'moneta'
 require 'active_support'
 require 'active_support/cache/moneta_store'
 require 'ostruct'
-
-module MonetaStoreHelpers
-  def with_notifications
-    described_class.instrument = true
-    yield
-  ensure
-    described_class.instrument = false
-  end
-end
-
-RSpec.configure do |config|
-  config.include(MonetaStoreHelpers)
-end
+require_relative '../moneta/adapters/memcached_helper.rb'
 
 describe "cache_moneta_store" do
   before(:all) do
@@ -30,75 +18,99 @@ describe "cache_moneta_store" do
 
   # All stores should implement this basic behavior.
   shared_examples :basic_store do
-    before(:each) do
-      @rabbit = OpenStruct.new name: 'bunny'
-      @white_rabbit = OpenStruct.new color: 'white'
+    let(:rabbit) { OpenStruct.new name: 'bunny' }
+    let(:white_rabbit) { OpenStruct.new color: 'white' }
 
+    before(:each) do
       store.clear
-      store.write 'rabbit', @rabbit
+      store.write 'rabbit', rabbit
+      @events.clear
     end
 
     it 'reads the data' do
-      store.read('rabbit').should == @rabbit
+      expect(store.read('rabbit')).to eq rabbit
     end
 
     it 'writes the data' do
-      store.write 'rabbit', @white_rabbit
-      store.read('rabbit').should == @white_rabbit
+      store.write 'rabbit', white_rabbit
+      expect(store.read('rabbit')).to eq white_rabbit
     end
 
     it 'deletes data' do
       store.delete 'rabbit'
-      store.read('rabbit').should be_nil
+      expect(store.read('rabbit')).to be_nil
     end
 
     it 'verifies existence of an object in the store' do
-      store.exist?('rabbit').should be true
-      (!!store.exist?('rab-a-dub')).should be false
+      expect(store.exist?('rabbit')).to be true
+      expect(!!store.exist?('rab-a-dub')).to be false
     end
 
     it 'fetches data' do
-      store.fetch('rabbit').should == @rabbit
-      store.fetch('rub-a-dub').should be_nil
+      expect(store.fetch('rabbit')).to eq rabbit
+      expect(store.fetch('rub-a-dub')).to be_nil
       store.fetch('rub-a-dub') { 'Flora de Cana' }
-      store.fetch('rub-a-dub').should == 'Flora de Cana'
+      expect(store.fetch('rub-a-dub')).to eq 'Flora de Cana'
     end
 
     it 'reads multiple keys' do
       store.write 'irish whisky', 'Jameson'
       result = store.read_multi 'rabbit', 'irish whisky'
-      result['rabbit'].should == @rabbit
-      result['irish whisky'].should == 'Jameson'
+      expect(result['rabbit']).to eq rabbit
+      expect(result['irish whisky']).to eq 'Jameson'
     end
 
     it 'reads multiple keys and returns only the matched ones' do
       store.delete 'irish whisky'
       result = store.read_multi 'rabbit', 'irish whisky'
-      result.should_not include('irish whisky')
-      result.should include('rabbit')
+      expect(result).not_to include('irish whisky')
+      expect(result).to include('rabbit')
+    end
+
+    it 'fetches multiple keys and fills in the missing ones' do
+      store.delete 'irish whisky'
+      result = store.fetch_multi('rabbit', 'irish whisky') do |k|
+        k + ' was missing'
+      end
+      expect(result['rabbit']).to eq rabbit
+      expect(result['irish whisky']).to eq 'irish whisky was missing'
+      expect(store.fetch('irish whisky')).to eq 'irish whisky was missing'
     end
   end
 
   shared_examples :expiry do
     it 'writes the data with expiration time' do
-      store.write 'rabbit', @white_rabbit, expires_in: 1.second
-      store.read('rabbit').should == @white_rabbit
-      sleep 2
-      store.read('rabbit').should be_nil
+      store.write 'rabbit', white_rabbit, expires_in: 0.2.second
+      expect(store.read('rabbit')).to eq white_rabbit
+      sleep 0.3
+      expect(store.read('rabbit')).to be_nil
+    end
+
+    it 'writes multiple values with expiration time' do
+      store.write_multi({
+                          'rabbit' => white_rabbit,
+                          'irish whisky' => 'Jameson'
+                        }, expires_in: 0.2.second)
+
+      expect(store.read_multi('rabbit', 'irish whisky')).to eq \
+        'rabbit' => white_rabbit,
+        'irish whisky' => 'Jameson'
+
+      sleep 0.3
+      expect(store.read_multi('rabbit', 'irish whisky')).to be_empty
     end
 
     it "sets expiry on cache miss" do
-      store.fetch('rabbit', force: true) # force cache miss
-      store.fetch('rabbit', force: true, expires_in: 1.second) { @white_rabbit }
-      store.fetch('rabbit').should == @white_rabbit
-      sleep 2
-      store.fetch('rabbit').should be_nil
+      store.fetch('rabbit', force: true, expires_in: 0.2.second) { white_rabbit }
+      expect(store.fetch('rabbit')).to eq white_rabbit
+      sleep 0.3
+      expect(store.fetch('rabbit')).to be_nil
     end
 
     it 'does not set expiry on cache hit' do
-      store.fetch('rabbit', expires_in: 1.second) { @white_rabbit }.should == @rabbit
-      sleep 2
-      store.fetch('rabbit').should == @rabbit
+      expect(store.fetch('rabbit', expires_in: 0.2.second) { white_rabbit }).to eq rabbit
+      sleep 0.3
+      expect(store.fetch('rabbit')).to eq rabbit
     end
   end
 
@@ -106,149 +118,160 @@ describe "cache_moneta_store" do
   shared_examples :increment_decrement do
     it 'increments a key' do
       store.write 'counter', 0, raw: true
-      3.times { store.increment 'counter' }
-      store.read('counter', raw: true).to_i.should == 3
+      (1..3).each do |i|
+        expect(store.increment('counter')).to eq i
+      end
+      expect(store.read('counter', raw: true).to_i).to eq 3
     end
 
     it 'decrements a key' do
       store.write 'counter', 0, raw: true
       3.times { store.increment 'counter' }
       2.times { store.decrement 'counter' }
-      store.read('counter', raw: true).to_i.should == 1
+      expect(store.read('counter', raw: true).to_i).to eq 1
     end
 
     it 'increments a key by given value' do
       store.write 'counter', 0, raw: true
       store.increment 'counter', 3
-      store.read('counter', raw: true).to_i.should == 3
+      expect(store.read('counter', raw: true).to_i).to eq 3
     end
 
     it 'decrements a key by given value' do
       store.write 'counter', 0, raw: true
       3.times { store.increment 'counter' }
       store.decrement 'counter', 2
-      store.read('counter', raw: true).to_i.should == 1
+      expect(store.read('counter', raw: true).to_i).to eq 1
     end
   end
 
   shared_examples :basic_instrumentation do
     it 'notifies on #fetch' do
-      with_notifications do
-        store.fetch('radiohead') { 'House Of Cards' }
-      end
+      store.fetch('radiohead') { 'House Of Cards' }
 
       read = @events.shift
-      read.name.should == 'cache_read.active_support'
-      read.payload.should == { key: 'radiohead', super_operation: :fetch }
+      expect(read.name).to eq 'cache_read.active_support'
+      expect(read.payload).to include(key: 'radiohead', super_operation: :fetch, hit: false)
 
       generate = @events.shift
-      generate.name.should == 'cache_generate.active_support'
-      generate.payload.should == { key: 'radiohead' }
+      expect(generate.name).to eq 'cache_generate.active_support'
+      expect(generate.payload).to include(key: 'radiohead')
 
       write = @events.shift
-      write.name.should == 'cache_write.active_support'
-      write.payload.should == { key: 'radiohead' }
+      expect(write.name).to eq 'cache_write.active_support'
+      expect(write.payload).to include(key: 'radiohead')
     end
 
     it 'notifies on #read' do
-      with_notifications do
-        store.read 'metallica'
-      end
+      store.read 'metallica'
 
       read = @events.shift
-      read.name.should == 'cache_read.active_support'
-      read.payload.should == { key: 'metallica', hit: false }
+      expect(read.name).to eq 'cache_read.active_support'
+      expect(read.payload).to include(key: 'metallica', hit: false)
     end
 
     it 'notifies on #write' do
-      with_notifications do
-        store.write 'depeche mode', 'Enjoy The Silence'
-      end
+      store.write 'depeche mode', 'Enjoy The Silence'
 
       write = @events.shift
-      write.name.should == 'cache_write.active_support'
-      write.payload.should == { key: 'depeche mode' }
+      expect(write.name).to eq 'cache_write.active_support'
+      expect(write.payload).to include(key: 'depeche mode')
     end
 
     it 'notifies on #delete' do
-      with_notifications do
-        store.delete 'the new cardigans'
-      end
+      store.delete 'the new cardigans'
 
       delete = @events.shift
-      delete.name.should == 'cache_delete.active_support'
-      delete.payload.should == { key: 'the new cardigans' }
+      expect(delete.name).to eq 'cache_delete.active_support'
+      expect(delete.payload).to include(key: 'the new cardigans')
     end
 
     it 'notifies on #exist?' do
-      with_notifications do
-        store.exist? 'the smiths'
-      end
+      store.exist? 'the smiths'
 
       exist = @events.shift
-      exist.name.should == 'cache_exist?.active_support'
-      exist.payload.should == { key: 'the smiths' }
+      expect(exist.name).to eq 'cache_exist?.active_support'
+      expect(exist.payload).to include(key: 'the smiths')
     end
-
   end
 
   # This doesn't seem to be documented at all, so we follow the
   # behavior of MemCacheStore.
   shared_examples :increment_decrement_instrumentation do
     it 'notifies on #increment' do
-      with_notifications do
-        store.increment 'pearl jam'
-      end
+      store.increment 'pearl jam'
 
       increment = @events.shift
-      increment.name.should == 'cache_increment.active_support'
-      increment.payload.should == { key: 'pearl jam', amount: 1 }
+      expect(increment.name).to eq 'cache_increment.active_support'
+      expect(increment.payload).to eq(key: 'pearl jam', amount: 1)
     end
 
     it 'notifies on #decrement' do
-      with_notifications do
-        store.decrement 'placebo'
-      end
-
+      store.decrement 'placebo'
       decrement = @events.shift
-      decrement.name.should == 'cache_decrement.active_support'
-      decrement.payload.should == { key: 'placebo', amount: 1 }
+      expect(decrement.name).to eq 'cache_decrement.active_support'
+      expect(decrement.payload).to eq(key: 'placebo', amount: 1)
     end
   end
 
   describe ActiveSupport::Cache::MonetaStore do
-    let(:store){ described_class.new(store: Moneta.new(:Memory)) }
-
-    include_examples :basic_store
-    include_examples :expiry
-    include_examples :increment_decrement
-    include_examples :basic_instrumentation
-    include_examples :increment_decrement_instrumentation
-
-    # FIXME: no other store does this -- perhaps this should be
-    # removed.
-    it 'notifies on #clear' do
-      with_notifications do
+    shared_examples :moneta_store do
+      include_examples :basic_store
+      include_examples :expiry
+      include_examples :increment_decrement
+      include_examples :basic_instrumentation
+      include_examples :increment_decrement_instrumentation
+
+      # FIXME: no other store does this -- perhaps this should be
+      # removed.
+      it 'notifies on #clear' do
         store.clear
+
+        clear = @events.shift
+        expect(clear.name).to eq 'cache_clear.active_support'
+        expect(clear.payload).to eq(key: nil)
       end
+    end
+
+    context "with :Memory store" do
+      let(:store) { described_class.new(store: :Memory) }
+      include_examples :moneta_store
+    end
+
+    context "with existing :Memory store" do
+      let(:store) { described_class.new(store: ::Moneta.new(:Memory)) }
+      include_examples :moneta_store
+    end
 
-      clear = @events.shift
-      clear.name.should == 'cache_clear.active_support'
-      clear.payload.should == { key: nil }
+    context "with Redis store", adapter: :Redis do
+      let(:store) { described_class.new(store: :Redis) }
+      include_examples :moneta_store
     end
   end
 
   describe ActiveSupport::Cache::MemoryStore do
-    let(:store){ described_class.new }
+    let(:store) { described_class.new }
+
+    include_examples :basic_store
+    include_examples :expiry
+    include_examples :increment_decrement
+    include_examples :basic_instrumentation
+  end
+
+  describe ActiveSupport::Cache::MemCacheStore, memcached: true do
+    let(:store) { described_class.new('127.0.0.1:11213') }
+
+    include_context :start_memcached, 11213
 
     include_examples :basic_store
     include_examples :expiry
     include_examples :increment_decrement
     include_examples :basic_instrumentation
+    include_examples :increment_decrement_instrumentation
   end
 
-  describe ActiveSupport::Cache::MemCacheStore do
-    let(:store){ described_class.new }
+  describe ActiveSupport::Cache::RedisCacheStore, redis: true do
+    let(:store) { described_class.new(url: "redis:///3") }
 
     include_examples :basic_store
     include_examples :expiry

data/spec/features/concurrent_create.rb

@@ -0,0 +1,42 @@
+shared_examples :concurrent_create do
+  # Each thread attempts to create
+  def create_thread(name)
+    Thread.new do
+      s = new_store
+      begin
+        (0...1000).map do |i|
+          s.create(i.to_s, name, expires: false).tap do
+            Thread.pass if rand(100) >= 99
+          end
+        end
+      ensure
+        s.close
+      end
+    end
+  end
+
+  it 'have atomic create across multiple threads', isolate: true do
+    names = %w{a b c}
+
+    # Spawn threads and then group results (lists of true/false values) by
+    # store index (0...1000)
+    results = names
+      .map { |name| create_thread(name) }
+      .map(&:value)
+      .transpose.each_with_index
+      .map { |created_values, i| [i.to_s, created_values] }
+      .to_h
+
+    # Just a quick sanity check
+    expect(results.length).to eq 1000
+
+    # Ensure that for each index, one and only one created value is true
+    expect(results.map { |_, created_values| created_values.inject(:^) }).to all(be true)
+
+    # Check that the when a call to create returned true, that the store
+    # contains the correct value as a result
+    expect(store.slice(*results.keys).to_h).to eq(results.map do |i, values|
+      [i, names[values.index(true)]]
+    end.to_h)
+  end
+end

data/spec/features/concurrent_increment.rb

@@ -0,0 +1,39 @@
+shared_examples :concurrent_increment do
+  def increment_thread(name)
+    Thread.new do
+      s = new_store
+      begin
+        # Create an array where each entry is a list of all the return values
+        # from calling increment for a particular key.
+        increments = (0...100).map { [] }
+        100.times do
+          100.times do |j|
+            increments[j] << s.increment(j.to_s, 1, expires: false)
+            Thread.pass if rand(1000) >= 995
+          end
+        end
+        increments
+      ensure
+        s.close
+      end
+    end
+  end
+
+  it 'have atomic increment across multiple threads', isolate: true do
+    results = %w{a b c}
+      .map { |name| increment_thread(name) }
+      .map(&:value)
+      .transpose # Now the array is indexed by store key instead of thread
+
+    # Sanity check
+    expect(results.length).to eq 100
+
+    results.each do |ith_values|
+      # ensure that for each pair in the triple there are no overlapping values
+      expect(ith_values.combination(2).map { |a, b| a & b }).to all be_empty
+
+      # ensure that when joined together they cover the full 1..300 range
+      expect(ith_values.inject(:+)).to contain_exactly(*1..300)
+    end
+  end
+end

data/spec/features/create.rb

@@ -0,0 +1,25 @@
+shared_examples :create do
+  it 'creates the given key' do
+    store.create('key','value').should be true
+    store['key'].should == 'value'
+  end
+
+  it 'creates raw value with the given key' do
+    store.raw.create('key','value').should be true
+    store.raw['key'].should == 'value'
+  end
+
+  it 'does not create a key if it exists' do
+    store['key'] = 'value'
+    store.create('key','another value').should be false
+    store['key'].should == 'value'
+  end
+
+  it 'supports Mutex' do
+    a = Moneta::Mutex.new(store, 'mutex')
+    b = Moneta::Mutex.new(store, 'mutex')
+    a.lock.should be true
+    b.try_lock.should be false
+    a.unlock.should be_nil
+  end
+end

data/spec/features/create_expires.rb

@@ -0,0 +1,19 @@
+shared_examples :create_expires do
+  it 'creates the given key and expires it' do
+    store.create('key','value', expires: min_ttl).should be true
+    store['key'].should == 'value'
+    advance min_ttl
+    2.times { advance_next_tick }
+    store.key?('key').should be false
+  end
+
+  it 'does not change expires if the key exists' do
+    store.store('key', 'value', expires: false).should == 'value'
+    store.create('key','another value', expires: min_ttl).should be false
+    store['key'].should == 'value'
+    advance min_ttl
+    2.times { advance_next_tick }
+    store['key'].should == 'value'
+    store.key?('key').should be true
+  end
+end

data/spec/features/default_expires.rb

@@ -0,0 +1,14 @@
+shared_examples :default_expires do
+  it 'sets the default expiration time', default_expires: true do
+    store['key1'] = 'val1'
+    advance(t_res / 4.0) # sleep less than a single time-space
+    store.key?('key1').should be true
+    store.fetch('key1').should == 'val1'
+    store.load('key1').should == 'val1'
+    advance min_ttl
+    2.times { advance_next_tick }
+    store.key?('key1').should be false
+    store.fetch('key1').should be_nil
+    store.load('key1').should be_nil
+  end
+end

data/spec/features/each_key.rb

@@ -0,0 +1,119 @@
+shared_examples :each_key do
+  shared_examples "enumerable" do
+    it 'returns an empty enum when there are no keys' do
+      expect(each_key.call.count).to eq(0)
+    end
+
+    it 'returns collection with the stored key/s' do
+      expect { store.store('1st_key', 'value') }
+        .to change { each_key.call.to_a }
+        .from([])
+        .to(['1st_key'])
+
+      expect { store.store('2nd_key', 'value') }
+        .to change { each_key.call.to_a.sort }
+        .from(['1st_key'])
+        .to(['1st_key', '2nd_key'].sort)
+    end
+
+    it 'when a lazy size implementation exist it returns the size of the collection or nil' do
+      expect(store.each_key.size).to eq(nil) | eq(0)
+
+      if !store.each_key.size.nil? && store.each_key.size.zero?
+        expect { store.store('1st_key', 'value') }
+          .to change { store.each_key.size }
+          .from(0)
+          .to(1)
+
+        expect { store.store('2nd_key', 'value') }
+          .to change { store.each_key.size }
+          .from(1)
+          .to(2)
+
+        expect { store.delete('1st_key') }
+          .to change { store.each_key.size }
+          .from(2)
+          .to(1)
+      end
+    end
+
+    it 'doesn\'t duplicate keys' do
+      expect { 2.times { |i| store.store('a_key', "#{i}_val") } }
+        .to change { each_key.call.to_a }
+        .from([])
+        .to(['a_key'])
+    end
+
+    it 'doesn\'t return deleted keys' do
+      store.store('a_key', "a_val")
+      store.store('b_key', "b_val")
+      expect { store.delete('a_key') }
+        .to change { each_key.call.to_a.sort }
+        .from(['a_key', 'b_key'].sort)
+        .to(['b_key'])
+    end
+
+    it 'allows checking and retrieving entries while enumerating' do
+      store['a'] = 'b'
+      store['c'] = 'd'
+      each_key.call do |k|
+        val = if k == 'a' then 'b' else 'd' end
+        expect(store.key?(k)).to be true
+        expect(store[k]).to eq val
+        expect(store.fetch(k)).to eq val
+      end
+    end
+  end
+
+  context "when a block is not given" do
+    let(:each_key) do
+      store.method(:each_key)
+    end
+
+    include_examples 'enumerable'
+
+    it "returns the store if a block is given to #each" do
+      expect(store.each_key.each.each.each{}).to eq store
+    end
+  end
+
+  context "when a block is given" do
+    let :each_key do
+      proc do |&block|
+        if block
+          store.each_key(&block)
+        else
+          Enumerator.new do |y|
+            store.each_key(&y.method(:<<))
+          end
+        end
+      end
+    end
+
+    include_examples 'enumerable'
+
+    it 'yields the keys to the block' do
+      # Make a list of keys that we expect to find in the store
+      keys = []
+
+      2.times do |i|
+        key = "key_#{i}"
+        keys << key
+        store.store(key, "#{i}_val")
+      end
+
+      # Enumerate the store, making store that at each iteration we find one of
+      # the keys we are looking for
+      expect(store.each_key do |k|
+        expect(keys.delete(k)).not_to be_nil
+      end).to eq(store)
+
+      # To assert that all keys were seen by the block
+      expect(keys).to be_empty
+    end
+
+    it "returns the store" do
+      expect(store.each_key{}).to eq store
+    end
+  end
+end