moneta 0.7.11 → 0.7.12

data/.travis.yml

@@ -14,6 +14,8 @@ before_install:
   - script/install-bundle
   - script/upload-bundle
 install: 'echo "Bundle installed"'
+before_script:
+  - mysql -e 'create database moneta;'
 env:
   global:
     - secure: "B0vx1g1CB1A6mM3B/iy2ATicfS4OXT80bb2RVe8mSRsPzez1B4q4Q4hJcaMI\nrMARONN8Krtnti+IqvmDnB0Z0AKYMEyIc+zT37zJOCjLdkLJl+x/thuU/MbC\nvlLVwjMf6JE2EUzTfORDRFYc5ycCqfsfgNk1Go0D2CPT6P9u9uQ="

data/CHANGES

@@ -1,3 +1,8 @@
+0.7.12
+
+* Concurrency tests added
+* Bugfixes for File, Sqlite, Sequel and Datamapper, ActiveRecord
+
 0.7.11
 
 * Logger: Add option :file

data/Gemfile

@@ -29,9 +29,9 @@ gem 'faraday'
 gem 'daybreak'
 gem 'dm-core'
 gem 'dm-migrations'
-gem 'dm-sqlite-adapter'
+gem 'dm-mysql-adapter'
 gem 'fog'
-gem 'activerecord', '>= 3.2.9'
+gem 'activerecord', '>= 3.2.11'
 gem 'redis'
 gem 'mongo'
 gem 'sequel'
@@ -53,9 +53,9 @@ end
 gem 'memcached', :platforms => :ruby
 gem 'jruby-memcached', :platforms => :jruby
 gem 'sqlite3', :platforms => :ruby
-gem 'jdbc-sqlite3', :platforms => :jruby
 gem 'activerecord-jdbc-adapter', :platforms => :jruby
-gem 'activerecord-jdbcsqlite3-adapter', :platforms => :jruby
+gem 'activerecord-jdbcmysql-adapter', :platforms => :jruby
+gem 'mysql2', '>= 0.3.12b5', :platforms => :ruby
 # gdbm for jruby needs ffi
 gem 'ffi', :platforms => :jruby
 gem 'gdbm', :platforms => :jruby
@@ -65,5 +65,5 @@ gem 'rack'
 gem 'rack-cache'
 
 # Rails integration testing
-gem 'actionpack'
+gem 'actionpack', '>= 3.2.11'
 gem 'minitest'

data/Rakefile

@@ -33,8 +33,8 @@ task :test do
   #   QuickLZ is also not maintained on Github, but on Bitbucket
   #   and I don't know where the issue tracker is.
   #
-  # * action_dispatch cannot be required for an unknown reason
-  unstable = specs.select {|s| s =~ /quicklz|action_dispatch/ }
+  # * Cassandra fails spuriously (An expert has to check the adapter!)
+  unstable = specs.select {|s| s =~ /quicklz|cassandra/ }
   specs -= unstable
 
   if group =~ /^(\d+)\/(\d+)$/

data/lib/moneta.rb

@@ -103,7 +103,7 @@ module Moneta
     raise ArgumentError, 'Name must be Symbol' unless Symbol === name
     case name
     when :Sequel, :ActiveRecord, :Couch, :DataMapper
-      # Sequel accept only base64 keys and values
+      # Sequel, DataMapper and AR accept only base64 keys and values
       # FIXME: Couch should work only with :marshal but this raises an error on 1.9
       transformer[:key] << :base64
       transformer[:value] << :base64

data/lib/moneta/adapters/activerecord.rb

@@ -78,11 +78,21 @@ module Moneta
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        record = @table.where(:k => key).lock.first_or_initialize
-        value = Utils.to_int(record.v) + amount
-        record.v = value.to_s
-        record.save
-        value
+        @table.transaction do
+          if record = @table.where(:k => key).lock.first
+            value = Utils.to_int(record.v) + amount
+            record.v = value.to_s
+            record.save
+            value
+          elsif create(key, amount.to_s, options)
+            amount
+          else
+            raise 'Concurrent modification'
+          end
+        end
+      rescue
+        tries ||= 0
+        (tries += 1) < 10 ? retry : raise
       end
 
       # (see Proxy#create)

data/lib/moneta/adapters/cassandra.rb

@@ -62,8 +62,7 @@ module Moneta
 
       # (see Proxy#load)
       def load(key, options = {})
-        value = @backend.get(@cf, key)
-        if value
+        if value = @backend.get(@cf, key)
           expires = expires_value(options, nil)
           @backend.insert(@cf, key, {'value' => value['value'] }, :ttl => expires || nil) if expires != nil
           value['value']

data/lib/moneta/adapters/datamapper.rb

@@ -12,7 +12,7 @@ module Moneta
 
       class Store
         include ::DataMapper::Resource
-        property :k, Text, :key => true
+        property :k, String, :key => true, :length => 255
         property :v, Text, :lazy => false
         self.raise_on_save_failure = true
       end

data/lib/moneta/adapters/file.rb

@@ -6,9 +6,7 @@ module Moneta
     # @api public
     class File
       include Defaults
-      include IncrementSupport
-
-      supports :create
+      supports :create, :increment
 
       # @param [Hash] options
       # @option options [String] :dir Directory where files will be stored
@@ -64,7 +62,22 @@ module Moneta
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        lock(key) { super }
+        path = store_path(key)
+        ::File.open(path, 'rb+') do |f|
+          Thread.pass until f.flock(::File::LOCK_EX)
+          value = Utils.to_int(f.read) + amount
+          f.truncate(0)
+          f.pos = 0
+          f.write(value.to_s)
+          value
+        end
+      rescue Errno::ENOENT
+        if create(key, amount.to_s, options)
+          amount
+        else
+          # Concurrent modification
+          retry
+        end
       end
 
       # (see Proxy#create)
@@ -82,19 +95,6 @@ module Moneta
 
       protected
 
-      def lock(key, &block)
-        path = store_path(key)
-        return yield unless ::File.exist?(path)
-        ::File.open(path, 'r+') do |f|
-          begin
-            Thread.pass until f.flock(::File::LOCK_EX)
-            yield
-          ensure
-            f.flock(::File::LOCK_UN)
-          end
-        end
-      end
-
       def store_path(key)
         ::File.join(@dir, key)
       end

data/lib/moneta/adapters/sequel.rb

@@ -16,7 +16,7 @@ module Moneta
       # @option options All other options passed to `Sequel#connect`
       # @option options [Sequel connection] :backend Use existing backend instance
       def initialize(options = {})
-        table = options.delete(:table) || :moneta
+        table = (options.delete(:table) || :moneta).to_sym
         @backend = options[:backend] ||
           begin
             raise ArgumentError, 'Option :db is required' unless db = options.delete(:db)
@@ -42,12 +42,10 @@ module Moneta
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        @backend.transaction do
-          begin
-            @table.insert(:k => key, :v => value)
-          rescue ::Sequel::DatabaseError
-            @table.update(:k => key, :v => value)
-          end
+        begin
+          @table.insert(:k => key, :v => value)
+        rescue ::Sequel::DatabaseError
+          @table.where(:k => key).update(:v => value)
         end
         value
       rescue ::Sequel::DatabaseError
@@ -57,9 +55,7 @@ module Moneta
 
       # (see Proxy#store)
       def create(key, value, options = {})
-        @backend.transaction do
-          @table.insert(:k => key, :v => value)
-        end
+        @table.insert(:k => key, :v => value)
         true
       rescue ::Sequel::DatabaseError
         # FIXME: This catches too many errors
@@ -73,22 +69,25 @@ module Moneta
           locked_table = @table.for_update
           if record = locked_table[:k => key]
             value = Utils.to_int(record[:v]) + amount
-            locked_table.update(:k => key, :v => value.to_s)
+            locked_table.where(:k => key).update(:v => value.to_s)
             value
           else
             locked_table.insert(:k => key, :v => amount.to_s)
             amount
           end
         end
+      rescue ::Sequel::DatabaseError
+        # FIXME: This catches too many errors
+        # it should only catch a not-unique-exception
+        tries ||= 0
+        (tries += 1) < 10 ? retry : raise
       end
 
       # (see Proxy#delete)
       def delete(key, options = {})
-        @backend.transaction do
-          if value = load(key, options)
-            @table.filter(:k => key).delete
-            value
-          end
+        if value = load(key, options)
+          @table.filter(:k => key).delete
+          value
         end
       end
 
@@ -97,6 +96,12 @@ module Moneta
         @table.delete
         self
       end
+
+      # (see Proxy#close)
+      def close
+        @backend.disconnect
+        nil
+      end
     end
   end
 end

data/lib/moneta/adapters/sqlite.rb

@@ -14,6 +14,7 @@ module Moneta
       # @param [Hash] options
       # @option options [String] :file Database file
       # @option options [String] :table ('moneta') Table name
+      # @option options [Fixnum] :busy_timeout (1000) Sqlite timeout if database is busy
       # @option options [::Sqlite3::Database] :backend Use existing backend instance
       def initialize(options = {})
         table = options[:table] || 'moneta'
@@ -22,6 +23,7 @@ module Moneta
             raise ArgumentError, 'Option :file is required' unless options[:file]
             ::SQLite3::Database.new(options[:file])
           end
+        @backend.busy_timeout(options[:busy_timeout] || 1000)
         @backend.execute("create table if not exists #{table} (k blob not null primary key, v blob)")
         @stmts =
           [@select = @backend.prepare("select v from #{table} where k = ?"),

data/lib/moneta/transformer/config.rb

@@ -25,7 +25,7 @@ module Moneta
                    [ :encode,    "%s.unpack('m').first",         "[%s].pack('m').gsub(\"\n\", '')"                 ],
       :escape   => [ :encode,    'Helper.unescape(%s)',          'Helper.escape(%s)'                               ],
       :hmac     => [ :hmac,      'Helper.hmacverify(%s, options[:secret] || @secret)',
-                                 'Helper.hmacsign(%s, options[:secret] || @secret)',                 'openssl'       ],
+                                 'Helper.hmacsign(%s, options[:secret] || @secret)',               'openssl'       ],
       :truncate => [ :truncate,  nil,                            'Helper.truncate(%s, @maxlen)',   'digest/md5'    ],
       :md5      => [ :digest,    nil,                            '::Digest::MD5.hexdigest(%s)',    'digest/md5'    ],
       :rmd160   => [ :digest,    nil,                            '::Digest::RMD160.hexdigest(%s)', 'digest/rmd160' ],

data/lib/moneta/version.rb

@@ -1,5 +1,5 @@
 module Moneta
   # Moneta version number
   # @api public
-  VERSION = '0.7.11'
+  VERSION = '0.7.12'
 end

data/script/benchmarks

@@ -34,18 +34,18 @@ class MonetaBenchmarks
     # SDBM is unstable, YAML is too slow
     # :SDBM => { :file => "#{DIR}/sdbm" },
     # :YAML => { :file => "#{DIR}/yaml" },
-    :ActiveRecord => { :connection => { :adapter  => 'sqlite3', :database => ':memory:' } },
+    :ActiveRecord => { :table => 'activerecord', :connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), :database => 'moneta' } },
     :Cassandra => {},
     :Client => {},
     :Couch => {},
     :DBM => { :file => "#{DIR}/dbm" },
-    :DataMapper => { :setup => "sqlite3:#{DIR}/datamapper" },
+    :DataMapper => { :setup => 'mysql://root:@localhost/moneta', :table => 'datamapper' },
     :Daybreak => { :file => "#{DIR}/daybreak" },
     :File => { :dir => "#{DIR}/file" },
     :GDBM => { :file => "#{DIR}/gdbm" },
     :HBase => {},
     :HashFile => { :dir => "#{DIR}/hashfile" },
-    :KyotoCabinet => { :file => 'kyotocabinet.kch' },
+    :KyotoCabinet => { :file => "#{DIR}/kyotocabinet.kch" },
     :LRUHash => {},
     :LevelDB => { :dir => "#{DIR}/leveldb" },
     :LocalMemCache => { :file => "#{DIR}/lmc" },
@@ -57,10 +57,10 @@ class MonetaBenchmarks
     :Redis => {},
     :RestClient => { :url => 'http://localhost:8808/' },
     :Riak => {},
-    :Sequel => { :db => 'sqlite:/' },
+    :Sequel => { :db => (defined?(JRUBY_VERSION) ? 'jdbc:mysql' : 'mysql2') + '://root:@localhost/moneta', :table => 'sequel' },
     :Sqlite => { :file => ':memory:' },
     :TDB => { :file => "#{DIR}/tdb" },
-    :TokyoCabinet => { :file => 'tokyocabinet' },
+    :TokyoCabinet => { :file => "#{DIR}/tokyocabinet" },
     :TokyoTyrant => {},
   }
 
@@ -79,7 +79,7 @@ class MonetaBenchmarks
       :runs => 3,
       :keys => 1000,
       :min_key_len => 3,
-      :max_key_len => 200,
+      :max_key_len => 128,
       :key_dist => :uniform,
       :min_val_len => 0,
       :max_val_len => 1024,
@@ -89,7 +89,7 @@ class MonetaBenchmarks
       :runs => 3,
       :keys => 100,
       :min_key_len => 3,
-      :max_key_len => 200,
+      :max_key_len => 128,
       :key_dist => :uniform,
       :min_val_len => 0,
       :max_val_len => 10240,
@@ -109,7 +109,7 @@ class MonetaBenchmarks
       :runs => 3,
       :keys => 1000,
       :min_key_len => 3,
-      :max_key_len => 200,
+      :max_key_len => 128,
       :key_dist => :normal,
       :min_val_len => 0,
       :max_val_len => 1024,
@@ -119,7 +119,7 @@ class MonetaBenchmarks
       :runs => 3,
       :keys => 100,
       :min_key_len => 3,
-      :max_key_len => 200,
+      :max_key_len => 128,
       :key_dist => :normal,
       :min_val_len => 0,
       :max_val_len => 10240,

data/script/generate-specs

@@ -38,15 +38,19 @@ class Specs
   end
 
   def without_increment
-    new(:specs => specs - [:increment] + [:not_increment])
+    new(:specs => specs - [:increment, :concurrent_increment] + [:not_increment])
+  end
+
+  def without_concurrent
+    new(:specs => specs - [:concurrent_increment, :concurrent_create])
   end
 
   def without_persist
-    new(:specs => specs - [:persist, :multiprocess] + [:not_persist])
+    new(:specs => specs - [:persist, :multiprocess, :concurrent_increment, :concurrent_create] + [:not_persist])
   end
 
   def without_multiprocess
-    new(:specs => specs - [:multiprocess])
+    new(:specs => specs - [:multiprocess, :concurrent_increment, :concurrent_create])
   end
 
   def with_expires
@@ -95,12 +99,12 @@ class Specs
   end
 
   def without_create
-    new(:specs => specs - [:create, :create_expires] + [:not_create])
+    new(:specs => specs - [:create, :concurrent_create, :create_expires] + [:not_create])
   end
 end
 
-ADAPTER_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :increment, :persist, :multiprocess, :create, :features], :key => %w(string), :value => %w(string))
-STANDARD_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :marshallable_key, :marshallable_value, :transform_value, :increment, :persist, :multiprocess, :create, :features])
+ADAPTER_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :increment, :concurrent_increment, :concurrent_create, :persist, :multiprocess, :create, :features], :key => %w(string), :value => %w(string))
+STANDARD_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :marshallable_key, :marshallable_value, :transform_value, :increment, :concurrent_increment, :concurrent_create, :persist, :multiprocess, :create, :features])
 TRANSFORMER_SPECS = Specs.new(:specs => [:null, :store, :returndifferent, :transform_value, :increment, :create, :features])
 
 header = "# Generated by #{File.basename(__FILE__)}\n"
@@ -352,12 +356,12 @@ end
   'simple_sqlite' => {
     :store => :Sqlite,
     :options => ':file => File.join(make_tempdir, "simple_sqlite")',
-    :specs => STANDARD_SPECS
+    :specs => STANDARD_SPECS.without_concurrent
   },
   'simple_sqlite_with_expires' => {
     :store => :Sqlite,
     :options => ':file => File.join(make_tempdir, "simple_sqlite_with_expires"), :expires => true',
-    :specs => STANDARD_SPECS.with_expires
+    :specs => STANDARD_SPECS.with_expires.without_concurrent
   },
   'simple_redis' => {
     :store => :Redis,
@@ -419,27 +423,27 @@ end
   },
   'simple_sequel' => {
     :store => :Sequel,
-    :options => ':db => (defined?(JRUBY_VERSION) ? "jdbc:sqlite:" : "sqlite:") + File.join(make_tempdir, "simple_sequel")',
+    :options => ':db => (defined?(JRUBY_VERSION) ? "jdbc:mysql" : "mysql2") + "://root:@localhost/moneta", :table => "simple_sequel"',
     :load_value => '::Marshal.load(value.unpack(\'m\').first)',
     :specs => STANDARD_SPECS
   },
   'simple_sequel_with_expires' => {
     :store => :Sequel,
-    :options => ':db => (defined?(JRUBY_VERSION) ? "jdbc:sqlite:" : "sqlite:") + File.join(make_tempdir, "simple_sequel_with_expires"), :expires => true',
+    :options => ':db => (defined?(JRUBY_VERSION) ? "jdbc:mysql" : "mysql2") + "://root:@localhost/moneta", :table => "simple_sequel_with_expires", :expires => true',
     :specs => STANDARD_SPECS.with_expires,
     :load_value => '::Marshal.load(value.unpack(\'m\').first)'
   },
   'simple_datamapper' => {
     :store => :DataMapper,
     :specs => STANDARD_SPECS.without_increment,
-    :options => ':setup => "sqlite3://#{make_tempdir}/simple_datamapper"',
+    :options => ':setup => "mysql://root:@localhost/moneta", :table => "simple_datamapper"',
     # DataMapper needs default repository to be setup
     :preamble => "require 'dm-core'\nDataMapper.setup(:default, :adapter => :in_memory)\n",
     :load_value => '::Marshal.load(value.unpack(\'m\').first)'
   },
   'simple_datamapper_with_expires' => {
     :store => :DataMapper,
-    :options => ':setup => "sqlite3://#{make_tempdir}/simple_datamapper_with_expires", :expires => true',
+    :options => ':setup => "mysql://root:@localhost/moneta", :table => "simple_datamapper_with_expires", :expires => true',
     # DataMapper needs default repository to be setup
     :preamble => "require 'dm-core'\nDataMapper.setup(:default, :adapter => :in_memory)\n",
     :specs => STANDARD_SPECS.without_increment.with_expires,
@@ -448,7 +452,7 @@ end
   'simple_datamapper_with_repository' => {
     :store => :DataMapper,
     :specs => STANDARD_SPECS.without_increment,
-    :options => ':repository => :repo, :setup => "sqlite3://#{make_tempdir}/simple_datamapper_with_repository"',
+    :options => ':repository => :repo, :setup => "mysql://root:@localhost/moneta", :table => "simple_datamapper_with_repository"',
     # DataMapper needs default repository to be setup
     :preamble => "require 'dm-core'\nDataMapper.setup(:default, :adapter => :in_memory)\n",
     :load_value => '::Marshal.load(value.unpack(\'m\').first)'
@@ -456,12 +460,12 @@ end
   'simple_activerecord' => {
     :store => :ActiveRecord,
     :specs => STANDARD_SPECS,
-    :options => ":connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'simple_activerecord') }",
+    :options => ":table => 'simple_activerecord', :connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), :database => 'moneta' }",
     :load_value => '::Marshal.load(value.unpack(\'m\').first)'
   },
   'simple_activerecord_with_expires' => {
     :store => :ActiveRecord,
-    :options => ":connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'simple_activerecord_with_expires') }, :expires => true",
+    :options => ":table => 'simple_activerecord_with_expires', :connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), :database => 'moneta' }, :expires => true",
     :specs => STANDARD_SPECS.with_expires,
     :load_value => '::Marshal.load(value.unpack(\'m\').first)'
   },
@@ -491,14 +495,14 @@ end
   use :WeakCreate
   adapter :Couch, :db => 'weak_create'
 end},
-    :specs => ADAPTER_SPECS.without_increment
+    :specs => ADAPTER_SPECS.without_increment.without_concurrent
   },
   'weak_increment' => {
     :build => %{Moneta.build do
   use :WeakIncrement
   adapter :Couch, :db => 'weak_increment'
 end},
-    :specs => ADAPTER_SPECS.without_create
+    :specs => ADAPTER_SPECS.without_create.without_concurrent
   },
   'expires_memory' => {
     :build => %{Moneta.build do
@@ -1097,7 +1101,7 @@ it 'compile transformer class' do
 end}
   },
   'adapter_activerecord' => {
-    :build => "Moneta::Adapters::ActiveRecord.new(:connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'adapter_activerecord') })",
+    :build => "Moneta::Adapters::ActiveRecord.new(:table => 'adapter_activerecord', :connection => { :adapter => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), :database => 'moneta' })",
     :specs => ADAPTER_SPECS,
     :tests => %{
 it 'updates an existing key/value' do
@@ -1108,9 +1112,9 @@ it 'updates an existing key/value' do
 end
 
 it 'uses an existing connection' do
-  ActiveRecord::Base.establish_connection :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'activerecord-existing')
+  ActiveRecord::Base.establish_connection :adapter => (defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'), :database => 'moneta'
 
-  store = Moneta::Adapters::ActiveRecord.new
+  store = Moneta::Adapters::ActiveRecord.new(:table => 'activerecord_existing')
   store.table.should be_table_exists
 end
 }
@@ -1146,16 +1150,16 @@ end
     :specs => ADAPTER_SPECS.without_increment.without_create
   },
   'adapter_datamapper' => {
-    :build => 'Moneta::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/adapter_datamapper")',
+    :build => 'Moneta::Adapters::DataMapper.new(:setup => "mysql://root:@localhost/moneta", :table => "adapter_datamapper")',
     # DataMapper needs default repository to be setup
     :preamble => "require 'dm-core'\nDataMapper.setup(:default, :adapter => :in_memory)\n",
     :specs => ADAPTER_SPECS.without_increment,
     :tests => %q{
 it 'does not cross contaminate when storing' do
-  first = Moneta::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/datamapper-first")
+  first = Moneta::Adapters::DataMapper.new(:setup => "mysql://root:@localhost/moneta", :table => "datamapper_first")
   first.clear
 
-  second = Moneta::Adapters::DataMapper.new(:repository => :sample, :setup => "sqlite3://#{make_tempdir}/datamapper-second")
+  second = Moneta::Adapters::DataMapper.new(:repository => :sample, :setup => "mysql://root:@localhost/moneta", :table => "datamapper_second")
   second.clear
 
   first['key'] = 'value'
@@ -1166,10 +1170,10 @@ it 'does not cross contaminate when storing' do
 end
 
 it 'does not cross contaminate when deleting' do
-  first = Moneta::Adapters::DataMapper.new(:setup => "sqlite3://#{make_tempdir}/datamapper-first")
+  first = Moneta::Adapters::DataMapper.new(:setup => "mysql://root:@localhost/moneta", :table => "datamapper_first")
   first.clear
 
-  second = Moneta::Adapters::DataMapper.new(:repository => :sample, :setup => "sqlite3://#{make_tempdir}/datamapper-second")
+  second = Moneta::Adapters::DataMapper.new(:repository => :sample, :setup => "mysql://root:@localhost/moneta", :table => "datamapper_second")
   second.clear
 
   first['key'] = 'value'
@@ -1304,12 +1308,12 @@ end}
     :specs => ADAPTER_SPECS.without_multiprocess
   },
   'adapter_sequel' => {
-    :build => 'Moneta::Adapters::Sequel.new(:db => (defined?(JRUBY_VERSION) ? "jdbc:sqlite:" : "sqlite:") + File.join(make_tempdir, "adapter_sequel"))',
+    :build => 'Moneta::Adapters::Sequel.new(:db => (defined?(JRUBY_VERSION) ? "jdbc:mysql" : "mysql2") + "://root:@localhost/moneta", :table => "adapter_sequel")',
     :specs => ADAPTER_SPECS
   },
   'adapter_sqlite' => {
     :build => 'Moneta::Adapters::Sqlite.new(:file => File.join(make_tempdir, "adapter_sqlite"))',
-    :specs => ADAPTER_SPECS
+    :specs => ADAPTER_SPECS.without_concurrent
   },
   'adapter_kyotocabinet' => {
     :build => 'Moneta::Adapters::KyotoCabinet.new(:file => File.join(make_tempdir, "adapter_kyotocabinet.kch"))',
@@ -1966,6 +1970,48 @@ it 'does not support #decrement' do
   end.to raise_error(NotImplementedError)
 end}
 
+SPECS['concurrent_increment'] = %{def increment_thread(name)
+  Thread.new do
+    s = new_store
+    1000.times do |i|
+      s.increment('counter')
+      s.store("\#{name}\#{i}", i.to_s, :expires => false)
+      sleep 0.01 if i % 100 == 0
+    end
+    s.close
+  end
+end
+
+it 'have atomic increment across multiple processes' do
+  a = increment_thread('a')
+  b = increment_thread('b')
+  a.join
+  b.join
+  1000.times do |i|
+    store["a\#{i}"].should == i.to_s
+    store["b\#{i}"].should == i.to_s
+  end
+  store.raw['counter'].should == 2000.to_s
+end}
+
+SPECS['concurrent_create'] = %{def create_thread(name)
+  a = Thread.new do
+    s = new_store
+    1000.times do |i|
+      s[i.to_s].should == name if s.create(i.to_s, name, :expires => false)
+      sleep 0.01 if i % 100 == 0
+    end
+    s.close
+  end
+end
+
+it 'have atomic create across multiple processes' do
+  a = create_thread('a')
+  b = create_thread('b')
+  a.join
+  b.join
+end}
+
 SPECS['increment'] = %{it 'initializes in #increment with 1' do
   store.key?('inckey').should be_false
   store.increment('inckey').should == 1