ibm_db 5.6.1 → 5.7.0

data/test/cases/migration/foreign_key_test.rb

@@ -3,12 +3,12 @@
 require "cases/helper"
 require "support/schema_dumping_helper"
 
-if ActiveRecord::Base.connection.supports_foreign_keys?
+if ActiveRecord::Base.lease_connection.supports_foreign_keys?
   module ActiveRecord
     class Migration
       class ForeignKeyInCreateTest < ActiveRecord::TestCase
         def test_foreign_keys
-          foreign_keys = ActiveRecord::Base.connection.foreign_keys("fk_test_has_fk")
+          foreign_keys = ActiveRecord::Base.lease_connection.foreign_keys("fk_test_has_fk")
           assert_equal 1, foreign_keys.size
 
           fk = foreign_keys.first
@@ -45,7 +45,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
         end
 
         def setup
-          @connection = ActiveRecord::Base.connection
+          @connection = ActiveRecord::Base.lease_connection
           @migration = CreateRocketsMigration.new
           silence_stream($stdout) { @migration.migrate(:up) }
           Rocket.reset_table_name
@@ -93,7 +93,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
         end
 
         def test_rename_reference_column_of_child_table
-          if current_adapter?(:Mysql2Adapter) && !@connection.send(:supports_rename_index?)
+          if current_adapter?(:Mysql2Adapter, :TrilogyAdapter) && !@connection.send(:supports_rename_index?)
             skip "Cannot drop index, needed in a foreign key constraint"
           end
 
@@ -177,14 +177,15 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
         end
 
         setup do
-          @connection = ActiveRecord::Base.connection
+          @connection = ActiveRecord::Base.lease_connection
           @connection.create_table "rockets", force: true do |t|
             t.string :name
           end
 
           @connection.create_table "astronauts", force: true do |t|
             t.string :name
-            t.references :rocket
+            t.references :rocket, type: :bigint
+            t.references :favorite_rocket
           end
         end
 
@@ -233,6 +234,16 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
           assert_equal "fk_rails_78146ddd2e", fk.name unless current_adapter?(:SQLite3Adapter)
         end
 
+        def test_add_foreign_key_with_if_not_exists_to_already_referenced_table
+          @connection.add_foreign_key :astronauts, :rockets
+          @connection.add_foreign_key :astronauts, :rockets, column: "favorite_rocket_id", if_not_exists: true
+
+          foreign_keys = @connection.foreign_keys("astronauts")
+          assert_equal 2, foreign_keys.size
+          assert foreign_keys.all? { |fk| fk.to_table == "rockets" }
+          assert_equal ["favorite_rocket_id", "rocket_id"], foreign_keys.map(&:column).sort
+        end
+
         def test_add_foreign_key_with_non_standard_primary_key
           @connection.create_table :space_shuttles, id: false, force: true do |t|
             t.bigint :pk, primary_key: true
@@ -260,7 +271,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
           assert_equal 1, foreign_keys.size
 
           fk = foreign_keys.first
-          if current_adapter?(:Mysql2Adapter)
+          if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
             # ON DELETE RESTRICT is the default on MySQL
             assert_nil fk.on_delete
           else
@@ -299,6 +310,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
         end
 
         def test_add_foreign_key_with_on_update
+          skip "DB2 does not support ON UPDATE SET NULL" if current_adapter?(:IBM_DBAdapter)
           @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_update: :nullify
 
           foreign_keys = @connection.foreign_keys("astronauts")
@@ -309,17 +321,19 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
         end
 
         def test_add_foreign_key_with_non_existent_from_table_raises
-          e = assert_raises ArgumentError do
+          skip "DB2 error messages differ from expected format" if current_adapter?(:IBM_DBAdapter)
+          e = assert_raises StatementInvalid do
             @connection.add_foreign_key :missions, :rockets
           end
-          assert_match(/missions/i, e.message)
+          assert_match(/missions/, e.message)
         end
 
         def test_add_foreign_key_with_non_existent_to_table_raises
-          e = assert_raises ArgumentError do
+          skip "DB2 error messages differ from expected format" if current_adapter?(:IBM_DBAdapter)
+          e = assert_raises StatementInvalid do
             @connection.add_foreign_key :missions, :rockets
           end
-          assert_match(/missions/i, e.message)
+          assert_match(/missions/, e.message)
         end
 
         def test_foreign_key_exists
@@ -329,6 +343,16 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
           assert_not @connection.foreign_key_exists?(:astronauts, :stars)
         end
 
+        def test_foreign_key_exists_referencing_table_having_keyword_as_name
+          @connection.create_table :user, force: true
+          @connection.add_column :rockets, :user_id, :bigint
+          @connection.add_foreign_key :rockets, :user
+          assert @connection.foreign_key_exists?(:rockets, :user)
+        ensure
+          @connection.remove_foreign_key :rockets, :user
+          @connection.drop_table :user
+        end
+
         def test_foreign_key_exists_by_column
           @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
 
@@ -359,6 +383,17 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
           end
         end
 
+        if supports_sql_standard_drop_constraint?
+          def test_remove_constraint
+            skip "DB2 SQL generation issue with DROP CONSTRAINT" if current_adapter?(:IBM_DBAdapter)
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk"
+
+            assert_equal 1, @connection.foreign_keys("astronauts").size
+            @connection.remove_constraint :astronauts, "fancy_named_fk"
+            assert_equal [], @connection.foreign_keys("astronauts")
+          end
+        end
+
         def test_remove_foreign_key_inferes_column
           @connection.add_foreign_key :astronauts, :rockets
 
@@ -412,7 +447,14 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
             @connection.foreign_keys("astronauts").map { |fk| [fk.from_table, fk.to_table, fk.column] }
         end
 
-        if ActiveRecord::Base.connection.supports_validate_constraints?
+        def test_remove_foreign_key_with_restrict_action
+          @connection.add_foreign_key :astronauts, :rockets, on_delete: :restrict
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+          @connection.remove_foreign_key :astronauts, :rockets, on_delete: :restrict
+          assert_empty @connection.foreign_keys("astronauts")
+        end
+
+        if ActiveRecord::Base.lease_connection.supports_validate_constraints?
           def test_add_invalid_foreign_key
             @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", validate: false
 
@@ -467,6 +509,22 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
             @connection.validate_constraint :astronauts, "fancy_named_fk"
             assert_predicate @connection.foreign_keys("astronauts").first, :validated?
           end
+
+          def test_schema_dumping_with_validate_false
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", validate: false
+
+            output = dump_table_schema "astronauts"
+
+            assert_match %r{\s+add_foreign_key "astronauts", "rockets", validate: false$}, output
+          end
+
+          def test_schema_dumping_with_validate_true
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", validate: true
+
+            output = dump_table_schema "astronauts"
+
+            assert_match %r{\s+add_foreign_key "astronauts", "rockets"$}, output
+          end
         else
           # Foreign key should still be created, but should not be invalid
           def test_add_invalid_foreign_key
@@ -480,6 +538,113 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
           end
         end
 
+        if ActiveRecord::Base.lease_connection.supports_deferrable_constraints?
+          def test_deferrable_foreign_key
+            assert_queries_match(/\("id"\)\s+DEFERRABLE INITIALLY IMMEDIATE\W*\z/i) do
+              @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: :immediate
+            end
+
+            foreign_keys = @connection.foreign_keys("astronauts")
+            assert_equal 1, foreign_keys.size
+
+            fk = foreign_keys.first
+            assert_equal :immediate, fk.deferrable
+          end
+
+          def test_not_deferrable_foreign_key
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: false
+
+            foreign_keys = @connection.foreign_keys("astronauts")
+            assert_equal 1, foreign_keys.size
+
+            fk = foreign_keys.first
+            assert_equal false, fk.deferrable
+          end
+
+          def test_deferrable_initially_deferred_foreign_key
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: :deferred
+
+            foreign_keys = @connection.foreign_keys("astronauts")
+            assert_equal 1, foreign_keys.size
+
+            fk = foreign_keys.first
+            assert_equal :deferred, fk.deferrable
+          end
+
+          def test_deferrable_initially_immediate_foreign_key
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: :immediate
+
+            foreign_keys = @connection.foreign_keys("astronauts")
+            assert_equal 1, foreign_keys.size
+
+            fk = foreign_keys.first
+            assert_equal :immediate, fk.deferrable
+          end
+
+          def test_schema_dumping_with_defferable
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: :immediate
+
+            output = dump_table_schema "astronauts"
+
+            assert_match %r{\s+add_foreign_key "astronauts", "rockets", deferrable: :immediate$}, output
+          end
+
+          def test_schema_dumping_with_disabled_defferable
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: false
+
+            output = dump_table_schema "astronauts"
+
+            assert_match %r{\s+add_foreign_key "astronauts", "rockets"$}, output
+          end
+
+          def test_schema_dumping_with_defferable_initially_deferred
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: :deferred
+
+            output = dump_table_schema "astronauts"
+
+            assert_match %r{\s+add_foreign_key "astronauts", "rockets", deferrable: :deferred$}, output
+          end
+
+          def test_schema_dumping_with_defferable_initially_immediate
+            @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", deferrable: :immediate
+
+            output = dump_table_schema "astronauts"
+
+            assert_match %r{\s+add_foreign_key "astronauts", "rockets", deferrable: :immediate$}, output
+          end
+
+          def test_schema_dumping_with_special_chars_deferrable
+            @connection.add_reference :astronauts, :røcket, foreign_key: { to_table: :rockets, deferrable: :deferred }
+
+            output = dump_table_schema "astronauts"
+
+            assert_match %r{\s+add_foreign_key "astronauts", "rockets", column: "røcket_id", deferrable: :deferred$}, output
+          end
+        end
+
+        def test_does_not_create_foreign_keys_when_bypassed_by_config
+          skip "Test requires SQLite3Adapter" if current_adapter?(:IBM_DBAdapter)
+          require "active_record/connection_adapters/sqlite3_adapter"
+          connection = ActiveRecord::ConnectionAdapters::SQLite3Adapter.new(
+            adapter: "sqlite3",
+            database: ":memory:",
+            foreign_keys: false,
+          )
+
+          connection.create_table "rockets", force: true do |t|
+            t.string :name
+          end
+          connection.create_table "astronauts", force: true do |t|
+            t.string :name
+            t.references :rocket
+          end
+
+          connection.add_foreign_key :astronauts, :rockets
+
+          foreign_keys = connection.foreign_keys("astronauts")
+          assert_equal 0, foreign_keys.size
+        end
+
         def test_schema_dumping
           @connection.add_foreign_key :astronauts, :rockets
           output = dump_table_schema "astronauts"
@@ -507,6 +672,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
         end
 
         def test_schema_dumping_on_delete_and_on_update_options
+          skip "DB2 does not support ON UPDATE CASCADE" if current_adapter?(:IBM_DBAdapter)
           @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :nullify, on_update: :cascade
 
           output = dump_table_schema "astronauts"
@@ -529,20 +695,30 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
         end
 
         def test_add_foreign_key_is_reversible
+          @connection.drop_table("cities", if_exists: true)
+          @connection.drop_table("houses", if_exists: true)
+
           migration = CreateCitiesAndHousesMigration.new
           silence_stream($stdout) { migration.migrate(:up) }
           assert_equal 1, @connection.foreign_keys("houses").size
-        ensure
           silence_stream($stdout) { migration.migrate(:down) }
+        ensure
+          @connection.drop_table("cities", if_exists: true)
+          @connection.drop_table("houses", if_exists: true)
         end
 
         def test_foreign_key_constraint_is_not_cached_incorrectly
+          @connection.drop_table("cities", if_exists: true)
+          @connection.drop_table("houses", if_exists: true)
+
           migration = CreateCitiesAndHousesMigration.new
           silence_stream($stdout) { migration.migrate(:up) }
           output = dump_table_schema "houses"
           assert_match %r{\s+add_foreign_key "houses",.+on_delete: :cascade$}, output
-        ensure
           silence_stream($stdout) { migration.migrate(:down) }
+        ensure
+          @connection.drop_table("cities", if_exists: true)
+          @connection.drop_table("houses", if_exists: true)
         end
 
         class CreateSchoolsAndClassesMigration < ActiveRecord::Migration::Current
@@ -575,6 +751,172 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
           silence_stream($stdout) { migration.migrate(:down) }
           ActiveRecord::Base.table_name_suffix = nil
         end
+
+        def test_remove_foreign_key_with_if_exists_not_set
+          @connection.add_foreign_key :astronauts, :rockets
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+
+          @connection.remove_foreign_key :astronauts, :rockets
+          assert_equal [], @connection.foreign_keys("astronauts")
+
+          error = assert_raises do
+            @connection.remove_foreign_key :astronauts, :rockets
+          end
+
+          assert_equal("Table 'astronauts' has no foreign key for rockets", error.message)
+        end
+
+        def test_remove_foreign_key_with_if_exists_set
+          @connection.add_foreign_key :astronauts, :rockets
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+
+          @connection.remove_foreign_key :astronauts, :rockets, if_exists: true
+          assert_equal [], @connection.foreign_keys("astronauts")
+
+          assert_nothing_raised do
+            @connection.remove_foreign_key :astronauts, :rockets, if_exists: true
+          end
+        end
+
+        def test_add_foreign_key_with_if_not_exists_not_set
+          @connection.add_foreign_key :astronauts, :rockets
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+
+          if current_adapter?(:SQLite3Adapter)
+            assert_nothing_raised do
+              @connection.add_foreign_key :astronauts, :rockets
+            end
+          elsif current_adapter?(:IBM_DBAdapter)
+            skip "DB2 error message format differs from PostgreSQL"
+          else
+            error = assert_raises do
+              @connection.add_foreign_key :astronauts, :rockets
+            end
+
+            if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+              if ActiveRecord::Base.lease_connection.mariadb?
+                assert_match(/Duplicate key on write or update/, error.message)
+              elsif ActiveRecord::Base.lease_connection.database_version < "8.0"
+                assert_match(/Can't write; duplicate key in table/, error.message)
+              else
+                assert_match(/Duplicate foreign key constraint name/, error.message)
+              end
+            else
+              assert_match(/PG::DuplicateObject: ERROR:.*for relation "astronauts" already exists/, error.message)
+            end
+
+          end
+        end
+
+        def test_add_foreign_key_with_if_not_exists_set
+          @connection.add_foreign_key :astronauts, :rockets
+          assert_equal 1, @connection.foreign_keys("astronauts").size
+
+          assert_nothing_raised do
+            @connection.add_foreign_key :astronauts, :rockets, if_not_exists: true
+          end
+        end
+
+        def test_add_foreign_key_preserves_existing_column_types
+          assert_no_changes -> { column_for(:astronauts, :rocket_id).bigint? }, from: true do
+            @connection.add_foreign_key :astronauts, :rockets
+          end
+        end
+
+        private
+          def column_for(table_name, column_name)
+            @connection.columns(table_name).find { |column| column.name == column_name.to_s }
+          end
+      end
+
+      class CompositeForeignKeyTest < ActiveRecord::TestCase
+        include SchemaDumpingHelper
+
+        setup do
+          @connection = ActiveRecord::Base.lease_connection
+          @connection.create_table :rockets, primary_key: [:tenant_id, :id], force: true do |t|
+            t.integer :tenant_id
+            t.integer :id
+          end
+          @connection.create_table :astronauts, force: true do |t|
+            t.integer :rocket_id
+            t.integer :rocket_tenant_id
+          end
+        end
+
+        teardown do
+          @connection.drop_table :astronauts, if_exists: true rescue nil
+          @connection.drop_table :rockets, if_exists: true rescue nil
+        end
+
+        def test_add_composite_foreign_key_raises_without_options
+          error = assert_raises(ActiveRecord::StatementInvalid) do
+            @connection.add_foreign_key :astronauts, :rockets
+          end
+
+          if current_adapter?(:PostgreSQLAdapter)
+            assert_match(/there is no unique constraint matching given keys for referenced table "rockets"/, error.message)
+          elsif current_adapter?(:SQLite3Adapter)
+            assert_match(/foreign key mismatch - "astronauts" referencing "rockets"/, error.message)
+          else
+            # MariaDB and different versions of MySQL generate different error messages.
+            [
+              /Foreign key constraint is incorrectly formed/i,
+              /Failed to add the foreign key constraint/i,
+              /Cannot add foreign key constraint/i
+            ].any? { |message| error.message.match?(message) }
+          end
+        end
+
+        def test_add_composite_foreign_key_infers_column
+          @connection.add_foreign_key :astronauts, :rockets, primary_key: [:tenant_id, :id]
+
+          foreign_keys = @connection.foreign_keys(:astronauts)
+          assert_equal 1, foreign_keys.size
+
+          fk = foreign_keys.first
+          assert_equal ["rocket_tenant_id", "rocket_id"], fk.column
+        end
+
+        def test_add_composite_foreign_key_raises_if_column_and_primary_key_sizes_mismatch
+          assert_raises(ArgumentError, match: ":column must reference all the :primary_key columns") do
+            @connection.add_foreign_key :astronauts, :rockets, column: :rocket_id, primary_key: [:tenant_id, :id]
+          end
+        end
+
+        def test_foreign_key_exists
+          @connection.add_foreign_key :astronauts, :rockets, primary_key: [:tenant_id, :id]
+
+          assert @connection.foreign_key_exists?(:astronauts, :rockets)
+          assert_not @connection.foreign_key_exists?(:astronauts, :stars)
+        end
+
+        def test_foreign_key_exists_by_options
+          @connection.add_foreign_key :astronauts, :rockets, primary_key: [:tenant_id, :id]
+
+          assert @connection.foreign_key_exists?(:astronauts, :rockets, primary_key: [:tenant_id, :id])
+          assert @connection.foreign_key_exists?(:astronauts, :rockets, column: [:rocket_tenant_id, :rocket_id], primary_key: [:tenant_id, :id])
+
+          assert_not @connection.foreign_key_exists?(:astronauts, :rockets, primary_key: [:id, :tenant_id])
+          assert_not @connection.foreign_key_exists?(:astronauts, :rockets, primary_key: :id)
+          assert_not @connection.foreign_key_exists?(:astronauts, :rockets, column: :rocket_id)
+        end
+
+        def test_remove_foreign_key
+          @connection.add_foreign_key :astronauts, :rockets, primary_key: [:tenant_id, :id]
+          assert_equal 1, @connection.foreign_keys(:astronauts).size
+
+          @connection.remove_foreign_key :astronauts, :rockets
+          assert_empty @connection.foreign_keys(:astronauts)
+        end
+
+        def test_schema_dumping
+          @connection.add_foreign_key :astronauts, :rockets, primary_key: [:tenant_id, :id]
+
+          output = dump_table_schema "astronauts"
+
+          assert_match %r{\s+add_foreign_key "astronauts", "rockets", column: \["rocket_tenant_id", "rocket_id"\], primary_key: \["tenant_id", "id"\]$}, output
+        end
       end
     end
   end

data/test/cases/migration/helper.rb

@@ -18,7 +18,10 @@ module ActiveRecord
 
       def setup
         super
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
+        connection.drop_table :testings, if_exists: true rescue nil
+        connection.drop_table :testing, if_exists: true rescue nil
+        connection.drop_table :test_models, if_exists: true rescue nil
         connection.create_table :test_models do |t|
           t.timestamps null: true
         end

data/test/cases/migration/index_test.rb

@@ -9,7 +9,7 @@ module ActiveRecord
 
       def setup
         super
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
         @table_name = :testings
 
         connection.create_table table_name do |t|
@@ -103,6 +103,11 @@ module ActiveRecord
         assert connection.index_name_exists?(table_name, "index_testings_on_foo_and_bar")
       end
 
+      def test_add_index_fallback_to_short_name
+        connection.add_index(table_name, [:foo, :bar, :first_name, :last_name, :administrator])
+        assert connection.index_name_exists?(table_name, "idx_on_foo_bar_first_name_last_name_administrator_5939248142")
+      end
+
       def test_remove_index_which_does_not_exist_doesnt_raise_with_option
         connection.add_index(table_name, "foo")
 
@@ -127,6 +132,19 @@ module ActiveRecord
         assert_not connection.index_exists?(table_name, :foo, name: "foo")
       end
 
+      def test_remove_index_with_column_array_which_does_not_exist_doesnt_raise_with_option
+        connection.add_index(table_name, [:foo], name: "foo")
+
+        assert connection.index_exists?(table_name, :foo, name: "foo")
+
+        assert_nothing_raised do
+          connection.remove_index(table_name, column: [:foo, :bar], if_exists: true)
+        end
+
+        assert connection.index_exists?(table_name, :foo, name: "foo")
+        assert_not connection.index_exists?(table_name, nil, column: [:foo, :bar], name: "foo")
+      end
+
       def test_internal_index_with_name_matching_database_limit
         good_index_name = "x" * connection.index_name_length
         connection.add_index(table_name, "foo", name: good_index_name, internal: true)
@@ -159,6 +177,7 @@ module ActiveRecord
       def test_index_exists_with_custom_name_checks_columns
         connection.add_index :testings, [:foo, :bar], name: "my_index"
         assert connection.index_exists?(:testings, [:foo, :bar], name: "my_index")
+        assert connection.index_exists?(:testings, [], name: "my_index")
         assert_not connection.index_exists?(:testings, [:foo], name: "my_index")
       end
 
@@ -201,7 +220,9 @@ module ActiveRecord
 
       def test_add_index
         connection.add_index("testings", "last_name")
+        assert connection.index_exists?("testings", "last_name")
         connection.remove_index("testings", "last_name")
+        assert_not connection.index_exists?("testings", "last_name")
 
         connection.add_index("testings", ["last_name", "first_name"])
         connection.remove_index("testings", column: ["last_name", "first_name"])
@@ -236,7 +257,7 @@ module ActiveRecord
         connection.remove_index("testings", name: "named_admin")
 
         # Selected adapters support index sort order
-        if current_adapter?(:SQLite3Adapter, :Mysql2Adapter, :PostgreSQLAdapter)
+        if current_adapter?(:SQLite3Adapter, :Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
           connection.add_index("testings", ["last_name"], order: { last_name: :desc })
           connection.remove_index("testings", ["last_name"])
           connection.add_index("testings", ["last_name", "first_name"], order: { last_name: :desc })
@@ -256,6 +277,50 @@ module ActiveRecord
           connection.remove_index("testings", "last_name")
           assert_not connection.index_exists?("testings", "last_name")
         end
+
+        def test_add_index_with_included_column
+          skip("current adapter doesn't support include indexes") unless supports_index_include?
+
+          connection.add_index("testings", "last_name", include: :foo)
+          assert connection.index_exists?("testings", "last_name", include: :foo)
+
+          connection.remove_index("testings", "last_name")
+          assert_not connection.index_exists?("testings", "last_name")
+        end
+
+        def test_add_index_with_multiple_included_columns
+          skip("current adapter doesn't support include indexes") unless supports_index_include?
+
+          connection.add_index("testings", "last_name", include: [:foo, :bar])
+          assert connection.index_exists?("testings", "last_name", include: [:foo, :bar])
+
+          connection.remove_index("testings", "last_name")
+          assert_not connection.index_exists?("testings", "last_name")
+        end
+
+        def test_add_index_with_included_column_and_where_clause
+          skip("current adapter doesn't support include indexes") unless supports_index_include?
+
+          connection.add_index("testings", "last_name", include: :foo, where: "first_name = 'john doe'")
+          assert connection.index_exists?("testings", "last_name", include: :foo, where: "first_name = 'john doe'")
+
+          connection.remove_index("testings", "last_name")
+          assert_not connection.index_exists?("testings", "last_name", include: :foo, where: "first_name = 'john doe'")
+        end
+
+        def test_add_index_with_nulls_not_distinct_assert_exists_with_same_values
+          skip("current adapter doesn't support nulls not distinct") unless supports_nulls_not_distinct?
+
+          connection.add_index("testings", "last_name", nulls_not_distinct: true)
+          assert connection.index_exists?("testings", "last_name", nulls_not_distinct: true)
+        end
+
+        def test_add_index_with_nulls_not_distinct_assert_exists_with_different_values
+          skip("current adapter doesn't support nulls not distinct") unless supports_nulls_not_distinct?
+
+          connection.add_index("testings", "last_name", nulls_not_distinct: false)
+          assert_not connection.index_exists?("testings", "last_name", nulls_not_distinct: true)
+        end
       end
 
       private