moneta 0.8.0 → 0.8.1

data/script/start-services

@@ -3,9 +3,9 @@
 echo 'Starting TokyoTyrant'
 /usr/sbin/ttserver -dmn -pid /tmp/ttserver.pid -log /tmp/ttserver.log -port 1978
 
-sudo service riak start &
-sudo service couchdb start &
-sudo service redis-server start &
-sudo service cassandra start &
-sudo service memcached start &
-sudo service mongodb start &
+# Waiting for servers to start
+sleep 3
+
+echo 'TokyoTyrant status'
+ps aux | grep ttserver
+cat /tmp/ttserver.log

data/spec/helper.rb

@@ -49,7 +49,7 @@ end
 
 RSpec.configure do |config|
   config.verbose_retry = true
-  config.color_enabled = true
+  config.color = true
   config.tty = true
   config.formatter = ENV['PARALLEL_TESTS'] ? MonetaParallelFormatter : :progress
 end

data/spec/moneta/adapter_datamapper_spec.rb

@@ -57,7 +57,7 @@ describe_moneta "adapter_datamapper" do
     second['key'] = 'value2'
 
     first.delete('key').should == 'value'
-    first.key?('key').should be_false
+    first.key?('key').should be false
     second['key'].should == 'value2'
   end
 

data/spec/moneta/adapter_lruhash_spec.rb

@@ -37,7 +37,100 @@ describe_moneta "adapter_lruhash" do
       (0...[9, i-1].min).each do |j|
         store.instance_variable_get(:@entry)[i-j].should_not be_nil
       end
-      store.key?(i-9).should be_false if i > 9
+      store.key?(i-9).should be false if i > 9
     end
   end
+
+  it 'adds a value that is the same as max_size' do
+    store = Moneta::Adapters::LRUHash.new(max_size: 21)
+    store[:a_key] = 'This is 21 bytes long'
+    store[:a_key].should eq('This is 21 bytes long')
+  end
+
+  it 'does not add a value that is larger than max_size' do
+    store = Moneta::Adapters::LRUHash.new(max_size: 20)
+    store[:too_long] = 'This is 21 bytes long'
+    store[:too_long].should be_nil
+  end
+
+  it 'removes an existing key that is replaced by an item that is larger than max_size' do
+    store = Moneta::Adapters::LRUHash.new(max_size: 20)
+    store[:a_key] = 'This will fit'
+    store[:a_key] = 'This is 21 bytes long'
+    store[:a_key].should be_nil
+  end
+
+  it 'does not add a value that is larger than max_size, when max_value is explicitly missing' do
+    store = Moneta::Adapters::LRUHash.new(max_size: 20, max_value: nil)
+    store[:too_long] = 'This is 21 bytes long'
+    store[:too_long].should be_nil
+  end
+
+  it 'does not add a value that is larger than max_size, even if max_value is larger than max_size' do
+    store = Moneta::Adapters::LRUHash.new(max_size: 20, max_value: 25)
+    store[:too_long] = 'This is 21 bytes long'
+    store[:too_long].should be_nil
+  end
+
+  it 'adds a value that is as large as the default max_size when max_size is missing' do
+    store = Moneta::Adapters::LRUHash.new
+    large_item = 'Really big'
+    allow(large_item).to receive(:bytesize).and_return(Moneta::Adapters::LRUHash::DEFAULT_MAX_SIZE)
+    store[:really_big] = large_item
+    store[:really_big].should eq(large_item)
+  end
+
+  it 'does not add values that are larger than the default max_size when max_size is missing' do
+    store = Moneta::Adapters::LRUHash.new
+    large_item = 'Really big'
+    allow(large_item).to receive(:bytesize).and_return(Moneta::Adapters::LRUHash::DEFAULT_MAX_SIZE + 1)
+    store[:really_big] = large_item
+    store[:really_big].should be_nil
+  end
+
+  it 'adds values that are larger than the default max_size when max_size is nil' do
+    store = Moneta::Adapters::LRUHash.new(max_size: nil)
+    large_item = 'Really big'
+    allow(large_item).to receive(:bytesize).and_return(Moneta::Adapters::LRUHash::DEFAULT_MAX_SIZE + 1)
+    store[:really_big] = large_item
+    store[:really_big].should eq(large_item)
+  end
+
+  it 'adds an individual value that is equal to max_value' do
+    store = Moneta::Adapters::LRUHash.new(max_value: 13)
+    store[:a_key] = '13 bytes long'
+    store[:a_key].should eq('13 bytes long')
+  end
+
+  it 'does not add a value that is larger than max_value' do
+    store = Moneta::Adapters::LRUHash.new(max_value: 20)
+    store[:too_long] = 'This is 21 bytes long'
+    store[:too_long].should be_nil
+  end
+
+  it 'removes keys that are replaced by values larger than max_value' do
+    store = Moneta::Adapters::LRUHash.new(max_value: 20)
+    store[:too_long] = 'This will fit'
+    store[:too_long] = 'This is 21 bytes long'
+    store[:too_long].should be_nil
+  end
+
+  it 'only allows the default number of items when max_count is missing' do
+    stub_const('Moneta::Adapters::LRUHash::DEFAULT_MAX_COUNT', 5)
+    store = Moneta::Adapters::LRUHash.new(max_value: nil, max_size: nil)
+    (1..6).each { |n| store[n] = n }
+    store.key?(1).should be false
+    store[1].should be_nil
+    store[2].should eq(2)
+    store[6].should eq(6)
+  end
+
+  it 'adds more values than DEFAULT_MAX_COUNT allows when max_count is nil' do
+    stub_const('Moneta::Adapters::LRUHash::DEFAULT_MAX_COUNT', 5)
+    store = Moneta::Adapters::LRUHash.new(max_count: nil, max_value: nil, max_size: nil)
+    (1..6).each { |n| store[n] = n }
+    store[1].should eq(1)
+    store[2].should eq(2)
+    store[6].should eq(6)
+  end
 end

data/spec/moneta/adapter_mongo_moped_spec.rb

@@ -8,7 +8,8 @@ describe_moneta "adapter_mongo_moped" do
   end
 
   def new_store
-    Moneta::Adapters::MongoMoped.new(db: "adapter_mongo")
+    Moneta::Adapters::MongoMoped.new(db: "adapter_mongo",
+                                     collection: 'moped')
   end
 
   def load_value(value)
@@ -49,8 +50,15 @@ describe_moneta "adapter_mongo_moped" do
   it_should_behave_like 'store_large'
   it 'automatically deletes expired document' do
     store.store('key', 'val', expires: 5)
-    store.instance_variable_get(:@collection).find('_id' => ::Moped::BSON::Binary.new(:generic, 'key')).one.should_not be_nil
-    sleep 70 # Mongo needs up to 60 seconds
-    store.instance_variable_get(:@collection).find('_id' => ::Moped::BSON::Binary.new(:generic, 'key')).one.should be_nil
+
+    i = 0
+    query = store.instance_variable_get(:@collection).find(_id: ::BSON::Binary.new('key'))
+    while i < 70 && query.first
+      i += 1
+      sleep 1 # Mongo needs up to 60 seconds
+    end
+
+    i.should be > 0 # Indicates that it took at least one sleep to expire
+    query.count.should == 0
   end
 end

data/spec/moneta/adapter_mongo_moped_with_default_expires_spec.rb

@@ -8,7 +8,9 @@ describe_moneta "adapter_mongo_moped_with_default_expires" do
   end
 
   def new_store
-    Moneta::Adapters::MongoMoped.new(expires: 1)
+    Moneta::Adapters::MongoMoped.new(db: "adapter_mongo",
+                                     collection: 'moped_with_default_expires',
+                                     expires: 1)
   end
 
   def load_value(value)

data/spec/moneta/adapter_mongo_official_spec.rb

@@ -8,7 +8,8 @@ describe_moneta "adapter_mongo_official" do
   end
 
   def new_store
-    Moneta::Adapters::MongoOfficial.new(db: "adapter_mongo")
+    Moneta::Adapters::MongoOfficial.new(db: "adapter_mongo",
+                                        collection: 'official')
   end
 
   def load_value(value)
@@ -49,8 +50,15 @@ describe_moneta "adapter_mongo_official" do
   it_should_behave_like 'store_large'
   it 'automatically deletes expired document' do
     store.store('key', 'val', expires: 5)
-    store.instance_variable_get(:@collection).find_one('_id' => ::BSON::Binary.new('key')).should_not be_nil
-    sleep 70 # Mongo needs up to 60 seconds
-    store.instance_variable_get(:@collection).find_one('_id' => ::BSON::Binary.new('key')).should be_nil
+
+    i = 0
+    query = store.instance_variable_get(:@collection).find(_id: ::BSON::Binary.new('key'))
+    while i < 70 && query.first
+      i += 1
+      sleep 1 # Mongo needs up to 60 seconds
+    end
+
+    i.should be > 0 # Indicates that it took at least one sleep to expire
+    query.count.should == 0
   end
 end

data/spec/moneta/adapter_mongo_official_with_default_expires_spec.rb

@@ -8,7 +8,9 @@ describe_moneta "adapter_mongo_official_with_default_expires" do
   end
 
   def new_store
-    Moneta::Adapters::MongoOfficial.new(expires: 1)
+    Moneta::Adapters::MongoOfficial.new(db: "adapter_mongo",
+                                        collection: 'official_with_default_expires',
+                                        expires: 1)
   end
 
   def load_value(value)

data/spec/moneta/adapter_mongo_spec.rb

@@ -8,7 +8,8 @@ describe_moneta "adapter_mongo" do
   end
 
   def new_store
-    Moneta::Adapters::Mongo.new(db: "adapter_mongo")
+    Moneta::Adapters::Mongo.new(db: "adapter_mongo",
+                                collection: 'default')
   end
 
   def load_value(value)

data/spec/moneta/adapter_mongo_with_default_expires_spec.rb

@@ -8,7 +8,9 @@ describe_moneta "adapter_mongo_with_default_expires" do
   end
 
   def new_store
-    Moneta::Adapters::Mongo.new(expires: 1)
+    Moneta::Adapters::Mongo.new(db: "adapter_mongo",
+                                collection: 'with_default_expires',
+                                expires: 1)
   end
 
   def load_value(value)

data/spec/moneta/mutex_spec.rb

@@ -19,8 +19,8 @@ describe_moneta "mutex" do
 
   it 'should have #lock' do
     mutex = Moneta::Mutex.new(store, 'mutex')
-    mutex.lock.should be_true
-    mutex.locked?.should be_true
+    mutex.lock.should be true
+    mutex.locked?.should be true
     expect do
      mutex.lock
     end.to raise_error(RuntimeError)
@@ -28,13 +28,13 @@ describe_moneta "mutex" do
      mutex.try_lock
     end.to raise_error(RuntimeError)
     mutex.unlock.should be_nil
-    mutex.locked?.should be_false
+    mutex.locked?.should be false
   end
 
   it 'should have #enter' do
     mutex = Moneta::Mutex.new(store, 'mutex')
-    mutex.enter.should be_true
-    mutex.locked?.should be_true
+    mutex.enter.should be true
+    mutex.locked?.should be true
     expect do
      mutex.enter
     end.to raise_error(RuntimeError)
@@ -42,31 +42,31 @@ describe_moneta "mutex" do
      mutex.try_enter
     end.to raise_error(RuntimeError)
     mutex.leave.should be_nil
-    mutex.locked?.should be_false
+    mutex.locked?.should be false
   end
 
   it 'should lock with #lock' 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.lock.should be true
+    b.try_lock.should be false
     a.unlock.should be_nil
   end
 
   it 'should have lock timeout' do
     a = Moneta::Mutex.new(store, 'mutex')
     b = Moneta::Mutex.new(store, 'mutex')
-    a.lock.should be_true
-    b.lock(1).should be_false
+    a.lock.should be true
+    b.lock(1).should be false
     a.unlock.should be_nil
   end
 
   it 'should have #synchronize' do
     mutex = Moneta::Mutex.new(store, 'mutex')
     mutex.synchronize do
-      mutex.locked?.should be_true
+      mutex.locked?.should be true
     end
-    mutex.locked?.should be_false
+    mutex.locked?.should be false
   end
 
 end

data/spec/moneta/optionmerger_spec.rb

@@ -105,7 +105,7 @@ describe_moneta "optionmerger" do
     compressed_store['key'] = 'compressed value'
     store['key'].should == 'uncompressed value'
     compressed_store['key'].should == 'compressed value'
-    store.key?('compressedkey').should be_true
+    store.key?('compressedkey').should be true
     # Check if value is compressed
     compressed_store['key'].should_not == store['compressedkey']
   end

data/spec/moneta/semaphore_spec.rb

@@ -19,8 +19,8 @@ describe_moneta "semaphore" do
 
   it 'should have #lock' do
     mutex = Moneta::Semaphore.new(store, 'semaphore')
-    mutex.lock.should be_true
-    mutex.locked?.should be_true
+    mutex.lock.should be true
+    mutex.locked?.should be true
     expect do
      mutex.lock
     end.to raise_error(RuntimeError)
@@ -28,13 +28,13 @@ describe_moneta "semaphore" do
      mutex.try_lock
     end.to raise_error(RuntimeError)
     mutex.unlock.should be_nil
-    mutex.locked?.should be_false
+    mutex.locked?.should be false
   end
 
   it 'should have #enter' do
     mutex = Moneta::Semaphore.new(store, 'semaphore')
-    mutex.enter.should be_true
-    mutex.locked?.should be_true
+    mutex.enter.should be true
+    mutex.locked?.should be true
     expect do
      mutex.enter
     end.to raise_error(RuntimeError)
@@ -42,22 +42,22 @@ describe_moneta "semaphore" do
      mutex.try_enter
     end.to raise_error(RuntimeError)
     mutex.leave.should be_nil
-    mutex.locked?.should be_false
+    mutex.locked?.should be false
   end
 
   it 'should lock with #lock' do
     a = Moneta::Semaphore.new(store, 'semaphore')
     b = Moneta::Semaphore.new(store, 'semaphore')
-    a.lock.should be_true
-    b.try_lock.should be_false
+    a.lock.should be true
+    b.try_lock.should be false
     a.unlock.should be_nil
   end
 
   it 'should have lock timeout' do
     a = Moneta::Semaphore.new(store, 'semaphore')
     b = Moneta::Semaphore.new(store, 'semaphore')
-    a.lock.should be_true
-    b.lock(1).should be_false
+    a.lock.should be true
+    b.lock(1).should be false
     a.unlock.should be_nil
   end
 
@@ -66,10 +66,10 @@ describe_moneta "semaphore" do
     b = Moneta::Semaphore.new(store, 'semaphore', 2)
     c = Moneta::Semaphore.new(store, 'semaphore', 2)
     a.synchronize do
-      a.locked?.should be_true
+      a.locked?.should be true
       b.synchronize do
-        b.locked?.should be_true
-        c.try_lock.should be_false
+        b.locked?.should be true
+        c.try_lock.should be false
       end
     end
   end
@@ -77,9 +77,9 @@ describe_moneta "semaphore" do
   it 'should have #synchronize' do
     semaphore = Moneta::Semaphore.new(store, 'semaphore')
     semaphore.synchronize do
-      semaphore.locked?.should be_true
+      semaphore.locked?.should be true
     end
-    semaphore.locked?.should be_false
+    semaphore.locked?.should be false
   end
 
 end

data/spec/moneta/shared_tcp_spec.rb

@@ -38,7 +38,7 @@ describe_moneta "shared_tcp" do
   it 'shares values' do
     store['shared_key'] = 'shared_value'
     second = new_store
-    second.key?('shared_key').should be_true
+    second.key?('shared_key').should be true
     second['shared_key'].should == 'shared_value'
     second.close
   end

data/spec/moneta/shared_unix_spec.rb

@@ -38,7 +38,7 @@ describe_moneta "shared_unix" do
   it 'shares values' do
     store['shared_key'] = 'shared_value'
     second = new_store
-    second.key?('shared_key').should be_true
+    second.key?('shared_key').should be true
     second['shared_key'].should == 'shared_value'
     second.close
   end

data/spec/moneta/standard_mongo_moped_spec.rb

@@ -8,7 +8,7 @@ describe_moneta "standard_mongo_moped" do
   end
 
   def new_store
-    Moneta.new(:MongoMoped, db: 'standard_mongo_moped', logger: {file: File.join(make_tempdir, 'standard_mongo_moped.log')})
+    Moneta.new(:MongoMoped, db: 'standard_mongo', collection: 'moped', logger: {file: File.join(make_tempdir, 'standard_mongo_moped.log')})
   end
 
   def load_value(value)

data/spec/moneta/standard_mongo_official_spec.rb

@@ -8,7 +8,7 @@ describe_moneta "standard_mongo_official" do
   end
 
   def new_store
-    Moneta.new(:MongoOfficial, db: 'standard_mongo_official', logger: {file: File.join(make_tempdir, 'standard_mongo_official.log')})
+    Moneta.new(:MongoOfficial, db: 'standard_mongo', collection: 'official', logger: {file: File.join(make_tempdir, 'standard_mongo_official.log')})
   end
 
   def load_value(value)

data/spec/moneta/standard_mongo_spec.rb

@@ -8,7 +8,7 @@ describe_moneta "standard_mongo" do
   end
 
   def new_store
-    Moneta.new(:Mongo, db: 'standard_mongo', logger: {file: File.join(make_tempdir, 'standard_mongo.log')})
+    Moneta.new(:Mongo, db: 'standard_mongo', collection: 'default', logger: {file: File.join(make_tempdir, 'standard_mongo.log')})
   end
 
   def load_value(value)