ibm_db 5.2.0-x86-mingw32 → 5.3.2-x86-mingw32

data/test/cases/migration/helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -28,12 +30,11 @@ module ActiveRecord
         super
         TestModel.reset_table_name
         TestModel.reset_sequence_name
-        connection.drop_table :test_models rescue nil
+        connection.drop_table :test_models, if_exists: true
       end
 
       private
-
-      delegate(*CONNECTION_METHODS, to: :connection)
+        delegate(*CONNECTION_METHODS, to: :connection)
     end
   end
 end

data/test/cases/migration/index_test.rb

@@ -1,4 +1,6 @@
-require 'cases/helper'
+# frozen_string_literal: true
+
+require "cases/helper"
 
 module ActiveRecord
   class Migration
@@ -11,12 +13,12 @@ module ActiveRecord
         @table_name = :testings
 
         connection.create_table table_name do |t|
-          t.column :foo, :string, :limit => 100
-          t.column :bar, :string, :limit => 100
+          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.string :last_name, limit: 100
+          t.string :key,       limit: 100
           t.boolean :administrator
         end
       end
@@ -28,33 +30,32 @@ module ActiveRecord
 
       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')
+        connection.add_index(table_name, [:foo], name: "old_idx")
+        connection.rename_index(table_name, "old_idx", "new_idx")
 
-        # if the adapter doesn't support the indexes call, pick defaults that let the test pass
-        assert_not connection.index_name_exists?(table_name, 'old_idx', false)
-        assert connection.index_name_exists?(table_name, 'new_idx', true)
+        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'
+      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')
-        e = assert_raises(ArgumentError) {
-          connection.rename_index(table_name, 'old_idx', too_long_index_name)
-        }
-        assert_match(/too long; the limit is #{connection.allowed_index_name_length} characters/, e.message)
+        connection.add_index(table_name, [:foo], name: :old_idx)
+        connection.rename_index(table_name, :old_idx, :new_idx)
 
-        # if the adapter doesn't support the indexes call, pick defaults that let the test pass
-        assert connection.index_name_exists?(table_name, 'old_idx', false)
+        assert_not connection.index_name_exists?(table_name, "old_idx")
+        assert connection.index_name_exists?(table_name, "new_idx")
       end
 
-
-      def test_double_add_index
-        connection.add_index(table_name, [:foo], :name => 'some_idx')
-        assert_raises(ArgumentError) {
-          connection.add_index(table_name, [:foo], :name => 'some_idx')
+      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
@@ -64,43 +65,89 @@ module ActiveRecord
       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, false)
+        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'
+        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.allowed_index_name_length} characters/, e.message)
+        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_not connection.index_name_exists?(table_name, too_long_index_name, false)
-        connection.add_index(table_name, "foo", :name => good_index_name)
+        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
+        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, false)
+        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.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)
+        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 !connection.index_exists?(:testings, :bar)
+        assert_not connection.index_exists?(:testings, :bar)
       end
 
       def test_index_exists_on_multiple_columns
@@ -122,29 +169,32 @@ module ActiveRecord
       end
 
       def test_unique_index_exists
-        connection.add_index :testings, :foo, :unique => true
+        connection.add_index :testings, :foo, unique: true
 
-        assert connection.index_exists?(: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"
+        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 !connection.index_exists?(:testings, :foo, :name => "other_index_name")
+        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 => "custom_index_name"
+        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 !connection.index_exists?(: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}
+        connection.add_index :testings, [:foo, :bar], length: { foo: 10, bar: nil }
 
         assert connection.index_exists?(:testings, [:foo, :bar])
       end
@@ -154,65 +204,64 @@ module ActiveRecord
         connection.remove_index("testings", "last_name")
 
         connection.add_index("testings", ["last_name", "first_name"])
-        connection.remove_index("testings", :column => ["last_name", "first_name"])
-
-        # Oracle adapter cannot have specified index name larger than 30 characters
-        # Oracle adapter is shortening index name when just column list is given
-        unless current_adapter?(:OracleAdapter)
-          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")
-        end
+        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.add_index("testings", ["last_name"], length: 10)
         connection.remove_index("testings", "last_name")
 
-        connection.add_index("testings", ["last_name"], :length => {:last_name => 10})
+        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.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.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"], :name => "key_idx", :unique => true)
-        connection.remove_index("testings", :name => "key_idx", :unique => true)
+        connection.add_index("testings", "key", unique: true)
+        connection.remove_index("testings", "key", unique: true)
 
-        connection.add_index("testings", %w(last_name first_name administrator), :name => "named_admin")
-        connection.remove_index("testings", :name => "named_admin")
+        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.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.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.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.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'")
+          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 !connection.index_exists?("testings", "last_name")
+          assert_not connection.index_exists?("testings", "last_name")
         end
       end
 
       private
         def good_index_name
-          'x' * connection.allowed_index_name_length
+          "x" * connection.index_name_length
         end
-
     end
   end
 end

data/test/cases/migration/logger_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -8,26 +10,27 @@ module ActiveRecord
 
       Migration = Struct.new(:name, :version) do
         def disable_ddl_transaction; false end
-        def migrate direction
+        def migrate(direction)
           # do nothing
         end
       end
 
       def setup
         super
-        ActiveRecord::SchemaMigration.create_table
-        ActiveRecord::SchemaMigration.delete_all
+        @schema_migration = ActiveRecord::Base.connection.schema_migration
+        @schema_migration.create_table
+        @schema_migration.delete_all
       end
 
       teardown do
-        ActiveRecord::SchemaMigration.drop_table
+        @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).migrate
+        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

data/test/cases/migration/pending_migrations_test.rb

@@ -1,50 +1,104 @@
-require 'cases/helper'
+# frozen_string_literal: true
+
+require "cases/helper"
 
 module ActiveRecord
   class Migration
-    class PendingMigrationsTest < ActiveRecord::TestCase
-      def setup
-        super
-        @connection = Minitest::Mock.new
-        @app = Minitest::Mock.new
-        conn = @connection
-        @pending = Class.new(CheckPending) {
-          define_method(:connection) { conn }
-        }.new(@app)
-        @pending.instance_variable_set :@last_check, -1 # Force checking
-      end
+    if current_adapter?(:SQLite3Adapter) && !in_memory_db?
+      class PendingMigrationsTest < ActiveRecord::TestCase
+        setup do
+          @migration_dir = Dir.mktmpdir("activerecord-migrations-")
 
-      def teardown
-        assert @connection.verify
-        assert @app.verify
-        super
-      end
+          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
 
-      def test_errors_if_pending
-        @connection.expect :supports_migrations?, true
+          @app = Minitest::Mock.new
+        end
+
+        teardown do
+          @conn.release_connection if @conn
+          ActiveRecord::Base.establish_connection :arunit
+          FileUtils.rm_rf(@migration_dir)
+        end
 
-        ActiveRecord::Migrator.stub :needs_migration?, true do
-          assert_raise ActiveRecord::PendingMigrationError do
-            @pending.call(nil)
+        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
-      end
 
-      def test_checks_if_supported
-        @connection.expect :supports_migrations?, true
-        @app.expect :call, nil, [:foo]
+        def test_checks_if_supported
+          run_migrations
+
+          check_pending = CheckPending.new(@app)
 
-        ActiveRecord::Migrator.stub :needs_migration?, false do
-          @pending.call(:foo)
+          @app.expect :call, nil, [{}]
+          check_pending.call({})
+          @app.verify
+
+          # With cached result
+          @app.expect :call, nil, [{}]
+          check_pending.call({})
+          @app.verify
         end
-      end
 
-      def test_doesnt_check_if_unsupported
-        @connection.expect :supports_migrations?, false
-        @app.expect :call, nil, [:foo]
+        def test_okay_with_no_migrations
+          check_pending = CheckPending.new(@app)
+
+          @app.expect :call, nil, [{}]
+          check_pending.call({})
+          @app.verify
 
-        ActiveRecord::Migrator.stub :needs_migration?, true do
-          @pending.call(:foo)
+          # 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