moneta 1.2.0 → 1.4.2

data/script/contributors

@@ -1,7 +1,12 @@
-#!/bin/sh
-git log --format='%aN <%aE>' |\
-sed -e 's/hiddenbek/Scott Wadden/g' |\
-sed -e 's/Asmod4n/Hendrik Beskow/' |\
-grep -v 'hannes.georg@xing.com\|spotapov\|yehuda-katzs-mac\|wycats ' |\
-sort -u | sort > CONTRIBUTORS
+#!/usr/bin/env ruby
 
+contributors = `git log --format='%aN <%aE>'`
+  .gsub(/hiddenbek/, 'Scott Wadden')
+  .gsub(/Asmod4n/, 'Hendrik Beskow')
+  .lines
+  .uniq
+  .reject { |line| line.match? /asppsa@gmail.com|hannes.georg@xing.com|spotapov|yehuda-katzs-mac|wycats / }
+  .sort { |str1, str2| str1.casecmp(str2) }
+
+file = File.open('CONTRIBUTORS', 'w')
+file << contributors.join

data/script/start-couchdb

@@ -0,0 +1,27 @@
+#!/bin/bash
+set -e
+
+# Copied from https://github.com/apache/couchdb-pkg/blob/master/debian/README.Debian
+COUCHDB_PASSWORD=password
+echo "couchdb couchdb/mode select standalone
+couchdb couchdb/mode seen true
+couchdb couchdb/bindaddress string 127.0.0.1
+couchdb couchdb/bindaddress seen true
+couchdb couchdb/adminpass password ${COUCHDB_PASSWORD}
+couchdb couchdb/adminpass seen true
+couchdb couchdb/adminpass_again password ${COUCHDB_PASSWORD}
+couchdb couchdb/adminpass_again seen true" | sudo debconf-set-selections
+DEBIAN_FRONTEND=noninteractive sudo apt-get install -y --force-yes couchdb
+
+# Reconfigure CouchDB to use delayed commits for speed: http://guide.couchdb.org/draft/performance.html
+sudo sed -i '/\[couchdb\]/a delayed_commits = true' /etc/couchdb/local.ini
+
+# (Re)start couchdb
+sudo systemctl restart couchdb
+
+# Display some info about CouchDB
+sudo systemctl status couchdb
+until curl http://localhost:5984/; do
+  sleep 1
+done
+

data/script/start-hbase

@@ -8,13 +8,13 @@ mkdir -p zookeeper
 mkdir -p downloads
 root=$(pwd)
 
-version=$(curl -sS https://www-us.apache.org/dist/hbase/stable/ | grep -oP '(?<=hbase-)(\d+\.?)+' | head -n1)
+version=$(curl -sS https://downloads.apache.org/hbase/stable/RELEASENOTES.md | grep -oP '(?<=# HBASE\s\s)(\d+\.?)+' | head -n1)
 
 echo HBase stable version is $version
 
 if [ ! -f downloads/hbase-$version-bin.tar.gz ]; then
   echo Downloading HBase ...
-  wget -P downloads http://www-us.apache.org/dist/hbase/stable/hbase-$version-bin.tar.gz
+  wget -P downloads https://downloads.apache.org/hbase/stable/hbase-$version-bin.tar.gz
 fi
 
 echo Extracting HBase ...

data/script/start-services

@@ -1,9 +1,9 @@
 #!/bin/bash
 
-# Restart CouchDB
-$(dirname $0)/reconfigure-couchdb
+# Install and start CouchDB
+$(dirname $0)/start-couchdb
 
-# Start HBase
+# Install and start HBase
 $(dirname $0)/start-hbase
 
 # Waiting for servers to start

data/spec/active_support/cache_moneta_store_spec.rb

@@ -74,45 +74,43 @@ describe "cache_moneta_store" do
       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'
+      expect(store.fetch('irish whisky')).to eq 'irish whisky was missing'
     end
   end
 
   shared_examples :expiry do
-    at_each_usec do
-      it 'writes the data with expiration time' do
-        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 the data with expiration time' do
+      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)
+    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'
+      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
+      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, 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 "sets expiry on cache miss" do
+      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
-        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
+    it 'does not set expiry on cache hit' do
+      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
 
@@ -236,23 +234,23 @@ describe "cache_moneta_store" do
     end
 
     context "with :Memory store" do
-      let(:store){ described_class.new(store: :Memory) }
+      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)) }
+      let(:store) { described_class.new(store: ::Moneta.new(:Memory)) }
       include_examples :moneta_store
     end
 
-    context "with Redis store" do
-      let(:store) {described_class.new(store: :Redis) }
+    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
@@ -260,8 +258,8 @@ describe "cache_moneta_store" do
     include_examples :basic_instrumentation
   end
 
-  describe ActiveSupport::Cache::MemCacheStore do
-    let(:store){ described_class.new('127.0.0.1:11213') }
+  describe ActiveSupport::Cache::MemCacheStore, memcached: true do
+    let(:store) { described_class.new('127.0.0.1:11213') }
 
     include_context :start_memcached, 11213
 
@@ -272,8 +270,8 @@ describe "cache_moneta_store" do
     include_examples :increment_decrement_instrumentation
   end
 
-  describe ActiveSupport::Cache::RedisCacheStore do
-    let(:store){ described_class.new(url: 'redis:///3') }
+  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_increment.rb

@@ -8,9 +8,8 @@ shared_examples :concurrent_increment do
         increments = (0...100).map { [] }
         100.times do
           100.times do |j|
-            increments[j] << s.increment(j.to_s, 1, expires: false).tap do
-              Thread.pass if rand(1000) >= 995
-            end
+            increments[j] << s.increment(j.to_s, 1, expires: false)
+            Thread.pass if rand(1000) >= 995
           end
         end
         increments

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