moneta 1.5.2 → 1.6.0

data/spec/features/create.rb

@@ -1,25 +0,0 @@
-shared_examples :create do
-  it 'creates the given key' do
-    store.create('key','value').should be true
-    store['key'].should == 'value'
-  end
-
-  it 'creates raw value with the given key' do
-    store.raw.create('key','value').should be true
-    store.raw['key'].should == 'value'
-  end
-
-  it 'does not create a key if it exists' do
-    store['key'] = 'value'
-    store.create('key','another value').should be false
-    store['key'].should == 'value'
-  end
-
-  it 'supports Mutex' do
-    a = Moneta::Mutex.new(store, 'mutex')
-    b = Moneta::Mutex.new(store, 'mutex')
-    a.lock.should be true
-    b.try_lock.should be false
-    a.unlock.should be_nil
-  end
-end

data/spec/features/create_expires.rb

@@ -1,19 +0,0 @@
-shared_examples :create_expires 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
-    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
-    2.times { advance_next_tick }
-    store['key'].should == 'value'
-    store.key?('key').should be true
-  end
-end

data/spec/features/default_expires.rb

@@ -1,14 +0,0 @@
-shared_examples :default_expires 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
-    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/each_key.rb

@@ -1,119 +0,0 @@
-shared_examples :each_key do
-  shared_examples "enumerable" do
-    it 'returns an empty enum when there are no keys' do
-      expect(each_key.call.count).to eq(0)
-    end
-
-    it 'returns collection with the stored key/s' do
-      expect { store.store('1st_key', 'value') }
-        .to change { each_key.call.to_a }
-        .from([])
-        .to(['1st_key'])
-
-      expect { store.store('2nd_key', 'value') }
-        .to change { each_key.call.to_a.sort }
-        .from(['1st_key'])
-        .to(['1st_key', '2nd_key'].sort)
-    end
-
-    it 'when a lazy size implementation exist it returns the size of the collection or nil' do
-      expect(store.each_key.size).to eq(nil) | eq(0)
-
-      if !store.each_key.size.nil? && store.each_key.size.zero?
-        expect { store.store('1st_key', 'value') }
-          .to change { store.each_key.size }
-          .from(0)
-          .to(1)
-
-        expect { store.store('2nd_key', 'value') }
-          .to change { store.each_key.size }
-          .from(1)
-          .to(2)
-
-        expect { store.delete('1st_key') }
-          .to change { store.each_key.size }
-          .from(2)
-          .to(1)
-      end
-    end
-
-    it 'doesn\'t duplicate keys' do
-      expect { 2.times { |i| store.store('a_key', "#{i}_val") } }
-        .to change { each_key.call.to_a }
-        .from([])
-        .to(['a_key'])
-    end
-
-    it 'doesn\'t return deleted keys' do
-      store.store('a_key', "a_val")
-      store.store('b_key', "b_val")
-      expect { store.delete('a_key') }
-        .to change { each_key.call.to_a.sort }
-        .from(['a_key', 'b_key'].sort)
-        .to(['b_key'])
-    end
-
-    it 'allows checking and retrieving entries while enumerating' do
-      store['a'] = 'b'
-      store['c'] = 'd'
-      each_key.call do |k|
-        val = if k == 'a' then 'b' else 'd' end
-        expect(store.key?(k)).to be true
-        expect(store[k]).to eq val
-        expect(store.fetch(k)).to eq val
-      end
-    end
-  end
-
-  context "when a block is not given" do
-    let(:each_key) do
-      store.method(:each_key)
-    end
-
-    include_examples 'enumerable'
-
-    it "returns the store if a block is given to #each" do
-      expect(store.each_key.each.each.each{}).to eq store
-    end
-  end
-
-  context "when a block is given" do
-    let :each_key do
-      proc do |&block|
-        if block
-          store.each_key(&block)
-        else
-          Enumerator.new do |y|
-            store.each_key(&y.method(:<<))
-          end
-        end
-      end
-    end
-
-    include_examples 'enumerable'
-
-    it 'yields the keys to the block' do
-      # Make a list of keys that we expect to find in the store
-      keys = []
-
-      2.times do |i|
-        key = "key_#{i}"
-        keys << key
-        store.store(key, "#{i}_val")
-      end
-
-      # Enumerate the store, making store that at each iteration we find one of
-      # the keys we are looking for
-      expect(store.each_key do |k|
-        expect(keys.delete(k)).not_to be_nil
-      end).to eq(store)
-
-      # To assert that all keys were seen by the block
-      expect(keys).to be_empty
-    end
-
-    it "returns the store" do
-      expect(store.each_key{}).to eq store
-    end
-  end
-end

data/spec/features/expires.rb

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

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

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

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

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

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

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

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

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

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