moneta 1.0.0 → 1.1.0

data/spec/features/features.rb

@@ -0,0 +1,16 @@
+shared_examples :features do
+  it 'should report correct features' do
+    expect(store.features).to contain_exactly(*features)
+  end
+
+  it 'should have frozen features' do
+    store.features.frozen?.should be true
+  end
+
+  it 'should have #supports?' do
+    features.each do |f|
+      store.supports?(f).should be true
+    end
+    store.supports?(:unknown).should be false
+  end
+end

data/spec/features/increment.rb

@@ -0,0 +1,98 @@
+shared_examples :increment do
+  it 'initializes in #increment with 1' do
+    store.key?('inckey').should be false
+    store.increment('inckey').should == 1
+    store.key?('inckey').should be true
+    store.raw['inckey'].should == '1'
+    store.raw.load('inckey').should == '1'
+    store.load('inckey', raw: true).should == '1'
+
+    store.delete('inckey', raw: true).should == '1'
+    store.key?('inckey').should be false
+  end
+
+  it 'initializes in #increment with higher value' do
+    store.increment('inckey', 42).should == 42
+    store.key?('inckey').should be true
+    store.raw['inckey'].should == '42'
+    store.delete('inckey', raw: true).should == '42'
+  end
+
+  it 'initializes in #increment with 0' do
+    store.increment('inckey', 0).should == 0
+    store.key?('inckey').should be true
+    store.raw['inckey'].should == '0'
+    store.delete('inckey', raw: true).should == '0'
+  end
+
+  it 'initializes in #decrement with 0' do
+    store.decrement('inckey', 0).should == 0
+    store.raw['inckey'].should == '0'
+  end
+
+  it 'initializes in #decrement with negative value' do
+    store.decrement('inckey', -42).should == 42
+    store.raw['inckey'].should == '42'
+  end
+
+  it 'supports incrementing existing value by value' do
+    store.increment('inckey').should == 1
+    store.increment('inckey', 42).should == 43
+    store.raw['inckey'].should == '43'
+  end
+
+  it 'supports decrementing existing value by value' do
+    store.increment('inckey').should == 1
+    store.decrement('inckey').should == 0
+    store.increment('inckey', 42).should == 42
+    store.decrement('inckey', 2).should == 40
+    store.raw['inckey'].should == '40'
+  end
+
+  it 'supports incrementing existing value by 0' do
+    store.increment('inckey').should == 1
+    store.increment('inckey', 0).should == 1
+    store.raw['inckey'].should == '1'
+  end
+
+  it 'supports decrementing existing value' do
+    store.increment('inckey', 10).should == 10
+    store.increment('inckey', -5).should == 5
+    store.raw['inckey'].should == '5'
+    store.increment('inckey', -5).should == 0
+    store.raw['inckey'].should == '0'
+  end
+
+  it 'interprets raw value as integer' do
+    store.store('inckey', '42', raw: true)
+    store.increment('inckey').should == 43
+    store.raw['inckey'].should == '43'
+  end
+
+  it 'raises error in #increment on non integer value' do
+    store['strkey'] = 'value'
+    expect do
+      store.increment('strkey')
+    end.to raise_error
+  end
+
+  it 'raises error in #decrement on non integer value' do
+    store['strkey'] = 'value'
+    expect do
+      store.decrement('strkey')
+    end.to raise_error
+  end
+
+  it 'supports Semaphore' do
+    a = Moneta::Semaphore.new(store, 'semaphore', 2)
+    b = Moneta::Semaphore.new(store, 'semaphore', 2)
+    c = Moneta::Semaphore.new(store, 'semaphore', 2)
+    a.synchronize do
+      a.locked?.should be true
+      b.synchronize do
+        b.locked?.should be true
+        c.try_lock.should be false
+      end
+    end
+  end
+end

data/spec/features/marshallable_key.rb

@@ -0,0 +1,43 @@
+shared_examples :marshallable_key do
+  it 'refuses to #[] from keys that cannot be marshalled' do
+    expect do
+      store[Struct.new(:foo).new(:bar)]
+    end.to raise_error(marshal_error)
+  end
+
+  it 'refuses to load from keys that cannot be marshalled' do
+    expect do
+      store.load(Struct.new(:foo).new(:bar))
+    end.to raise_error(marshal_error)
+  end
+
+  it 'refuses to fetch from keys that cannot be marshalled' do
+    expect do
+      store.fetch(Struct.new(:foo).new(:bar), true)
+    end.to raise_error(marshal_error)
+  end
+
+  it 'refuses to #[]= to keys that cannot be marshalled' do
+    expect do
+      store[Struct.new(:foo).new(:bar)] = 'value'
+    end.to raise_error(marshal_error)
+  end
+
+  it 'refuses to store to keys that cannot be marshalled' do
+    expect do
+      store.store Struct.new(:foo).new(:bar), 'value'
+    end.to raise_error(marshal_error)
+  end
+
+  it 'refuses to check for #key? if the key cannot be marshalled' do
+    expect do
+      store.key? Struct.new(:foo).new(:bar)
+    end.to raise_error(marshal_error)
+  end
+
+  it 'refuses to delete a key if the key cannot be marshalled' do
+    expect do
+      store.delete Struct.new(:foo).new(:bar)
+    end.to raise_error(marshal_error)
+  end
+end

data/spec/features/marshallable_value.rb

@@ -0,0 +1,7 @@
+shared_examples :marshallable_value do
+  it 'refuses to store values that cannot be marshalled' do
+    expect do
+      store.store 'key', Struct.new(:foo).new(:bar)
+    end.to raise_error(marshal_error)
+  end
+end

data/spec/features/multiprocess.rb

@@ -0,0 +1,8 @@
+shared_examples :multiprocess do
+  it 'supports access by multiple instances/processes' do
+    store['key'] = 'val'
+    store2 = new_store
+    store2['key'].should == 'val'
+    store2.close
+  end
+end

data/spec/features/not_create.rb

@@ -0,0 +1,7 @@
+shared_examples :not_create do
+  it 'does not support #create' do
+    expect do
+      store.create('key','value')
+    end.to raise_error(NotImplementedError)
+  end
+end

data/spec/features/not_each_key.rb

@@ -0,0 +1,7 @@
+shared_examples :not_each_key do
+  it 'does not support #each_key' do
+    expect do
+      store.each_key
+    end.to raise_error(NotImplementedError)
+  end
+end

data/spec/features/not_increment.rb

@@ -0,0 +1,13 @@
+shared_examples :not_increment do
+  it 'does not support #increment' do
+    expect do
+      store.increment('inckey')
+    end.to raise_error(NotImplementedError)
+  end
+
+  it 'does not support #decrement' do
+    expect do
+      store.increment('inckey')
+    end.to raise_error(NotImplementedError)
+  end
+end

data/spec/features/not_persist.rb

@@ -0,0 +1,9 @@
+shared_examples :not_persist do
+  it 'does not persist values' do
+    store['key'] = 'val'
+    store.close
+    @store = nil
+
+    store['key'].should be_nil
+  end
+end

data/spec/features/null.rb

@@ -0,0 +1,66 @@
+shared_examples :null do
+  it 'reads from keys like a Hash' do
+    moneta_property_of(keys: 1).check do |keys:|
+      store[keys[0]].should be_nil
+      store.load(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 |keys:, values:|
+      (store[keys[0]] = values[0]).should equal(values[0])
+    end
+  end
+
+  it 'returns false from #key? if a key is not available' do
+    moneta_property_of(keys: 1).check(1) do |keys:|
+      store.key?(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 |keys:|
+      store.delete(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 |keys:, values:|
+      store[keys[0]] = values[0]
+      store[keys[1]] = values[1]
+      store.clear.should equal(store)
+      store.key?(keys[0]).should be false
+      store.key?(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 |keys:, values:|
+      store.fetch(keys[0], values[0]).should == 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 |keys:, values:|
+      store.fetch(keys[0]) do |k|
+        k.should equal(keys[0])
+        values[0]
+      end.should equal(values[0])
+    end
+  end
+
+  it 'accepts frozen options' do
+    moneta_property_of(keys: 1, values: 1).check do |keys:, values:|
+      options = {option1: 1, options2: 2}
+      options.freeze
+      store.clear.should equal(store)
+      store.key?(keys[0], options).should be false
+      store.load(keys[0], options).should be_nil
+      store.fetch(keys[0], 42, options).should == 42
+      store.fetch(keys[0], options) { 42 }.should == 42
+      store.delete(keys[0], options).should be_nil
+      store.clear(options).should equal(store)
+      store.store(keys[0], values[0], options).should == values[0]
+    end
+  end
+end

data/spec/features/persist.rb

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

data/spec/features/returndifferent.rb

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

data/spec/features/returnsame.rb

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

data/spec/features/store.rb

@@ -0,0 +1,261 @@
+shared_examples :store do
+  it 'writes values to keys that like a Hash' do
+    moneta_property_of(keys: 1, values: 1).check do |keys:, values:|
+      store[keys[0]] = values[0]
+      store[keys[0]].should == values[0]
+      store.load(keys[0]).should == values[0]
+    end
+  end
+
+  it 'returns true from #key? if a key is available' do
+    moneta_property_of(keys: 1, values: 1).check do |keys:, values:|
+      store[keys[0]] = values[0]
+      store.key?(keys[0]).should be true
+    end
+  end
+
+  it 'stores values with #store' do
+    moneta_property_of(keys: 1, values: 1).check do |keys:, values:|
+      value = values[0]
+      store.store(keys[0], value).should equal(value)
+      store[keys[0]].should == values[0]
+      store.load(keys[0]).should == values[0]
+    end
+  end
+
+  it 'stores values after clear' do
+    moneta_property_of(keys: 2, values: 2).check do |keys:, values:|
+      store[keys[0]] = values[0]
+      store[keys[1]] = values[1]
+      store.clear.should equal(store)
+      store[keys[0]] = values[0]
+      store[keys[0]].should == values[0]
+      store[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 |keys:, values:|
+      store[keys[0]] = values[0]
+      store.delete(keys[0]).should == values[0]
+      store.key?(keys[0]).should be false
+    end
+  end
+
+  it 'overwrites existing values' do
+    moneta_property_of(keys: 1, values: 2).check do |keys:, values:|
+      store[keys[0]] = values[0]
+      store[keys[0]].should == values[0]
+      store[keys[0]] = values[1]
+      store[keys[0]].should == values[1]
+    end
+  end
+
+  it 'stores frozen values' do
+    moneta_property_of(keys: 1, values: 1).check do |keys:, values:|
+      value = values[0].freeze
+      (store[keys[0]] = value).should equal(value)
+      store[keys[0]].should == values[0]
+    end
+  end
+
+  it 'stores frozen keys' do
+    moneta_property_of(keys: 1, values: 1).check do |keys:, values:|
+      key = keys[0].freeze
+      store[key] = values[0]
+      store[keys[0]].should == 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 |keys:, values:|
+      next if values[0].nil?
+      store[keys[0]] = values[0]
+      store.fetch(keys[0], values[1]).should == 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 |keys:, values:|
+      next if values[0].nil?
+      store[keys[0]] = values[0]
+      unaltered = 'unaltered'
+      store.fetch(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 |keys:, values:|
+        store[keys[0]] = values[0]
+        store[keys[1]] = values[1]
+        store[keys[2]] = values[2]
+        expect(store.public_send(name, keys[1], keys[2], keys[0])).to eq [values[1], values[2], values[0]]
+        store.clear
+      end
+    end
+
+    it 'returns nil in place of missing values' do
+      moneta_property_of(keys: 3, values: 2).check do |keys:, values:|
+        store[keys[0]] = values[0]
+        store[keys[1]] = values[1]
+        expect(store.public_send(name, keys[1], keys[2], keys[0])).to eq [values[1], nil, 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 |keys:, values:|
+        store[keys[0]] = values[0]
+        store[keys[1]] = values[1]
+        store[keys[2]] = values[2]
+
+        expect do |b|
+          store.fetch_values(keys[0], keys[1], keys[2], keys[3], &b)
+        end.to yield_with_args(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 |keys:, values:|
+        store[keys[0]] = values[0]
+        store[keys[1]] = values[1]
+        store[keys[2]] = values[2]
+
+        expect(store.fetch_values(keys[0], keys[1], keys[2], keys[3]) do |key|
+          expect(key).to eq keys[3]
+          values[3]
+        end).to eq [values[0], values[1], values[2], 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 |keys:, values:|
+        store[keys[0]] = values[0]
+        store[keys[1]] = values[1]
+        store[keys[2]] = values[2]
+
+        expect(store.slice(*[keys[0], keys[1], keys[2]].shuffle).to_a).to \
+          contain_exactly([keys[0], values[0]], [keys[1], values[1]], [keys[2], 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 |keys:, values:|
+        store[keys[0]] = values[0]
+        store[keys[1]] = values[1]
+        store[keys[2]] = values[2]
+
+        expect(store.slice(*[keys[0], keys[1], keys[2], keys[3]].shuffle).to_a).to \
+          contain_exactly([keys[0], values[0]], [keys[1], values[1]], [keys[2], values[2]])
+
+        store.clear
+      end
+    end
+  end
+
+  shared_examples :merge! do
+    it 'stores values' do
+      moneta_property_of(keys: 3, values: 3).check do |keys:, values:|
+        expect(store.public_send(method, pairs.call(keys[0] => values[0], keys[1] => values[1], keys[2] => values[2]))).to be store
+        expect(store.key?(keys[0])).to be true
+        expect(store[keys[0]]).to eq values[0]
+        expect(store.key?(keys[1])).to be true
+        expect(store[keys[1]]).to eq values[1]
+        expect(store.key?(keys[2])).to be true
+        expect(store[keys[2]]).to eq values[2]
+        store.clear
+      end
+    end
+
+    it 'overwrites existing values' do
+      moneta_property_of(keys: 2, values: 3).check do |keys:, values:|
+        expect(store[keys[0]] = values[0]).to eq values[0]
+        expect(store.public_send(method, pairs.call(keys[0] => values[1], keys[1] => values[2]))).to be store
+        expect(store.key?(keys[0])).to be true
+        expect(store[keys[0]]).to eq values[1]
+        expect(store.key?(keys[1])).to be true
+        expect(store[keys[1]]).to eq 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 |keys:, values:|
+        expect(store[keys[0]] = values[0]).to eq values[0]
+        expect(store.public_send(method, pairs.call(keys[0] => values[1], keys[1] => values[2])) do |key, old_val, new_val|
+          expect(key).to eq keys[0]
+          expect(old_val).to eq values[0]
+          expect(new_val).to eq values[1]
+          values[3]
+        end).to be store
+
+        expect(store.key?(keys[0])).to be true
+        expect(store[keys[0]]).to eq values[3]
+        expect(store.key?(keys[1])).to be true
+        expect(store[keys[1]]).to eq 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