moneta 1.0.0 → 1.1.0

data/spec/features/concurrent_create.rb

@@ -0,0 +1,21 @@
+shared_examples :concurrent_create do
+  def create_thread(name)
+    Thread.new do
+      s = new_store
+      1000.times do |i|
+        s[i.to_s].should == name if s.create(i.to_s, name, expires: false)
+        Thread.pass if rand(100) >= 99
+      end
+      s.close
+    end
+  end
+
+  it 'have atomic create across multiple threads', isolate: true do
+    a = create_thread('a')
+    b = create_thread('b')
+    c = create_thread('c')
+    a.join
+    b.join
+    c.join
+  end
+end

data/spec/features/concurrent_increment.rb

@@ -0,0 +1,32 @@
+shared_examples :concurrent_increment do
+  def increment_thread(name)
+    Thread.new do
+      s = new_store
+      100.times do |i|
+        100.times do |j|
+          s.increment("counter#{j}", 1, expires: false)
+          Thread.pass if rand(1000) >= 995
+        end
+        s.store("#{name}#{i}", i.to_s, expires: false)
+      end
+      s.close
+    end
+  end
+
+  it 'have atomic increment across multiple threads', isolate: true do
+    a = increment_thread('a')
+    b = increment_thread('b')
+    c = increment_thread('c')
+    a.join
+    b.join
+    c.join
+    100.times do |i|
+      store["a#{i}"].should == i.to_s
+      store["b#{i}"].should == i.to_s
+      store["c#{i}"].should == i.to_s
+    end
+    100.times do |j|
+      store.raw["counter#{j}"].should == 300.to_s
+    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
+  at_each_usec 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 + t_res
+      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 + t_res
+      store['key'].should == 'value'
+      store.key?('key').should be true
+    end
+  end
+end

data/spec/features/default_expires.rb

@@ -0,0 +1,15 @@
+shared_examples :default_expires do
+  at_each_usec 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 + t_res
+      store.key?('key1').should be false
+      store.fetch('key1').should be_nil
+      store.load('key1').should be_nil
+    end
+  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

data/spec/features/expires.rb

@@ -0,0 +1,291 @@
+shared_examples :expires do
+  before do
+    raise "t_res must be <= min_ttl" unless t_res <= min_ttl
+  end
+
+  at_each_usec do
+    # All methods that are used for updating that include an :expires parameter
+    shared_examples :updater_expiry do
+      context "with a positive numeric :expires parameter" do
+        before do
+          updater.call(expires: min_ttl)
+        end
+
+        it 'causes the value to expire after the given number of seconds' do
+          keys.zip(values).each do |key, value|
+            expect(store.load(key)).to eq value
+            expect(store[key]).to eq value
+          end
+          advance min_ttl + t_res
+          keys.each do |key, value|
+            expect(store.load(key)).to be_nil
+            expect(store[key]).to be_nil
+          end
+        end
+      end
+
+      shared_examples :updater_no_expires do
+        it 'causes the value not to expire after the given number of seconds' do
+          updater.call(expires: expires)
+          keys.zip(values).each do |key, value|
+            expect(store.load(key)).to eq value
+            expect(store[key]).to eq value
+          end
+          advance min_ttl + t_res
+          keys.zip(values).each do |key, value|
+            expect(store.load(key)).to eq value
+            expect(store[key]).to eq value
+          end
+        end
+      end
+
+      context "with a zero :expires parameter" do
+        let(:expires) { 0 }
+        include_examples :updater_no_expires
+      end
+
+      context "with a false :expires parameter" do
+        let(:expires) { false }
+        include_examples :updater_no_expires
+      end
+    end
+
+    # All methods that are used to for loading, and that include an expire parameter
+    shared_examples :loader_expiry do
+      it "does not affect expiry if the value is not present" do
+        expect(loader.call(expires: min_ttl)).to be_absent
+        expect(loader.call).to be_absent
+      end
+
+      shared_examples :loader_expires do
+        context 'when passed a positive numeric :expires parameter' do
+          it 'changes the expiry of the value(s) to the given number of seconds' do
+            expect(loader.call).to be_present
+            expect(loader.call(expires: min_ttl + 2 * t_res)).to be_present
+            advance min_ttl + t_res
+            expect(loader.call).to be_present
+            advance 2 * t_res
+            expect(loader.call).to be_absent
+          end
+        end
+      end
+
+      context 'with previously stored expiring value(s)' do
+        before do
+          keys.zip(values).each do |key, value|
+            store.store(key, value, expires: min_ttl)
+          end
+        end
+        include_examples :loader_expires
+
+        shared_examples :loader_no_expires do
+          it "changes the expiry of the value(s) so that they don't expire" do
+            expect(loader.call(expires: expires)).to be_present
+            advance min_ttl + t_res
+            expect(loader.call).to be_present
+          end
+        end
+
+        context "when passed a zero :expires parameter" do
+          let(:expires) { 0 }
+          include_examples :loader_no_expires
+        end
+
+        context "when passed false :expires parameter" do
+          let(:expires) { false }
+          include_examples :loader_no_expires
+        end
+
+        shared_examples :loader_no_effect do
+          it 'does not affect the expiry time' do
+            expect(loader_no_effect.call).to be_present
+            advance min_ttl + t_res
+            expect(loader.call).to be_absent
+          end
+        end
+
+        context 'when passed a nil :expires parameter' do
+          let(:loader_no_effect) { lambda { loader.call(expires: nil) } }
+          include_examples :loader_no_effect
+        end
+
+        context 'when not passed an :expires parameter' do
+          let(:loader_no_effect) { loader }
+          include_examples :loader_no_effect
+        end
+      end
+
+      context "with previously stored not expiring value(s)" do
+        before do
+          keys.zip(values).each do |key, value|
+            store.store(key, value, expires: false)
+          end
+        end
+        include_examples :loader_expires
+      end
+    end
+
+    describe '#store' do
+      let(:keys) { ['key1'] }
+      let(:values) { ['value1'] }
+      let(:updater) do
+        lambda do |**options|
+          expect(store.store(keys[0], values[0], options)).to eq values[0]
+        end
+      end
+
+      include_examples :updater_expiry
+    end
+
+    describe '#load' do
+      let(:keys) { ['key1'] }
+      let(:values) { ['value1'] }
+      let(:loader) do
+        lambda { |**options| store.load('key1', options) }
+      end
+      let(:be_present) { eq 'value1' }
+      let(:be_absent) { be_nil }
+
+      include_examples :loader_expiry
+    end
+
+    describe '#key?' do
+      let(:keys) { ['key1'] }
+      let(:values) { ['value1'] }
+      let(:loader) do
+        lambda { |**options| store.key?('key1', options) }
+      end
+      let(:be_present) { be true }
+      let(:be_absent) { be false }
+
+      include_examples :loader_expiry
+    end
+
+    describe '#fetch' do
+      let(:keys) { ['key1'] }
+      let(:values) { ['value1'] }
+      let(:be_present) { eq 'value1' }
+
+      context "with default given as second parameter" do
+        let(:loader) do
+          lambda { |**options| store.fetch('key1', 'missing', options) }
+        end
+        let(:be_absent) { eq 'missing' }
+
+        include_examples :loader_expiry
+      end
+
+      context "with default given as a block" do
+        let(:loader) do
+          lambda { |**options| store.fetch('key1', options) { 'missing' } }
+        end
+        let(:be_absent) { eq 'missing' }
+
+        include_examples :loader_expiry
+      end
+
+      context "with nil default given" do
+        let(:loader) do
+          lambda { |**options| store.fetch('key1', nil, options) }
+        end
+        let(:be_absent) { be_nil }
+
+        include_examples :loader_expiry
+      end
+    end
+
+    describe '#delete' do
+      context 'with an already expired value' do
+        before do
+          store.store('key2', 'val2', expires: min_ttl)
+          expect(store['key2']).to eq 'val2'
+          advance min_ttl + t_res
+        end
+
+        it 'does not return the expired value' do
+          expect(store.delete('key2')).to be_nil
+        end
+      end
+    end
+
+    describe '#expires' do
+      it "returns a store with access to the same items" do
+        store.store('persistent_key', 'persistent_value', expires: false)
+        store_expires = store.expires(min_ttl)
+        expect(store_expires['persistent_key']).to eq 'persistent_value'
+      end
+
+      it "returns a store with default expiry set" do
+        store_expires = store.expires(min_ttl)
+        expect(store_expires.store('key1', 'val1')).to eq 'val1'
+        expect(store_expires['key1']).to eq 'val1'
+        advance min_ttl + t_res
+        expect(store['key1']).to be_nil
+      end
+    end
+
+    describe '#merge!' do
+      let(:keys) { ['key1', 'key2'] }
+      let(:values) { ['value1', 'value2'] }
+      let(:updater) do
+        lambda do |**options|
+          expect(store.merge!(keys.zip(values), options)).to eq store
+        end
+      end
+
+      include_examples :updater_expiry
+    end
+
+    describe '#values_at' do
+      let(:keys) { ['key1', 'key2'] }
+      let(:values) { ['value1', 'value2'] }
+      let(:loader) do
+        lambda { |**options| store.values_at('key1', 'key2', **options) }
+      end
+      let(:be_present) { eq ['value1', 'value2'] }
+      let(:be_absent) { eq [nil, nil] }
+
+      include_examples :loader_expiry
+    end
+
+    describe '#fetch_values' do
+      let(:keys) { ['key1', 'key2'] }
+      let(:values) { ['value1', 'value2'] }
+      let(:be_present) { eq ['value1', 'value2'] }
+
+      context 'with default values given via a block' do
+        let(:loader) do
+          lambda do |**options|
+            store.fetch_values('key1', 'key2', **options) { |k| "#{k} missing" }
+          end
+        end
+        let(:be_absent) { eq ['key1 missing', 'key2 missing'] }
+
+        include_examples :loader_expiry
+      end
+
+      context 'without default values given' do
+        let(:loader) do
+          lambda do |**options|
+            store.fetch_values('key1', 'key2', **options)
+          end
+        end
+        let(:be_absent) { eq [nil, nil] }
+
+        include_examples :loader_expiry
+      end
+    end
+
+    describe '#slice' do
+      let(:keys) { ['key1', 'key2'] }
+      let(:values) { ['value1', 'value2'] }
+      let(:loader) do
+        lambda { |**options| store.slice('key1', 'key2', **options) }
+      end
+      let(:be_present) { contain_exactly(['key1', 'value1'], ['key2', 'value2']) }
+      let(:be_absent) { be_empty }
+
+      include_examples :loader_expiry
+    end
+  end
+end