moneta 1.4.1 → 1.5.1

data/spec/features/store.rb

@@ -1,106 +1,106 @@
 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]
+    moneta_property_of(keys: 1, values: 1).check do |m|
+      store[m.keys[0]] = m.values[0]
+      store[m.keys[0]].should == m.values[0]
+      store.load(m.keys[0]).should == m.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
+    moneta_property_of(keys: 1, values: 1).check do |m|
+      store[m.keys[0]] = m.values[0]
+      store.key?(m.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]
+    moneta_property_of(keys: 1, values: 1).check do |m|
+      value = m.values[0]
+      store.store(m.keys[0], value).should equal(value)
+      store[m.keys[0]].should == m.values[0]
+      store.load(m.keys[0]).should == m.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]
+    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[keys[0]] = values[0]
-      store[keys[0]].should == values[0]
-      store[keys[1]].should be_nil
+      store[m.keys[0]] = m.values[0]
+      store[m.keys[0]].should == m.values[0]
+      store[m.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
+    moneta_property_of(keys: 1, values: 1).check do |m|
+      store[m.keys[0]] = m.values[0]
+      store.delete(m.keys[0]).should == m.values[0]
+      store.key?(m.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]
+    moneta_property_of(keys: 1, values: 2).check do |m|
+      store[m.keys[0]] = m.values[0]
+      store[m.keys[0]].should == m.values[0]
+      store[m.keys[0]] = m.values[1]
+      store[m.keys[0]].should == m.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]
+    moneta_property_of(keys: 1, values: 1).check do |m|
+      value = m.values[0].freeze
+      (store[m.keys[0]] = value).should equal(value)
+      store[m.keys[0]].should == m.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]
+    moneta_property_of(keys: 1, values: 1).check do |m|
+      key = m.keys[0].freeze
+      store[key] = m.values[0]
+      store[m.keys[0]].should == m.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]
+    moneta_property_of(keys: 1, values: 2).check do |m|
+      next if m.values[0].nil?
+      store[m.keys[0]] = m.values[0]
+      store.fetch(m.keys[0], m.values[1]).should == m.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]
+    moneta_property_of(keys: 1, values: 1).check do |m|
+      next if m.values[0].nil?
+      store[m.keys[0]] = m.values[0]
       unaltered = 'unaltered'
-      store.fetch(keys[0]) { unaltered = 'altered' }
+      store.fetch(m.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]]
+      moneta_property_of(keys: 3, values: 3).check do |m|
+        store[m.keys[0]] = m.values[0]
+        store[m.keys[1]] = m.values[1]
+        store[m.keys[2]] = m.values[2]
+        expect(store.public_send(name, m.keys[1], m.keys[2], m.keys[0])).to eq [m.values[1], m.values[2], m.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]]
+      moneta_property_of(keys: 3, values: 2).check do |m|
+        store[m.keys[0]] = m.values[0]
+        store[m.keys[1]] = m.values[1]
+        expect(store.public_send(name, m.keys[1], m.keys[2], m.keys[0])).to eq [m.values[1], nil, m.values[0]]
         store.clear
       end
     end
@@ -114,29 +114,29 @@ shared_examples :store 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]
+      moneta_property_of(keys: 4, values: 3).check do |m|
+        store[m.keys[0]] = m.values[0]
+        store[m.keys[1]] = m.values[1]
+        store[m.keys[2]] = m.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.fetch_values(m.keys[0], m.keys[1], m.keys[2], m.keys[3], &b)
+        end.to yield_with_args(m.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]
+      moneta_property_of(keys: 4, values: 4).check do |m|
+        store[m.keys[0]] = m.values[0]
+        store[m.keys[1]] = m.values[1]
+        store[m.keys[2]] = m.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]]
+        expect(store.fetch_values(m.keys[0], m.keys[1], m.keys[2], m.keys[3]) do |key|
+          expect(key).to eq m.keys[3]
+          m.values[3]
+        end).to eq [m.values[0], m.values[1], m.values[2], m.values[3]]
 
         store.clear
       end
@@ -149,26 +149,26 @@ shared_examples :store do
 
   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]
+      moneta_property_of(keys: 3, values: 3).check do |m|
+        store[m.keys[0]] = m.values[0]
+        store[m.keys[1]] = m.values[1]
+        store[m.keys[2]] = m.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]])
+        expect(store.slice(*[m.keys[0], m.keys[1], m.keys[2]].shuffle).to_a).to \
+          contain_exactly([m.keys[0], m.values[0]], [m.keys[1], m.values[1]], [m.keys[2], m.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]
+      moneta_property_of(keys: 4, values: 3).check do |m|
+        store[m.keys[0]] = m.values[0]
+        store[m.keys[1]] = m.values[1]
+        store[m.keys[2]] = m.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]])
+        expect(store.slice(*[m.keys[0], m.keys[1], m.keys[2], m.keys[3]].shuffle).to_a).to \
+          contain_exactly([m.keys[0], m.values[0]], [m.keys[1], m.values[1]], [m.keys[2], m.values[2]])
 
         store.clear
       end
@@ -177,44 +177,44 @@ 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.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]
+      moneta_property_of(keys: 3, values: 3).check do |m|
+        expect(store.public_send(method, pairs.call({ m.keys[0] => m.values[0], m.keys[1] => m.values[1], m.keys[2] => m.values[2] }))).to be store
+        expect(store.key?(m.keys[0])).to be true
+        expect(store[m.keys[0]]).to eq m.values[0]
+        expect(store.key?(m.keys[1])).to be true
+        expect(store[m.keys[1]]).to eq m.values[1]
+        expect(store.key?(m.keys[2])).to be true
+        expect(store[m.keys[2]]).to eq m.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]
+      moneta_property_of(keys: 2, values: 3).check do |m|
+        expect(store[m.keys[0]] = m.values[0]).to eq m.values[0]
+        expect(store.public_send(method, pairs.call({ m.keys[0] => m.values[1], m.keys[1] => m.values[2] }))).to be store
+        expect(store.key?(m.keys[0])).to be true
+        expect(store[m.keys[0]]).to eq m.values[1]
+        expect(store.key?(m.keys[1])).to be true
+        expect(store[m.keys[1]]).to eq m.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]
+      moneta_property_of(keys: 2, values: 4).check do |m|
+        expect(store[m.keys[0]] = m.values[0]).to eq m.values[0]
+        expect(store.public_send(method, pairs.call({ m.keys[0] => m.values[1], m.keys[1] => m.values[2] })) do |key, old_val, new_val|
+          expect(key).to eq m.keys[0]
+          expect(old_val).to eq m.values[0]
+          expect(new_val).to eq m.values[1]
+          m.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]
+        expect(store.key?(m.keys[0])).to be true
+        expect(store[m.keys[0]]).to eq m.values[3]
+        expect(store.key?(m.keys[1])).to be true
+        expect(store[m.keys[1]]).to eq m.values[2]
         store.clear
       end
     end

data/spec/helper.rb

@@ -213,11 +213,18 @@ ADAPTER_SPECS = MonetaSpecs.new(
     :create, :features, :store_large, :not_each_key],
   key: %w(string path),
   value: %w(string path binary))
+
+NATIVE_EXPIRY_SPECS = MonetaSpecs.new(
+  specs: [:create, :expires, :create_expires],
+  key: %w(string path),
+  value: %w(string path binary))
+
 STANDARD_SPECS = MonetaSpecs.new(
   specs: [:null, :store, :returndifferent,
     :marshallable_key, :marshallable_value, :transform_value, :increment,
     :concurrent_increment, :concurrent_create, :persist, :multiprocess, :create,
     :features, :store_large, :not_each_key])
+
 TRANSFORMER_SPECS = MonetaSpecs.new(
   specs: [:null, :store, :returndifferent,
     :transform_value, :increment, :create, :features, :store_large,
@@ -260,18 +267,24 @@ module MonetaHelpers
 
       # Used by tests that rely on MySQL.  These env vars can be used if you
       # want to run the tests but don't want to grant root access to moneta
+      let(:mysql_host) { ENV['MYSQL_HOST'] || 'localhost' }
+      let(:mysql_port) { ENV['MYSQL_TCP_PORT'] || '3306' }
       let(:mysql_username) { ENV['MONETA_MYSQL_USERNAME'] || 'root' }
       let(:mysql_password) { ENV['MONETA_MYSQL_PASSWORD'] }
       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_username) { ENV['PGUSER'] || 'postgres' }
+      let(:postgres_password) { ENV['PGPASSWORD'] }
       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' }
 
+      let(:redis_host) { ENV.fetch('REDIS_HOST', 'localhost') }
+      let(:redis_port) { ENV.fetch('REDIS_PORT', '6379') }
+
       before do
         store = new_store
         store.clear
@@ -322,9 +335,7 @@ module MonetaHelpers
         value_values = values.times.map { call(values_meta) }
         guard value_values.uniq.length == value_values.length
 
-        [[:keys, key_values], [:values, value_values]].
-          reject { |key, value| value.empty? }.
-          to_h
+        Struct.new(:keys, :values).new(key_values, value_values)
       end
     end
 

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

@@ -1,4 +1,4 @@
-describe 'adapter_activerecord_existing_connection', adapter: :ActiveRecord do
+describe 'adapter_activerecord_existing_connection', adapter: :ActiveRecord, mysql: true do
   before :all do
     require 'active_record'
   end
@@ -8,6 +8,8 @@ describe 'adapter_activerecord_existing_connection', adapter: :ActiveRecord do
     ActiveRecord::Base.configurations = {
       default_env => {
         'adapter' => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'),
+        'host' => mysql_host,
+        'port' => mysql_port,
         'database' => mysql_database1,
         'username' => mysql_username,
         'password' => mysql_password

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

@@ -58,32 +58,39 @@ describe 'adapter_activerecord', adapter: :ActiveRecord do
     end
   end
 
-  context "with MySQL" do
+  context "with MySQL", mysql: true do
     let(:connection1) do
       {
         adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'),
+        host: mysql_host,
+        port: mysql_port,
         database: mysql_database1,
-        username: mysql_username
+        username: mysql_username,
+        password: mysql_password
       }
     end
 
     let(:connection2) do
       {
         adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'),
+        host: mysql_host,
+        port: mysql_port,
         database: mysql_database2,
-        username: mysql_username
+        username: mysql_username,
+        password: mysql_password
       }
     end
 
     include_examples :adapter_activerecord, activerecord_specs
   end
 
-  context "with PostgreSQL" do
+  context "with PostgreSQL", postgres: true do
     let(:connection1) do
       {
         adapter: (defined?(JRUBY_VERSION) ? 'jdbcpostgresql' : 'postgresql'),
         database: postgres_database1,
-        username: postgres_username
+        username: postgres_username,
+        password: postgres_password
       }
     end
 
@@ -91,14 +98,15 @@ describe 'adapter_activerecord', adapter: :ActiveRecord do
       {
         adapter: (defined?(JRUBY_VERSION) ? 'jdbcpostgresql' : 'postgresql'),
         database: postgres_database2,
-        username: postgres_username
+        username: postgres_username,
+        password: postgres_password
       }
     end
 
     include_examples :adapter_activerecord, activerecord_specs
   end
 
-  context "with SQLite" do
+  context "with SQLite", sqlite: true do
     let(:connection1) do
       {
         adapter: (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'),

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

@@ -1,11 +1,14 @@
-describe "standard_activerecord", adapter: :ActiveRecord do
+describe "standard_activerecord", adapter: :ActiveRecord, mysql: true do
   moneta_store :ActiveRecord do
     {
       table: 'standard_activerecord',
       connection: {
         adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'),
+        host: mysql_host,
+        port: mysql_port,
         database: mysql_database1,
-        username: mysql_username
+        username: mysql_username,
+        password: mysql_password
       }
     }
   end

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

@@ -1,4 +1,4 @@
-describe "standard_activerecord_with_expires", adapter: :ActiveRecord do
+describe "standard_activerecord_with_expires", adapter: :ActiveRecord, mysql: true do
   let(:t_res) { 0.125 }
   let(:min_ttl) { t_res }
   use_timecop
@@ -8,8 +8,11 @@ describe "standard_activerecord_with_expires", adapter: :ActiveRecord do
       table: 'standard_activerecord_with_expires',
       connection: {
         adapter: (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'),
+        host: mysql_host,
+        port: mysql_port,
         database: mysql_database1,
-        username: mysql_username
+        username: mysql_username,
+        password: mysql_password
       },
       expires: true
     }

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

@@ -23,7 +23,7 @@ describe 'adapter_activesupportcache', adapter: :ActiveSupportCache do
     include_examples :adapter_activesupportcache
   end
 
-  context 'using MemCacheStore' do
+  context 'using MemCacheStore', memcached: true do
     let(:t_res) { 1 }
     let(:min_ttl) { 2 }
     use_timecop
@@ -34,12 +34,12 @@ describe 'adapter_activesupportcache', adapter: :ActiveSupportCache do
     include_examples :adapter_activesupportcache
   end
 
-  context 'using RedisCacheStore' do
+  context 'using RedisCacheStore', redis: true do
     let(:t_res) { 1 }
     let(:min_ttl) { t_res }
     use_timecop
 
-    let(:backend) { ActiveSupport::Cache::RedisCacheStore.new(url: 'redis:///1') }
+    let(:backend) { ActiveSupport::Cache::RedisCacheStore.new(url: "redis://#{redis_host}:#{redis_port}/1") }
     include_examples :adapter_activesupportcache
   end
 

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

@@ -23,7 +23,7 @@ describe 'adapter_activesupportcache_with_default_expires', adapter: :ActiveSupp
     include_examples :adapter_activesupportcache_with_default_expires
   end
 
-  context 'using MemCacheStore' do
+  context 'using MemCacheStore', memcached: true do
     let(:t_res) { 1 }
     let(:min_ttl) { 2 }
     use_timecop
@@ -39,7 +39,7 @@ describe 'adapter_activesupportcache_with_default_expires', adapter: :ActiveSupp
     let(:min_ttl) { t_res }
     use_timecop
 
-    let(:backend) { ActiveSupport::Cache::RedisCacheStore.new(url: 'redis:///2') }
+    let(:backend) { ActiveSupport::Cache::RedisCacheStore.new(url: "redis://#{redis_host}:#{redis_port}/2") }
     include_examples :adapter_activesupportcache_with_default_expires
   end
 

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

@@ -1,6 +1,6 @@
 require_relative './helper.rb'
 
-describe 'adapter_cassandra', retry: 3, adapter: :Cassandra do
+describe 'adapter_cassandra', retry: 3, adapter: :Cassandra, unsupported: RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0') do
   let(:t_res) { 1 }
   let(:min_ttl) { 2 }
 

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

@@ -1,6 +1,6 @@
 require_relative './helper.rb'
 
-describe 'adapter_cassandra_with_default_expires', isolate: true, retry: 3, adapter: :Cassandra do
+describe 'adapter_cassandra_with_default_expires', isolate: true, retry: 3, adapter: :Cassandra, unsupported: RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0') do
   let(:t_res) { 1 }
   let(:min_ttl) { 2 }
 

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

@@ -1,6 +1,6 @@
 require_relative './helper.rb'
 
-describe "standard_cassandra", retry: 3, adapter: :Cassandra do
+describe "standard_cassandra", retry: 3, adapter: :Cassandra, unsupported: RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0') do
   let(:t_res) { 1 }
   let(:min_ttl) { 2 }
 

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

@@ -12,13 +12,14 @@ RSpec.shared_context :start_server do |**options|
       puts "Failed to start server - #{ex.message}"
       tries ||= 0
       tries += 1
-      sleep Moneta::Server::TIMEOUT
+      timeout = options[:timeout] || Moneta::Server.config_defaults[:timeout]
+      sleep 1
       tries < 3 ? retry : raise
     end
   end
 
   after :context do
-    @server.stop
-    @thread.join
+    @server&.stop
+    @thread&.join
   end
 end

data/spec/moneta/adapters/datamapper/adapter_datamapper_spec.rb

@@ -1,22 +1,32 @@
-describe 'adapter_datamapper', broken: defined?(JRUBY_VERSION), adapter: :DataMapper do
+describe 'adapter_datamapper', unsupported: defined?(JRUBY_VERSION) || RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0'), adapter: :DataMapper, mysql: true do
   before :all do
     require 'dm-core'
 
     # DataMapper needs default repository to be setup
     DataMapper.setup(:default, adapter: :in_memory)
   end
-  
+
   moneta_build do
-    Moneta::Adapters::DataMapper.new(setup: "mysql://#{mysql_username}:#{mysql_password}@localhost/#{mysql_database1}", table: "adapter_datamapper")
+    Moneta::Adapters::DataMapper.new(
+      setup: "mysql://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{mysql_database1}",
+      table: "adapter_datamapper"
+    )
   end
 
   moneta_specs ADAPTER_SPECS.without_increment.with_values(:nil).without_values(:binary)
-    
+
   it 'does not cross contaminate when storing' do
-    first = Moneta::Adapters::DataMapper.new(setup: "mysql://#{mysql_username}:#{mysql_password}@localhost/#{mysql_database1}", table: "datamapper_first")
+    first = Moneta::Adapters::DataMapper.new(
+      setup: "mysql://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{mysql_database1}",
+      table: "datamapper_first"
+    )
     first.clear
 
-    second = Moneta::Adapters::DataMapper.new(repository: :sample, setup: "mysql://#{mysql_username}:#{mysql_password}@localhost/#{mysql_database1}", table: "datamapper_second")
+    second = Moneta::Adapters::DataMapper.new(
+      repository: :sample,
+      setup: "mysql://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{mysql_database1}",
+      table: "datamapper_second"
+    )
     second.clear
 
     first['key'] = 'value'
@@ -27,10 +37,17 @@ describe 'adapter_datamapper', broken: defined?(JRUBY_VERSION), adapter: :DataMa
   end
 
   it 'does not cross contaminate when deleting' do
-    first = Moneta::Adapters::DataMapper.new(setup: "mysql://#{mysql_username}:#{mysql_password}@localhost/#{mysql_database1}", table: "datamapper_first")
+    first = Moneta::Adapters::DataMapper.new(
+      setup: "mysql://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{mysql_database1}",
+      table: "datamapper_first"
+    )
     first.clear
 
-    second = Moneta::Adapters::DataMapper.new(repository: :sample, setup: "mysql://#{mysql_username}:#{mysql_password}@localhost/#{mysql_database1}", table: "datamapper_second")
+    second = Moneta::Adapters::DataMapper.new(
+      repository: :sample,
+      setup: "mysql://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{mysql_database1}",
+      table: "datamapper_second"
+    )
     second.clear
 
     first['key'] = 'value'

data/spec/moneta/adapters/datamapper/standard_datamapper_spec.rb

@@ -1,4 +1,4 @@
-describe "standard_datamapper", broken: defined?(JRUBY_VERSION), adapter: :DataMapper do
+describe "standard_datamapper", unsupported: defined?(JRUBY_VERSION) || RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0'), adapter: :DataMapper, mysql: true do
   before :all do
     require 'dm-core'
 
@@ -8,7 +8,7 @@ describe "standard_datamapper", broken: defined?(JRUBY_VERSION), adapter: :DataM
 
   moneta_store :DataMapper do
     {
-      setup: "mysql://#{mysql_username}:#{mysql_password}@localhost/#{mysql_database1}",
+      setup: "mysql://#{mysql_username}:#{mysql_password}@#{mysql_host}:#{mysql_port}/#{mysql_database1}",
       table: "simple_datamapper"
     }
   end