moneta 1.1.1 → 1.4.1

data/spec/features/increment.rb

@@ -1,72 +1,72 @@
 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'
+    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/)
 
-    store.delete('inckey', raw: true).should == '1'
-    store.key?('inckey').should be false
+    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
-    store.increment('inckey', 42).should == 42
-    store.key?('inckey').should be true
-    store.raw['inckey'].should == '42'
-    store.delete('inckey', raw: true).should == '42'
+    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
-    store.increment('inckey', 0).should == 0
-    store.key?('inckey').should be true
-    store.raw['inckey'].should == '0'
-    store.delete('inckey', raw: true).should == '0'
+    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
-    store.decrement('inckey', 0).should == 0
-    store.raw['inckey'].should == '0'
+    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
-    store.decrement('inckey', -42).should == 42
-    store.raw['inckey'].should == '42'
+    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
-    store.increment('inckey').should == 1
-    store.increment('inckey', 42).should == 43
-    store.raw['inckey'].should == '43'
+    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
-    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'
+    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
-    store.increment('inckey').should == 1
-    store.increment('inckey', 0).should == 1
-    store.raw['inckey'].should == '1'
+    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
-    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'
+    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)
-    store.increment('inckey').should == 43
-    store.raw['inckey'].should == '43'
+    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
@@ -88,10 +88,10 @@ shared_examples :increment do
     b = Moneta::Semaphore.new(store, 'semaphore', 2)
     c = Moneta::Semaphore.new(store, 'semaphore', 2)
     a.synchronize do
-      a.locked?.should be true
+      expect(a.locked?).to be true
       b.synchronize do
-        b.locked?.should be true
-        c.try_lock.should be false
+        expect(b.locked?).to be true
+        expect(c.try_lock).to be false
       end
     end
   end

data/spec/features/store.rb

@@ -178,7 +178,7 @@ shared_examples :store do
   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.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
@@ -192,7 +192,7 @@ shared_examples :store do
     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.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
@@ -204,7 +204,7 @@ shared_examples :store do
     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(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]

data/spec/helper.rb

@@ -262,13 +262,16 @@ module MonetaHelpers
       # want to run the tests but don't want to grant root access to moneta
       let(:mysql_username) { ENV['MONETA_MYSQL_USERNAME'] || 'root' }
       let(:mysql_password) { ENV['MONETA_MYSQL_PASSWORD'] }
-      let(:mysql_database1) { ENV['MONETA_MYSQL_DATABSASE1'] || 'moneta' }
-      let(:mysql_database2) { ENV['MONETA_MYSQL_DATABSASE2'] || 'moneta2' }
+      let(:mysql_database1) { ENV['MONETA_MYSQL_DATABASE1'] || 'moneta' }
+      let(:mysql_database2) { ENV['MONETA_MYSQL_DATABASE2'] || 'moneta2' }
 
       let(:postgres_username) { ENV['MONETA_POSTGRES_USERNAME'] || 'postgres' }
       let(:postgres_database1) { ENV['MONETA_POSTGRES_DATABSASE1'] || 'moneta1' }
       let(:postgres_database2) { ENV['MONETA_POSTGRES_DATABSASE1'] || 'moneta2' }
 
+      let(:couch_login) { ENV['COUCH_LOGIN'] || 'admin' }
+      let(:couch_password) { ENV['COUCH_PASSWORD'] || 'password' }
+
       before do
         store = new_store
         store.clear
@@ -282,36 +285,9 @@ module MonetaHelpers
       end
     end
 
-    # Used to test time-dependent specs (e.g. expiry at different positions
-    # within a second). Once close to the start of the second, and once close
-    # to the end.
-    def usecs
-      [1e4, 99e4].map(&:to_i)
-    end
-
-    def at_each_usec(&block)
-      usecs.each do |usec|
-        context "at #{usec} microseconds", isolate: true do
-          include_examples :at_usec, usec, &block
-        end
-      end
-    end
-
     def use_timecop
-      before{ @timecop = true }
-    end
-
-    def start_memcached(port)
-      before :context do
-        @memcached = spawn("memcached -p #{port}")
-        sleep 0.5
-      end
-
-      after :context do
-        Process.kill("TERM", @memcached)
-        Process.wait(@memcached)
-        @memcached = nil
-      end
+      before { @timecop = true }
+      after { Timecop.return }
     end
   end
 
@@ -336,41 +312,6 @@ module MonetaHelpers
       end
     end
 
-    def start_restserver
-      require 'rack'
-      require 'webrick'
-      require 'rack/moneta_rest'
-
-      # Keep webrick quiet
-      ::WEBrick::HTTPServer.class_eval do
-        def access_log(config, req, res); end
-      end
-      ::WEBrick::BasicLog.class_eval do
-        def log(level, data); end
-      end
-
-      Thread.start do
-        Rack::Server.start(:app => Rack::Builder.app do
-                             use Rack::Lint
-                             map '/moneta' do
-                               run Rack::MonetaRest.new(:store => :Memory)
-                             end
-                           end,
-                           :environment => :none,
-                           :server => :webrick,
-                           :Port => 8808)
-      end
-      sleep 1
-    end
-
-    def start_server(*args)
-      server = Moneta::Server.new(*args)
-      Thread.new { server.run }
-      sleep 0.1 until server.running?
-    rescue Exception => ex
-      puts "Failed to start server - #{ex.message}"
-    end
-
     def moneta_property_of(keys: 0, values: 0)
       keys_meta = self.keys_meta
       values_meta = self.values_meta
@@ -395,6 +336,20 @@ module MonetaHelpers
         sleep seconds
       end
     end
+
+    def time_till_next(tick)
+      now = Time.now.to_f
+      tick - (now % tick)
+    end
+
+    # advance to the moment just after a tick. 1e-2 is needed in some
+    # environments (JRuby) to be able to pass the "not in earlier half" test.
+    def advance_next_tick
+      tick = t_res
+      offset = time_till_next(tick) + 1e-2
+      advance offset
+      raise "not in earlier half of tick" unless Time.now.to_f % tick < tick / 2.0
+    end
   end
 end
 
@@ -475,20 +430,4 @@ RSpec.shared_context :setup_moneta_store do |builder|
   end
 end
 
-RSpec.shared_examples :at_usec do |usec|
-  before do
-    now = Time.now
-    # 1000us is a rough guess at how many microseconds this code will take to run
-    if now.usec + 1000 > usec
-      advance(1 - 1e-6 * (now.usec - usec))
-    else
-      advance(1e-6 * (usec - now.usec))
-    end
-  end
-
-  after do
-    Timecop.return if @timecop
-  end
-end
-
 Dir['./spec/features/*.rb'].each{ |rb| require rb }

data/spec/moneta/adapters/activerecord/standard_activerecord_spec.rb

@@ -14,5 +14,5 @@ describe "standard_activerecord", adapter: :ActiveRecord do
     ::Marshal.load(value.unpack('m').first)
   end
 
-  moneta_specs STANDARD_SPECS
+  moneta_specs STANDARD_SPECS.with_each_key
 end

data/spec/moneta/adapters/activerecord/standard_activerecord_with_expires_spec.rb

@@ -20,5 +20,5 @@ describe "standard_activerecord_with_expires", adapter: :ActiveRecord do
     ::Marshal.load(value.unpack('m').first)
   end
 
-  moneta_specs STANDARD_SPECS.with_expires
+  moneta_specs STANDARD_SPECS.with_expires.with_each_key
 end

data/spec/moneta/adapters/activesupportcache/adapter_activesupportcache_spec.rb

@@ -1,3 +1,5 @@
+require_relative '../memcached_helper.rb'
+
 describe 'adapter_activesupportcache', adapter: :ActiveSupportCache do
   before :all do
     require 'active_support'
@@ -25,7 +27,8 @@ describe 'adapter_activesupportcache', adapter: :ActiveSupportCache do
     let(:t_res) { 1 }
     let(:min_ttl) { 2 }
     use_timecop
-    start_memcached 11215
+
+    include_context :start_memcached, 11215
 
     let(:backend) { ActiveSupport::Cache::MemCacheStore.new('127.0.0.1:11215') }
     include_examples :adapter_activesupportcache

data/spec/moneta/adapters/activesupportcache/adapter_activesupportcache_with_default_expires_spec.rb

@@ -1,3 +1,5 @@
+require_relative '../memcached_helper'
+
 describe 'adapter_activesupportcache_with_default_expires', adapter: :ActiveSupportCache do
   before :all do
     require 'active_support'
@@ -25,7 +27,8 @@ describe 'adapter_activesupportcache_with_default_expires', adapter: :ActiveSupp
     let(:t_res) { 1 }
     let(:min_ttl) { 2 }
     use_timecop
-    start_memcached 11223
+
+    include_context :start_memcached, 11223
 
     let(:backend) { ActiveSupport::Cache::MemCacheStore.new('127.0.0.1:11223') }
     include_examples :adapter_activesupportcache_with_default_expires

data/spec/moneta/adapters/activesupportcache/standard_activesupportcache_spec.rb

@@ -0,0 +1,14 @@
+describe 'standard_activesupportcache' do
+  before :context do
+    require 'active_support'
+  end
+
+  let(:t_res) { 0.1 }
+  let(:min_ttl) { 0.1 }
+
+  moneta_store :ActiveSupportCache do
+    { backend: ActiveSupport::Cache::MemoryStore.new }
+  end
+
+  moneta_specs STANDARD_SPECS.without_create.without_persist.with_native_expires
+end

data/spec/moneta/adapters/cassandra/standard_cassandra_spec.rb

@@ -14,5 +14,5 @@ describe "standard_cassandra", retry: 3, adapter: :Cassandra do
     }
   end
 
-  moneta_specs STANDARD_SPECS.without_increment.without_create.with_native_expires
+  moneta_specs STANDARD_SPECS.without_increment.without_create.with_native_expires.with_each_key
 end

data/spec/moneta/adapters/client/adapter_client_spec.rb

@@ -1,11 +1,11 @@
-describe 'adapter_client', isolate: true, adapter: :Client do
-  before :all do
-    start_server(Moneta::Adapters::Memory.new)
-  end
+require_relative './client_helper.rb'
+
+describe 'adapter_client', adapter: :Client do
+  include_context :start_server, port: 9002, backend: ->{ Moneta::Adapters::Memory.new }
 
   moneta_build do
-    Moneta::Adapters::Client.new
+    Moneta::Adapters::Client.new(port: 9002)
   end
 
-  moneta_specs ADAPTER_SPECS
+  moneta_specs ADAPTER_SPECS.with_each_key
 end

data/spec/moneta/adapters/client/client_helper.rb

@@ -0,0 +1,24 @@
+RSpec.shared_context :start_server do |**options|
+  before :context do
+    begin
+      options.each do |key, value|
+        options[key] = instance_exec(&value) if value.respond_to? :call
+      end
+      backend = options.delete(:backend)
+      @server = Moneta::Server.new(backend, options)
+      @thread = Thread.new { @server.run }
+      sleep 0.1 until @server.running?
+    rescue Exception => ex
+      puts "Failed to start server - #{ex.message}"
+      tries ||= 0
+      tries += 1
+      sleep Moneta::Server::TIMEOUT
+      tries < 3 ? retry : raise
+    end
+  end
+
+  after :context do
+    @server.stop
+    @thread.join
+  end
+end

data/spec/moneta/adapters/client/standard_client_tcp_spec.rb

@@ -1,17 +1,17 @@
-describe "standard_client_tcp", isolate: true, adapter: :Client do
-  before :all do
-    start_server(Moneta::Adapters::Memory.new)
-  end
+require_relative './client_helper.rb'
+
+describe "standard_client_tcp", adapter: :Client do
+  include_context :start_server, port: 9003, backend: ->{ Moneta::Adapters::Memory.new }
 
-  moneta_store :Client
-  moneta_specs STANDARD_SPECS
+  moneta_store :Client, port: 9003
+  moneta_specs STANDARD_SPECS.with_each_key
 
   it 'supports multiple clients' do
     store['shared_key'] = 'shared_val'
-    threads = (1..100).map do |i|
+    threads = (1..32).map do |i|
       Thread.new do
         client = new_store
-        (1..100).each do |j|
+        (1..31).each do |j|
           client['shared_key'].should == 'shared_val'
           client["key-\#{j}-\#{i}"] = "val-\#{j}-\#{i}"
           client["key-\#{j}-\#{i}"].should == "val-\#{j}-\#{i}"

data/spec/moneta/adapters/client/standard_client_unix_spec.rb

@@ -1,12 +1,28 @@
-describe "standard_client_unix", isolate: true, adapter: :Client do
-  before :all do
-    start_server Moneta::Adapters::Memory.new,
-                 socket: File.join(tempdir, 'standard_client_unix')
-  end
+require_relative './client_helper.rb'
+
+describe "standard_client_unix", adapter: :Client do
+  include_context :start_server,
+                  backend: ->{ Moneta::Adapters::Memory.new },
+                  socket: ->{ File.join(tempdir, 'standard_client_unix') }
 
   moneta_store :Client do
-    {socket: File.join(tempdir, 'standard_client_unix')}
+    { socket: File.join(tempdir, 'standard_client_unix') }
   end
 
-  moneta_specs STANDARD_SPECS
+  moneta_specs STANDARD_SPECS.with_each_key
+
+  it 'supports multiple clients' do
+    store['shared_key'] = 'shared_val'
+    threads = (1..32).map do |i|
+      Thread.new do
+        client = new_store
+        (1..31).each do |j|
+          client['shared_key'].should == 'shared_val'
+          client["key-\#{j}-\#{i}"] = "val-\#{j}-\#{i}"
+          client["key-\#{j}-\#{i}"].should == "val-\#{j}-\#{i}"
+        end
+      end
+    end
+    threads.map(&:join)
+  end
 end