ibm_db 5.6.1 → 5.7.0

data/test/cases/instrumentation_test.rb

@@ -1,20 +1,21 @@
 # frozen_string_literal: true
 
 require "cases/helper"
+require "models/author"
 require "models/book"
+require "models/clothing_item"
 
 module ActiveRecord
   class InstrumentationTest < ActiveRecord::TestCase
     def setup
-      ActiveRecord::Base.connection.schema_cache.add(Book.table_name)
+      ActiveRecord::Base.schema_cache.add(Book.table_name)
     end
 
     def test_payload_name_on_load
       Book.create(name: "test book")
-      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
-        event = ActiveSupport::Notifications::Event.new(*args)
-        if event.payload[:sql].match "SELECT"
-          assert_equal "Book Load", event.payload[:name]
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+        if payload[:sql].match?("SELECT")
+          assert_equal "Book Load", payload[:name]
         end
       end
       Book.first
@@ -23,10 +24,9 @@ module ActiveRecord
     end
 
     def test_payload_name_on_create
-      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
-        event = ActiveSupport::Notifications::Event.new(*args)
-        if event.payload[:sql].match "INSERT"
-          assert_equal "Book Create", event.payload[:name]
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+        if payload[:sql].match?("INSERT")
+          assert_equal "Book Create", payload[:name]
         end
       end
       Book.create(name: "test book")
@@ -35,10 +35,9 @@ module ActiveRecord
     end
 
     def test_payload_name_on_update
-      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
-        event = ActiveSupport::Notifications::Event.new(*args)
-        if event.payload[:sql].match "UPDATE"
-          assert_equal "Book Update", event.payload[:name]
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+        if payload[:sql].match?("UPDATE")
+          assert_equal "Book Update", payload[:name]
         end
       end
       book = Book.create(name: "test book", format: "paperback")
@@ -48,23 +47,20 @@ module ActiveRecord
     end
 
     def test_payload_name_on_update_all
-      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
-        event = ActiveSupport::Notifications::Event.new(*args)
-        if event.payload[:sql].match "UPDATE"
-          assert_equal "Book Update All", event.payload[:name]
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+        if payload[:sql].match?("UPDATE")
+          assert_equal "Book Update All", payload[:name]
         end
       end
-      Book.create(name: "test book", format: "paperback")
       Book.update_all(format: "ebook")
     ensure
       ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
     end
 
     def test_payload_name_on_destroy
-      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
-        event = ActiveSupport::Notifications::Event.new(*args)
-        if event.payload[:sql].match "DELETE"
-          assert_equal "Book Destroy", event.payload[:name]
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+        if payload[:sql].match?("DELETE")
+          assert_equal "Book Destroy", payload[:name]
         end
       end
       book = Book.create(name: "test book")
@@ -73,11 +69,122 @@ module ActiveRecord
       ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
     end
 
+    def test_payload_name_on_delete_all
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+        if payload[:sql].match?("DELETE")
+          assert_equal "Book Delete All", payload[:name]
+        end
+      end
+      Book.delete_all
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_payload_name_on_pluck
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+        if payload[:sql].match?("SELECT")
+          assert_equal "Book Pluck", payload[:name]
+        end
+      end
+      Book.pluck(:name)
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_payload_name_on_count
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+        if payload[:sql].match?("SELECT")
+          assert_equal "Book Count", payload[:name]
+        end
+      end
+      Book.count
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_payload_name_on_grouped_count
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+        if payload[:sql].match?("SELECT")
+          assert_equal "Book Count", payload[:name]
+        end
+      end
+      Book.group(:status).count
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_payload_row_count_on_select_all
+      # DB2 composite unique index (author_id, name) treats (NULL, 'row count book 1') as duplicate on 2nd insert
+      skip if current_adapter?(:IBM_DBAdapter)
+      10.times { Book.create(name: "row count book 1") }
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+        if payload[:sql].match?("SELECT")
+          assert_equal 10, payload[:row_count]
+        end
+      end
+      Book.where(name: "row count book 1").to_a
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_payload_row_count_on_pluck
+      # DB2 composite unique index (author_id, name) treats (NULL, 'row count book 2') as duplicate on 2nd insert
+      skip if current_adapter?(:IBM_DBAdapter)
+      10.times { Book.create(name: "row count book 2") }
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+        if payload[:sql].match?("SELECT")
+          assert_equal 10, payload[:row_count]
+        end
+      end
+      Book.where(name: "row count book 2").pluck(:name)
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_payload_row_count_on_raw_sql
+      # DB2 composite unique index (author_id, name) treats (NULL, 'row count book 3') as duplicate on 2nd insert
+      skip if current_adapter?(:IBM_DBAdapter)
+      10.times { Book.create(name: "row count book 3") }
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+        if payload[:sql].match?("SELECT")
+          assert_equal 10, payload[:row_count]
+        end
+      end
+      ActiveRecord::Base.lease_connection.execute("SELECT * FROM books WHERE name='row count book 3';")
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_payload_row_count_on_cache
+      # IBM_DB adapter logs row_count: 0 by default (no post-fetch notification update);
+      # skip since this is an adapter feature gap, not a DB2 incompatibility
+      skip if current_adapter?(:IBM_DBAdapter)
+      events = []
+      callback = -> (event) do
+        payload = event.payload
+        events << payload if payload[:sql].include?("SELECT")
+      end
+
+      Book.create!(name: "row count book")
+      ActiveSupport::Notifications.subscribed(callback, "sql.active_record") do
+        Book.cache do
+          Book.first
+          Book.first
+        end
+      end
+
+      assert_equal 2, events.size
+      assert_not events[0][:cached]
+      assert events[1][:cached]
+
+      assert_equal 1, events[0][:row_count]
+      assert_equal 1, events[1][:row_count]
+    end
+
     def test_payload_connection_with_query_cache_disabled
-      connection = Book.connection
-      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
-        event = ActiveSupport::Notifications::Event.new(*args)
-        assert_equal connection, event.payload[:connection]
+      connection = ClothingItem.lease_connection
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+        assert_equal connection, payload[:connection]
       end
       Book.first
     ensure
@@ -85,10 +192,9 @@ module ActiveRecord
     end
 
     def test_payload_connection_with_query_cache_enabled
-      connection = Book.connection
-      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
-        event = ActiveSupport::Notifications::Event.new(*args)
-        assert_equal connection, event.payload[:connection]
+      connection = ClothingItem.lease_connection
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+        assert_equal connection, payload[:connection]
       end
       Book.cache do
         Book.first
@@ -97,5 +203,71 @@ module ActiveRecord
     ensure
       ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
     end
+
+    def test_no_instantiation_notification_when_no_records
+      author = Author.create!(id: 100, name: "David")
+
+      called = false
+      subscriber = ActiveSupport::Notifications.subscribe("instantiation.active_record") do
+        called = true
+      end
+
+      Author.where(id: 0).to_a
+      author.books.to_a
+
+      assert_equal false, called
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+  end
+
+  module TransactionInSqlActiveRecordPayloadTests
+    def test_payload_without_an_open_transaction
+      asserted = false
+
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+        if event.payload.fetch(:name) == "Book Count"
+          assert_nil event.payload.fetch(:transaction)
+          asserted = true
+        end
+      end
+
+      Book.count
+
+      assert asserted
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber)
+    end
+
+    def test_payload_with_an_open_transaction
+      asserted = false
+      expected_transaction = nil
+
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+        if event.payload.fetch(:name) == "Book Count"
+          assert_same expected_transaction, event.payload.fetch(:transaction)
+          asserted = true
+        end
+      end
+
+      Book.transaction do |transaction|
+        expected_transaction = transaction
+        Book.count
+      end
+
+      assert asserted
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber)
+    end
+  end
+
+  class TransactionInSqlActiveRecordPayloadTest < ActiveRecord::TestCase
+    include TransactionInSqlActiveRecordPayloadTests
+  end
+
+  class TransactionInSqlActiveRecordPayloadNonTransactionalTest < ActiveRecord::TestCase
+    include TransactionInSqlActiveRecordPayloadTests
+
+    self.use_transactional_tests = false
   end
 end

data/test/cases/integration_test.rb

@@ -6,6 +6,7 @@ require "models/developer"
 require "models/computer"
 require "models/owner"
 require "models/pet"
+require "models/cpk"
 
 class IntegrationTest < ActiveRecord::TestCase
   fixtures :companies, :developers, :owners, :pets
@@ -97,6 +98,25 @@ class IntegrationTest < ActiveRecord::TestCase
     assert_equal "Firm", Firm.to_param
   end
 
+  def test_to_param_for_a_composite_primary_key_model
+    assert_equal "1_123", Cpk::Order.new(id: [1, 123]).to_param
+  end
+
+  def test_param_delimiter_changes_delimiter_used_in_to_param
+    Cpk::Order.stub(:param_delimiter, ",") do
+      assert_equal("1,123", Cpk::Order.new(id: [1, 123]).to_param)
+    end
+  end
+
+  def test_param_delimiter_is_defined_per_class
+    Cpk::Order.stub(:param_delimiter, ",") do
+      Cpk::Book.stub(:param_delimiter, ";") do
+        assert_equal("1,123", Cpk::Order.new(id: [1, 123]).to_param)
+        assert_equal("1;123", Cpk::Book.new(id: [1, 123]).to_param)
+      end
+    end
+  end
+
   def test_cache_key_for_existing_record_is_not_timezone_dependent
     utc_key = Developer.first.cache_key
 
@@ -108,12 +128,12 @@ class IntegrationTest < ActiveRecord::TestCase
 
   def test_cache_key_format_for_existing_record_with_updated_at
     dev = Developer.first
-    assert_equal "developers/#{dev.id}-#{dev.updated_at.utc.to_s(:usec)}", dev.cache_key
+    assert_equal "developers/#{dev.id}-#{dev.updated_at.utc.to_fs(:usec)}", dev.cache_key
   end
 
   def test_cache_key_format_for_existing_record_with_updated_at_and_custom_cache_timestamp_format
     dev = CachedDeveloper.first
-    assert_equal "cached_developers/#{dev.id}-#{dev.updated_at.utc.to_s(:number)}", dev.cache_key
+    assert_equal "cached_developers/#{dev.id}-#{dev.updated_at.utc.to_fs(:number)}", dev.cache_key
   end
 
   def test_cache_key_changes_when_child_touched
@@ -138,23 +158,22 @@ class IntegrationTest < ActiveRecord::TestCase
   def test_cache_key_for_updated_on
     dev = Developer.first
     dev.updated_at = nil
-    assert_equal "developers/#{dev.id}-#{dev.updated_on.utc.to_s(:usec)}", dev.cache_key
+    assert_equal "developers/#{dev.id}-#{dev.updated_on.utc.to_fs(:usec)}", dev.cache_key
   end
 
   def test_cache_key_for_newer_updated_at
     dev = Developer.first
     dev.updated_at += 3600
-    assert_equal "developers/#{dev.id}-#{dev.updated_at.utc.to_s(:usec)}", dev.cache_key
+    assert_equal "developers/#{dev.id}-#{dev.updated_at.utc.to_fs(:usec)}", dev.cache_key
   end
 
   def test_cache_key_for_newer_updated_on
     dev = Developer.first
     dev.updated_on += 3600
-    assert_equal "developers/#{dev.id}-#{dev.updated_on.utc.to_s(:usec)}", dev.cache_key
+    assert_equal "developers/#{dev.id}-#{dev.updated_on.utc.to_fs(:usec)}", dev.cache_key
   end
 
   def test_cache_key_format_is_precise_enough
-    skip("Subsecond precision is not supported") unless supports_datetime_with_precision?
     dev = Developer.first
     key = dev.cache_key
     travel_to dev.updated_at + 0.000001 do
@@ -171,7 +190,6 @@ class IntegrationTest < ActiveRecord::TestCase
   end
 
   def test_cache_version_format_is_precise_enough
-    skip("Subsecond precision is not supported") unless supports_datetime_with_precision?
     with_cache_versioning do
       dev = Developer.first
       version = dev.cache_version.to_param

data/test/cases/invalid_connection_test.rb

@@ -2,17 +2,17 @@
 
 require "cases/helper"
 
-if current_adapter?(:Mysql2Adapter) or current_adapter?(:IBM_DBAdapter)
-  class TestAdapterWithInvalidConnection < ActiveRecord::TestCase
-    self.use_transactional_tests = false
+class TestAdapterWithInvalidConnection < ActiveRecord::TestCase
+  self.use_transactional_tests = false
 
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
     class Bird < ActiveRecord::Base
     end
 
     def setup
       # Can't just use current adapter; sqlite3 will create a database
       # file on the fly.
-      Bird.establish_connection adapter: "ibm_db", database: "i_do_not_exist"
+      Bird.establish_connection adapter: ARTest.connection_name, database: "i_do_not_exist", host: "127.0.0.1", port: 12, username: "invalid"
     end
 
     teardown do
@@ -20,7 +20,7 @@ if current_adapter?(:Mysql2Adapter) or current_adapter?(:IBM_DBAdapter)
     end
 
     test "inspect on Model class does not raise" do
-      assert_equal "#{Bird.name} (call '#{Bird.name}.connection' to establish a connection)", Bird.inspect
+      assert_equal "#{Bird.name} (call '#{Bird.name}.load_schema' to load schema informations)", Bird.inspect
     end
   end
 end

data/test/cases/invertible_migration_test.rb

@@ -19,6 +19,7 @@ module ActiveRecord
           t.column :content, :text
           t.column :remind_at, :datetime
           t.column :place_id, :integer
+          t.column :parent_id, :bigint
         end
       end
     end
@@ -96,7 +97,7 @@ module ActiveRecord
       def change
         change_table("horses") do |t|
           t.remove_index [:name, :color]
-          t.remove_index [:color], if_exists: true
+          t.remove_index [:color] if t.index_exists?(:color)
         end
       end
     end
@@ -149,7 +150,15 @@ module ActiveRecord
 
     class DisableExtension2 < SilentMigration
       def change
-        disable_extension "hstore"
+        disable_extension "hstore", force: :cascade
+      end
+    end
+
+    class DropTableMigration < SilentMigration
+      def change
+        drop_table("horses") do |t|
+          t.string :name
+        end
       end
     end
 
@@ -220,6 +229,24 @@ module ActiveRecord
       end
     end
 
+    class RevertUniqueConstraintWithInvalidOption < SilentMigration
+      def change
+        add_unique_constraint :horses, :place_id, invalid: :option
+      end
+    end
+
+    class RevertForeignKeyWithInvalidOption < SilentMigration
+      def change
+        add_foreign_key :horses, :horses, column: :parent_id, invalid: :option
+      end
+    end
+
+    class RevertCheckConstraintWithInvalidOption < SilentMigration
+      def change
+        add_check_constraint :horses, "place_id > 0", invalid: :option
+      end
+    end
+
     self.use_transactional_tests = false
 
     setup do
@@ -228,8 +255,8 @@ module ActiveRecord
 
     teardown do
       %w[horses new_horses].each do |table|
-        if ActiveRecord::Base.connection.table_exists?(table)
-          ActiveRecord::Base.connection.drop_table(table)
+        if ActiveRecord::Base.lease_connection.table_exists?(table)
+          ActiveRecord::Base.lease_connection.drop_table(table)
         end
       end
       ActiveRecord::Migration.verbose = @verbose_was
@@ -356,7 +383,7 @@ module ActiveRecord
       assert_equal "Sekitoba", Horse.new.name
     end
 
-    if ActiveRecord::Base.connection.supports_comments?
+    if ActiveRecord::Base.lease_connection.supports_comments?
       def test_migrate_revert_change_column_comment
         migration1 = ChangeColumnComment1.new
         migration1.migrate(:up)
@@ -374,7 +401,7 @@ module ActiveRecord
       end
 
       def test_migrate_revert_change_table_comment
-        connection = ActiveRecord::Base.connection
+        connection = ActiveRecord::Base.lease_connection
         migration1 = ChangeTableComment1.new
         migration1.migrate(:up)
         assert_equal "Sekitoba", connection.table_comment("horses")
@@ -390,32 +417,48 @@ module ActiveRecord
 
     if current_adapter?(:PostgreSQLAdapter)
       def test_migrate_enable_and_disable_extension
+        connection = Horse.lease_connection
         migration1 = InvertibleMigration.new
         migration2 = DisableExtension1.new
         migration3 = DisableExtension2.new
 
-        assert_equal true, Horse.connection.extension_available?("hstore")
+        assert_equal true, connection.extension_available?("hstore")
 
         migration1.migrate(:up)
         migration2.migrate(:up)
-        assert_equal true, Horse.connection.extension_enabled?("hstore")
+        assert_equal true, connection.extension_enabled?("hstore")
 
         migration3.migrate(:up)
-        assert_equal false, Horse.connection.extension_enabled?("hstore")
+        assert_equal false, connection.extension_enabled?("hstore")
 
         migration3.migrate(:down)
-        assert_equal true, Horse.connection.extension_enabled?("hstore")
+        assert_equal true, connection.extension_enabled?("hstore")
 
         migration2.migrate(:down)
-        assert_equal false, Horse.connection.extension_enabled?("hstore")
+        assert_equal false, connection.extension_enabled?("hstore")
       ensure
-        enable_extension!("hstore", ActiveRecord::Base.connection)
+        enable_extension!("hstore", ActiveRecord::Base.lease_connection)
       end
     end
 
+    def test_migrate_revert_drop_table
+      skip if current_adapter?(:IBM_DBAdapter) # Ruby 4.0: invert_drop_table pushes {} as positional arg; create_table(table_name, **options) rejects 2 positional args
+      connection = ActiveRecord::Base.lease_connection
+      migration1 = InvertibleMigration.new
+      migration1.migrate(:up)
+      assert connection.table_exists?("horses")
+
+      migration2 = DropTableMigration.new
+      migration2.migrate(:up)
+      assert_not connection.table_exists?("horses")
+
+      migration2.migrate(:down)
+      assert connection.table_exists?("horses")
+    end
+
     def test_revert_order
       block = Proc.new { |t| t.string :name }
-      recorder = ActiveRecord::Migration::CommandRecorder.new(ActiveRecord::Base.connection)
+      recorder = ActiveRecord::Migration::CommandRecorder.new(ActiveRecord::Base.lease_connection)
       recorder.instance_eval do
         create_table("apples", &block)
         revert do
@@ -439,24 +482,24 @@ module ActiveRecord
 
     def test_legacy_up
       LegacyMigration.migrate :up
-      assert ActiveRecord::Base.connection.table_exists?("horses"), "horses should exist"
+      assert ActiveRecord::Base.lease_connection.table_exists?("horses"), "horses should exist"
     end
 
     def test_legacy_down
       LegacyMigration.migrate :up
       LegacyMigration.migrate :down
-      assert_not ActiveRecord::Base.connection.table_exists?("horses"), "horses should not exist"
+      assert_not ActiveRecord::Base.lease_connection.table_exists?("horses"), "horses should not exist"
     end
 
     def test_up
       LegacyMigration.up
-      assert ActiveRecord::Base.connection.table_exists?("horses"), "horses should exist"
+      assert ActiveRecord::Base.lease_connection.table_exists?("horses"), "horses should exist"
     end
 
     def test_down
       LegacyMigration.up
       LegacyMigration.down
-      assert_not ActiveRecord::Base.connection.table_exists?("horses"), "horses should not exist"
+      assert_not ActiveRecord::Base.lease_connection.table_exists?("horses"), "horses should not exist"
     end
 
     def test_migrate_down_with_table_name_prefix
@@ -465,7 +508,7 @@ module ActiveRecord
       migration = InvertibleMigration.new
       migration.migrate(:up)
       assert_nothing_raised { migration.migrate(:down) }
-      assert_not ActiveRecord::Base.connection.table_exists?("p_horses_s"), "p_horses_s should not exist"
+      assert_not ActiveRecord::Base.lease_connection.table_exists?("p_horses_s"), "p_horses_s should not exist"
     ensure
       ActiveRecord::Base.table_name_prefix = ActiveRecord::Base.table_name_suffix = ""
     end
@@ -474,17 +517,20 @@ module ActiveRecord
       migration = RevertCustomForeignKeyTable.new
       InvertibleMigration.migrate(:up)
       migration.migrate(:up)
+      assert ActiveRecord::Base.lease_connection.column_exists?(:horses, :owner_id)
       migration.migrate(:down)
+      assert_not ActiveRecord::Base.lease_connection.column_exists?(:horses, :owner_id)
     end
 
     # MySQL 5.7 and Oracle do not allow to create duplicate indexes on the same columns
-    unless current_adapter?(:Mysql2Adapter, :OracleAdapter, :IBM_DBAdapter)
+    # IBM_DB/DB2 also raises SQL0605W when a duplicate matching index exists
+    unless current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :IBM_DBAdapter)
       def test_migrate_revert_add_index_with_name
         RevertNamedIndexMigration1.new.migrate(:up)
         RevertNamedIndexMigration2.new.migrate(:up)
         RevertNamedIndexMigration2.new.migrate(:down)
 
-        connection = ActiveRecord::Base.connection
+        connection = ActiveRecord::Base.lease_connection
         assert connection.index_exists?(:horses, :content),
                "index on content should exist"
         assert_not connection.index_exists?(:horses, :content, name: "horses_index_named"),
@@ -496,7 +542,7 @@ module ActiveRecord
       InvertibleMigration.new.migrate(:up)
       RevertNonNamedExpressionIndexMigration.new.migrate(:up)
 
-      connection = ActiveRecord::Base.connection
+      connection = ActiveRecord::Base.lease_connection
       assert connection.index_exists?(:horses, [:remind_at, :place_id]),
              "index on remind_at and place_id should exist"
 
@@ -515,13 +561,51 @@ module ActiveRecord
       horse1.reload
       horse2 = Horse.create
 
-      assert 1, horse1.oldie # created before migration
-      assert 0, horse2.oldie # created after migration
+      assert_equal 1, horse1.oldie # created before migration
+      assert_equal 0, horse2.oldie # created after migration
 
       UpOnlyMigration.new.migrate(:down) # should be no error
-      connection = ActiveRecord::Base.connection
+      connection = ActiveRecord::Base.lease_connection
       assert_not connection.column_exists?(:horses, :oldie)
       Horse.reset_column_information
     end
+
+    if ActiveRecord::Base.lease_connection.supports_unique_constraints?
+      def test_migrate_revert_add_unique_constraint_with_invalid_option
+        skip if current_adapter?(:IBM_DBAdapter) # DB2 SQL0542N: unique constraint columns must be NOT NULL
+        InvertibleMigration.new.migrate(:up)
+        RevertUniqueConstraintWithInvalidOption.new.migrate(:up)
+
+        connection = ActiveRecord::Base.lease_connection
+        assert_equal 1, connection.unique_constraints(:horses).count
+
+        RevertUniqueConstraintWithInvalidOption.new.migrate(:down)
+        assert_empty connection.unique_constraints(:horses)
+      end
+    end
+
+    def test_migrate_revert_add_foreign_key_with_invalid_option
+      InvertibleMigration.new.migrate(:up)
+      RevertForeignKeyWithInvalidOption.new.migrate(:up)
+
+      connection = ActiveRecord::Base.lease_connection
+      assert_equal 1, connection.foreign_keys(:horses).count
+
+      RevertForeignKeyWithInvalidOption.new.migrate(:down)
+      assert_empty connection.foreign_keys(:horses)
+    end
+
+    if ActiveRecord::Base.lease_connection.supports_check_constraints?
+      def test_migrate_revert_add_check_constraint_with_invalid_option
+        InvertibleMigration.new.migrate(:up)
+        RevertCheckConstraintWithInvalidOption.new.migrate(:up)
+
+        connection = ActiveRecord::Base.lease_connection
+        assert_equal 1, connection.check_constraints(:horses).count
+
+        RevertCheckConstraintWithInvalidOption.new.migrate(:down)
+        assert_empty connection.check_constraints(:horses)
+      end
+    end
   end
 end

data/test/cases/json_attribute_test.rb

@@ -18,6 +18,7 @@ class JsonAttributeTest < ActiveRecord::TestCase
 
   def setup
     super
+    @connection.drop_table("json_data_type", if_exists: true)
     @connection.create_table("json_data_type") do |t|
       t.string "payload"
       t.string "settings"