moneta 1.5.2 → 1.6.0

data/spec/features/null.rb

@@ -1,66 +0,0 @@
-shared_examples :null do
-  it 'reads from keys like a Hash' do
-    moneta_property_of(keys: 1).check do |m|
-      store[m.keys[0]].should be_nil
-      store.load(m.keys[0]).should be_nil
-    end
-  end
-
-  it 'guarantees that the same value is returned when setting a key' do
-    moneta_property_of(keys: 1, values: 1).check do |m|
-      (store[m.keys[0]] = m.values[0]).should equal(m.values[0])
-    end
-  end
-
-  it 'returns false from #key? if a key is not available' do
-    moneta_property_of(keys: 1).check(1) do |m|
-      store.key?(m.keys[0]).should be false
-    end
-  end
-
-  it 'returns nil from delete if a value for a key does not exist' do
-    moneta_property_of(keys: 1).check do |m|
-      store.delete(m.keys[0]).should be_nil
-    end
-  end
-
-  it 'removes all keys from the store with clear' do
-    moneta_property_of(keys: 2, values: 2).check do |m|
-      store[m.keys[0]] = m.values[0]
-      store[m.keys[1]] = m.values[1]
-      store.clear.should equal(store)
-      store.key?(m.keys[0]).should be false
-      store.key?(m.keys[1]).should be false
-    end
-  end
-
-  it 'fetches a key with a default value with fetch, if the key is not available' do
-    moneta_property_of(keys: 1, values: 1).check do |m|
-      store.fetch(m.keys[0], m.values[0]).should == m.values[0]
-    end
-  end
-
-  it 'fetches a key with a block with fetch, if the key is not available' do
-    moneta_property_of(keys: 1, values: 1).check do |m|
-      store.fetch(m.keys[0]) do |k|
-        k.should equal(m.keys[0])
-        m.values[0]
-      end.should equal(m.values[0])
-    end
-  end
-
-  it 'accepts frozen options' do
-    moneta_property_of(keys: 1, values: 1).check do |m|
-      options = {option1: 1, options2: 2}
-      options.freeze
-      store.clear.should equal(store)
-      store.key?(m.keys[0], options).should be false
-      store.load(m.keys[0], options).should be_nil
-      store.fetch(m.keys[0], 42, options).should == 42
-      store.fetch(m.keys[0], options) { 42 }.should == 42
-      store.delete(m.keys[0], options).should be_nil
-      store.clear(options).should equal(store)
-      store.store(m.keys[0], m.values[0], options).should == m.values[0]
-    end
-  end
-end

data/spec/features/persist.rb

@@ -1,14 +0,0 @@
-shared_examples :persist do
-  it 'persists values' do
-    moneta_property_of(keys: 1, values: 1).check do |m|
-      new_store.tap do |store|
-        store[m.keys[0]] = m.values[0]
-        store.close
-      end
-      new_store.tap do |store|
-        store[m.keys[0]].should == m.values[0]
-        store.close
-      end
-    end
-  end
-end

data/spec/features/returndifferent.rb

@@ -1,9 +0,0 @@
-shared_examples :returndifferent do
-  it 'guarantees that a different value is retrieved' do
-    moneta_property_of(keys: 1, values: 1).check do |m|
-      next if [TrueClass,FalseClass,NilClass,Numeric].any?(&m.values[0].method(:is_a?))
-      store[m.keys[0]] = m.values[0]
-      store[m.keys[0]].should_not be_equal(m.values[0])
-    end
-  end
-end

data/spec/features/returnsame.rb

@@ -1,9 +0,0 @@
-shared_examples :returnsame do
-  it 'guarantees that the same value is retrieved' do
-    moneta_property_of(keys: 1, values: 1).check do |m|
-      next if [TrueClass, FalseClass, Numeric].any?(&m.values[0].method(:is_a?))
-      store[m.keys[0]] = m.values[0]
-      store[m.keys[0]].should be_equal(m.values[0])
-    end
-  end
-end

data/spec/features/store.rb

@@ -1,261 +0,0 @@
-shared_examples :store do
-  it 'writes values to keys that like a Hash' do
-    moneta_property_of(keys: 1, values: 1).check do |m|
-      store[m.keys[0]] = m.values[0]
-      store[m.keys[0]].should == m.values[0]
-      store.load(m.keys[0]).should == m.values[0]
-    end
-  end
-
-  it 'returns true from #key? if a key is available' do
-    moneta_property_of(keys: 1, values: 1).check do |m|
-      store[m.keys[0]] = m.values[0]
-      store.key?(m.keys[0]).should be true
-    end
-  end
-
-  it 'stores values with #store' do
-    moneta_property_of(keys: 1, values: 1).check do |m|
-      value = m.values[0]
-      store.store(m.keys[0], value).should equal(value)
-      store[m.keys[0]].should == m.values[0]
-      store.load(m.keys[0]).should == m.values[0]
-    end
-  end
-
-  it 'stores values after clear' do
-    moneta_property_of(keys: 2, values: 2).check do |m|
-      store[m.keys[0]] = m.values[0]
-      store[m.keys[1]] = m.values[1]
-      store.clear.should equal(store)
-      store[m.keys[0]] = m.values[0]
-      store[m.keys[0]].should == m.values[0]
-      store[m.keys[1]].should be_nil
-    end
-  end
-
-  it 'removes and returns a value from the backing store via delete if it exists' do
-    moneta_property_of(keys: 1, values: 1).check do |m|
-      store[m.keys[0]] = m.values[0]
-      store.delete(m.keys[0]).should == m.values[0]
-      store.key?(m.keys[0]).should be false
-    end
-  end
-
-  it 'overwrites existing values' do
-    moneta_property_of(keys: 1, values: 2).check do |m|
-      store[m.keys[0]] = m.values[0]
-      store[m.keys[0]].should == m.values[0]
-      store[m.keys[0]] = m.values[1]
-      store[m.keys[0]].should == m.values[1]
-    end
-  end
-
-  it 'stores frozen values' do
-    moneta_property_of(keys: 1, values: 1).check do |m|
-      value = m.values[0].freeze
-      (store[m.keys[0]] = value).should equal(value)
-      store[m.keys[0]].should == m.values[0]
-    end
-  end
-
-  it 'stores frozen keys' do
-    moneta_property_of(keys: 1, values: 1).check do |m|
-      key = m.keys[0].freeze
-      store[key] = m.values[0]
-      store[m.keys[0]].should == m.values[0]
-    end
-  end
-
-  it 'fetches a key with a default value with fetch, if the key is available' do
-    moneta_property_of(keys: 1, values: 2).check do |m|
-      next if m.values[0].nil?
-      store[m.keys[0]] = m.values[0]
-      store.fetch(m.keys[0], m.values[1]).should == m.values[0]
-    end
-  end
-
-  it 'does not run the block in fetch if the key is available' do
-    moneta_property_of(keys: 1, values: 1).check do |m|
-      next if m.values[0].nil?
-      store[m.keys[0]] = m.values[0]
-      unaltered = 'unaltered'
-      store.fetch(m.keys[0]) { unaltered = 'altered' }
-      unaltered.should == 'unaltered'
-    end
-  end
-
-  shared_examples :values_at do |name|
-    it 'retrieves stored values' do
-      moneta_property_of(keys: 3, values: 3).check do |m|
-        store[m.keys[0]] = m.values[0]
-        store[m.keys[1]] = m.values[1]
-        store[m.keys[2]] = m.values[2]
-        expect(store.public_send(name, m.keys[1], m.keys[2], m.keys[0])).to eq [m.values[1], m.values[2], m.values[0]]
-        store.clear
-      end
-    end
-
-    it 'returns nil in place of missing values' do
-      moneta_property_of(keys: 3, values: 2).check do |m|
-        store[m.keys[0]] = m.values[0]
-        store[m.keys[1]] = m.values[1]
-        expect(store.public_send(name, m.keys[1], m.keys[2], m.keys[0])).to eq [m.values[1], nil, m.values[0]]
-        store.clear
-      end
-    end
-  end
-
-  describe '#values_at' do
-    include_examples :values_at, :values_at
-  end
-
-  describe '#fetch_values' do
-    include_examples :values_at, :fetch_values
-
-    it 'yields to the block, if given, for keys that are not in the store' do
-      moneta_property_of(keys: 4, values: 3).check do |m|
-        store[m.keys[0]] = m.values[0]
-        store[m.keys[1]] = m.values[1]
-        store[m.keys[2]] = m.values[2]
-
-        expect do |b|
-          store.fetch_values(m.keys[0], m.keys[1], m.keys[2], m.keys[3], &b)
-        end.to yield_with_args(m.keys[3])
-
-        store.clear
-      end
-    end
-
-    it 'uses the value of the block, if given, for keys that are not in the store' do
-      moneta_property_of(keys: 4, values: 4).check do |m|
-        store[m.keys[0]] = m.values[0]
-        store[m.keys[1]] = m.values[1]
-        store[m.keys[2]] = m.values[2]
-
-        expect(store.fetch_values(m.keys[0], m.keys[1], m.keys[2], m.keys[3]) do |key|
-          expect(key).to eq m.keys[3]
-          m.values[3]
-        end).to eq [m.values[0], m.values[1], m.values[2], m.values[3]]
-
-        store.clear
-      end
-    end
-
-    it 'raises any error raised in the block' do
-      expect { store.fetch_values('key') { raise 'yarg' } }.to raise_error 'yarg'
-    end
-  end
-
-  describe '#slice' do
-    it 'returns pairs of stored keys and values' do
-      moneta_property_of(keys: 3, values: 3).check do |m|
-        store[m.keys[0]] = m.values[0]
-        store[m.keys[1]] = m.values[1]
-        store[m.keys[2]] = m.values[2]
-
-        expect(store.slice(*[m.keys[0], m.keys[1], m.keys[2]].shuffle).to_a).to \
-          contain_exactly([m.keys[0], m.values[0]], [m.keys[1], m.values[1]], [m.keys[2], m.values[2]])
-
-        store.clear
-      end
-    end
-
-    it 'does not return pairs for any keys absent from the store' do
-      moneta_property_of(keys: 4, values: 3).check do |m|
-        store[m.keys[0]] = m.values[0]
-        store[m.keys[1]] = m.values[1]
-        store[m.keys[2]] = m.values[2]
-
-        expect(store.slice(*[m.keys[0], m.keys[1], m.keys[2], m.keys[3]].shuffle).to_a).to \
-          contain_exactly([m.keys[0], m.values[0]], [m.keys[1], m.values[1]], [m.keys[2], m.values[2]])
-
-        store.clear
-      end
-    end
-  end
-
-  shared_examples :merge! do
-    it 'stores values' do
-      moneta_property_of(keys: 3, values: 3).check do |m|
-        expect(store.public_send(method, pairs.call({ m.keys[0] => m.values[0], m.keys[1] => m.values[1], m.keys[2] => m.values[2] }))).to be store
-        expect(store.key?(m.keys[0])).to be true
-        expect(store[m.keys[0]]).to eq m.values[0]
-        expect(store.key?(m.keys[1])).to be true
-        expect(store[m.keys[1]]).to eq m.values[1]
-        expect(store.key?(m.keys[2])).to be true
-        expect(store[m.keys[2]]).to eq m.values[2]
-        store.clear
-      end
-    end
-
-    it 'overwrites existing values' do
-      moneta_property_of(keys: 2, values: 3).check do |m|
-        expect(store[m.keys[0]] = m.values[0]).to eq m.values[0]
-        expect(store.public_send(method, pairs.call({ m.keys[0] => m.values[1], m.keys[1] => m.values[2] }))).to be store
-        expect(store.key?(m.keys[0])).to be true
-        expect(store[m.keys[0]]).to eq m.values[1]
-        expect(store.key?(m.keys[1])).to be true
-        expect(store[m.keys[1]]).to eq m.values[2]
-        store.clear
-      end
-    end
-
-    it 'stores the return value of the block, if given, for keys that will be overwritten' do
-      moneta_property_of(keys: 2, values: 4).check do |m|
-        expect(store[m.keys[0]] = m.values[0]).to eq m.values[0]
-        expect(store.public_send(method, pairs.call({ m.keys[0] => m.values[1], m.keys[1] => m.values[2] })) do |key, old_val, new_val|
-          expect(key).to eq m.keys[0]
-          expect(old_val).to eq m.values[0]
-          expect(new_val).to eq m.values[1]
-          m.values[3]
-        end).to be store
-
-        expect(store.key?(m.keys[0])).to be true
-        expect(store[m.keys[0]]).to eq m.values[3]
-        expect(store.key?(m.keys[1])).to be true
-        expect(store[m.keys[1]]).to eq m.values[2]
-        store.clear
-      end
-    end
-
-    it 'raises any error raised in the block' do
-      store['x'] = 'y'
-      expect { store.public_send(method, 'x' => 'v') { raise 'yarg' } }.to raise_error 'yarg'
-    end
-  end
-
-  shared_examples :merge_or_update do
-    context 'when passed a hash' do
-      let(:pairs) { :itself.to_proc }
-      include_examples :merge!
-    end
-
-    context 'when passed an array' do
-      let(:pairs) { :to_a.to_proc }
-      include_examples :merge!
-    end
-
-    context 'when passed a lazy enumerator' do
-      let :pairs do
-        lambda do |hash|
-          Enumerator.new do |y|
-            hash.each(&y.method(:<<))
-          end.lazy
-        end
-      end
-
-      include_examples :merge!
-    end
-  end
-
-  describe '#merge!' do
-    let(:method) { :merge! }
-    include_examples :merge_or_update
-  end
-
-  describe '#update' do
-    let(:method) { :update }
-    include_examples :merge_or_update
-  end
-end

data/spec/features/store_large.rb

@@ -1,13 +0,0 @@
-shared_examples :store_large do
-  it 'should store values up to 32k' do
-    value = 'x' * (32 * 1024)
-    store['large'] = value
-    store['large'].should == value
-  end
-
-  it 'should store keys up to 128 bytes' do
-    key = 'x' * 128
-    store[key] = 'value'
-    store[key].should == 'value'
-  end
-end

data/spec/features/transform_value.rb

@@ -1,44 +0,0 @@
-shared_examples :transform_value do
-  it 'allows to bypass transformer with :raw' do
-    store['key'] = 'value'
-    load_value(store.load('key', raw: true)).should == 'value'
-
-    store.store('key', 'value', raw: true)
-    store.load('key', raw: true).should == 'value'
-    store.delete('key', raw: true).should == 'value'
-  end
-
-  it 'allows to bypass transformer with raw syntactic sugar' do
-    store['key'] = 'value'
-    load_value(store.raw.load('key')).should == 'value'
-
-    store.raw.store('key', 'value')
-    store.raw['key'].should == 'value'
-    store.raw.load('key').should == 'value'
-    store.raw.delete('key').should == 'value'
-
-    store.raw['key'] = 'value2'
-    store.raw['key'].should == 'value2'
-  end
-
-  it 'returns unmarshalled value' do
-    store.store('key', 'unmarshalled value', raw: true)
-    store.load('key', raw: true).should == 'unmarshalled value'
-  end
-
-  it 'might raise exception on invalid value' do
-    store.store('key', 'unmarshalled value', raw: true)
-
-    begin
-      store['key'].should == load_value('unmarshalled value')
-      store.delete('key').should == load_value('unmarshalled value')
-    rescue Exception => ex
-      expect do
-        store['key']
-      end.to raise_error
-      expect do
-        store.delete('key')
-      end.to raise_error
-    end
-  end
-end

data/spec/features/transform_value_expires.rb

@@ -1,41 +0,0 @@
-shared_examples :transform_value_expires do
-  it 'allows to bypass transformer with :raw' do
-    store['key'] = 'value'
-    load_value(store.load('key', raw: true)).should == 'value'
-    store['key'] = [1,2,3]
-    load_value(store.load('key', raw: true)).should == [[1,2,3]]
-    store['key'] = nil
-    load_value(store.load('key', raw: true)).should == [nil]
-    store['key'] = false
-    load_value(store.load('key', raw: true)).should be false
-
-    store.store('key', 'value', expires: 10)
-    load_value(store.load('key', raw: true)).first.should == 'value'
-    load_value(store.load('key', raw: true)).last.should respond_to(:to_int)
-
-    store.store('key', 'value', raw: true)
-    store.load('key', raw: true).should == 'value'
-    store.delete('key', raw: true).should == 'value'
-  end
-
-  it 'returns unmarshalled value' do
-    store.store('key', 'unmarshalled value', raw: true)
-    store.load('key', raw: true).should == 'unmarshalled value'
-  end
-
-  it 'might raise exception on invalid value' do
-    store.store('key', 'unmarshalled value', raw: true)
-
-    begin
-      store['key'].should == load_value('unmarshalled value')
-      store.delete('key').should == load_value('unmarshalled value')
-    rescue Exception => ex
-      expect do
-        store['key']
-      end.to raise_error
-      expect do
-        store.delete('key')
-      end.to raise_error
-    end
-  end
-end