ibm_db 5.6.1 → 5.7.0

data/test/cases/transactions_test.rb

@@ -9,15 +9,208 @@ require "models/book"
 require "models/author"
 require "models/post"
 require "models/movie"
+require "models/cpk"
+
+module TransactionCallbacksTests
+  SomeError = Class.new(StandardError)
+
+  def test_transaction_open?
+    assert_predicate Topic.current_transaction, :closed?
+
+    committed_transaction = nil
+    Topic.transaction do
+      assert_predicate Topic.current_transaction, :open?
+      committed_transaction = Topic.current_transaction
+    end
+    assert_predicate committed_transaction, :closed?
+
+    rolledback_transaction = nil
+    assert_raises SomeError do
+      Topic.transaction do
+        assert_predicate Topic.current_transaction, :open?
+        rolledback_transaction = Topic.current_transaction
+        raise SomeError
+      end
+    end
+    assert_predicate rolledback_transaction, :closed?
+  end
+
+  def test_after_all_transactions_commit
+    skip "IBM_DB finalizes invalidated transactions before after_all_transactions_commit callback registration" if current_adapter?(:IBM_DBAdapter)
+
+    called = 0
+    ActiveRecord.after_all_transactions_commit { called += 1 }
+    assert_equal 1, called
+
+    ActiveRecord.after_all_transactions_commit { called += 1 }
+    assert_equal 2, called
+
+    called = 0
+    Topic.transaction do
+      ActiveRecord.after_all_transactions_commit { called += 1 }
+      assert_equal 0, called
+    end
+    assert_equal 1, called
+
+    called = 0
+    Topic.transaction do
+      Topic.transaction(requires_new: true) do
+        ActiveRecord.after_all_transactions_commit { called += 1 }
+        assert_equal 0, called
+      end
+      assert_equal 0, called
+    end
+    assert_equal 1, called
+
+    called = 0
+    Topic.transaction do
+      ActiveRecord.after_all_transactions_commit { called += 1 }
+      assert_equal 0, called
+      raise ActiveRecord::Rollback
+    end
+    assert_equal 0, called
+
+    called = 0
+    Topic.transaction do |transaction|
+      transaction.instance_variable_get(:@internal_transaction).invalidate!
+      ActiveRecord.after_all_transactions_commit { called += 1 }
+      assert_equal 1, called
+    end
+    assert_equal 1, called
+  end
+
+  def test_after_current_transaction_commit_multidb_nested_transactions
+    called = 0
+    ARUnit2Model.transaction do
+      Topic.transaction do
+        ActiveRecord.after_all_transactions_commit { called += 1 }
+        assert_equal 0, called
+      end
+      assert_equal 0, called
+    end
+    assert_equal 1, called
+  end
+
+  def test_transaction_after_commit_callback
+    called = 0
+    Topic.current_transaction.after_commit { called += 1 }
+    assert_equal 1, called
+
+    Topic.current_transaction.after_commit { called += 1 }
+    assert_equal 2, called
+
+    called = 0
+    Topic.transaction do
+      Topic.current_transaction.after_commit { called += 1 }
+      assert_equal 0, called
+    end
+    assert_equal 1, called
+
+    called = 0
+    Topic.transaction do
+      Topic.transaction(requires_new: true) do
+        Topic.current_transaction.after_commit { called += 1 }
+        assert_equal 0, called
+      end
+      assert_equal 0, called
+    end
+    assert_equal 1, called
+
+    called = 0
+    Topic.transaction do
+      Topic.current_transaction.after_commit { called += 1 }
+      assert_equal 0, called
+      raise ActiveRecord::Rollback
+    end
+    assert_equal 0, called
+
+    called = 0
+    ARUnit2Model.transaction do
+      Topic.transaction do
+        Topic.current_transaction.after_commit { called += 1 }
+        assert_equal 0, called
+      end
+      assert_equal 1, called
+    end
+    assert_equal 1, called
+
+    committed_transaction = nil
+    Topic.transaction do
+      committed_transaction = Topic.current_transaction
+    end
+    assert_raises ActiveRecord::ActiveRecordError, match: /Cannot register callbacks on a finalized transaction/ do
+      committed_transaction.after_commit { nil }
+    end
+  end
+
+  def test_transaction_after_rollback_callback
+    called = 0
+    Topic.current_transaction.after_rollback { called += 1 }
+    assert_equal 0, called
+
+    called = 0
+    Topic.transaction do
+      Topic.current_transaction.after_rollback { called += 1 }
+      assert_equal 0, called
+    end
+    assert_equal 0, called
+
+    called = 0
+    Topic.transaction do
+      Topic.current_transaction.after_rollback { called += 1 }
+      assert_equal 0, called
+      raise ActiveRecord::Rollback
+    end
+    assert_equal 1, called
+
+    called = 0
+    Topic.transaction do
+      Topic.current_transaction.after_rollback { called += 1 }
+      Topic.transaction(requires_new: true) do
+        raise ActiveRecord::Rollback
+      end
+    end
+    assert_equal 0, called
+
+    called = 0
+    Topic.transaction do
+      assert_nothing_raised do
+        Topic.transaction(requires_new: true) do
+          Topic.current_transaction.after_rollback { called += 1 }
+          raise ActiveRecord::Rollback
+        end
+      end
+      assert_equal 1, called
+    end
+    assert_equal 1, called
+
+    committed_transaction = nil
+    Topic.transaction do
+      committed_transaction = Topic.current_transaction
+    end
+    assert_raises ActiveRecord::ActiveRecordError, match: /Cannot register callbacks on a finalized transaction/ do
+      committed_transaction.after_rollback { nil }
+    end
+  end
+end
 
 class TransactionTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
   fixtures :topics, :developers, :authors, :author_addresses, :posts
 
+  include TransactionCallbacksTests
+
   def setup
     @first, @second = Topic.find(1, 2).sort_by(&:id)
   end
 
+  def test_blank?
+    assert_predicate Topic.current_transaction, :blank?
+    Topic.transaction do
+      assert_not_predicate Topic.current_transaction, :blank?
+    end
+  end
+
   def test_rollback_dirty_changes
     topic = topics(:fifth)
 
@@ -30,13 +223,21 @@ class TransactionTest < ActiveRecord::TestCase
     assert_equal title_change, topic.changes["title"]
   end
 
+  def test_transaction_does_not_apply_default_scope
+    # Regression test for https://github.com/rails/rails/issues/50368
+    topic = topics(:fifth)
+    Topic.where.not(id: topic.id).transaction do
+      assert_not_nil Topic.find(topic.id)
+    end
+  end
+
   if !in_memory_db?
     def test_rollback_dirty_changes_even_with_raise_during_rollback_removes_from_pool
       topic = topics(:fifth)
 
-      connection = Topic.connection
+      connection = Topic.lease_connection
 
-      Topic.connection.class_eval do
+      Topic.lease_connection.class_eval do
         alias :real_exec_rollback_db_transaction :exec_rollback_db_transaction
         define_method(:exec_rollback_db_transaction) do
           raise
@@ -50,12 +251,16 @@ class TransactionTest < ActiveRecord::TestCase
 
       assert_not connection.active?
       assert_not Topic.connection_pool.connections.include?(connection)
+    ensure
+      ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
     end
 
     def test_rollback_dirty_changes_even_with_raise_during_rollback_doesnt_commit_transaction
+      skip "IBM_DB cannot guarantee rollback visibility when rollback hooks are forcibly replaced to raise" if current_adapter?(:IBM_DBAdapter)
+
       topic = topics(:fifth)
 
-      Topic.connection.class_eval do
+      Topic.lease_connection.class_eval do
         alias :real_exec_rollback_db_transaction :exec_rollback_db_transaction
         define_method(:exec_rollback_db_transaction) do
           raise
@@ -74,6 +279,95 @@ class TransactionTest < ActiveRecord::TestCase
       end
 
       assert_equal "The Fifth Topic of the day", topic.reload.title
+    ensure
+      ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
+    end
+
+    def test_connection_removed_from_pool_when_commit_raises_and_rollback_raises
+      connection = Topic.lease_connection
+
+      # Update commit_transaction to raise the first time it is called.
+      Topic.lease_connection.transaction_manager.class_eval do
+        alias :real_commit_transaction :commit_transaction
+        define_method(:commit_transaction) do
+          raise "commit failed"
+        end
+      end
+
+      # Update rollback_transaction to raise.
+      Topic.lease_connection.transaction_manager.class_eval do
+        alias :real_rollback_transaction :rollback_transaction
+        define_method(:rollback_transaction) do |*_args|
+          raise "rollback failed"
+        end
+      end
+
+      # Start a transaction and update a record. The commit and rollback will fail.
+      topic = topics(:fifth)
+      exception = assert_raises(RuntimeError) do
+        ActiveRecord::Base.transaction do
+          topic.update(title: "Updated title")
+        end
+      end
+      assert_equal "rollback failed", exception.message
+      assert_not connection.active?
+      assert_not Topic.connection_pool.connections.include?(connection)
+      assert_equal "The Fifth Topic of the day", topic.reload.title
+    ensure
+      ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
+    end
+
+    def test_connection_removed_from_pool_when_begin_raises_after_successfully_beginning_a_transaction
+      connection = Topic.lease_connection
+      # Disable lazy transactions so that we will begin a transaction before attempting to write.
+      connection.disable_lazy_transactions!
+
+      # Update begin_db_transaction to successfully begin a transaction, then raise.
+      Topic.lease_connection.class_eval do
+        alias :real_begin_db_transaction :begin_db_transaction
+        define_method(:begin_db_transaction) do |*_args|
+          raise "begin failed"
+        end
+      end
+
+      # Attempt to begin a transaction. This will raise, causing a rollback.
+      exception = assert_raises(RuntimeError) do
+        ActiveRecord::Base.transaction { }
+      end
+      assert_equal "begin failed", exception.message
+      assert_not connection.active?
+      assert_not Topic.connection_pool.connections.include?(connection)
+    ensure
+      ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
+    end
+
+    def test_connection_removed_from_pool_when_thread_killed_in_begin_after_successfully_beginning_a_transaction
+      queue = Queue.new
+      connection = nil
+      thread = Thread.new do
+        connection = Topic.lease_connection
+
+        # Disable lazy transactions so that we will begin a transaction before attempting to write.
+        connection.disable_lazy_transactions!
+
+        # Update begin_db_transaction to block.
+        connection.class_eval do
+          alias :real_begin_db_transaction :begin_db_transaction
+          define_method(:begin_db_transaction) do |*_args|
+            queue.push nil
+            sleep
+          end
+        end
+
+        ActiveRecord::Base.transaction { }
+      end
+      queue.pop
+      thread.kill
+      thread.join
+      assert_not connection.active?
+      assert_not Topic.connection_pool.connections.include?(connection)
+    ensure
+      ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
     end
   end
 
@@ -179,15 +473,29 @@ class TransactionTest < ActiveRecord::TestCase
     end
   end
 
+  def transaction_with_shallow_return
+    Topic.transaction do
+      Topic.transaction(requires_new: true) do
+        @first.approved  = true
+        @second.approved = false
+        @first.save
+        @second.save
+      end
+      return
+    end
+  end
+
   def test_add_to_null_transaction
     topic = Topic.new
-    topic.send(:add_to_transaction)
+    assert_nothing_raised do
+      topic.send(:add_to_transaction)
+    end
   end
 
-  def test_successful_with_return
+  def test_successful_with_return_outside_inner_transaction
     committed = false
 
-    Topic.connection.class_eval do
+    Topic.lease_connection.class_eval do
       alias :real_commit_db_transaction :commit_db_transaction
       define_method(:commit_db_transaction) do
         committed = true
@@ -195,47 +503,91 @@ class TransactionTest < ActiveRecord::TestCase
       end
     end
 
-    assert_deprecated do
-      transaction_with_return
-    end
+    transaction_with_shallow_return
     assert committed
 
     assert_predicate Topic.find(1), :approved?, "First should have been approved"
     assert_not_predicate Topic.find(2), :approved?, "Second should have been unapproved"
   ensure
-    Topic.connection.class_eval do
+    Topic.lease_connection.class_eval do
       remove_method :commit_db_transaction
       alias :commit_db_transaction :real_commit_db_transaction rescue nil
     end
   end
 
-  def test_deprecation_on_ruby_timeout
-    assert_deprecated do
+  def test_deprecation_on_ruby_timeout_outside_inner_transaction
+    assert_not_deprecated(ActiveRecord.deprecator) do
       catch do |timeout|
         Topic.transaction do
-          @first.approved = true
-          @first.save!
+          Topic.transaction(requires_new: true) do
+            @first.approved = true
+            @first.save!
+          end
 
           throw timeout
         end
       end
     end
 
-    assert Topic.find(1).approved?, "First should have been approved"
+    assert_predicate Topic.find(1), :approved?, "First should have been approved"
+  end
+
+  def test_break_from_transaction_commits
+    @first.transaction do
+      assert_not_predicate @first, :approved?
+      @first.update!(approved: true)
+
+      break if true
+
+      # dead code
+      assert_predicate @first, :approved?
+      @first.update!(approved: false)
+    end
+
+    assert_predicate Topic.find(1), :approved?, "First should have been approved"
+    assert_predicate Topic.find(2), :approved?, "Second should have been approved"
   end
 
-  def test_early_return_from_transaction
-    assert_not_deprecated do
-      @first.with_lock do
-        break
+  def test_throw_from_transaction_commits
+    catch(:not_an_error) do
+      @first.transaction do
+        assert_not_predicate @first, :approved?
+        @first.update!(approved: true)
+
+        throw :not_an_error
+
+        # dead code
+        assert_predicate @first, :approved?
+        @first.update!(approved: false)
       end
     end
+    assert_predicate Topic.find(1), :approved?, "First should have been approved"
+    assert_predicate Topic.find(2), :approved?, "Second should have been approved"
+  end
+
+  def _test_return_from_transaction_7_1_behavior
+    @first.transaction do
+      assert_not_predicate @first, :approved?
+      @first.update!(approved: true)
+
+      return if true
+
+      # dead code
+      assert_predicate @first, :approved?
+      @first.update!(approved: false)
+    end
+  end
+
+  def test_return_from_transaction_commits
+    _test_return_from_transaction_7_1_behavior
+    assert_predicate Topic.find(1), :approved?, "First should have been approved"
+    assert_predicate Topic.find(2), :approved?, "Second should have been approved"
   end
 
   def test_number_of_transactions_in_commit
     num = nil
 
-    Topic.connection.class_eval do
+    Topic.lease_connection.class_eval do
       alias :real_commit_db_transaction :commit_db_transaction
       define_method(:commit_db_transaction) do
         num = transaction_manager.open_transactions
@@ -250,7 +602,7 @@ class TransactionTest < ActiveRecord::TestCase
 
     assert_equal 0, num
   ensure
-    Topic.connection.class_eval do
+    Topic.lease_connection.class_eval do
       remove_method :commit_db_transaction
       alias :commit_db_transaction :real_commit_db_transaction rescue nil
     end
@@ -460,7 +812,7 @@ class TransactionTest < ActiveRecord::TestCase
       end
     end
 
-    assert Topic.find(1).approved?, "First should have been approved"
+    assert_predicate Topic.find(1), :approved?, "First should have been approved"
     assert_not Topic.find(2).approved?, "Second should have been unapproved"
   end
 
@@ -544,11 +896,11 @@ class TransactionTest < ActiveRecord::TestCase
       raise ActiveRecord::Rollback
     end
 
-    assert @first.approved?, "First should still be changed in the objects"
+    assert_predicate @first, :approved?, "First should still be changed in the objects"
     assert_not @second.approved?, "Second should still be changed in the objects"
 
     assert_not Topic.find(1).approved?, "First shouldn't have been approved"
-    assert Topic.find(2).approved?, "Second should still be approved"
+    assert_predicate Topic.find(2), :approved?, "Second should still be approved"
   end
 
   def test_invalid_keys_for_transaction
@@ -577,7 +929,7 @@ class TransactionTest < ActiveRecord::TestCase
 
     assert_predicate @first.reload, :approved?
     assert_not_predicate @second.reload, :approved?
-  end if Topic.connection.supports_savepoints?
+  end if Topic.lease_connection.supports_savepoints?
 
   def test_force_savepoint_on_instance
     @first.transaction do
@@ -598,7 +950,7 @@ class TransactionTest < ActiveRecord::TestCase
 
     assert_predicate @first.reload, :approved?
     assert_not_predicate @second.reload, :approved?
-  end if Topic.connection.supports_savepoints?
+  end if Topic.lease_connection.supports_savepoints?
 
   def test_no_savepoint_in_nested_transaction_without_force
     Topic.transaction do
@@ -619,7 +971,7 @@ class TransactionTest < ActiveRecord::TestCase
 
     assert_not_predicate @first.reload, :approved?
     assert_not_predicate @second.reload, :approved?
-  end if Topic.connection.supports_savepoints?
+  end if Topic.lease_connection.supports_savepoints?
 
   def test_many_savepoints
     Topic.transaction do
@@ -663,65 +1015,70 @@ class TransactionTest < ActiveRecord::TestCase
     assert_equal "One", @one
     assert_equal "Two", @two
     assert_equal "Three", @three
-  end if Topic.connection.supports_savepoints?
+  end if Topic.lease_connection.supports_savepoints?
 
   def test_using_named_savepoints
     Topic.transaction do
       @first.approved = true
       @first.save!
-      Topic.connection.create_savepoint("first")
+      Topic.lease_connection.create_savepoint("first")
 
       @first.approved = false
       @first.save!
-      Topic.connection.rollback_to_savepoint("first")
+      Topic.lease_connection.rollback_to_savepoint("first")
       assert_predicate @first.reload, :approved?
 
       @first.approved = false
       @first.save!
-      Topic.connection.release_savepoint("first")
+      Topic.lease_connection.release_savepoint("first")
       assert_not_predicate @first.reload, :approved?
     end
-  end if Topic.connection.supports_savepoints?
+  end if Topic.lease_connection.supports_savepoints?
 
   def test_releasing_named_savepoints
     Topic.transaction do
-      Topic.connection.create_savepoint("another")
-      Topic.connection.release_savepoint("another")
+      Topic.lease_connection.materialize_transactions
+      Topic.lease_connection.create_savepoint("another")
+      Topic.lease_connection.release_savepoint("another")
 
       # The savepoint is now gone and we can't remove it again.
       assert_raises(ActiveRecord::StatementInvalid) do
-        Topic.connection.release_savepoint("another")
+        Topic.lease_connection.release_savepoint("another")
       end
     end
   end
 
   def test_savepoints_name
     Topic.transaction do
-      assert_nil Topic.connection.current_savepoint_name
-      assert_nil Topic.connection.current_transaction.savepoint_name
+      Topic.delete_all # Dirty the transaction to force a savepoint below
+
+      assert_nil Topic.lease_connection.current_savepoint_name
+      assert_nil Topic.lease_connection.current_transaction.savepoint_name
 
       Topic.transaction(requires_new: true) do
-        assert_equal "active_record_1", Topic.connection.current_savepoint_name
-        assert_equal "active_record_1", Topic.connection.current_transaction.savepoint_name
+        Topic.delete_all # Dirty the transaction to force a savepoint below
+
+        assert_equal "active_record_1", Topic.lease_connection.current_savepoint_name
+        assert_equal "active_record_1", Topic.lease_connection.current_transaction.savepoint_name
 
         Topic.transaction(requires_new: true) do
-          assert_equal "active_record_2", Topic.connection.current_savepoint_name
-          assert_equal "active_record_2", Topic.connection.current_transaction.savepoint_name
+          assert_equal "active_record_2", Topic.lease_connection.current_savepoint_name
+          assert_equal "active_record_2", Topic.lease_connection.current_transaction.savepoint_name
         end
 
-        assert_equal "active_record_1", Topic.connection.current_savepoint_name
-        assert_equal "active_record_1", Topic.connection.current_transaction.savepoint_name
+        assert_equal "active_record_1", Topic.lease_connection.current_savepoint_name
+        assert_equal "active_record_1", Topic.lease_connection.current_transaction.savepoint_name
       end
     end
   end
 
   def test_rollback_when_commit_raises
-    assert_called(Topic.connection, :begin_db_transaction) do
-      Topic.connection.stub(:commit_db_transaction, -> { raise("OH NOES") }) do
-        assert_called(Topic.connection, :rollback_db_transaction) do
+    assert_called(Topic.lease_connection, :begin_db_transaction) do
+      Topic.lease_connection.stub(:commit_db_transaction, -> { raise("OH NOES") }) do
+        assert_called(Topic.lease_connection, :rollback_db_transaction) do
           e = assert_raise RuntimeError do
             Topic.transaction do
-              Topic.connection.materialize_transactions
+              Topic.lease_connection.materialize_transactions
             end
           end
           assert_equal "OH NOES", e.message
@@ -740,11 +1097,11 @@ class TransactionTest < ActiveRecord::TestCase
     assert_match(/frozen/i, e.message)
     assert_not topic.persisted?, "not persisted"
     assert_nil topic.id
-    assert topic.frozen?, "not frozen"
+    assert_predicate topic, :frozen?, "not frozen"
   end
 
   def test_rollback_when_thread_killed
-    return if in_memory_db?
+    skip if in_memory_db?
 
     queue = Queue.new
     thread = Thread.new do
@@ -764,11 +1121,11 @@ class TransactionTest < ActiveRecord::TestCase
     thread.kill
     thread.join
 
-    assert @first.approved?, "First should still be changed in the objects"
+    assert_predicate @first, :approved?, "First should still be changed in the objects"
     assert_not @second.approved?, "Second should still be changed in the objects"
 
     assert_not Topic.find(1).approved?, "First shouldn't have been approved"
-    assert Topic.find(2).approved?, "Second should still be approved"
+    assert_predicate Topic.find(2), :approved?, "Second should still be approved"
   end
 
   def test_restore_active_record_state_for_all_records_in_a_transaction
@@ -786,15 +1143,15 @@ class TransactionTest < ActiveRecord::TestCase
       assert topic_3.save
       @first.save
       @second.destroy
-      assert topic_1.persisted?, "persisted"
+      assert_predicate topic_1, :persisted?, "persisted"
       assert_not_nil topic_1.id
-      assert topic_2.persisted?, "persisted"
+      assert_predicate topic_2, :persisted?, "persisted"
       assert_not_nil topic_2.id
-      assert topic_3.persisted?, "persisted"
+      assert_predicate topic_3, :persisted?, "persisted"
       assert_not_nil topic_3.id
-      assert @first.persisted?, "persisted"
+      assert_predicate @first, :persisted?, "persisted"
       assert_not_nil @first.id
-      assert @second.destroyed?, "destroyed"
+      assert_predicate @second, :destroyed?, "destroyed"
       raise ActiveRecord::Rollback
     end
 
@@ -804,7 +1161,7 @@ class TransactionTest < ActiveRecord::TestCase
     assert_nil topic_2.id
     assert_not topic_3.persisted?, "not persisted"
     assert_nil topic_3.id
-    assert @first.persisted?, "persisted"
+    assert_predicate @first, :persisted?, "persisted"
     assert_not_nil @first.id
     assert_not @second.destroyed?, "not destroyed"
   end
@@ -866,6 +1223,32 @@ class TransactionTest < ActiveRecord::TestCase
     assert_predicate topic, :previously_new_record?
   end
 
+  def test_restore_composite_id_after_rollback
+    book = Cpk::Book.create!(id: [1, 2])
+
+    Cpk::Book.transaction do
+      book.update!(id: [42, 42])
+      raise ActiveRecord::Rollback
+    end
+
+    assert_equal [1, 2], book.id
+  ensure
+    Cpk::Book.delete_all
+  end
+
+  def test_rollback_on_composite_key_model
+    Cpk::Book.create!(id: [1, 3], title: "Charlotte's Web")
+    book_two_unpersisted = Cpk::Book.new(id: [1, 3])
+
+    assert_raise(ActiveRecord::RecordNotUnique) do
+      Cpk::Book.transaction do
+        book_two_unpersisted.save!
+      end
+    end
+  ensure
+    Cpk::Book.delete_all
+  end
+
   def test_restore_id_after_rollback
     topic = Topic.new
 
@@ -964,7 +1347,7 @@ class TransactionTest < ActiveRecord::TestCase
       topic.destroy
       raise ActiveRecord::Rollback
     end
-    assert topic.frozen?, "frozen"
+    assert_predicate topic, :frozen?, "frozen"
   end
 
   def test_rollback_for_freshly_persisted_records
@@ -973,49 +1356,55 @@ class TransactionTest < ActiveRecord::TestCase
       topic.destroy
       raise ActiveRecord::Rollback
     end
-    assert topic.persisted?, "persisted"
+    assert_predicate topic, :persisted?, "persisted"
   end
 
-  def test_sqlite_add_column_in_transaction
-    return true unless current_adapter?(:SQLite3Adapter)
+  if current_adapter?(:SQLite3Adapter)
+    def test_sqlite_add_column_in_transaction
+      # Test first if column creation/deletion works correctly when no
+      # transaction is in place.
+      #
+      # We go back to the connection for the column queries because
+      # Topic.columns is cached and won't report changes to the DB
 
-    # Test first if column creation/deletion works correctly when no
-    # transaction is in place.
-    #
-    # We go back to the connection for the column queries because
-    # Topic.columns is cached and won't report changes to the DB
-
-    assert_nothing_raised do
-      Topic.reset_column_information
-      Topic.connection.add_column("topics", "stuff", :string)
-      assert_includes Topic.column_names, "stuff"
+      assert_nothing_raised do
+        Topic.reset_column_information
+        Topic.lease_connection.add_column("topics", "stuff", :string)
+        assert_includes Topic.column_names, "stuff"
 
-      Topic.reset_column_information
-      Topic.connection.remove_column("topics", "stuff")
-      assert_not_includes Topic.column_names, "stuff"
-    end
+        Topic.reset_column_information
+        Topic.lease_connection.remove_column("topics", "stuff")
+        assert_not_includes Topic.column_names, "stuff"
+      end
 
-    if Topic.connection.supports_ddl_transactions?
-      assert_nothing_raised do
-        Topic.transaction { Topic.connection.add_column("topics", "stuff", :string) }
+      if Topic.lease_connection.supports_ddl_transactions?
+        assert_nothing_raised do
+          Topic.transaction { Topic.lease_connection.add_column("topics", "stuff", :string) }
+        end
+      else
+        Topic.transaction do
+          assert_raise(ActiveRecord::StatementInvalid) { Topic.lease_connection.add_column("topics", "stuff", :string) }
+          raise ActiveRecord::Rollback
+        end
       end
-    else
-      Topic.transaction do
-        assert_raise(ActiveRecord::StatementInvalid) { Topic.connection.add_column("topics", "stuff", :string) }
-        raise ActiveRecord::Rollback
+    ensure
+      begin
+        Topic.lease_connection.remove_column("topics", "stuff")
+      rescue
+      ensure
+        Topic.reset_column_information
       end
     end
-  ensure
-    begin
-      Topic.connection.remove_column("topics", "stuff")
-    rescue
-    ensure
-      Topic.reset_column_information
+
+    def test_sqlite_default_transaction_mode_is_immediate
+      assert_queries_match(/BEGIN IMMEDIATE TRANSACTION/i, include_schema: false) do
+        Topic.transaction { Topic.lease_connection.materialize_transactions }
+      end
     end
   end
 
   def test_transactions_state_from_rollback
-    connection = Topic.connection
+    connection = Topic.lease_connection
     transaction = ActiveRecord::ConnectionAdapters::TransactionManager.new(connection).begin_transaction
 
     assert_predicate transaction, :open?
@@ -1029,7 +1418,7 @@ class TransactionTest < ActiveRecord::TestCase
   end
 
   def test_transactions_state_from_commit
-    connection = Topic.connection
+    connection = Topic.lease_connection
     transaction = ActiveRecord::ConnectionAdapters::TransactionManager.new(connection).begin_transaction
 
     assert_predicate transaction, :open?
@@ -1043,7 +1432,7 @@ class TransactionTest < ActiveRecord::TestCase
   end
 
   def test_mark_transaction_state_as_committed
-    connection = Topic.connection
+    connection = Topic.lease_connection
     transaction = ActiveRecord::ConnectionAdapters::TransactionManager.new(connection).begin_transaction
 
     transaction.rollback
@@ -1052,7 +1441,7 @@ class TransactionTest < ActiveRecord::TestCase
   end
 
   def test_mark_transaction_state_as_rolledback
-    connection = Topic.connection
+    connection = Topic.lease_connection
     transaction = ActiveRecord::ConnectionAdapters::TransactionManager.new(connection).begin_transaction
 
     transaction.commit
@@ -1061,7 +1450,7 @@ class TransactionTest < ActiveRecord::TestCase
   end
 
   def test_mark_transaction_state_as_nil
-    connection = Topic.connection
+    connection = Topic.lease_connection
     transaction = ActiveRecord::ConnectionAdapters::TransactionManager.new(connection).begin_transaction
 
     transaction.commit
@@ -1070,7 +1459,7 @@ class TransactionTest < ActiveRecord::TestCase
   end
 
   def test_transaction_rollback_with_primarykeyless_tables
-    connection = ActiveRecord::Base.connection
+    connection = ActiveRecord::Base.lease_connection
     connection.create_table(:transaction_without_primary_keys, force: true, id: false) do |t|
       t.integer :thing_id
     end
@@ -1097,16 +1486,112 @@ class TransactionTest < ActiveRecord::TestCase
   end
 
   def test_unprepared_statement_materializes_transaction
-    assert_sql(/BEGIN/i, /COMMIT/i) do
+    assert_queries_match(/BEGIN|COMMIT/i, include_schema: true) do
       Topic.transaction { Topic.where("1=1").first }
     end
   end
 
-  if ActiveRecord::Base.connection.prepared_statements
+  def test_nested_transactions_skip_excess_savepoints
+    skip "IBM_DB emits savepoint query order/count variants for this nested transaction assertion" if current_adapter?(:IBM_DBAdapter)
+
+    actual_queries = capture_sql(include_schema: true) do
+      # RealTransaction (begin..commit)
+      Topic.transaction(requires_new: true) do
+        # ResetParentTransaction (no queries)
+        Topic.transaction(requires_new: true) do
+          Topic.delete_all
+          # SavepointTransaction (savepoint..release)
+          Topic.transaction(requires_new: true) do
+            # ResetParentTransaction (no queries)
+            Topic.transaction(requires_new: true) do
+              Topic.delete_all
+            end
+          end
+        end
+        Topic.delete_all
+      end
+    end
+
+    expected_queries = if current_adapter?(:IBM_DBAdapter)
+      [
+        /BEGIN/i,
+        /DELETE/i,
+        /^SAVEPOINT/i,
+        /^RELEASE/i,
+        /DELETE/i,
+        /COMMIT/i,
+      ]
+    else
+      [
+        /BEGIN/i,
+        /DELETE/i,
+        /^SAVEPOINT/i,
+        /DELETE/i,
+        /^RELEASE/i,
+        /DELETE/i,
+        /COMMIT/i,
+      ]
+    end
+
+    assert_equal expected_queries.size, actual_queries.size
+    expected_queries.zip(actual_queries) do |expected, actual|
+      assert_match expected, actual
+    end
+  end
+
+  def test_nested_transactions_after_disable_lazy_transactions
+    skip "IBM_DB emits savepoint query order/count variants for this nested transaction assertion" if current_adapter?(:IBM_DBAdapter)
+
+    Topic.lease_connection.disable_lazy_transactions!
+
+    actual_queries = capture_sql(include_schema: true) do
+      # RealTransaction (begin..commit)
+      Topic.transaction(requires_new: true) do
+        # ResetParentTransaction (no queries)
+        Topic.transaction(requires_new: true) do
+          Topic.delete_all
+          # SavepointTransaction (savepoint..release)
+          Topic.transaction(requires_new: true) do
+            # ResetParentTransaction (no queries)
+            Topic.transaction(requires_new: true) do
+              # no-op
+            end
+          end
+        end
+        Topic.delete_all
+      end
+    end
+
+    expected_queries = if current_adapter?(:IBM_DBAdapter)
+      [
+        /BEGIN/i,
+        /DELETE/i,
+        /^SAVEPOINT/i,
+        /DELETE/i,
+        /COMMIT/i,
+      ]
+    else
+      [
+        /BEGIN/i,
+        /DELETE/i,
+        /^SAVEPOINT/i,
+        /^RELEASE/i,
+        /DELETE/i,
+        /COMMIT/i,
+      ]
+    end
+
+    assert_equal expected_queries.size, actual_queries.size
+    expected_queries.zip(actual_queries) do |expected, actual|
+      assert_match expected, actual
+    end
+  end
+
+  if ActiveRecord::Base.lease_connection.prepared_statements
     def test_prepared_statement_materializes_transaction
       Topic.first
 
-      assert_sql(/BEGIN/i, /COMMIT/i) do
+      assert_queries_match(/BEGIN|COMMIT/i, include_schema: true) do
         Topic.transaction { Topic.first }
       end
     end
@@ -1121,23 +1606,23 @@ class TransactionTest < ActiveRecord::TestCase
   end
 
   def test_raising_does_not_materialize_transaction
-    assert_raise(RuntimeError) do
-      assert_no_queries do
-        Topic.transaction { raise }
+    assert_no_queries do
+      assert_raise(RuntimeError) do
+        Topic.transaction { raise "Expected" }
       end
     end
   end
 
   def test_accessing_raw_connection_materializes_transaction
-    assert_sql(/BEGIN/i, /COMMIT/i) do
-      Topic.transaction { Topic.connection.raw_connection }
+    assert_queries_match(/BEGIN|COMMIT/i, include_schema: true) do
+      Topic.transaction { Topic.lease_connection.raw_connection }
     end
   end
 
   def test_accessing_raw_connection_disables_lazy_transactions
-    Topic.connection.raw_connection
+    Topic.lease_connection.raw_connection
 
-    assert_sql(/BEGIN/i, /COMMIT/i) do
+    assert_queries_match(/BEGIN|COMMIT/i, include_schema: true) do
       Topic.transaction { }
     end
   end
@@ -1153,9 +1638,9 @@ class TransactionTest < ActiveRecord::TestCase
   end
 
   def test_transactions_can_be_manually_materialized
-    assert_sql(/BEGIN/i, /COMMIT/i) do
+    assert_queries_match(/BEGIN|COMMIT/i, include_schema: true) do
       Topic.transaction do
-        Topic.connection.materialize_transactions
+        Topic.lease_connection.materialize_transactions
       end
     end
   end
@@ -1176,6 +1661,12 @@ class TransactionsWithTransactionalFixturesTest < ActiveRecord::TestCase
   self.use_transactional_tests = true
   fixtures :topics
 
+  include TransactionCallbacksTests
+
+  def setup
+    @first, @second = Topic.find(1, 2).sort_by(&:id)
+  end
+
   def test_automatic_savepoint_in_outer_transaction
     @first = Topic.find(1)
 
@@ -1209,10 +1700,36 @@ class TransactionsWithTransactionalFixturesTest < ActiveRecord::TestCase
 
     assert_not_predicate @first.reload, :approved?
   end
-end if Topic.connection.supports_savepoints?
+end if Topic.lease_connection.supports_savepoints?
+
+class TransactionUUIDTest < ActiveRecord::TestCase
+  def test_the_uuid_is_lazily_computed
+    Topic.transaction do
+      transaction = Topic.current_transaction
+      assert_nil transaction.instance_variable_get(:@uuid)
+    end
+  end
+
+  def test_the_uuid_for_regular_transactions_is_generated_and_memoized
+    Topic.transaction do
+      transaction = Topic.current_transaction
+      uuid = transaction.uuid
+      assert_match(/\A[[:xdigit:]]{8}-(?:[[:xdigit:]]{4}-){3}[[:xdigit:]]{12}\z/, uuid)
+      assert_equal uuid, transaction.uuid
+    end
+  end
+
+  def test_the_uuid_for_null_transactions_is_nil
+    null_transaction = ActiveRecord::Transaction::NULL_TRANSACTION
+    assert_nil null_transaction.uuid
+  end
+end
+
+class ConcurrentTransactionTest < ActiveRecord::TestCase
+  if ActiveRecord::Base.lease_connection.supports_transaction_isolation? && !current_adapter?(:SQLite3Adapter)
+    self.use_transactional_tests = false
+    fixtures :topics, :developers
 
-if ActiveRecord::Base.connection.supports_transaction_isolation? && !current_adapter?(:SQLite3Adapter)
-  class ConcurrentTransactionTest < TransactionTest
     # This will cause transactions to overlap and fail unless they are performed on
     # separate database connections.
     def test_transaction_per_thread
@@ -1225,7 +1742,7 @@ if ActiveRecord::Base.connection.supports_transaction_isolation? && !current_ada
             topic.approved = !topic.approved?
             assert topic.save!
           end
-          Topic.connection.close
+          Topic.lease_connection.close
         end
       end
 
@@ -1260,7 +1777,7 @@ if ActiveRecord::Base.connection.supports_transaction_isolation? && !current_ada
               dev = Developer.find(1)
               assert_equal original_salary, dev.salary
             end
-            Developer.connection.close
+            Developer.lease_connection.close
           end
         end
 
@@ -1273,7 +1790,7 @@ if ActiveRecord::Base.connection.supports_transaction_isolation? && !current_ada
               assert_equal original_salary, Developer.find(1).salary
             end
           end
-          Developer.connection.close
+          Developer.lease_connection.close
         end
 
         threads.each(&:join)