moneta 1.0.0 → 1.5.1

data/spec/features/expires.rb

@@ -0,0 +1,296 @@
+shared_examples :expires do
+  before do
+    raise "t_res must be <= min_ttl" unless t_res <= 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
+        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
+        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 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
+          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
+      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 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
+          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 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
+        advance_next_tick
+      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
+      advance_next_tick
+      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

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
+    expect(store.key?('inckey')).to be false
+    expect(store.increment('inckey')).to eq 1
+    expect(store.key?('inckey')).to be true
+    expect(store.raw['inckey'].to_s).to match(/^1\b/)
+    expect(store.raw.load('inckey').to_s).to match(/^1\b/)
+    expect(store.load('inckey', raw: true).to_s).to match(/^1\b/)
+
+    expect(store.delete('inckey', raw: true).to_s).to match(/^1\b/)
+    expect(store.key?('inckey')).to be false
+  end
+
+  it 'initializes in #increment with higher value' do
+    expect(store.increment('inckey', 42)).to eq 42
+    expect(store.key?('inckey')).to be true
+    expect(store.raw['inckey'].to_s).to match(/^42\b/)
+    expect(store.delete('inckey', raw: true).to_s).to match(/^42\b/)
+  end
+
+  it 'initializes in #increment with 0' do
+    expect(store.increment('inckey', 0)).to eq 0
+    expect(store.key?('inckey')).to be true
+    expect(store.raw['inckey'].to_s).to match(/^0\b/)
+    expect(store.delete('inckey', raw: true).to_s).to match(/^0\b/)
+  end
+
+  it 'initializes in #decrement with 0' do
+    expect(store.decrement('inckey', 0)).to eq 0
+    expect(store.raw['inckey'].to_s).to match(/^0\b/)
+  end
+
+  it 'initializes in #decrement with negative value' do
+    expect(store.decrement('inckey', -42)).to eq 42
+    expect(store.raw['inckey'].to_s).to match(/^42\b/)
+  end
+
+  it 'supports incrementing existing value by value' do
+    expect(store.increment('inckey')).to eq 1
+    expect(store.increment('inckey', 42)).to eq 43
+    expect(store.raw['inckey'].to_s).to match(/^43\b/)
+  end
+
+  it 'supports decrementing existing value by value' do
+    expect(store.increment('inckey')).to eq 1
+    expect(store.decrement('inckey')).to eq 0
+    expect(store.increment('inckey', 42)).to eq 42
+    expect(store.decrement('inckey', 2)).to eq 40
+    expect(store.raw['inckey'].to_s).to match(/^40\b/)
+  end
+
+  it 'supports incrementing existing value by 0' do
+    expect(store.increment('inckey')).to eq 1
+    expect(store.increment('inckey', 0)).to eq 1
+    expect(store.raw['inckey'].to_s).to match(/^1\b/)
+  end
+
+  it 'supports decrementing existing value' do
+    expect(store.increment('inckey', 10)).to eq 10
+    expect(store.increment('inckey', -5)).to eq 5
+    expect(store.raw['inckey'].to_s).to match(/^5\b/)
+    expect(store.increment('inckey', -5)).to eq 0
+    expect(store.raw['inckey'].to_s).to match(/^0\b/)
+  end
+
+  it 'interprets raw value as integer' do
+    store.store('inckey', '42', raw: true)
+    expect(store.increment('inckey')).to eq 43
+    expect(store.raw['inckey'].to_s).to match(/^43\b/)
+  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
+      expect(a.locked?).to be true
+      b.synchronize do
+        expect(b.locked?).to be true
+        expect(c.try_lock).to 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 |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

@@ -0,0 +1,14 @@
+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

@@ -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 |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

@@ -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 |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