ibm_db 5.6.1 → 5.7.0

data/test/cases/migration/invalid_options_test.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "cases/migration/helper"
+
+module ActiveRecord
+  class Migration
+    class InvalidOptionsTest < ActiveRecord::TestCase
+      include ActiveRecord::Migration::TestHelper
+
+      def invalid_add_column_option_exception_message(key)
+        default_keys = [":limit", ":precision", ":scale", ":default", ":null", ":collation", ":comment", ":primary_key", ":if_exists", ":if_not_exists"]
+
+        if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+          default_keys.concat([":auto_increment", ":charset", ":as", ":size", ":unsigned", ":first", ":after", ":type", ":stored"])
+        elsif current_adapter?(:PostgreSQLAdapter)
+          default_keys.concat([":array", ":using", ":cast_as", ":as", ":type", ":enum_type", ":stored"])
+        elsif current_adapter?(:SQLite3Adapter)
+          default_keys.concat([":as", ":type", ":stored"])
+        end
+
+        "Unknown key: :#{key}. Valid keys are: #{default_keys.join(", ")}"
+      end
+
+      def invalid_add_index_option_exception_message(key)
+        "Unknown key: :#{key}. Valid keys are: :unique, :length, :order, :opclass, :where, :type, :using, :comment, :algorithm, :include, :nulls_not_distinct"
+      end
+
+      def invalid_create_table_option_exception_message(key)
+        table_keys = [":temporary", ":if_not_exists", ":options", ":as", ":comment", ":charset", ":collation"]
+        primary_keys = [":limit", ":default", ":precision"]
+
+        if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+          primary_keys.concat([":unsigned", ":auto_increment"])
+        elsif current_adapter?(:SQLite3Adapter)
+          table_keys.concat([":rename"])
+        end
+
+        "Unknown key: :#{key}. Valid keys are: #{(table_keys + primary_keys).join(", ")}"
+      end
+
+      def test_add_reference_with_invalid_options
+        skip "DB2 includes :auto_increment in the valid option list, so this shared error message assertion is not portable" if current_adapter?(:IBM_DBAdapter)
+        exception = assert_raises(ArgumentError) do
+          connection.create_table "my_table", force: true do |t|
+            t.references :some_table, boring_key: true
+          end
+        end
+
+        assert_equal(
+          invalid_add_column_option_exception_message(:boring_key),
+          exception.message
+        )
+
+        exception = assert_raises(ArgumentError) do
+          add_reference :some_table, :some_column, boring_key: true
+        end
+
+        assert_equal(
+          invalid_add_column_option_exception_message(:boring_key),
+          exception.message
+        )
+      ensure
+        connection.drop_table :my_table, if_exists: true
+      end
+
+      def test_add_column_with_invalid_options
+        skip "DB2 includes :auto_increment in the valid option list, so this shared error message assertion is not portable" if current_adapter?(:IBM_DBAdapter)
+        exception = assert_raises(ArgumentError) do
+          add_column "test_models", "first_name", :string, preccision: true
+        end
+
+        assert_equal(
+          invalid_add_column_option_exception_message(:preccision),
+          exception.message
+        )
+
+        exception = assert_raises(ArgumentError) do
+          connection.create_table "my_table", force: true do |t|
+            t.string :first_name, index: { nema: "test" }
+          end
+        end
+
+        assert_equal(
+          invalid_add_index_option_exception_message(:nema),
+          exception.message
+        )
+      ensure
+        connection.drop_table :my_table, if_exists: true
+      end
+
+      def test_add_index_with_invalid_options
+        exception = assert_raises(ArgumentError) do
+          add_index "test_models", "first_name", nema: "my_index"
+        end
+
+        assert_equal(
+          invalid_add_index_option_exception_message(:nema),
+          exception.message
+        )
+      end
+
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
+        def test_change_column_with_invalid_options
+          exception = assert_raises(ArgumentError) do
+            change_column "posts", "title", :text, liimit: true
+          end
+
+          assert_equal(
+            invalid_add_column_option_exception_message(:liimit),
+            exception.message
+          )
+        end
+      end
+
+      def test_create_table_with_invalid_options
+        skip "DB2 includes :auto_increment in the valid option list, so this shared error message assertion is not portable" if current_adapter?(:IBM_DBAdapter)
+        exception = assert_raises(ArgumentError) do
+          connection.create_table "my_table", idd: false do |t|
+          end
+        end
+
+        assert_equal(
+          invalid_create_table_option_exception_message(:idd),
+          exception.message
+        )
+      end
+    end
+  end
+end

data/test/cases/migration/logger_test.rb

@@ -17,20 +17,23 @@ module ActiveRecord
 
       def setup
         super
-        @schema_migration = ActiveRecord::Base.connection.schema_migration
+        @schema_migration = ActiveRecord::Base.connection_pool.schema_migration
         @schema_migration.create_table
-        @schema_migration.delete_all
+        @schema_migration.delete_all_versions
+        @internal_metadata = ActiveRecord::Base.connection_pool.internal_metadata
       end
 
       teardown do
-        @schema_migration.drop_table
+        @schema_migration&.delete_all_versions
       end
 
       def test_migration_should_be_run_without_logger
         previous_logger = ActiveRecord::Base.logger
         ActiveRecord::Base.logger = nil
         migrations = [Migration.new("a", 1), Migration.new("b", 2), Migration.new("c", 3)]
-        ActiveRecord::Migrator.new(:up, migrations, @schema_migration).migrate
+        assert_nothing_raised do
+          ActiveRecord::Migrator.new(:up, migrations, @schema_migration, @internal_metadata).migrate
+        end
       ensure
         ActiveRecord::Base.logger = previous_logger
       end

data/test/cases/migration/pending_migrations_test.rb

@@ -1,41 +1,39 @@
 # frozen_string_literal: true
 
 require "cases/helper"
+require "active_support/core_ext/hash/deep_merge"
 
 module ActiveRecord
   class Migration
-    if current_adapter?(:SQLite3Adapter) && !in_memory_db?
-      class PendingMigrationsTest < ActiveRecord::TestCase
-        setup do
-          @migration_dir = Dir.mktmpdir("activerecord-migrations-")
-
-          file = ActiveRecord::Base.connection.raw_connection.filename
-          @conn = ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:", migrations_paths: @migration_dir
-          source_db = SQLite3::Database.new file
-          dest_db = ActiveRecord::Base.connection.raw_connection
-          backup = SQLite3::Backup.new(dest_db, "main", source_db, "main")
-          backup.step(-1)
-          backup.finish
+    class PendingMigrationsTest < ActiveRecord::TestCase
+      if current_adapter?(:SQLite3Adapter) && !in_memory_db?
+        self.use_transactional_tests = false
 
-          ActiveRecord::Base.connection.drop_table "schema_migrations", if_exists: true
+        setup do
+          @tmp_dir = Dir.mktmpdir("pending_migrations_test-")
 
-          @app = Minitest::Mock.new
+          @original_configurations = ActiveRecord::Base.configurations
+          ActiveRecord::Base.configurations = base_config
+          ActiveRecord::Base.establish_connection(:primary)
         end
 
         teardown do
-          @conn.release_connection if @conn
-          ActiveRecord::Base.establish_connection :arunit
-          FileUtils.rm_rf(@migration_dir)
+          ActiveRecord::Base.configurations = @original_configurations
+          ActiveRecord::Base.establish_connection(:arunit)
+          FileUtils.rm_rf(@tmp_dir)
         end
 
         def run_migrations
-          migrator = Base.connection.migration_context
+          migrator = Base.connection_pool.migration_context
           capture(:stdout) { migrator.migrate }
         end
 
-        def create_migration(number, name)
+        def create_migration(number, name, database: :primary)
+          migration_dir = migrations_path_for(database)
+          FileUtils.mkdir_p(migration_dir)
+
           filename = "#{number}_#{name.underscore}.rb"
-          File.write(File.join(@migration_dir, filename), <<~RUBY)
+          File.write(File.join(migration_dir, filename), <<~RUBY)
             class #{name.classify} < ActiveRecord::Migration::Current
             end
           RUBY
@@ -43,63 +41,108 @@ module ActiveRecord
 
         def test_errors_if_pending
           create_migration "01", "create_foo"
-
-          assert_raises ActiveRecord::PendingMigrationError do
-            CheckPending.new(@app).call({})
-          end
-
-          # Continues failing
-          assert_raises ActiveRecord::PendingMigrationError do
-            CheckPending.new(@app).call({})
-          end
+          assert_pending_migrations("01_create_foo.rb")
         end
 
         def test_checks_if_supported
           run_migrations
-
-          check_pending = CheckPending.new(@app)
-
-          @app.expect :call, nil, [{}]
-          check_pending.call({})
-          @app.verify
-
-          # With cached result
-          @app.expect :call, nil, [{}]
-          check_pending.call({})
-          @app.verify
+          assert_no_pending_migrations
         end
 
         def test_okay_with_no_migrations
-          check_pending = CheckPending.new(@app)
-
-          @app.expect :call, nil, [{}]
-          check_pending.call({})
-          @app.verify
-
-          # With cached result
-          @app.expect :call, nil, [{}]
-          check_pending.call({})
-          @app.verify
+          assert_no_pending_migrations
         end
 
         # Regression test for https://github.com/rails/rails/pull/29759
         def test_understands_migrations_created_out_of_order
           # With a prior file before even initialization
           create_migration "05", "create_bar"
-          run_migrations
-
-          check_pending = CheckPending.new(@app)
-
-          @app.expect :call, nil, [{}]
-          check_pending.call({})
-          @app.verify
+          quietly { run_migrations }
+          assert_no_pending_migrations
 
           # It understands the new migration created at 01
           create_migration "01", "create_foo"
-          assert_raises ActiveRecord::PendingMigrationError do
-            check_pending.call({})
-          end
+          assert_pending_migrations("01_create_foo.rb")
+        end
+
+        def test_with_multiple_database
+          create_migration "01", "create_bar", database: :primary
+          create_migration "02", "create_foo", database: :secondary
+          assert_pending_migrations("01_create_bar.rb", "02_create_foo.rb")
+
+          ActiveRecord::Base.establish_connection(:secondary)
+          quietly { run_migrations }
+
+          ActiveRecord::Base.establish_connection(:primary)
+          quietly { run_migrations }
+
+          assert_no_pending_migrations
+        end
+
+        def test_with_stdlib_logger
+          old, ActiveRecord::Base.logger = ActiveRecord::Base.logger, ::Logger.new(StringIO.new)
+          assert_nothing_raised { CheckPending.new(proc { }).call({}) }
+        ensure
+          ActiveRecord::Base.logger = old
         end
+
+        private
+          def assert_pending_migrations(*expected_migrations)
+            2.times do
+              assert_raises ActiveRecord::PendingMigrationError do
+                ActiveRecord::Migration.check_all_pending!
+              end
+
+              error = assert_raises ActiveRecord::PendingMigrationError do
+                CheckPending.new(proc { flunk }).call({})
+              end
+
+              assert_includes error.message, "Migrations are pending."
+              expected_migrations.each do |migration|
+                assert_includes error.message, migration
+              end
+            end
+          end
+
+          def assert_no_pending_migrations
+            app = Minitest::Mock.new
+            check_pending = CheckPending.new(app)
+
+            2.times do
+              assert_nothing_raised do
+                ActiveRecord::Migration.check_all_pending!
+              end
+
+              app.expect :call, nil, [{}]
+              check_pending.call({})
+              app.verify
+            end
+          end
+
+          def database_path_for(database_name)
+            File.join(@tmp_dir, "#{database_name}.sqlite3")
+          end
+
+          def migrations_path_for(database_name)
+            File.join(@tmp_dir, "#{database_name}-migrations")
+          end
+
+          def base_config(additional_config = {})
+            {
+              ActiveRecord::ConnectionHandling::DEFAULT_ENV.call => {
+                primary: {
+                  adapter: "sqlite3",
+                  database: database_path_for(:primary),
+                  migrations_paths: migrations_path_for(:primary),
+                },
+                secondary: {
+                  adapter: "sqlite3",
+                  database: database_path_for(:secondary),
+                  migrations_paths: migrations_path_for(:secondary),
+                },
+              }.deep_merge(additional_config)
+            }
+          end
       end
     end
   end

data/test/cases/migration/references_foreign_key_test.rb

@@ -2,12 +2,14 @@
 
 require "cases/helper"
 
-if ActiveRecord::Base.connection.supports_foreign_keys?
+if ActiveRecord::Base.lease_connection.supports_foreign_keys?
   module ActiveRecord
     class Migration
       class ReferencesForeignKeyInCreateTest < ActiveRecord::TestCase
         setup do
-          @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.create_table(:testing_parents, force: true)
         end
 
@@ -35,7 +37,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
         end
 
         test "foreign keys can be created in one query when index is not added" do
-          assert_queries(1) do
+          assert_queries_count(1) do
             @connection.create_table :testings do |t|
               t.references :testing_parent, foreign_key: true, index: false
             end
@@ -43,6 +45,9 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
         end
 
         test "options hash can be passed" do
+          assert current_adapter?(:IBM_DBAdapter)
+          skip "DB2 requires a unique constraint, not just a unique index, for referenced parent keys" if current_adapter?(:IBM_DBAdapter)
+
           @connection.change_table :testing_parents do |t|
             t.references :other, index: { unique: true }
           end
@@ -62,6 +67,48 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
           assert_equal([["testings", "testing_parents", "parent_id"]],
                        fks.map { |fk| [fk.from_table, fk.to_table, fk.column] })
         end
+
+        if ActiveRecord::Base.lease_connection.supports_deferrable_constraints?
+          test "deferrable: false option can be passed" do
+            @connection.create_table :testings do |t|
+              t.references :testing_parent, foreign_key: { deferrable: false }
+            end
+
+            fks = @connection.foreign_keys("testings")
+            assert_equal([["testings", "testing_parents", "testing_parent_id", false]],
+                         fks.map { |fk| [fk.from_table, fk.to_table, fk.column, fk.deferrable] })
+          end
+
+          test "deferrable: :immediate option can be passed" do
+            @connection.create_table :testings do |t|
+              t.references :testing_parent, foreign_key: { deferrable: :immediate }
+            end
+
+            fks = @connection.foreign_keys("testings")
+            assert_equal([["testings", "testing_parents", "testing_parent_id", :immediate]],
+                         fks.map { |fk| [fk.from_table, fk.to_table, fk.column, fk.deferrable] })
+          end
+
+          test "deferrable: :deferred option can be passed" do
+            @connection.create_table :testings do |t|
+              t.references :testing_parent, foreign_key: { deferrable: :deferred }
+            end
+
+            fks = @connection.foreign_keys("testings")
+            assert_equal([["testings", "testing_parents", "testing_parent_id", :deferred]],
+                         fks.map { |fk| [fk.from_table, fk.to_table, fk.column, fk.deferrable] })
+          end
+
+          test "deferrable and on_(delete|update) option can be passed" do
+            @connection.create_table :testings do |t|
+              t.references :testing_parent, foreign_key: { on_update: :cascade, on_delete: :cascade, deferrable: :immediate }
+            end
+
+            fks = @connection.foreign_keys("testings")
+            assert_equal([["testings", "testing_parents", "testing_parent_id", :cascade, :cascade, :immediate]],
+                         fks.map { |fk| [fk.from_table, fk.to_table, fk.column, fk.on_delete, fk.on_update, fk.deferrable] })
+          end
+        end
       end
     end
   end
@@ -70,7 +117,9 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
     class Migration
       class ReferencesForeignKeyTest < ActiveRecord::TestCase
         setup do
-          @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.create_table(:testing_parents, force: true)
         end
 
@@ -108,6 +157,8 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
         end
 
         test "foreign keys accept options when changing the table" do
+          skip "DB2 requires a unique constraint, not just a unique index, for referenced parent keys" if current_adapter?(:IBM_DBAdapter)
+
           @connection.change_table :testing_parents do |t|
             t.references :other, index: { unique: true }
           end
@@ -169,6 +220,24 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
           @connection.drop_table "testing", if_exists: true
         end
 
+        test "remove_reference responds to if_exists option" do
+          @connection.create_table :testings
+
+          assert_nothing_raised do
+            @connection.remove_reference :testings, :nonexistent, foreign_key: true, if_exists: true
+          end
+        end
+
+        test "add_reference responds to if_not_exists option" do
+          @connection.create_table :testings do |t|
+            t.references :testing, foreign_key: true
+          end
+
+          assert_nothing_raised do
+            @connection.add_reference :testings, :testing, foreign_key: true, if_not_exists: true
+          end
+        end
+
         class CreateDogsMigration < ActiveRecord::Migration::Current
           def change
             create_table :dog_owners

data/test/cases/migration/references_index_test.rb

@@ -9,8 +9,10 @@ module ActiveRecord
 
       def setup
         super
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
         @table_name = :testings
+        connection.drop_table :testings, if_exists: true rescue nil
+        connection.drop_table :testing, if_exists: true rescue nil
       end
 
       teardown do
@@ -51,22 +53,20 @@ module ActiveRecord
         assert connection.index_exists?(table_name, :bar_id, name: :index_testings_on_bar_id, unique: true)
       end
 
-      unless current_adapter? :OracleAdapter
-        def test_creates_polymorphic_index
-          connection.create_table table_name do |t|
-            t.references :foo, polymorphic: true, index: true
-          end
-
-          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo)
+      def test_creates_polymorphic_index
+        connection.create_table table_name do |t|
+          t.references :foo, polymorphic: true, index: true
         end
 
-        def test_creates_polymorphic_index_with_custom_name
-          connection.create_table table_name do |t|
-            t.references :foo, polymorphic: true, index: { name: :testings_foo_index }
-          end
+        assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo)
+      end
 
-          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :testings_foo_index)
+      def test_creates_polymorphic_index_with_custom_name
+        connection.create_table table_name do |t|
+          t.references :foo, polymorphic: true, index: { name: :testings_foo_index }
         end
+
+        assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :testings_foo_index)
       end
 
       def test_creates_index_for_existing_table
@@ -96,24 +96,22 @@ module ActiveRecord
         assert_not connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
       end
 
-      unless current_adapter? :OracleAdapter
-        def test_creates_polymorphic_index_for_existing_table
-          connection.create_table table_name
-          connection.change_table table_name do |t|
-            t.references :foo, polymorphic: true, index: true
-          end
-
-          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo)
+      def test_creates_polymorphic_index_for_existing_table
+        connection.create_table table_name
+        connection.change_table table_name do |t|
+          t.references :foo, polymorphic: true, index: true
         end
 
-        def test_creates_polymorphic_index_for_existing_table_with_custom_name
-          connection.create_table table_name
-          connection.change_table table_name do |t|
-            t.references :foo, polymorphic: true, index: { name: :testings_foo_index }
-          end
+        assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo)
+      end
 
-          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :testings_foo_index)
+      def test_creates_polymorphic_index_for_existing_table_with_custom_name
+        connection.create_table table_name
+        connection.change_table table_name do |t|
+          t.references :foo, polymorphic: true, index: { name: :testings_foo_index }
         end
+
+        assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :testings_foo_index)
       end
     end
   end

data/test/cases/migration/references_statements_test.rb

@@ -7,10 +7,10 @@ module ActiveRecord
     class ReferencesStatementsTest < ActiveRecord::TestCase
       include ActiveRecord::Migration::TestHelper
 
-      self.use_transactional_tests = false
-
       def setup
         super
+        connection.drop_table :testings, if_exists: true rescue nil
+        connection.drop_table :testing, if_exists: true rescue nil
         @table_name = :test_models
 
         add_column table_name, :supplier_id, :integer
@@ -22,6 +22,13 @@ module ActiveRecord
         assert column_exists?(table_name, :user_id, :integer)
       end
 
+      def test_primary_key_and_references_columns_should_be_identical_type
+        add_reference table_name, :user
+        pk = connection.send(:column_for, :users, :id)
+        ref = connection.send(:column_for, table_name, :user_id)
+        assert_equal pk.sql_type, ref.sql_type
+      end
+
       def test_does_not_create_reference_type_column
         add_reference table_name, :taggable
         assert_not column_exists?(table_name, :taggable_type, :string)
@@ -62,7 +69,8 @@ module ActiveRecord
 
       def test_does_not_share_options_with_reference_type_column
         add_reference table_name, :taggable, type: :integer, limit: 2, polymorphic: true
-        assert column_exists?(table_name, :taggable_id, :integer)
+          skip "DB2 always applies column size constraints to polymorphic type columns" if ENV['ARCONN'] == 'ibm_db'
+        assert column_exists?(table_name, :taggable_id, :integer, limit: 2)
         assert column_exists?(table_name, :taggable_type, :string)
         assert_not column_exists?(table_name, :taggable_type, :string, limit: 2)
       end
@@ -125,6 +133,22 @@ module ActiveRecord
         assert_not column_exists?(table_name, :supplier_id, :integer)
       end
 
+      def test_responds_to_if_exists_option
+        with_polymorphic_column do
+          assert_nothing_raised do
+            remove_reference table_name, :nonexistent, polymorphic: true, if_exists: true
+          end
+        end
+      end
+
+      def test_responds_to_if_not_exists_option
+        with_polymorphic_column do
+          assert_nothing_raised do
+            add_reference table_name, :supplier, polymorphic: true, if_not_exists: true
+          end
+        end
+      end
+
       private
         def with_polymorphic_column
           add_column table_name, :supplier_type, :string