ibm_db 5.6.1-arm64-darwin-24

data/test/cases/migration/index_test.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  class Migration
+    class IndexTest < ActiveRecord::TestCase
+      attr_reader :connection, :table_name
+
+      def setup
+        super
+        @connection = ActiveRecord::Base.connection
+        @table_name = :testings
+
+        connection.create_table table_name do |t|
+          t.column :foo, :string, limit: 100
+          t.column :bar, :string, limit: 100
+
+          t.string :first_name
+          t.string :last_name, limit: 100
+          t.string :key,       limit: 100
+          t.boolean :administrator
+        end
+      end
+
+      teardown do
+        connection.drop_table :testings rescue nil
+        ActiveRecord::Base.primary_key_prefix_type = nil
+      end
+
+      def test_rename_index
+        # keep the names short to make Oracle and similar behave
+        connection.add_index(table_name, [:foo], name: "old_idx")
+        connection.rename_index(table_name, "old_idx", "new_idx")
+
+        assert_not connection.index_name_exists?(table_name, "old_idx")
+        assert connection.index_name_exists?(table_name, "new_idx")
+      end
+
+      def test_rename_index_with_symbol
+        # keep the names short to make Oracle and similar behave
+        connection.add_index(table_name, [:foo], name: :old_idx)
+        connection.rename_index(table_name, :old_idx, :new_idx)
+
+        assert_not connection.index_name_exists?(table_name, "old_idx")
+        assert connection.index_name_exists?(table_name, "new_idx")
+      end
+
+      def test_rename_index_too_long
+        too_long_index_name = good_index_name + "x"
+        # keep the names short to make Oracle and similar behave
+        connection.add_index(table_name, [:foo], name: "old_idx")
+        e = assert_raises(ArgumentError) {
+          connection.rename_index(table_name, "old_idx", too_long_index_name)
+        }
+        assert_match(/too long; the limit is #{connection.index_name_length} characters/, e.message)
+
+        assert connection.index_name_exists?(table_name, "old_idx")
+      end
+
+      def test_remove_nonexistent_index
+        assert_raise(ArgumentError) { connection.remove_index(table_name, "no_such_index") }
+      end
+
+      def test_add_index_works_with_long_index_names
+        connection.add_index(table_name, "foo", name: good_index_name)
+
+        assert connection.index_name_exists?(table_name, good_index_name)
+        connection.remove_index(table_name, name: good_index_name)
+      end
+
+      def test_add_index_does_not_accept_too_long_index_names
+        too_long_index_name = good_index_name + "x"
+
+        e = assert_raises(ArgumentError) {
+          connection.add_index(table_name, "foo", name: too_long_index_name)
+        }
+        assert_match(/too long; the limit is #{connection.index_name_length} characters/, e.message)
+
+        assert_not connection.index_name_exists?(table_name, too_long_index_name)
+        connection.add_index(table_name, "foo", name: good_index_name)
+      end
+
+      def test_add_index_which_already_exists_does_not_raise_error_with_option
+        connection.add_index(table_name, "foo")
+
+        assert_nothing_raised do
+          connection.add_index(table_name, "foo", if_not_exists: true)
+        end
+
+        assert connection.index_name_exists?(table_name, "index_testings_on_foo")
+      end
+
+      def test_add_index_with_if_not_exists_matches_exact_index
+        connection.add_index(table_name, [:foo, :bar], unique: false, name: "index_testings_on_foo_bar")
+
+        assert connection.index_name_exists?(table_name, "index_testings_on_foo_bar")
+
+        assert_nothing_raised do
+          connection.add_index(table_name, [:foo, :bar], unique: true, if_not_exists: true)
+        end
+
+        assert connection.index_name_exists?(table_name, "index_testings_on_foo_and_bar")
+      end
+
+      def test_remove_index_which_does_not_exist_doesnt_raise_with_option
+        connection.add_index(table_name, "foo")
+
+        connection.remove_index(table_name, "foo")
+
+        assert_raises ArgumentError do
+          connection.remove_index(table_name, "foo")
+        end
+
+        assert_nothing_raised do
+          connection.remove_index(table_name, "foo", if_exists: true)
+        end
+      end
+
+      def test_remove_index_with_name_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")
+
+        connection.remove_index(table_name, nil, name: "foo", if_exists: true)
+
+        assert_not connection.index_exists?(table_name, :foo, 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)
+
+        assert connection.index_name_exists?(table_name, good_index_name)
+        connection.remove_index(table_name, name: good_index_name)
+      end
+
+      def test_index_symbol_names
+        connection.add_index table_name, :foo, name: :symbol_index_name
+        assert connection.index_exists?(table_name, :foo, name: :symbol_index_name)
+
+        connection.remove_index table_name, name: :symbol_index_name
+        assert_not connection.index_exists?(table_name, :foo, name: :symbol_index_name)
+      end
+
+      def test_index_exists
+        connection.add_index :testings, :foo
+
+        assert connection.index_exists?(:testings, :foo)
+        assert_not connection.index_exists?(:testings, :bar)
+      end
+
+      def test_index_exists_on_multiple_columns
+        connection.add_index :testings, [:foo, :bar]
+
+        assert connection.index_exists?(:testings, [:foo, :bar])
+      end
+
+      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_not connection.index_exists?(:testings, [:foo], name: "my_index")
+      end
+
+      def test_valid_index_options
+        assert_raise ArgumentError do
+          connection.add_index :testings, :foo, unqiue: true
+        end
+      end
+
+      def test_unique_index_exists
+        connection.add_index :testings, :foo, unique: true
+
+        assert connection.index_exists?(:testings, :foo, unique: true)
+      end
+
+      def test_named_index_exists
+        connection.add_index :testings, :foo, name: "custom_index_name"
+
+        assert connection.index_exists?(:testings, :foo)
+        assert connection.index_exists?(:testings, :foo, name: "custom_index_name")
+        assert_not connection.index_exists?(:testings, :foo, name: "other_index_name")
+      end
+
+      def test_remove_named_index
+        connection.add_index :testings, :foo, name: "index_testings_on_custom_index_name"
+
+        assert connection.index_exists?(:testings, :foo)
+
+        assert_raise(ArgumentError) { connection.remove_index(:testings, "custom_index_name") }
+
+        connection.remove_index :testings, :foo
+        assert_not connection.index_exists?(:testings, :foo)
+      end
+
+      def test_add_index_attribute_length_limit
+        connection.add_index :testings, [:foo, :bar], length: { foo: 10, bar: nil }
+
+        assert connection.index_exists?(:testings, [:foo, :bar])
+      end
+
+      def test_add_index
+        connection.add_index("testings", "last_name")
+        connection.remove_index("testings", "last_name")
+
+        connection.add_index("testings", ["last_name", "first_name"])
+        connection.remove_index("testings", column: ["last_name", "first_name"])
+
+        connection.add_index("testings", ["last_name", "first_name"])
+        connection.remove_index("testings", name: :index_testings_on_last_name_and_first_name)
+        connection.add_index("testings", ["last_name", "first_name"])
+        connection.remove_index("testings", "last_name_and_first_name")
+
+        connection.add_index("testings", ["last_name", "first_name"])
+        connection.remove_index("testings", ["last_name", "first_name"])
+
+        connection.add_index("testings", ["last_name"], length: 10)
+        connection.remove_index("testings", "last_name")
+
+        connection.add_index("testings", ["last_name"], length: { last_name: 10 })
+        connection.remove_index("testings", ["last_name"])
+
+        connection.add_index("testings", ["last_name", "first_name"], length: 10)
+        connection.remove_index("testings", ["last_name", "first_name"])
+
+        connection.add_index("testings", ["last_name", "first_name"], length: { last_name: 10, first_name: 20 })
+        connection.remove_index("testings", ["last_name", "first_name"])
+
+        connection.add_index("testings", "key", unique: true)
+        connection.remove_index("testings", "key", unique: true)
+
+        connection.add_index("testings", ["key"], name: "key_idx", unique: true)
+        connection.remove_index("testings", name: "key_idx", unique: true)
+
+        connection.add_index("testings", %w(last_name first_name administrator), name: "named_admin")
+        connection.remove_index("testings", name: "named_admin")
+
+        # Selected adapters support index sort order
+        if current_adapter?(:SQLite3Adapter, :Mysql2Adapter, :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 })
+          connection.remove_index("testings", ["last_name", "first_name"])
+          connection.add_index("testings", ["last_name", "first_name"], order: { last_name: :desc, first_name: :asc })
+          connection.remove_index("testings", ["last_name", "first_name"])
+          connection.add_index("testings", ["last_name", "first_name"], order: :desc)
+          connection.remove_index("testings", ["last_name", "first_name"])
+        end
+      end
+
+      if current_adapter?(:PostgreSQLAdapter)
+        def test_add_partial_index
+          connection.add_index("testings", "last_name", where: "first_name = 'john doe'")
+          assert connection.index_exists?("testings", "last_name")
+
+          connection.remove_index("testings", "last_name")
+          assert_not connection.index_exists?("testings", "last_name")
+        end
+      end
+
+      private
+        def good_index_name
+          "x" * connection.index_name_length
+        end
+    end
+  end
+end

data/test/cases/migration/logger_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  class Migration
+    class LoggerTest < ActiveRecord::TestCase
+      # MySQL can't roll back ddl changes
+      self.use_transactional_tests = false
+
+      Migration = Struct.new(:name, :version) do
+        def disable_ddl_transaction; false end
+        def migrate(direction)
+          # do nothing
+        end
+      end
+
+      def setup
+        super
+        @schema_migration = ActiveRecord::Base.connection.schema_migration
+        @schema_migration.create_table
+        @schema_migration.delete_all
+      end
+
+      teardown do
+        @schema_migration.drop_table
+      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
+      ensure
+        ActiveRecord::Base.logger = previous_logger
+      end
+    end
+  end
+end

data/test/cases/migration/pending_migrations_test.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+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
+
+          ActiveRecord::Base.connection.drop_table "schema_migrations", if_exists: true
+
+          @app = Minitest::Mock.new
+        end
+
+        teardown do
+          @conn.release_connection if @conn
+          ActiveRecord::Base.establish_connection :arunit
+          FileUtils.rm_rf(@migration_dir)
+        end
+
+        def run_migrations
+          migrator = Base.connection.migration_context
+          capture(:stdout) { migrator.migrate }
+        end
+
+        def create_migration(number, name)
+          filename = "#{number}_#{name.underscore}.rb"
+          File.write(File.join(@migration_dir, filename), <<~RUBY)
+            class #{name.classify} < ActiveRecord::Migration::Current
+            end
+          RUBY
+        end
+
+        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
+        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
+        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
+        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
+
+          # It understands the new migration created at 01
+          create_migration "01", "create_foo"
+          assert_raises ActiveRecord::PendingMigrationError do
+            check_pending.call({})
+          end
+        end
+      end
+    end
+  end
+end

data/test/cases/migration/references_foreign_key_test.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+if ActiveRecord::Base.connection.supports_foreign_keys?
+  module ActiveRecord
+    class Migration
+      class ReferencesForeignKeyInCreateTest < ActiveRecord::TestCase
+        setup do
+          @connection = ActiveRecord::Base.connection
+          @connection.create_table(:testing_parents, force: true)
+        end
+
+        teardown do
+          @connection.drop_table "testings", if_exists: true
+          @connection.drop_table "testing_parents", if_exists: true
+        end
+
+        test "foreign keys can be created with the table" do
+          @connection.create_table :testings do |t|
+            t.references :testing_parent, foreign_key: true
+          end
+
+          fk = @connection.foreign_keys("testings").first
+          assert_equal "testings", fk.from_table
+          assert_equal "testing_parents", fk.to_table
+        end
+
+        test "no foreign key is created by default" do
+          @connection.create_table :testings do |t|
+            t.references :testing_parent
+          end
+
+          assert_equal [], @connection.foreign_keys("testings")
+        end
+
+        test "foreign keys can be created in one query when index is not added" do
+          assert_queries(1) do
+            @connection.create_table :testings do |t|
+              t.references :testing_parent, foreign_key: true, index: false
+            end
+          end
+        end
+
+        test "options hash can be passed" do
+          @connection.change_table :testing_parents do |t|
+            t.references :other, index: { unique: true }
+          end
+          @connection.create_table :testings do |t|
+            t.references :testing_parent, foreign_key: { primary_key: :other_id }
+          end
+
+          fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }
+          assert_equal "other_id", fk.primary_key
+        end
+
+        test "to_table option can be passed" do
+          @connection.create_table :testings do |t|
+            t.references :parent, foreign_key: { to_table: :testing_parents }
+          end
+          fks = @connection.foreign_keys("testings")
+          assert_equal([["testings", "testing_parents", "parent_id"]],
+                       fks.map { |fk| [fk.from_table, fk.to_table, fk.column] })
+        end
+      end
+    end
+  end
+
+  module ActiveRecord
+    class Migration
+      class ReferencesForeignKeyTest < ActiveRecord::TestCase
+        setup do
+          @connection = ActiveRecord::Base.connection
+          @connection.create_table(:testing_parents, force: true)
+        end
+
+        teardown do
+          @connection.drop_table "testings", if_exists: true
+          @connection.drop_table "testing_parents", if_exists: true
+        end
+
+        test "foreign keys cannot be added to polymorphic relations when creating the table" do
+          @connection.create_table :testings do |t|
+            assert_raises(ArgumentError) do
+              t.references :testing_parent, polymorphic: true, foreign_key: true
+            end
+          end
+        end
+
+        test "foreign keys can be created while changing the table" do
+          @connection.create_table :testings
+          @connection.change_table :testings do |t|
+            t.references :testing_parent, foreign_key: true
+          end
+
+          fk = @connection.foreign_keys("testings").first
+          assert_equal "testings", fk.from_table
+          assert_equal "testing_parents", fk.to_table
+        end
+
+        test "foreign keys are not added by default when changing the table" do
+          @connection.create_table :testings
+          @connection.change_table :testings do |t|
+            t.references :testing_parent
+          end
+
+          assert_equal [], @connection.foreign_keys("testings")
+        end
+
+        test "foreign keys accept options when changing the table" do
+          @connection.change_table :testing_parents do |t|
+            t.references :other, index: { unique: true }
+          end
+          @connection.create_table :testings
+          @connection.change_table :testings do |t|
+            t.references :testing_parent, foreign_key: { primary_key: :other_id }
+          end
+
+          fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }
+          assert_equal "other_id", fk.primary_key
+        end
+
+        test "foreign keys cannot be added to polymorphic relations when changing the table" do
+          @connection.create_table :testings
+          @connection.change_table :testings do |t|
+            assert_raises(ArgumentError) do
+              t.references :testing_parent, polymorphic: true, foreign_key: true
+            end
+          end
+        end
+
+        test "foreign key column can be removed" do
+          @connection.create_table :testings do |t|
+            t.references :testing_parent, index: true, foreign_key: true
+          end
+
+          assert_difference "@connection.foreign_keys('testings').size", -1 do
+            @connection.remove_reference :testings, :testing_parent, foreign_key: true
+          end
+        end
+
+        test "removing column removes foreign key" do
+          @connection.create_table :testings do |t|
+            t.references :testing_parent, index: true, foreign_key: true
+          end
+
+          assert_difference "@connection.foreign_keys('testings').size", -1 do
+            @connection.remove_column :testings, :testing_parent_id
+          end
+        end
+
+        test "foreign key methods respect pluralize_table_names" do
+          original_pluralize_table_names = ActiveRecord::Base.pluralize_table_names
+          ActiveRecord::Base.pluralize_table_names = false
+          @connection.create_table :testing
+          @connection.change_table :testing_parents do |t|
+            t.references :testing, foreign_key: true
+          end
+
+          fk = @connection.foreign_keys("testing_parents").first
+          assert_equal "testing_parents", fk.from_table
+          assert_equal "testing", fk.to_table
+
+          assert_difference "@connection.foreign_keys('testing_parents').size", -1 do
+            @connection.remove_reference :testing_parents, :testing, foreign_key: true
+          end
+        ensure
+          ActiveRecord::Base.pluralize_table_names = original_pluralize_table_names
+          @connection.drop_table "testing", if_exists: true
+        end
+
+        class CreateDogsMigration < ActiveRecord::Migration::Current
+          def change
+            create_table :dog_owners
+
+            create_table :dogs do |t|
+              t.references :dog_owner, foreign_key: true
+            end
+          end
+        end
+
+        def test_references_foreign_key_with_prefix
+          ActiveRecord::Base.table_name_prefix = "p_"
+          migration = CreateDogsMigration.new
+          silence_stream($stdout) { migration.migrate(:up) }
+          assert_equal 1, @connection.foreign_keys("p_dogs").size
+        ensure
+          silence_stream($stdout) { migration.migrate(:down) }
+          ActiveRecord::Base.table_name_prefix = nil
+        end
+
+        def test_references_foreign_key_with_suffix
+          ActiveRecord::Base.table_name_suffix = "_s"
+          migration = CreateDogsMigration.new
+          silence_stream($stdout) { migration.migrate(:up) }
+          assert_equal 1, @connection.foreign_keys("dogs_s").size
+        ensure
+          silence_stream($stdout) { migration.migrate(:down) }
+          ActiveRecord::Base.table_name_suffix = nil
+        end
+
+        test "multiple foreign keys can be added to the same table" do
+          @connection.create_table :testings do |t|
+            t.references :parent1, foreign_key: { to_table: :testing_parents }
+            t.references :parent2, foreign_key: { to_table: :testing_parents }
+            t.references :self_join, foreign_key: { to_table: :testings }
+          end
+
+          fks = @connection.foreign_keys("testings").sort_by(&:column)
+
+          fk_definitions = fks.map { |fk| [fk.from_table, fk.to_table, fk.column] }
+          assert_equal([["testings", "testing_parents", "parent1_id"],
+                        ["testings", "testing_parents", "parent2_id"],
+                        ["testings", "testings", "self_join_id"]], fk_definitions)
+        end
+
+        test "multiple foreign keys can be removed to the selected one" do
+          @connection.create_table :testings do |t|
+            t.references :parent1, foreign_key: { to_table: :testing_parents }
+            t.references :parent2, foreign_key: { to_table: :testing_parents }
+          end
+
+          assert_difference "@connection.foreign_keys('testings').size", -1 do
+            @connection.remove_reference :testings, :parent1, foreign_key: { to_table: :testing_parents }
+          end
+
+          fks = @connection.foreign_keys("testings").sort_by(&:column)
+
+          fk_definitions = fks.map { |fk| [fk.from_table, fk.to_table, fk.column] }
+          assert_equal([["testings", "testing_parents", "parent2_id"]], fk_definitions)
+        end
+      end
+    end
+  end
+end