ibm_db 3.0.4-x86-mingw32 → 5.0.4-x86-mingw32

data/test/cases/locking_test.rb

@@ -1,477 +1,493 @@
-require 'thread'
-require "cases/helper"
-require 'models/person'
-require 'models/job'
-require 'models/reader'
-require 'models/ship'
-require 'models/legacy_thing'
-require 'models/personal_legacy_thing'
-require 'models/reference'
-require 'models/string_key_object'
-require 'models/car'
-require 'models/bulb'
-require 'models/engine'
-require 'models/wheel'
-require 'models/treasure'
-
-class LockWithoutDefault < ActiveRecord::Base; end
-
-class LockWithCustomColumnWithoutDefault < ActiveRecord::Base
-  self.table_name = :lock_without_defaults_cust
-  self.column_defaults # to test @column_defaults caching.
-  self.locking_column = :custom_lock_version
-end
-
-class ReadonlyNameShip < Ship
-  attr_readonly :name
-end
-
-class OptimisticLockingTest < ActiveRecord::TestCase
-  fixtures :people, :legacy_things, :references, :string_key_objects, :peoples_treasures
-
-  def test_lock_version_is_incremented
-    p1 = Person.find(1)
-    assert_equal 0, p1.lock_version
-
-    p1.first_name = 'anika2'
-    p1.save!
-
-    assert_equal 1, p1.lock_version
-  end
-
-  def test_non_integer_lock_existing
-    s1 = StringKeyObject.find("record1")
-    s2 = StringKeyObject.find("record1")
-    assert_equal 0, s1.lock_version
-    assert_equal 0, s2.lock_version
-
-    s1.name = 'updated record'
-    s1.save!
-    assert_equal 1, s1.lock_version
-    assert_equal 0, s2.lock_version
-
-    s2.name = 'doubly updated record'
-    assert_raise(ActiveRecord::StaleObjectError) { s2.save! }
-  end
-
-  def test_non_integer_lock_destroy
-    s1 = StringKeyObject.find("record1")
-    s2 = StringKeyObject.find("record1")
-    assert_equal 0, s1.lock_version
-    assert_equal 0, s2.lock_version
-
-    s1.name = 'updated record'
-    s1.save!
-    assert_equal 1, s1.lock_version
-    assert_equal 0, s2.lock_version
-    assert_raise(ActiveRecord::StaleObjectError) { s2.destroy }
-
-    assert s1.destroy
-    assert s1.frozen?
-    assert s1.destroyed?
-    assert_raises(ActiveRecord::RecordNotFound) { StringKeyObject.find("record1") }
-  end
-
-  def test_lock_existing
-    p1 = Person.find(1)
-    p2 = Person.find(1)
-    assert_equal 0, p1.lock_version
-    assert_equal 0, p2.lock_version
-
-    p1.first_name = 'stu'
-    p1.save!
-    assert_equal 1, p1.lock_version
-    assert_equal 0, p2.lock_version
-
-    p2.first_name = 'sue'
-    assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
-  end
-
-  # See Lighthouse ticket #1966
-  def test_lock_destroy
-    p1 = Person.find(1)
-    p2 = Person.find(1)
-    assert_equal 0, p1.lock_version
-    assert_equal 0, p2.lock_version
-
-    p1.first_name = 'stu'
-    p1.save!
-    assert_equal 1, p1.lock_version
-    assert_equal 0, p2.lock_version
-
-    assert_raises(ActiveRecord::StaleObjectError) { p2.destroy }
-
-    assert p1.destroy
-    assert p1.frozen?
-    assert p1.destroyed?
-    assert_raises(ActiveRecord::RecordNotFound) { Person.find(1) }
-  end
-
-  def test_lock_repeating
-    p1 = Person.find(1)
-    p2 = Person.find(1)
-    assert_equal 0, p1.lock_version
-    assert_equal 0, p2.lock_version
-
-    p1.first_name = 'stu'
-    p1.save!
-    assert_equal 1, p1.lock_version
-    assert_equal 0, p2.lock_version
-
-    p2.first_name = 'sue'
-    assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
-    p2.first_name = 'sue2'
-    assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
-  end
-
-  def test_lock_new
-    p1 = Person.new(:first_name => 'anika')
-    assert_equal 0, p1.lock_version
-
-    p1.first_name = 'anika2'
-    p1.save!
-    p2 = Person.find(p1.id)
-    assert_equal 0, p1.lock_version
-    assert_equal 0, p2.lock_version
-
-    p1.first_name = 'anika3'
-    p1.save!
-    assert_equal 1, p1.lock_version
-    assert_equal 0, p2.lock_version
-
-    p2.first_name = 'sue'
-    assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
-  end
-
-  def test_lock_exception_record
-    p1 = Person.new(:first_name => 'mira')
-    assert_equal 0, p1.lock_version
-
-    p1.first_name = 'mira2'
-    p1.save!
-    p2 = Person.find(p1.id)
-    assert_equal 0, p1.lock_version
-    assert_equal 0, p2.lock_version
-
-    p1.first_name = 'mira3'
-    p1.save!
-
-    p2.first_name = 'sue'
-    error = assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
-    assert_equal(error.record.object_id, p2.object_id)
-  end
-
-  def test_lock_new_with_nil
-    p1 = Person.new(:first_name => 'anika')
-    p1.save!
-    p1.lock_version = nil # simulate bad fixture or column with no default
-    p1.save!
-    assert_equal 1, p1.lock_version
-  end
-
-  def test_touch_existing_lock
-    p1 = Person.find(1)
-    assert_equal 0, p1.lock_version
-
-    p1.touch
-    assert_equal 1, p1.lock_version
-  end
-
-  def test_lock_column_name_existing
-    t1 = LegacyThing.find(1)
-    t2 = LegacyThing.find(1)
-    assert_equal 0, t1.version
-    assert_equal 0, t2.version
-
-    t1.tps_report_number = 700
-    t1.save!
-    assert_equal 1, t1.version
-    assert_equal 0, t2.version
-
-    t2.tps_report_number = 800
-    assert_raise(ActiveRecord::StaleObjectError) { t2.save! }
-  end
-
-  def test_lock_column_is_mass_assignable
-    p1 = Person.create(:first_name => 'bianca')
-    assert_equal 0, p1.lock_version
-    assert_equal p1.lock_version, Person.new(p1.attributes).lock_version
-
-    p1.first_name = 'bianca2'
-    p1.save!
-    assert_equal 1, p1.lock_version
-    assert_equal p1.lock_version, Person.new(p1.attributes).lock_version
-  end
-
-  def test_lock_without_default_sets_version_to_zero
-    t1 = LockWithoutDefault.new
-    assert_equal 0, t1.lock_version
-
-    t1.save
-    t1 = LockWithoutDefault.find(t1.id)
-    assert_equal 0, t1.lock_version
-  end
-
-  def test_lock_with_custom_column_without_default_sets_version_to_zero
-    t1 = LockWithCustomColumnWithoutDefault.new
-    assert_equal 0, t1.custom_lock_version
-    assert_nil t1.custom_lock_version_before_type_cast
-
-    t1.save!
-    t1.reload
-    assert_equal 0, t1.custom_lock_version
-    assert [0, "0"].include?(t1.custom_lock_version_before_type_cast)
-  end
-
-  def test_readonly_attributes
-    assert_equal Set.new([ 'name' ]), ReadonlyNameShip.readonly_attributes
-
-    s = ReadonlyNameShip.create(:name => "unchangeable name")
-    s.reload
-    assert_equal "unchangeable name", s.name
-
-    s.update(name: "changed name")
-    s.reload
-    assert_equal "unchangeable name", s.name
-  end
-
-  def test_quote_table_name
-    ref = references(:michael_magician)
-    ref.favourite = !ref.favourite
-    assert ref.save
-  end
-
-  # Useful for partial updates, don't only update the lock_version if there
-  # is nothing else being updated.
-  def test_update_without_attributes_does_not_only_update_lock_version
-    assert_nothing_raised do
-      p1 = Person.create!(:first_name => 'anika')
-      lock_version = p1.lock_version
-      p1.save
-      p1.reload
-      assert_equal lock_version, p1.lock_version
-    end
-  end
-
-  def test_polymorphic_destroy_with_dependencies_and_lock_version
-    car = Car.create!
-
-    assert_difference 'car.wheels.count'  do
-      car.wheels << Wheel.create!
-    end
-    assert_difference 'car.wheels.count', -1  do
-      car.destroy
-    end
-    assert car.destroyed?
-  end
-
-  def test_removing_has_and_belongs_to_many_associations_upon_destroy
-    p = RichPerson.create! first_name: 'Jon'
-    p.treasures.create!
-    assert !p.treasures.empty?
-    p.destroy
-    assert p.treasures.empty?
-    assert RichPerson.connection.select_all("SELECT * FROM peoples_treasures WHERE rich_person_id = 1").empty?
-  end
-
-  def test_yaml_dumping_with_lock_column
-    t1 = LockWithoutDefault.new
-    t2 = YAML.load(YAML.dump(t1))
-
-    assert_equal t1.attributes, t2.attributes
-  end
-end
-
-class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
-  fixtures :people, :legacy_things, :references
-
-  # need to disable transactional fixtures, because otherwise the sqlite3
-  # adapter (at least) chokes when we try and change the schema in the middle
-  # of a test (see test_increment_counter_*).
-  self.use_transactional_fixtures = false
-
-  { :lock_version => Person, :custom_lock_version => LegacyThing }.each do |name, model|
-    define_method("test_increment_counter_updates_#{name}") do
-      counter_test model, 1 do |id|
-        model.increment_counter :test_count, id
-      end
-    end
-
-    define_method("test_decrement_counter_updates_#{name}") do
-      counter_test model, -1 do |id|
-        model.decrement_counter :test_count, id
-      end
-    end
-
-    define_method("test_update_counters_updates_#{name}") do
-      counter_test model, 1 do |id|
-        model.update_counters id, :test_count => 1
-      end
-    end
-  end
-
-  # See Lighthouse ticket #1966
-  def test_destroy_dependents
-    # Establish dependent relationship between Person and PersonalLegacyThing
-    add_counter_column_to(Person, 'personal_legacy_things_count')
-    PersonalLegacyThing.reset_column_information
-
-    # Make sure that counter incrementing doesn't cause problems
-    p1 = Person.new(:first_name => 'fjord')
-    p1.save!
-    t = PersonalLegacyThing.new(:person => p1)
-    t.save!
-    p1.reload
-    assert_equal 1, p1.personal_legacy_things_count
-    assert p1.destroy
-    assert_equal true, p1.frozen?
-    assert_raises(ActiveRecord::RecordNotFound) { Person.find(p1.id) }
-    assert_raises(ActiveRecord::RecordNotFound) { PersonalLegacyThing.find(t.id) }
-  ensure
-    remove_counter_column_from(Person, 'personal_legacy_things_count')
-    PersonalLegacyThing.reset_column_information
-  end
-
-  private
-
-    def add_counter_column_to(model, col='test_count')
-      model.connection.add_column model.table_name, col, :integer, :null => false, :default => 0
-      model.reset_column_information
-    end
-
-    def remove_counter_column_from(model, col = :test_count)
-      model.connection.remove_column model.table_name, col
-      model.reset_column_information
-    end
-
-    def counter_test(model, expected_count)
-      add_counter_column_to(model)
-      object = model.first
-      assert_equal 0, object.test_count
-      assert_equal 0, object.send(model.locking_column)
-      yield object.id
-      object.reload
-      assert_equal expected_count, object.test_count
-      assert_equal 1, object.send(model.locking_column)
-    ensure
-      remove_counter_column_from(model)
-    end
-end
-
-
-# TODO: test against the generated SQL since testing locking behavior itself
-# is so cumbersome. Will deadlock Ruby threads if the underlying db.execute
-# blocks, so separate script called by Kernel#system is needed.
-# (See exec vs. async_exec in the PostgreSQL adapter.)
-unless in_memory_db?
-  class PessimisticLockingTest < ActiveRecord::TestCase
-    self.use_transactional_fixtures = false
-    fixtures :people, :readers
-
-    def setup
-      Person.connection_pool.clear_reloadable_connections!
-      # Avoid introspection queries during tests.
-      Person.columns; Reader.columns
-    end
-
-    # Test typical find.
-    def test_sane_find_with_lock
-      assert_nothing_raised do
-        Person.transaction do
-          Person.lock.find(1)
-        end
-      end
-    end
-
-    # PostgreSQL protests SELECT ... FOR UPDATE on an outer join.
-    unless current_adapter?(:PostgreSQLAdapter)
-      # Test locked eager find.
-      def test_eager_find_with_lock
-        assert_nothing_raised do
-          Person.transaction do
-            Person.includes(:readers).lock.find(1)
-          end
-        end
-      end
-    end
-
-    # Locking a record reloads it.
-    def test_sane_lock_method
-      assert_nothing_raised do
-        Person.transaction do
-          person = Person.find 1
-          old, person.first_name = person.first_name, 'fooman'
-          person.lock!
-          assert_equal old, person.first_name
-        end
-      end
-    end
-
-    def test_with_lock_commits_transaction
-      person = Person.find 1
-      person.with_lock do
-        person.first_name = 'fooman'
-        person.save!
-      end
-      assert_equal 'fooman', person.reload.first_name
-    end
-
-    def test_with_lock_rolls_back_transaction
-      person = Person.find 1
-      old = person.first_name
-      person.with_lock do
-        person.first_name = 'fooman'
-        person.save!
-        raise 'oops'
-      end rescue nil
-      assert_equal old, person.reload.first_name
-    end
-
-    if current_adapter?(:PostgreSQLAdapter)
-      def test_lock_sending_custom_lock_statement
-        Person.transaction do
-          person = Person.find(1)
-          assert_sql(/LIMIT 1 FOR SHARE NOWAIT/) do
-            person.lock!('FOR SHARE NOWAIT')
-          end
-        end
-      end
-    end
-
-    if current_adapter?(:PostgreSQLAdapter, :OracleAdapter)
-      def test_no_locks_no_wait
-        first, second = duel { Person.find 1 }
-        assert first.end > second.end
-      end
-
-      protected
-        def duel(zzz = 5)
-          t0, t1, t2, t3 = nil, nil, nil, nil
-
-          a = Thread.new do
-            t0 = Time.now
-            Person.transaction do
-              yield
-              sleep zzz       # block thread 2 for zzz seconds
-            end
-            t1 = Time.now
-          end
-
-          b = Thread.new do
-            sleep zzz / 2.0   # ensure thread 1 tx starts first
-            t2 = Time.now
-            Person.transaction { yield }
-            t3 = Time.now
-          end
-
-          a.join
-          b.join
-
-          assert t1 > t0 + zzz
-          assert t2 > t0
-          assert t3 > t2
-          [t0.to_f..t1.to_f, t2.to_f..t3.to_f]
-        end
-    end
-  end
-end
+require 'thread'
+require "cases/helper"
+require 'models/person'
+require 'models/job'
+require 'models/reader'
+require 'models/ship'
+require 'models/legacy_thing'
+require 'models/personal_legacy_thing'
+require 'models/reference'
+require 'models/string_key_object'
+require 'models/car'
+require 'models/bulb'
+require 'models/engine'
+require 'models/wheel'
+require 'models/treasure'
+
+class LockWithoutDefault < ActiveRecord::Base; end
+
+class LockWithCustomColumnWithoutDefault < ActiveRecord::Base
+  self.table_name = :lock_without_defaults_cust
+  self.column_defaults # to test @column_defaults caching.
+  self.locking_column = :custom_lock_version
+end
+
+class ReadonlyNameShip < Ship
+  attr_readonly :name
+end
+
+class OptimisticLockingTest < ActiveRecord::TestCase
+  fixtures :people, :legacy_things, :references, :string_key_objects, :peoples_treasures
+
+  def test_quote_value_passed_lock_col
+    p1 = Person.find(1)
+    assert_equal 0, p1.lock_version
+
+    p1.first_name = 'anika2'
+    p1.save!
+
+    assert_equal 1, p1.lock_version
+  end
+
+  def test_non_integer_lock_existing
+    s1 = StringKeyObject.find("record1")
+    s2 = StringKeyObject.find("record1")
+    assert_equal 0, s1.lock_version
+    assert_equal 0, s2.lock_version
+
+    s1.name = 'updated record'
+    s1.save!
+    assert_equal 1, s1.lock_version
+    assert_equal 0, s2.lock_version
+
+    s2.name = 'doubly updated record'
+    assert_raise(ActiveRecord::StaleObjectError) { s2.save! }
+  end
+
+  def test_non_integer_lock_destroy
+    s1 = StringKeyObject.find("record1")
+    s2 = StringKeyObject.find("record1")
+    assert_equal 0, s1.lock_version
+    assert_equal 0, s2.lock_version
+
+    s1.name = 'updated record'
+    s1.save!
+    assert_equal 1, s1.lock_version
+    assert_equal 0, s2.lock_version
+    assert_raise(ActiveRecord::StaleObjectError) { s2.destroy }
+
+    assert s1.destroy
+    assert s1.frozen?
+    assert s1.destroyed?
+    assert_raises(ActiveRecord::RecordNotFound) { StringKeyObject.find("record1") }
+  end
+
+  def test_lock_existing
+    p1 = Person.find(1)
+    p2 = Person.find(1)
+    assert_equal 0, p1.lock_version
+    assert_equal 0, p2.lock_version
+
+    p1.first_name = 'stu'
+    p1.save!
+    assert_equal 1, p1.lock_version
+    assert_equal 0, p2.lock_version
+
+    p2.first_name = 'sue'
+    assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
+  end
+
+  # See Lighthouse ticket #1966
+  def test_lock_destroy
+    p1 = Person.find(1)
+    p2 = Person.find(1)
+    assert_equal 0, p1.lock_version
+    assert_equal 0, p2.lock_version
+
+    p1.first_name = 'stu'
+    p1.save!
+    assert_equal 1, p1.lock_version
+    assert_equal 0, p2.lock_version
+
+    assert_raises(ActiveRecord::StaleObjectError) { p2.destroy }
+
+    assert p1.destroy
+    assert p1.frozen?
+    assert p1.destroyed?
+    assert_raises(ActiveRecord::RecordNotFound) { Person.find(1) }
+  end
+
+  def test_lock_repeating
+    p1 = Person.find(1)
+    p2 = Person.find(1)
+    assert_equal 0, p1.lock_version
+    assert_equal 0, p2.lock_version
+
+    p1.first_name = 'stu'
+    p1.save!
+    assert_equal 1, p1.lock_version
+    assert_equal 0, p2.lock_version
+
+    p2.first_name = 'sue'
+    assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
+    p2.first_name = 'sue2'
+    assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
+  end
+
+  def test_lock_new
+    p1 = Person.new(:first_name => 'anika')
+    assert_equal 0, p1.lock_version
+
+    p1.first_name = 'anika2'
+    p1.save!
+    p2 = Person.find(p1.id)
+    assert_equal 0, p1.lock_version
+    assert_equal 0, p2.lock_version
+
+    p1.first_name = 'anika3'
+    p1.save!
+    assert_equal 1, p1.lock_version
+    assert_equal 0, p2.lock_version
+
+    p2.first_name = 'sue'
+    assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
+  end
+
+  def test_lock_exception_record
+    p1 = Person.new(:first_name => 'mira')
+    assert_equal 0, p1.lock_version
+
+    p1.first_name = 'mira2'
+    p1.save!
+    p2 = Person.find(p1.id)
+    assert_equal 0, p1.lock_version
+    assert_equal 0, p2.lock_version
+
+    p1.first_name = 'mira3'
+    p1.save!
+
+    p2.first_name = 'sue'
+    error = assert_raise(ActiveRecord::StaleObjectError) { p2.save! }
+    assert_equal(error.record.object_id, p2.object_id)
+  end
+
+  def test_lock_new_with_nil
+    p1 = Person.new(:first_name => 'anika')
+    p1.save!
+    p1.lock_version = nil # simulate bad fixture or column with no default
+    p1.save!
+    assert_equal 1, p1.lock_version
+  end
+
+  def test_lock_new_when_explicitly_passing_nil
+    p1 = Person.new(:first_name => 'anika', lock_version: nil)
+    p1.save!
+    assert_equal 0, p1.lock_version
+  end
+
+  def test_touch_existing_lock
+    p1 = Person.find(1)
+    assert_equal 0, p1.lock_version
+
+    p1.touch
+    assert_equal 1, p1.lock_version
+  end
+
+  def test_touch_stale_object
+    person = Person.create!(first_name: 'Mehmet Emin')
+    stale_person = Person.find(person.id)
+    person.update_attribute(:gender, 'M')
+
+    assert_raises(ActiveRecord::StaleObjectError) do
+      stale_person.touch
+    end
+  end
+
+  def test_lock_column_name_existing
+    t1 = LegacyThing.find(1)
+    t2 = LegacyThing.find(1)
+    assert_equal 0, t1.version
+    assert_equal 0, t2.version
+
+    t1.tps_report_number = 700
+    t1.save!
+    assert_equal 1, t1.version
+    assert_equal 0, t2.version
+
+    t2.tps_report_number = 800
+    assert_raise(ActiveRecord::StaleObjectError) { t2.save! }
+  end
+
+  def test_lock_column_is_mass_assignable
+    p1 = Person.create(:first_name => 'bianca')
+    assert_equal 0, p1.lock_version
+    assert_equal p1.lock_version, Person.new(p1.attributes).lock_version
+
+    p1.first_name = 'bianca2'
+    p1.save!
+    assert_equal 1, p1.lock_version
+    assert_equal p1.lock_version, Person.new(p1.attributes).lock_version
+  end
+
+  def test_lock_without_default_sets_version_to_zero
+    t1 = LockWithoutDefault.new
+    assert_equal 0, t1.lock_version
+
+    t1.save
+    t1 = LockWithoutDefault.find(t1.id)
+    assert_equal 0, t1.lock_version
+  end
+
+  def test_lock_with_custom_column_without_default_sets_version_to_zero
+    t1 = LockWithCustomColumnWithoutDefault.new
+    assert_equal 0, t1.custom_lock_version
+    assert_nil t1.custom_lock_version_before_type_cast
+
+    t1.save!
+    t1.reload
+    assert_equal 0, t1.custom_lock_version
+    assert [0, "0"].include?(t1.custom_lock_version_before_type_cast)
+  end
+
+  def test_readonly_attributes
+    assert_equal Set.new([ 'name' ]), ReadonlyNameShip.readonly_attributes
+
+    s = ReadonlyNameShip.create(:name => "unchangeable name")
+    s.reload
+    assert_equal "unchangeable name", s.name
+
+    s.update(name: "changed name")
+    s.reload
+    assert_equal "unchangeable name", s.name
+  end
+
+  def test_quote_table_name
+    ref = references(:michael_magician)
+    ref.favourite = !ref.favourite
+    assert ref.save
+  end
+
+  # Useful for partial updates, don't only update the lock_version if there
+  # is nothing else being updated.
+  def test_update_without_attributes_does_not_only_update_lock_version
+    assert_nothing_raised do
+      p1 = Person.create!(:first_name => 'anika')
+      lock_version = p1.lock_version
+      p1.save
+      p1.reload
+      assert_equal lock_version, p1.lock_version
+    end
+  end
+
+  def test_polymorphic_destroy_with_dependencies_and_lock_version
+    car = Car.create!
+
+    assert_difference 'car.wheels.count'  do
+      car.wheels << Wheel.create!
+    end
+    assert_difference 'car.wheels.count', -1  do
+      car.reload.destroy
+    end
+    assert car.destroyed?
+  end
+
+  def test_removing_has_and_belongs_to_many_associations_upon_destroy
+    p = RichPerson.create! first_name: 'Jon'
+    p.treasures.create!
+    assert !p.treasures.empty?
+    p.destroy
+    assert p.treasures.empty?
+    assert RichPerson.connection.select_all("SELECT * FROM peoples_treasures WHERE rich_person_id = 1").empty?
+  end
+
+  def test_yaml_dumping_with_lock_column
+    t1 = LockWithoutDefault.new
+    t2 = YAML.load(YAML.dump(t1))
+
+    assert_equal t1.attributes, t2.attributes
+  end
+end
+
+class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
+  fixtures :people, :legacy_things, :references
+
+  # need to disable transactional tests, because otherwise the sqlite3
+  # adapter (at least) chokes when we try and change the schema in the middle
+  # of a test (see test_increment_counter_*).
+  self.use_transactional_tests = false
+
+  { :lock_version => Person, :custom_lock_version => LegacyThing }.each do |name, model|
+    define_method("test_increment_counter_updates_#{name}") do
+      counter_test model, 1 do |id|
+        model.increment_counter :test_count, id
+      end
+    end
+
+    define_method("test_decrement_counter_updates_#{name}") do
+      counter_test model, -1 do |id|
+        model.decrement_counter :test_count, id
+      end
+    end
+
+    define_method("test_update_counters_updates_#{name}") do
+      counter_test model, 1 do |id|
+        model.update_counters id, :test_count => 1
+      end
+    end
+  end
+
+  # See Lighthouse ticket #1966
+  def test_destroy_dependents
+    # Establish dependent relationship between Person and PersonalLegacyThing
+    add_counter_column_to(Person, 'personal_legacy_things_count')
+    PersonalLegacyThing.reset_column_information
+
+    # Make sure that counter incrementing doesn't cause problems
+    p1 = Person.new(:first_name => 'fjord')
+    p1.save!
+    t = PersonalLegacyThing.new(:person => p1)
+    t.save!
+    p1.reload
+    assert_equal 1, p1.personal_legacy_things_count
+    assert p1.destroy
+    assert_equal true, p1.frozen?
+    assert_raises(ActiveRecord::RecordNotFound) { Person.find(p1.id) }
+    assert_raises(ActiveRecord::RecordNotFound) { PersonalLegacyThing.find(t.id) }
+  ensure
+    remove_counter_column_from(Person, 'personal_legacy_things_count')
+    PersonalLegacyThing.reset_column_information
+  end
+
+  private
+
+    def add_counter_column_to(model, col='test_count')
+      model.connection.add_column model.table_name, col, :integer, :null => false, :default => 0
+      model.reset_column_information
+    end
+
+    def remove_counter_column_from(model, col = :test_count)
+      model.connection.remove_column model.table_name, col
+      model.reset_column_information
+    end
+
+    def counter_test(model, expected_count)
+      add_counter_column_to(model)
+      object = model.first
+      assert_equal 0, object.test_count
+      assert_equal 0, object.send(model.locking_column)
+      yield object.id
+      object.reload
+      assert_equal expected_count, object.test_count
+      assert_equal 1, object.send(model.locking_column)
+    ensure
+      remove_counter_column_from(model)
+    end
+end
+
+
+# TODO: test against the generated SQL since testing locking behavior itself
+# is so cumbersome. Will deadlock Ruby threads if the underlying db.execute
+# blocks, so separate script called by Kernel#system is needed.
+# (See exec vs. async_exec in the PostgreSQL adapter.)
+unless in_memory_db?
+  class PessimisticLockingTest < ActiveRecord::TestCase
+    self.use_transactional_tests = false
+    fixtures :people, :readers
+
+    def setup
+      Person.connection_pool.clear_reloadable_connections!
+      # Avoid introspection queries during tests.
+      Person.columns; Reader.columns
+    end
+
+    # Test typical find.
+    def test_sane_find_with_lock
+      assert_nothing_raised do
+        Person.transaction do
+          Person.lock.find(1)
+        end
+      end
+    end
+
+    # PostgreSQL protests SELECT ... FOR UPDATE on an outer join.
+    unless current_adapter?(:PostgreSQLAdapter)
+      # Test locked eager find.
+      def test_eager_find_with_lock
+        assert_nothing_raised do
+          Person.transaction do
+            Person.includes(:readers).lock.find(1)
+          end
+        end
+      end
+    end
+
+    # Locking a record reloads it.
+    def test_sane_lock_method
+      assert_nothing_raised do
+        Person.transaction do
+          person = Person.find 1
+          old, person.first_name = person.first_name, 'fooman'
+          person.lock!
+          assert_equal old, person.first_name
+        end
+      end
+    end
+
+    def test_with_lock_commits_transaction
+      person = Person.find 1
+      person.with_lock do
+        person.first_name = 'fooman'
+        person.save!
+      end
+      assert_equal 'fooman', person.reload.first_name
+    end
+
+    def test_with_lock_rolls_back_transaction
+      person = Person.find 1
+      old = person.first_name
+      person.with_lock do
+        person.first_name = 'fooman'
+        person.save!
+        raise 'oops'
+      end rescue nil
+      assert_equal old, person.reload.first_name
+    end
+
+    if current_adapter?(:PostgreSQLAdapter)
+      def test_lock_sending_custom_lock_statement
+        Person.transaction do
+          person = Person.find(1)
+          assert_sql(/LIMIT \$?\d FOR SHARE NOWAIT/) do
+            person.lock!('FOR SHARE NOWAIT')
+          end
+        end
+      end
+    end
+
+    if current_adapter?(:PostgreSQLAdapter, :OracleAdapter)
+      def test_no_locks_no_wait
+        first, second = duel { Person.find 1 }
+        assert first.end > second.end
+      end
+
+      protected
+        def duel(zzz = 5)
+          t0, t1, t2, t3 = nil, nil, nil, nil
+
+          a = Thread.new do
+            t0 = Time.now
+            Person.transaction do
+              yield
+              sleep zzz       # block thread 2 for zzz seconds
+            end
+            t1 = Time.now
+          end
+
+          b = Thread.new do
+            sleep zzz / 2.0   # ensure thread 1 tx starts first
+            t2 = Time.now
+            Person.transaction { yield }
+            t3 = Time.now
+          end
+
+          a.join
+          b.join
+
+          assert t1 > t0 + zzz
+          assert t2 > t0
+          assert t3 > t2
+          [t0.to_f..t1.to_f, t2.to_f..t3.to_f]
+        end
+    end
+  end
+end