moneta 1.1.1 → 1.4.1

data/spec/features/concurrent_increment.rb

@@ -2,31 +2,38 @@ 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
+      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
-        s.store("#{name}#{i}", i.to_s, expires: false)
+        increments
+      ensure
+        s.close
       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
+    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_expires.rb

@@ -1,19 +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 '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 + t_res
-      store['key'].should == 'value'
-      store.key?('key').should be true
-    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

@@ -1,15 +1,14 @@
 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
+  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/expires.rb

@@ -3,289 +3,294 @@ shared_examples :expires 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
+  # 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
+      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
+        2.times { advance_next_tick }
+        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
+    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
+        2.times { advance_next_tick }
+        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 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
+    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
+  # 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
+    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
+          advance_next_tick
+          expect(loader.call).to be_present
+          2.times { advance_next_tick }
+          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
+    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
-        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
+      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
+          advance_next_tick
+          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 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
+      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
+      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
+          advance_next_tick
+          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 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
+      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
+    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
-        include_examples :loader_expires
       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
+  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
+    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 '#load' do
-      let(:keys) { ['key1'] }
-      let(:values) { ['value1'] }
+  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.load('key1', options) }
+        lambda { |**options| store.fetch('key1', 'missing', options) }
       end
-      let(:be_present) { eq 'value1' }
-      let(:be_absent) { be_nil }
+      let(:be_absent) { eq 'missing' }
 
       include_examples :loader_expiry
     end
 
-    describe '#key?' do
-      let(:keys) { ['key1'] }
-      let(:values) { ['value1'] }
+    context "with default given as a block" do
       let(:loader) do
-        lambda { |**options| store.key?('key1', options) }
+        lambda { |**options| store.fetch('key1', options) { 'missing' } }
       end
-      let(:be_present) { be true }
-      let(:be_absent) { be false }
+      let(:be_absent) { eq 'missing' }
 
       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
+    context "with nil default given" do
+      let(:loader) do
+        lambda { |**options| store.fetch('key1', nil, options) }
       end
+      let(:be_absent) { be_nil }
 
-      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
+  end
 
-        include_examples :loader_expiry
+  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
+        advance_next_tick
       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
+      it 'does not return the expired value' do
+        expect(store.delete('key2')).to be_nil
       end
     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
+  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 'does not return the expired value' do
-          expect(store.delete('key2')).to be_nil
-        end
-      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
+      advance_next_tick
+      expect(store['key1']).to be_nil
     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'
+  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
 
-      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
+    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] }
 
-    describe '#merge!' do
-      let(:keys) { ['key1', 'key2'] }
-      let(:values) { ['value1', 'value2'] }
-      let(:updater) do
+    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|
-          expect(store.merge!(keys.zip(values), options)).to eq store
+          store.fetch_values('key1', 'key2', **options) { |k| "#{k} missing" }
         end
       end
+      let(:be_absent) { eq ['key1 missing', 'key2 missing'] }
 
-      include_examples :updater_expiry
+      include_examples :loader_expiry
     end
 
-    describe '#values_at' do
-      let(:keys) { ['key1', 'key2'] }
-      let(:values) { ['value1', 'value2'] }
+    context 'without default values given' do
       let(:loader) do
-        lambda { |**options| store.values_at('key1', 'key2', **options) }
+        lambda do |**options|
+          store.fetch_values('key1', 'key2', **options)
+        end
       end
-      let(:be_present) { eq ['value1', 'value2'] }
       let(:be_absent) { eq [nil, nil] }
 
       include_examples :loader_expiry
     end
+  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
+  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 }
 
-    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
+    include_examples :loader_expiry
   end
 end