Merge branch 'master' into fix_26964

63 files changed, 647 insertions, 215 deletions

diff --git a/activerecord/test/cases/adapter_test.rb b/activerecord/test/cases/adapter_test.rb
index 8bcecf2ed3..3fce0a1df1 100644
--- a/activerecord/test/cases/adapter_test.rb
+++ b/activerecord/test/cases/adapter_test.rb
@@ -182,6 +182,14 @@ module ActiveRecord
       assert_not_nil error.cause
     end
 
+    def test_not_null_violations_are_translated_to_specific_exception
+      error = assert_raises(ActiveRecord::NotNullViolation) do
+        Post.create
+      end
+
+      assert_not_nil error.cause
+    end
+
     unless current_adapter?(:SQLite3Adapter)
       def test_foreign_key_violations_are_translated_to_specific_exception
         error = assert_raises(ActiveRecord::InvalidForeignKey) do
@@ -218,6 +226,14 @@ module ActiveRecord
 
         assert_not_nil error.cause
       end
+
+      def test_numeric_value_out_of_ranges_are_translated_to_specific_exception
+        error = assert_raises(ActiveRecord::RangeError) do
+          Book.connection.create("INSERT INTO books(author_id) VALUES (2147483648)")
+        end
+
+        assert_not_nil error.cause
+      end
     end
 
     def test_disable_referential_integrity
@@ -269,13 +285,13 @@ module ActiveRecord
 
     unless current_adapter?(:PostgreSQLAdapter)
       def test_log_invalid_encoding
-        error = assert_raise ActiveRecord::StatementInvalid do
+        error = assert_raises RuntimeError do
           @connection.send :log, "SELECT 'ы' FROM DUAL" do
             raise "ы".force_encoding(Encoding::ASCII_8BIT)
           end
         end
 
-        assert_not_nil error.cause
+        assert_not_nil error.message
       end
     end
 
diff --git a/activerecord/test/cases/adapters/mysql2/active_schema_test.rb b/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
index a70eb5a094..2a528b2cb1 100644
--- a/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/active_schema_test.rb
@@ -28,12 +28,15 @@ class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
 
     expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`(15)) "
     assert_equal expected, add_index(:people, [:last_name, :first_name], length: 15)
+    assert_equal expected, add_index(:people, ["last_name", "first_name"], length: 15)
 
     expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`) "
     assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15 })
+    assert_equal expected, add_index(:people, ["last_name", "first_name"], length: { last_name: 15 })
 
     expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`(10)) "
     assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15, first_name: 10 })
+    assert_equal expected, add_index(:people, ["last_name", :first_name], length: { last_name: 15, "first_name" => 10 })
 
     %w(SPATIAL FULLTEXT UNIQUE).each do |type|
       expected = "CREATE #{type} INDEX `index_people_on_last_name`  ON `people` (`last_name`) "
diff --git a/activerecord/test/cases/adapters/mysql2/connection_test.rb b/activerecord/test/cases/adapters/mysql2/connection_test.rb
index 9c109d8a24..c1de2218e2 100644
--- a/activerecord/test/cases/adapters/mysql2/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/connection_test.rb
@@ -186,7 +186,7 @@ class Mysql2ConnectionTest < ActiveRecord::Mysql2TestCase
       "expected release_advisory_lock to return false when there was no lock to release"
   end
 
-  protected
+  private
 
     def test_lock_free(lock_name)
       @connection.select_value("SELECT IS_FREE_LOCK(#{@connection.quote(lock_name)})") == 1
diff --git a/activerecord/test/cases/adapters/mysql2/json_test.rb b/activerecord/test/cases/adapters/mysql2/json_test.rb
index 5d4db1be91..6954006003 100644
--- a/activerecord/test/cases/adapters/mysql2/json_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/json_test.rb
@@ -93,7 +93,7 @@ if ActiveRecord::Base.connection.supports_json?
     def test_null_json
       @connection.execute "insert into json_data_type (payload) VALUES(null)"
       x = JsonDataType.first
-      assert_equal(nil, x.payload)
+      assert_nil(x.payload)
     end
 
     def test_select_array_json_value
@@ -111,7 +111,7 @@ if ActiveRecord::Base.connection.supports_json?
     def test_select_nil_json_after_update
       json = JsonDataType.create(payload: "foo")
       x = JsonDataType.where(payload: nil).first
-      assert_equal(nil, x)
+      assert_nil(x)
 
       json.update_attributes payload: nil
       x = JsonDataType.where(payload: nil).first
diff --git a/activerecord/test/cases/adapters/mysql2/legacy_migration_test.rb b/activerecord/test/cases/adapters/mysql2/legacy_migration_test.rb
new file mode 100644
index 0000000000..5d3125c2be
--- /dev/null
+++ b/activerecord/test/cases/adapters/mysql2/legacy_migration_test.rb
@@ -0,0 +1,60 @@
+require "cases/helper"
+
+class MysqlLegacyMigrationTest < ActiveRecord::Mysql2TestCase
+  self.use_transactional_tests = false
+
+  class GenerateTableWithoutBigint < ActiveRecord::Migration[5.0]
+    def change
+      create_table :legacy_integer_pk do |table|
+        table.string :foo
+      end
+
+      create_table :override_pk, id: :bigint do |table|
+        table.string :bar
+      end
+    end
+  end
+
+  def setup
+    super
+    @connection = ActiveRecord::Base.connection
+
+    @migration_verbose_old = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+
+    migrations = [GenerateTableWithoutBigint.new(nil, 1)]
+
+    ActiveRecord::Migrator.new(:up, migrations).migrate
+  end
+
+  def teardown
+    ActiveRecord::Migration.verbose = @migration_verbose_old
+    @connection.drop_table("legacy_integer_pk")
+    @connection.drop_table("override_pk")
+    ActiveRecord::SchemaMigration.delete_all rescue nil
+    super
+  end
+
+  def test_create_table_uses_integer_as_pkey_by_default
+    col = column(:legacy_integer_pk, :id)
+    assert_equal "int(11)", sql_type_for(col)
+    assert col.auto_increment?
+  end
+
+  def test_create_tables_respects_pk_column_type_override
+    col = column(:override_pk, :id)
+    assert_equal "bigint(20)", sql_type_for(col)
+  end
+
+  private
+
+    def column(table_name, column_name)
+      ActiveRecord::Base.connection
+        .columns(table_name.to_s)
+        .detect { |c| c.name == column_name.to_s }
+    end
+
+    def sql_type_for(col)
+      col && col.sql_type
+    end
+end
diff --git a/activerecord/test/cases/adapters/mysql2/mysql2_adapter_test.rb b/activerecord/test/cases/adapters/mysql2/mysql2_adapter_test.rb
index 69336eb906..aab3dcb724 100644
--- a/activerecord/test/cases/adapters/mysql2/mysql2_adapter_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/mysql2_adapter_test.rb
@@ -65,6 +65,19 @@ class Mysql2AdapterTest < ActiveRecord::Mysql2TestCase
       @conn.columns_for_distinct("posts.id", [order])
   end
 
+  def test_errors_for_bigint_fks_on_integer_pk_table
+    # table old_cars has primary key of integer
+
+    error = assert_raises(ActiveRecord::MismatchedForeignKey) do
+      @conn.add_reference :engines, :old_car
+      @conn.add_foreign_key :engines, :old_cars
+    end
+
+    assert_match "Column `old_car_id` on table `engines` has a type of `bigint(20)`", error.message
+    assert_not_nil error.cause
+    @conn.exec_query("ALTER TABLE engines DROP COLUMN old_car_id")
+  end
+
   private
 
     def with_example_table(definition = "id int auto_increment primary key, number int, data varchar(255)", &block)
diff --git a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
index b400f4d2f9..2c778b1150 100644
--- a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
@@ -143,7 +143,7 @@ class Mysql2ReservedWordTest < ActiveRecord::Mysql2TestCase
     end
 
     # custom create table, uses execute on connection to create a table, note: escapes table_name, does NOT escape columns
-    def create_tables_directly (tables, connection = @connection)
+    def create_tables_directly(tables, connection = @connection)
       tables.each do |table_name, column_properties|
         connection.execute("CREATE TABLE `#{table_name}` ( #{column_properties} )")
       end
diff --git a/activerecord/test/cases/adapters/mysql2/unsigned_type_test.rb b/activerecord/test/cases/adapters/mysql2/unsigned_type_test.rb
index 59475ad177..a0823be143 100644
--- a/activerecord/test/cases/adapters/mysql2/unsigned_type_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/unsigned_type_test.rb
@@ -15,6 +15,7 @@ class Mysql2UnsignedTypeTest < ActiveRecord::Mysql2TestCase
       t.bigint  :unsigned_bigint,  unsigned: true
       t.float   :unsigned_float,   unsigned: true
       t.decimal :unsigned_decimal, unsigned: true, precision: 10, scale: 2
+      t.column  :unsigned_zerofill, "int unsigned zerofill"
     end
   end
 
@@ -34,10 +35,10 @@ class Mysql2UnsignedTypeTest < ActiveRecord::Mysql2TestCase
     assert_raise(ActiveModel::RangeError) do
       UnsignedType.create(unsigned_bigint: -10)
     end
-    assert_raise(ActiveRecord::StatementInvalid) do
+    assert_raise(ActiveRecord::RangeError) do
       UnsignedType.create(unsigned_float: -10.0)
     end
-    assert_raise(ActiveRecord::StatementInvalid) do
+    assert_raise(ActiveRecord::RangeError) do
       UnsignedType.create(unsigned_decimal: -10.0)
     end
   end
@@ -48,7 +49,6 @@ class Mysql2UnsignedTypeTest < ActiveRecord::Mysql2TestCase
       t.unsigned_bigint  :unsigned_bigint_t
       t.unsigned_float   :unsigned_float_t
       t.unsigned_decimal :unsigned_decimal_t, precision: 10, scale: 2
-      t.column :unsigned_zerofill, "int unsigned zerofill"
     end
 
     @connection.columns("unsigned_types").select { |c| /^unsigned_/.match?(c.name) }.each do |column|
diff --git a/activerecord/test/cases/adapters/postgresql/active_schema_test.rb b/activerecord/test/cases/adapters/postgresql/active_schema_test.rb
index d3c65f3d94..b787de8453 100644
--- a/activerecord/test/cases/adapters/postgresql/active_schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/active_schema_test.rb
@@ -39,6 +39,10 @@ class PostgresqlActiveSchemaTest < ActiveRecord::PostgreSQLTestCase
     expected = %(CREATE  INDEX CONCURRENTLY "index_people_on_last_name" ON "people"  ("last_name"))
     assert_equal expected, add_index(:people, :last_name, algorithm: :concurrently)
 
+    expected = %(CREATE  INDEX  "index_people_on_last_name_and_first_name" ON "people"  ("last_name" DESC, "first_name" ASC))
+    assert_equal expected, add_index(:people, [:last_name, :first_name], order: { last_name: :desc, first_name: :asc })
+    assert_equal expected, add_index(:people, ["last_name", :first_name], order: { last_name: :desc, "first_name" => :asc })
+
     %w(gin gist hash btree).each do |type|
       expected = %(CREATE  INDEX  "index_people_on_last_name" ON "people" USING #{type} ("last_name"))
       assert_equal expected, add_index(:people, :last_name, using: type)
diff --git a/activerecord/test/cases/adapters/postgresql/bytea_test.rb b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
index dc0df8715a..5c207116c4 100644
--- a/activerecord/test/cases/adapters/postgresql/bytea_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
@@ -52,7 +52,7 @@ class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_type_case_nil
-    assert_equal(nil, @type.deserialize(nil))
+    assert_nil(@type.deserialize(nil))
   end
 
   def test_read_value
@@ -66,7 +66,7 @@ class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
   def test_read_nil_value
     @connection.execute "insert into bytea_data_type (payload) VALUES (null)"
     record = ByteaDataType.first
-    assert_equal(nil, record.payload)
+    assert_nil(record.payload)
     record.delete
   end
 
@@ -106,8 +106,8 @@ class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
   def test_write_nil
     record = ByteaDataType.create(payload: nil)
     assert_not record.new_record?
-    assert_equal(nil, record.payload)
-    assert_equal(nil, ByteaDataType.where(id: record.id).first.payload)
+    assert_nil(record.payload)
+    assert_nil(ByteaDataType.where(id: record.id).first.payload)
   end
 
   class Serializer
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index 48c82cb7b9..45aa748ffc 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -245,7 +245,7 @@ module ActiveRecord
       end
     end
 
-    protected
+    private
 
       def with_warning_suppression
         log_level = @connection.client_min_messages
diff --git a/activerecord/test/cases/adapters/postgresql/geometric_test.rb b/activerecord/test/cases/adapters/postgresql/geometric_test.rb
index a65d4d1ad9..c1f3a4ae2c 100644
--- a/activerecord/test/cases/adapters/postgresql/geometric_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/geometric_test.rb
@@ -96,7 +96,7 @@ class PostgresqlPointTest < ActiveRecord::PostgreSQLTestCase
     assert_nothing_raised { PostgresqlPoint.new(x: "") }
 
     p = PostgresqlPoint.new(x: "")
-    assert_equal nil, p.x
+    assert_nil p.x
   end
 
   def test_array_of_points_round_trip
diff --git a/activerecord/test/cases/adapters/postgresql/json_test.rb b/activerecord/test/cases/adapters/postgresql/json_test.rb
index 991dedfdf1..93558ac4d2 100644
--- a/activerecord/test/cases/adapters/postgresql/json_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/json_test.rb
@@ -110,7 +110,7 @@ module PostgresqlJSONSharedTestCases
   def test_null_json
     @connection.execute "insert into json_data_type (payload) VALUES(null)"
     x = JsonDataType.first
-    assert_equal(nil, x.payload)
+    assert_nil(x.payload)
   end
 
   def test_select_nil_json_after_create
@@ -122,7 +122,7 @@ module PostgresqlJSONSharedTestCases
   def test_select_nil_json_after_update
     json = JsonDataType.create(payload: "foo")
     x = JsonDataType.where(payload: nil).first
-    assert_equal(nil, x)
+    assert_nil(x)
 
     json.update_attributes payload: nil
     x = JsonDataType.where(payload: nil).first
diff --git a/activerecord/test/cases/adapters/postgresql/legacy_migration_test.rb b/activerecord/test/cases/adapters/postgresql/legacy_migration_test.rb
new file mode 100644
index 0000000000..082fe95053
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/legacy_migration_test.rb
@@ -0,0 +1,54 @@
+require "cases/helper"
+
+class PostgresqlLegacyMigrationTest < ActiveRecord::PostgreSQLTestCase
+  class GenerateTableWithoutBigserial < ActiveRecord::Migration[5.0]
+    def change
+      create_table :legacy_integer_pk do |table|
+        table.string :foo
+      end
+
+      create_table :override_pk, id: :bigint do |table|
+        table.string :bar
+      end
+    end
+  end
+
+  def setup
+    super
+
+    @migration_verbose_old = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+
+    migrations = [GenerateTableWithoutBigserial.new(nil, 1)]
+    ActiveRecord::Migrator.new(:up, migrations).migrate
+  end
+
+  def teardown
+    ActiveRecord::Migration.verbose = @migration_verbose_old
+
+    super
+  end
+
+  def test_create_table_uses_serial_as_pkey_by_default
+    col = column(:legacy_integer_pk, :id)
+    assert_equal "integer", sql_type_for(col)
+    assert col.serial?
+  end
+
+  def test_create_tables_respects_pk_column_type_override
+    col = column(:override_pk, :id)
+    assert_equal "bigint", sql_type_for(col)
+  end
+
+  private
+
+    def column(table_name, column_name)
+      ActiveRecord::Base.connection.
+        columns(table_name.to_s).
+        detect { |c| c.name == column_name.to_s }
+    end
+
+    def sql_type_for(col)
+      col && col.sql_type
+    end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/quoting_test.rb b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
index a9e81ab3d8..141baffa5b 100644
--- a/activerecord/test/cases/adapters/postgresql/quoting_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/quoting_test.rb
@@ -36,7 +36,7 @@ module ActiveRecord
         def test_quote_bit_string
           value = "'); SELECT * FROM users; /*\n01\n*/--"
           type = OID::Bit.new
-          assert_equal nil, @conn.quote(type.serialize(value))
+          assert_nil @conn.quote(type.serialize(value))
         end
       end
     end
diff --git a/activerecord/test/cases/adapters/postgresql/transaction_test.rb b/activerecord/test/cases/adapters/postgresql/transaction_test.rb
index f130e344c4..9b42d0383d 100644
--- a/activerecord/test/cases/adapters/postgresql/transaction_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/transaction_test.rb
@@ -89,7 +89,7 @@ module ActiveRecord
       end
     end
 
-    protected
+    private
 
       def with_warning_suppression
         log_level = ActiveRecord::Base.connection.client_min_messages
diff --git a/activerecord/test/cases/adapters/postgresql/utils_test.rb b/activerecord/test/cases/adapters/postgresql/utils_test.rb
index 7f6ea3887d..9f9e3bda2f 100644
--- a/activerecord/test/cases/adapters/postgresql/utils_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/utils_test.rb
@@ -56,7 +56,7 @@ class PostgreSQLNameTest < ActiveRecord::PostgreSQLTestCase
   test "can be used as hash key" do
     hash = { Name.new("schema", "article_seq") => "success" }
     assert_equal "success", hash[Name.new("schema", "article_seq")]
-    assert_equal nil, hash[Name.new("schema", "articles")]
-    assert_equal nil, hash[Name.new("public", "article_seq")]
+    assert_nil hash[Name.new("schema", "articles")]
+    assert_nil hash[Name.new("public", "article_seq")]
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/uuid_test.rb b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
index 4604c2eb3b..f34d50e25c 100644
--- a/activerecord/test/cases/adapters/postgresql/uuid_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
@@ -71,12 +71,12 @@ class PostgresqlUUIDTest < ActiveRecord::PostgreSQLTestCase
 
   def test_treat_blank_uuid_as_nil
     UUIDType.create! guid: ""
-    assert_equal(nil, UUIDType.last.guid)
+    assert_nil(UUIDType.last.guid)
   end
 
   def test_treat_invalid_uuid_as_nil
     uuid = UUIDType.create! guid: "foobar"
-    assert_equal(nil, uuid.guid)
+    assert_nil(uuid.guid)
   end
 
   def test_invalid_uuid_dont_modify_before_type_cast
@@ -210,7 +210,7 @@ class PostgresqlUUIDGenerationTest < ActiveRecord::PostgreSQLTestCase
     def test_pk_and_sequence_for_uuid_primary_key
       pk, seq = connection.pk_and_sequence_for("pg_uuids")
       assert_equal "id", pk
-      assert_equal nil, seq
+      assert_nil seq
     end
 
     def test_schema_dumper_for_uuid_primary_key
diff --git a/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb b/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
index 8342b05870..91967c1e33 100644
--- a/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/copy_table_test.rb
@@ -75,7 +75,7 @@ class CopyTableTest < ActiveRecord::SQLite3TestCase
     test_copy_table "binaries", "binaries2"
   end
 
-protected
+private
   def copy_table(from, to, options = {})
     @connection.copy_table(from, to, { temporary: true }.merge(options))
   end
diff --git a/activerecord/test/cases/adapters/sqlite3/legacy_migration_test.rb b/activerecord/test/cases/adapters/sqlite3/legacy_migration_test.rb
new file mode 100644
index 0000000000..fcca8d66b5
--- /dev/null
+++ b/activerecord/test/cases/adapters/sqlite3/legacy_migration_test.rb
@@ -0,0 +1,59 @@
+require "cases/helper"
+
+class SqliteLegacyMigrationTest < ActiveRecord::SQLite3TestCase
+  self.use_transactional_tests = false
+
+  class GenerateTableWithoutBigint < ActiveRecord::Migration[5.0]
+    def change
+      create_table :legacy_integer_pk do |table|
+        table.string :foo
+      end
+
+      create_table :override_pk, id: :bigint do |table|
+        table.string :bar
+      end
+    end
+  end
+
+  def setup
+    super
+    @connection = ActiveRecord::Base.connection
+
+    @migration_verbose_old = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+
+    migrations = [GenerateTableWithoutBigint.new(nil, 1)]
+
+    ActiveRecord::Migrator.new(:up, migrations).migrate
+  end
+
+  def teardown
+    ActiveRecord::Migration.verbose = @migration_verbose_old
+    @connection.drop_table("legacy_integer_pk")
+    @connection.drop_table("override_pk")
+    ActiveRecord::SchemaMigration.delete_all rescue nil
+    super
+  end
+
+  def test_create_table_uses_integer_as_pkey_by_default
+    col = column(:legacy_integer_pk, :id)
+    assert_equal "INTEGER", sql_type_for(col)
+    assert primary_key?(:legacy_integer_pk, "id"), "id is not primary key"
+  end
+
+  private
+
+    def column(table_name, column_name)
+      ActiveRecord::Base.connection
+        .columns(table_name.to_s)
+        .detect { |c| c.name == column_name.to_s }
+    end
+
+    def sql_type_for(col)
+      col && col.sql_type
+    end
+
+    def primary_key?(table_name, column)
+      ActiveRecord::Base.connection.execute("PRAGMA table_info(#{table_name})").find { |col| col["name"] == column }["pk"] == 1
+    end
+end
diff --git a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
index 80a37e83ff..9750840051 100644
--- a/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/quoting_test.rb
@@ -37,7 +37,7 @@ class SQLite3QuotingTest < ActiveRecord::SQLite3TestCase
   end
 
   def test_type_cast_nil
-    assert_equal nil, @conn.type_cast(nil)
+    assert_nil @conn.type_cast(nil)
   end
 
   def test_type_cast_true
diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 72f1b3b125..b75e2a47a6 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -1057,7 +1057,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     comment.parent = nil
     comment.save!
 
-    assert_equal nil, comment.reload.parent
+    assert_nil comment.reload.parent
     assert_equal 0, comments(:greetings).reload.children_count
   end
 
@@ -1072,6 +1072,20 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal 1, parent.reload.children_count
   end
 
+  def test_belongs_to_with_out_of_range_value_assigning
+    model = Class.new(Comment) do
+      def self.name; "Temp"; end
+      validates :post, presence: true
+    end
+
+    comment = model.new
+    comment.post_id = 9223372036854775808 # out of range in the bigint
+
+    assert_nil comment.post
+    assert_not comment.valid?
+    assert_equal [{ error: :blank }], comment.errors.details[:post]
+  end
+
   def test_polymorphic_with_custom_primary_key
     toy = Toy.create!
     sponsor = Sponsor.create!(sponsorable: toy)
diff --git a/activerecord/test/cases/associations/eager_load_nested_include_test.rb b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
index ed1b0f5226..e9f551b6b2 100644
--- a/activerecord/test/cases/associations/eager_load_nested_include_test.rb
+++ b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
@@ -12,7 +12,7 @@ module Remembered
 
   included do
     after_create :remember
-  protected
+  private
     def remember; self.class.remembered << self; end
   end
 
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index dc04ccdccc..ff1bf8acd4 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -241,7 +241,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     post = assert_queries(1) { Post.all.merge!(includes: { author_with_address: :author_address }).find(post.id) }
     # find the post, then find the author which is null so no query for the author or address
     assert_no_queries do
-      assert_equal nil, post.author_with_address
+      assert_nil post.author_with_address
     end
   end
 
@@ -250,7 +250,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     sponsor.update!(sponsorable: nil)
     sponsor = assert_queries(1) { Sponsor.all.merge!(includes: :sponsorable).find(sponsor.id) }
     assert_no_queries do
-      assert_equal nil, sponsor.sponsorable
+      assert_nil sponsor.sponsorable
     end
   end
 
@@ -261,7 +261,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
       assert_nothing_raised { Sponsor.all.merge!(includes: :sponsorable).find(sponsor.id) }
     end
     assert_no_queries do
-      assert_equal nil, sponsor.sponsorable
+      assert_nil sponsor.sponsorable
     end
   end
 
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index d657be71cc..482b086e5c 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -187,7 +187,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     ship.parts.clear
     part.reload
 
-    assert_equal nil, part.ship
+    assert_nil part.ship
     assert !part.updated_at_changed?
   end
 
@@ -2475,7 +2475,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   test "double insertion of new object to association when same association used in the after create callback of a new object" do
     reset_callbacks(:save, Bulb) do
-      Bulb.after_save { |record| record.car.bulbs.to_a }
+      Bulb.after_save { |record| record.car.bulbs.load }
       car = Car.create!
       car.bulbs << Bulb.new
       assert_equal 1, car.bulbs.size
diff --git a/activerecord/test/cases/associations/has_many_through_associations_test.rb b/activerecord/test/cases/associations/has_many_through_associations_test.rb
index 8defb09db7..fd79d4a5f9 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -402,7 +402,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
       end
     end
 
-    assert_equal nil, reference.reload.job_id
+    assert_nil reference.reload.job_id
   ensure
     Reference.make_comments = false
   end
@@ -423,7 +423,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     end
 
     # Check that the destroy callback on Reference did not run
-    assert_equal nil, person.reload.comments
+    assert_nil person.reload.comments
   ensure
     Reference.make_comments = false
   end
@@ -485,7 +485,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     end
 
     references.each do |reference|
-      assert_equal nil, reference.reload.job_id
+      assert_nil reference.reload.job_id
     end
   end
 
@@ -904,6 +904,13 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     assert_match(/Couldn't find all Clients with 'name'/, e.message)
   end
 
+  def test_collection_singular_ids_through_setter_raises_exception_when_invalid_ids_set
+    author = authors(:david)
+    ids = [categories(:general).name, "Unknown"]
+    e = assert_raises(ActiveRecord::RecordNotFound) { author.essay_category_ids = ids }
+    assert_equal "Couldn't find all Categories with 'name': (General, Unknown) (found 1 results, but was looking for 2)", e.message
+  end
+
   def test_build_a_model_from_hm_through_association_with_where_clause
     assert_nothing_raised { books(:awdr).subscribers.where(nick: "marklazz").build }
   end
diff --git a/activerecord/test/cases/associations/has_one_through_associations_test.rb b/activerecord/test/cases/associations/has_one_through_associations_test.rb
index 6ba062a248..432c3526a5 100644
--- a/activerecord/test/cases/associations/has_one_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_through_associations_test.rb
@@ -82,7 +82,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   def test_set_record_to_nil_should_delete_association
     @member.club = nil
     @member.reload
-    assert_equal nil, @member.current_membership
+    assert_nil @member.current_membership
     assert_nil @member.club
   end
 
@@ -110,12 +110,12 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     # conditions on the through table
     assert_equal clubs(:moustache_club), Member.all.merge!(includes: :favourite_club).find(@member.id).favourite_club
     memberships(:membership_of_favourite_club).update_columns(favourite: false)
-    assert_equal nil,                    Member.all.merge!(includes: :favourite_club).find(@member.id).reload.favourite_club
+    assert_nil Member.all.merge!(includes: :favourite_club).find(@member.id).reload.favourite_club
 
     # conditions on the source table
     assert_equal clubs(:moustache_club), Member.all.merge!(includes: :hairy_club).find(@member.id).hairy_club
     clubs(:moustache_club).update_columns(name: "Association of Clean-Shaven Persons")
-    assert_equal nil,                    Member.all.merge!(includes: :hairy_club).find(@member.id).reload.hairy_club
+    assert_nil Member.all.merge!(includes: :hairy_club).find(@member.id).reload.hairy_club
   end
 
   def test_has_one_through_polymorphic_with_source_type
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index ba6877a6a6..3dc0c0ce53 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -92,7 +92,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
 
   test "attribute keys on a new instance" do
     t = Topic.new
-    assert_equal nil, t.title, "The topics table has a title column, so it should be nil"
+    assert_nil t.title, "The topics table has a title column, so it should be nil"
     assert_raise(NoMethodError) { t.title2 }
   end
 
@@ -156,7 +156,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     keyboard = Keyboard.create
     keyboard.key_number = "10"
     assert_equal "10", keyboard.id_before_type_cast
-    assert_equal nil, keyboard.read_attribute_before_type_cast("id")
+    assert_nil keyboard.read_attribute_before_type_cast("id")
     assert_equal "10", keyboard.read_attribute_before_type_cast("key_number")
     assert_equal "10", keyboard.read_attribute_before_type_cast(:key_number)
   end
@@ -213,7 +213,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
 
       record.written_on = "345643456"
       assert_equal "345643456", record.written_on_before_type_cast
-      assert_equal nil, record.written_on
+      assert_nil record.written_on
 
       record.written_on = "2009-10-11 12:13:14"
       assert_equal "2009-10-11 12:13:14", record.written_on_before_type_cast
@@ -319,6 +319,13 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal "Still another topic: part 4", topic.title
   end
 
+  test "write_attribute can write aliased attributes as well" do
+    topic = Topic.new(title: "Don't change the topic")
+    topic.write_attribute :heading, "New topic"
+
+    assert_equal "New topic", topic.title
+  end
+
   test "read_attribute" do
     topic = Topic.new
     topic.title = "Don't change the topic"
@@ -329,6 +336,16 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal "Don't change the topic", topic[:title]
   end
 
+  test "read_attribute can read aliased attributes as well" do
+    topic = Topic.new(title: "Don't change the topic")
+
+    assert_equal "Don't change the topic", topic.read_attribute("heading")
+    assert_equal "Don't change the topic", topic["heading"]
+
+    assert_equal "Don't change the topic", topic.read_attribute(:heading)
+    assert_equal "Don't change the topic", topic[:heading]
+  end
+
   test "read_attribute raises ActiveModel::MissingAttributeError when the attribute does not exist" do
     computer = Computer.select("id").first
     assert_raises(ActiveModel::MissingAttributeError) { computer[:developer] }
@@ -737,7 +754,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   test "time zone-aware attributes do not recurse infinitely on invalid values" do
     in_time_zone "Pacific Time (US & Canada)" do
       record = @target.new(bonus_time: [])
-      assert_equal nil, record.bonus_time
+      assert_nil record.bonus_time
     end
   end
 
diff --git a/activerecord/test/cases/attribute_set_test.rb b/activerecord/test/cases/attribute_set_test.rb
index 059b5b2401..bd4b200735 100644
--- a/activerecord/test/cases/attribute_set_test.rb
+++ b/activerecord/test/cases/attribute_set_test.rb
@@ -25,7 +25,7 @@ module ActiveRecord
       attributes = builder.build_from_database(foo: "3.3")
 
       assert_equal "3.3", attributes[:foo].value_before_type_cast
-      assert_equal nil, attributes[:bar].value_before_type_cast
+      assert_nil attributes[:bar].value_before_type_cast
       assert_equal :bar, attributes[:bar].name
     end
 
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index a3f82ed49d..6d31b7a091 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -36,11 +36,11 @@ class TestAutosaveAssociationsInGeneral < ActiveRecord::TestCase
 
       private
 
-      def should_be_cool
-        unless self.first_name == "cool"
-          errors.add :first_name, "not cool"
+        def should_be_cool
+          unless self.first_name == "cool"
+            errors.add :first_name, "not cool"
+          end
         end
-      end
     }
     reference = Class.new(ActiveRecord::Base) {
       self.table_name = "references"
@@ -1391,6 +1391,14 @@ module AutosaveAssociationOnACollectionAssociationTests
     assert_equal "Squawky", parrot.reload.name
   end
 
+  def test_should_not_update_children_when_parent_creation_with_no_reason
+    parrot = Parrot.create!(name: "Polly")
+    assert_equal 0, parrot.updated_count
+
+    Pirate.create!(parrot_ids: [parrot.id], catchphrase: "Arrrr")
+    assert_equal 0, parrot.reload.updated_count
+  end
+
   def test_should_automatically_validate_the_associated_models
     @pirate.send(@association_name).each { |child| child.name = "" }
 
@@ -1699,3 +1707,27 @@ class TestAutosaveAssociationWithTouch < ActiveRecord::TestCase
     assert_nothing_raised { invoice.line_items.create(amount: 10) }
   end
 end
+
+class TestAutosaveAssociationOnAHasManyAssociationWithInverse < ActiveRecord::TestCase
+  class Post < ActiveRecord::Base
+    has_many :comments, inverse_of: :post
+  end
+
+  class Comment < ActiveRecord::Base
+    belongs_to :post, inverse_of: :comments
+
+    attr_accessor :post_comments_count
+    after_save do
+      self.post_comments_count = post.comments.count
+    end
+  end
+
+  def test_after_save_callback_with_autosave
+    post = Post.new(title: "Test", body: "...")
+    comment = post.comments.build(body: "...")
+    post.save!
+
+    assert_equal 1, post.comments.count
+    assert_equal 1, comment.post_comments_count
+  end
+end
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 4e9d78de5d..ad9bc60944 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -622,7 +622,7 @@ class BasicsTest < ActiveRecord::TestCase
       Topic.find(topic.id).destroy
     end
 
-    assert_equal nil, Topic.find_by_id(topic.id)
+    assert_nil Topic.find_by_id(topic.id)
   end
 
   def test_comparison_with_different_objects
diff --git a/activerecord/test/cases/callbacks_test.rb b/activerecord/test/cases/callbacks_test.rb
index 4b517e9d70..11ec6fb2c5 100644
--- a/activerecord/test/cases/callbacks_test.rb
+++ b/activerecord/test/cases/callbacks_test.rb
@@ -449,7 +449,7 @@ class CallbacksTest < ActiveRecord::TestCase
       assert david.valid?
       assert !david.save
       exc = assert_raise(ActiveRecord::RecordNotSaved) { david.save! }
-      assert_equal exc.record, david
+      assert_equal david, exc.record
       assert_equal "Failed to save the record", exc.message
     end
 
@@ -493,7 +493,7 @@ class CallbacksTest < ActiveRecord::TestCase
     assert_deprecated do
       assert !david.destroy
       exc = assert_raise(ActiveRecord::RecordNotDestroyed) { david.destroy! }
-      assert_equal exc.record, david
+      assert_equal david, exc.record
       assert_equal "Failed to destroy the record", exc.message
     end
     assert_not_nil ImmutableDeveloper.find_by_id(1)
@@ -527,7 +527,7 @@ class CallbacksTest < ActiveRecord::TestCase
     assert david.valid?
     assert !david.save
     exc = assert_raise(ActiveRecord::RecordNotSaved) { david.save! }
-    assert_equal exc.record, david
+    assert_equal david, exc.record
 
     david = DeveloperWithCanceledCallbacks.find(1)
     david.salary = 10_000_000
@@ -554,7 +554,7 @@ class CallbacksTest < ActiveRecord::TestCase
     david = DeveloperWithCanceledCallbacks.find(1)
     assert !david.destroy
     exc = assert_raise(ActiveRecord::RecordNotDestroyed) { david.destroy! }
-    assert_equal exc.record, david
+    assert_equal david, exc.record
     assert_not_nil ImmutableDeveloper.find_by_id(1)
 
     someone = CallbackHaltedDeveloper.find(1)
diff --git a/activerecord/test/cases/comment_test.rb b/activerecord/test/cases/comment_test.rb
index 262ad319be..a625299e8d 100644
--- a/activerecord/test/cases/comment_test.rb
+++ b/activerecord/test/cases/comment_test.rb
@@ -2,7 +2,6 @@ require "cases/helper"
 require "support/schema_dumping_helper"
 
 if ActiveRecord::Base.connection.supports_comments?
-
   class CommentTest < ActiveRecord::TestCase
     include SchemaDumpingHelper
 
@@ -102,6 +101,7 @@ if ActiveRecord::Base.connection.supports_comments?
       # Do all the stuff from other tests
       @connection.add_column    :commenteds, :rating, :integer, comment: "I am running out of imagination"
       @connection.change_column :commenteds, :content, :string, comment: "Whoa, content describes itself!"
+      @connection.change_column :commenteds, :content, :string
       @connection.change_column :commenteds, :obvious, :string, comment: nil
       @connection.add_index     :commenteds, :obvious, name: "idx_obvious", comment: "We need to see obvious comments"
 
@@ -135,5 +135,4 @@ if ActiveRecord::Base.connection.supports_comments?
       assert_no_match %r[t\.string\s+"absent_comment", comment:\n], output
     end
   end
-
 end
diff --git a/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb b/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
index a8955152c3..8faa67255d 100644
--- a/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
+++ b/activerecord/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb
@@ -142,13 +142,13 @@ module ActiveRecord
                      "database" => "foo",
                      "host"     => "localhost" }
         assert_equal expected, actual["default_env"]
-        assert_equal nil,      actual["production"]
-        assert_equal nil,      actual["development"]
-        assert_equal nil,      actual["test"]
-        assert_equal nil,      actual[:default_env]
-        assert_equal nil,      actual[:production]
-        assert_equal nil,      actual[:development]
-        assert_equal nil,      actual[:test]
+        assert_nil actual["production"]
+        assert_nil actual["development"]
+        assert_nil actual["test"]
+        assert_nil actual[:default_env]
+        assert_nil actual[:production]
+        assert_nil actual[:development]
+        assert_nil actual[:test]
       end
 
       def test_blank_with_database_url_with_rails_env
@@ -162,15 +162,15 @@ module ActiveRecord
                      "host"     => "localhost" }
 
         assert_equal expected, actual["not_production"]
-        assert_equal nil,      actual["production"]
-        assert_equal nil,      actual["default_env"]
-        assert_equal nil,      actual["development"]
-        assert_equal nil,      actual["test"]
-        assert_equal nil,      actual[:default_env]
-        assert_equal nil,      actual[:not_production]
-        assert_equal nil,      actual[:production]
-        assert_equal nil,      actual[:development]
-        assert_equal nil,      actual[:test]
+        assert_nil actual["production"]
+        assert_nil actual["default_env"]
+        assert_nil actual["development"]
+        assert_nil actual["test"]
+        assert_nil actual[:default_env]
+        assert_nil actual[:not_production]
+        assert_nil actual[:production]
+        assert_nil actual[:development]
+        assert_nil actual[:test]
       end
 
       def test_blank_with_database_url_with_rack_env
@@ -184,15 +184,15 @@ module ActiveRecord
                      "host"     => "localhost" }
 
         assert_equal expected, actual["not_production"]
-        assert_equal nil,      actual["production"]
-        assert_equal nil,      actual["default_env"]
-        assert_equal nil,      actual["development"]
-        assert_equal nil,      actual["test"]
-        assert_equal nil,      actual[:default_env]
-        assert_equal nil,      actual[:not_production]
-        assert_equal nil,      actual[:production]
-        assert_equal nil,      actual[:development]
-        assert_equal nil,      actual[:test]
+        assert_nil actual["production"]
+        assert_nil actual["default_env"]
+        assert_nil actual["development"]
+        assert_nil actual["test"]
+        assert_nil actual[:default_env]
+        assert_nil actual[:not_production]
+        assert_nil actual[:production]
+        assert_nil actual[:development]
+        assert_nil actual[:test]
       end
 
       def test_database_url_with_ipv6_host_and_port
diff --git a/activerecord/test/cases/connection_adapters/schema_cache_test.rb b/activerecord/test/cases/connection_adapters/schema_cache_test.rb
index d4459603af..1b4f80fc67 100644
--- a/activerecord/test/cases/connection_adapters/schema_cache_test.rb
+++ b/activerecord/test/cases/connection_adapters/schema_cache_test.rb
@@ -12,6 +12,33 @@ module ActiveRecord
         assert_equal "id", @cache.primary_keys("posts")
       end
 
+      def test_yaml_dump_and_load
+        @cache.columns("posts")
+        @cache.columns_hash("posts")
+        @cache.data_sources("posts")
+        @cache.primary_keys("posts")
+
+        new_cache = YAML.load(YAML.dump(@cache))
+        assert_no_queries do
+          assert_equal 11, new_cache.columns("posts").size
+          assert_equal 11, new_cache.columns_hash("posts").size
+          assert new_cache.data_sources("posts")
+          assert_equal "id", new_cache.primary_keys("posts")
+        end
+      end
+
+      def test_yaml_loads_5_1_dump
+        body = File.open(schema_dump_path).read
+        cache = YAML.load(body)
+
+        assert_no_queries do
+          assert_equal 11, cache.columns("posts").size
+          assert_equal 11, cache.columns_hash("posts").size
+          assert cache.data_sources("posts")
+          assert_equal "id", cache.primary_keys("posts")
+        end
+      end
+
       def test_primary_key_for_non_existent_table
         assert_nil @cache.primary_keys("omgponies")
       end
@@ -45,10 +72,12 @@ module ActiveRecord
 
         @cache = Marshal.load(Marshal.dump(@cache))
 
-        assert_equal 11, @cache.columns("posts").size
-        assert_equal 11, @cache.columns_hash("posts").size
-        assert @cache.data_sources("posts")
-        assert_equal "id", @cache.primary_keys("posts")
+        assert_no_queries do
+          assert_equal 11, @cache.columns("posts").size
+          assert_equal 11, @cache.columns_hash("posts").size
+          assert @cache.data_sources("posts")
+          assert_equal "id", @cache.primary_keys("posts")
+        end
       end
 
       def test_table_methods_deprecation
@@ -56,6 +85,12 @@ module ActiveRecord
         assert_deprecated { assert @cache.tables("posts") }
         assert_deprecated { @cache.clear_table_cache!("posts") }
       end
+
+      private
+
+        def schema_dump_path
+          "test/assets/schema_dump_5_1.yml"
+        end
     end
   end
 end
diff --git a/activerecord/test/cases/connection_pool_test.rb b/activerecord/test/cases/connection_pool_test.rb
index 1d4cd3c78b..42600e53fd 100644
--- a/activerecord/test/cases/connection_pool_test.rb
+++ b/activerecord/test/cases/connection_pool_test.rb
@@ -501,11 +501,11 @@ module ActiveRecord
                 first_thread.join(2)
                 second_thread.join(2)
 
-                puts '---'
+                puts "---"
                 p [first_thread, second_thread]
                 p pool.stat
                 p pool.connections.map(&:owner)
-                puts '<<<'
+                puts "<<<"
                 puts
               end
 
diff --git a/activerecord/test/cases/defaults_test.rb b/activerecord/test/cases/defaults_test.rb
index fcaff38f82..6532efcf22 100644
--- a/activerecord/test/cases/defaults_test.rb
+++ b/activerecord/test/cases/defaults_test.rb
@@ -169,7 +169,7 @@ if current_adapter?(:Mysql2Adapter)
           assert_nil record.non_null_text
           assert_nil record.non_null_blob
 
-          assert_raises(ActiveRecord::StatementInvalid) { klass.create }
+          assert_raises(ActiveRecord::NotNullViolation) { klass.create }
         end
       end
     end
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 7eaf31aa24..d6d24004fe 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -488,12 +488,12 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal topics(:fourth), Topic.offset(1).second_to_last
     assert_equal topics(:fourth), Topic.offset(2).second_to_last
     assert_equal topics(:fourth), Topic.offset(3).second_to_last
-    assert_equal nil, Topic.offset(4).second_to_last
-    assert_equal nil, Topic.offset(5).second_to_last
+    assert_nil Topic.offset(4).second_to_last
+    assert_nil Topic.offset(5).second_to_last
 
     #test with limit
-    # assert_equal nil, Topic.limit(1).second # TODO: currently failing
-    assert_equal nil, Topic.limit(1).second_to_last
+    # assert_nil Topic.limit(1).second # TODO: currently failing
+    assert_nil Topic.limit(1).second_to_last
   end
 
   def test_second_to_last_have_primary_key_order_by_default
@@ -516,15 +516,15 @@ class FinderTest < ActiveRecord::TestCase
     # test with offset
     assert_equal topics(:third), Topic.offset(1).third_to_last
     assert_equal topics(:third), Topic.offset(2).third_to_last
-    assert_equal nil, Topic.offset(3).third_to_last
-    assert_equal nil, Topic.offset(4).third_to_last
-    assert_equal nil, Topic.offset(5).third_to_last
+    assert_nil Topic.offset(3).third_to_last
+    assert_nil Topic.offset(4).third_to_last
+    assert_nil Topic.offset(5).third_to_last
 
     # test with limit
-    # assert_equal nil, Topic.limit(1).third # TODO: currently failing
-    assert_equal nil, Topic.limit(1).third_to_last
-    # assert_equal nil, Topic.limit(2).third # TODO: currently failing
-    assert_equal nil, Topic.limit(2).third_to_last
+    # assert_nil Topic.limit(1).third # TODO: currently failing
+    assert_nil Topic.limit(1).third_to_last
+    # assert_nil Topic.limit(2).third # TODO: currently failing
+    assert_nil Topic.limit(2).third_to_last
   end
 
   def test_third_to_last_have_primary_key_order_by_default
@@ -983,7 +983,6 @@ class FinderTest < ActiveRecord::TestCase
 
     assert_equal devs[2], Developer.offset(2).first
     assert_equal devs[-3], Developer.offset(2).last
-    assert_equal devs[-3], Developer.offset(2).last
     assert_equal devs[-3], Developer.offset(2).order("id DESC").first
   end
 
@@ -1167,7 +1166,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   test "find_by returns nil if the record is missing" do
-    assert_equal nil, Post.find_by("1 = 0")
+    assert_nil Post.find_by("1 = 0")
   end
 
   test "find_by with associations" do
@@ -1221,7 +1220,7 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal tyre2, zyke.tyres.custom_find_by(id: tyre2.id)
   end
 
-  protected
+  private
     def table_with_custom_primary_key
       yield(Class.new(Toy) do
         def self.name
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
index f3d0e4a1b1..dd48053823 100644
--- a/activerecord/test/cases/fixtures_test.rb
+++ b/activerecord/test/cases/fixtures_test.rb
@@ -12,9 +12,11 @@ require "models/company"
 require "models/computer"
 require "models/course"
 require "models/developer"
+require "models/dog"
 require "models/doubloon"
 require "models/joke"
 require "models/matey"
+require "models/other_dog"
 require "models/parrot"
 require "models/pirate"
 require "models/post"
@@ -211,9 +213,19 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_dirty_dirty_yaml_file
-    assert_raise(ActiveRecord::Fixture::FormatError) do
-      ActiveRecord::FixtureSet.new(Account.connection, "courses", Course, FIXTURES_ROOT + "/naked/yml/courses")
+    fixture_path = FIXTURES_ROOT + "/naked/yml/courses"
+    error = assert_raise(ActiveRecord::Fixture::FormatError) do
+      ActiveRecord::FixtureSet.new(Account.connection, "courses", Course, fixture_path)
     end
+    assert_equal "fixture is not a hash: #{fixture_path}.yml", error.to_s
+  end
+
+  def test_yaml_file_with_one_invalid_fixture
+    fixture_path = FIXTURES_ROOT + "/naked/yml/courses_with_invalid_key"
+    error = assert_raise(ActiveRecord::Fixture::FormatError) do
+      ActiveRecord::FixtureSet.new(Account.connection, "courses", Course, fixture_path)
+    end
+    assert_equal "fixture key is not a hash: #{fixture_path}.yml, keys: [\"two\"]", error.to_s
   end
 
   def test_yaml_file_with_invalid_column
@@ -1011,3 +1023,16 @@ class FixtureClassNamesTest < ActiveRecord::TestCase
     assert_nil fixture_class_names["unregistered_identifier"]
   end
 end
+
+class SameNameDifferentDatabaseFixturesTest < ActiveRecord::TestCase
+  fixtures :dogs, :other_dogs
+
+  test "fixtures are properly loaded" do
+    # Force loading the fixtures again to reproduce issue
+    ActiveRecord::FixtureSet.reset_cache
+    create_fixtures("dogs", "other_dogs")
+
+    assert_kind_of Dog, dogs(:sophie)
+    assert_kind_of OtherDog, other_dogs(:lassie)
+  end
+end
diff --git a/activerecord/test/cases/integration_test.rb b/activerecord/test/cases/integration_test.rb
index 00457965d7..d7aa091623 100644
--- a/activerecord/test/cases/integration_test.rb
+++ b/activerecord/test/cases/integration_test.rb
@@ -15,7 +15,7 @@ class IntegrationTest < ActiveRecord::TestCase
 
   def test_to_param_returns_nil_if_not_persisted
     client = Client.new
-    assert_equal nil, client.to_param
+    assert_nil client.to_param
   end
 
   def test_to_param_returns_id_if_not_persisted_but_id_is_set
@@ -89,7 +89,7 @@ class IntegrationTest < ActiveRecord::TestCase
 
   def test_to_param_class_method_uses_default_if_not_persisted
     firm = Firm.new(name: "Fancy Shirts")
-    assert_equal nil, firm.to_param
+    assert_nil firm.to_param
   end
 
   def test_to_param_with_no_arguments
diff --git a/activerecord/test/cases/json_serialization_test.rb b/activerecord/test/cases/json_serialization_test.rb
index a2150483f3..155e858822 100644
--- a/activerecord/test/cases/json_serialization_test.rb
+++ b/activerecord/test/cases/json_serialization_test.rb
@@ -243,7 +243,7 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
 
     assert !@david.posts.first.respond_to?(:favorite_quote)
     assert_match %r{"favorite_quote":"Constraints are liberating"}, json
-    assert_equal %r{"favorite_quote":}.match(json).size, 1
+    assert_equal 1, %r{"favorite_quote":}.match(json).size
   end
 
   def test_should_allow_only_option_for_list_of_authors
diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index 9b0ec54aa7..95fb670dac 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -579,7 +579,7 @@ unless in_memory_db?
         assert first.end > second.end
       end
 
-      protected
+      private
 
       def duel(zzz = 5)
         t0, t1, t2, t3 = nil, nil, nil, nil
diff --git a/activerecord/test/cases/migration/change_schema_test.rb b/activerecord/test/cases/migration/change_schema_test.rb
index bdb90eaa74..03f9c4a9ed 100644
--- a/activerecord/test/cases/migration/change_schema_test.rb
+++ b/activerecord/test/cases/migration/change_schema_test.rb
@@ -43,7 +43,7 @@ module ActiveRecord
           t.column :foo, :string, null: false
         end
 
-        assert_raises(ActiveRecord::StatementInvalid) do
+        assert_raises(ActiveRecord::NotNullViolation) do
           connection.execute "insert into testings (foo) values (NULL)"
         end
       end
@@ -233,7 +233,7 @@ module ActiveRecord
           end
           connection.add_column :testings, :bar, :string, null: false
 
-          assert_raise(ActiveRecord::StatementInvalid) do
+          assert_raise(ActiveRecord::NotNullViolation) do
             connection.execute "insert into testings (foo, bar) values ('hello', NULL)"
           end
         end
@@ -244,12 +244,16 @@ module ActiveRecord
           t.column :foo, :string
         end
 
-        con = connection
-        connection.execute "insert into testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}) values (1, 'hello')"
-        assert_nothing_raised { connection.add_column :testings, :bar, :string, null: false, default: "default" }
+        quoted_id  = connection.quote_column_name("id")
+        quoted_foo = connection.quote_column_name("foo")
+        quoted_bar = connection.quote_column_name("bar")
+        connection.execute("insert into testings (#{quoted_id}, #{quoted_foo}) values (1, 'hello')")
+        assert_nothing_raised do
+          connection.add_column :testings, :bar, :string, null: false, default: "default"
+        end
 
-        assert_raises(ActiveRecord::StatementInvalid) do
-          connection.execute "insert into testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}, #{con.quote_column_name('bar')}) values (2, 'hello', NULL)"
+        assert_raises(ActiveRecord::NotNullViolation) do
+          connection.execute("insert into testings (#{quoted_id}, #{quoted_foo}, #{quoted_bar}) values (2, 'hello', NULL)")
         end
       end
 
diff --git a/activerecord/test/cases/migration/change_table_test.rb b/activerecord/test/cases/migration/change_table_test.rb
index ec817a579b..8a4242cf1d 100644
--- a/activerecord/test/cases/migration/change_table_test.rb
+++ b/activerecord/test/cases/migration/change_table_test.rb
@@ -101,7 +101,12 @@ module ActiveRecord
 
       def test_primary_key_creates_primary_key_column
         with_change_table do |t|
-          @connection.expect :add_column, nil, [:delete_me, :id, :primary_key, primary_key: true, first: true]
+          if current_adapter?(:Mysql2Adapter)
+            @connection.expect :add_column, nil, [:delete_me, :id, :primary_key, { first: true, auto_increment: true, limit: 8, primary_key: true }]
+          else
+            @connection.expect :add_column, nil, [:delete_me, :id, :primary_key, primary_key: true, first: true]
+          end
+
           t.primary_key :id, first: true
         end
       end
diff --git a/activerecord/test/cases/migration/foreign_key_test.rb b/activerecord/test/cases/migration/foreign_key_test.rb
index cab2069754..9be6667aa1 100644
--- a/activerecord/test/cases/migration/foreign_key_test.rb
+++ b/activerecord/test/cases/migration/foreign_key_test.rb
@@ -76,7 +76,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
         end
 
         def test_add_foreign_key_with_non_standard_primary_key
-          with_example_table @connection, "space_shuttles", "pk integer PRIMARY KEY" do
+          with_example_table @connection, "space_shuttles", "pk BIGINT PRIMARY KEY" do
             @connection.add_foreign_key(:astronauts, :space_shuttles,
                                         column: "rocket_id", primary_key: "pk", name: "custom_pk")
 
@@ -101,7 +101,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
           fk = foreign_keys.first
           if current_adapter?(:Mysql2Adapter)
             # ON DELETE RESTRICT is the default on MySQL
-            assert_equal nil, fk.on_delete
+            assert_nil fk.on_delete
           else
             assert_equal :restrict, fk.on_delete
           end
@@ -229,7 +229,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
             create_table("cities") { |t| }
 
             create_table("houses") do |t|
-              t.column :city_id, :integer
+              t.column :city_id, :bigint
             end
             add_foreign_key :houses, :cities, column: "city_id"
 
@@ -261,7 +261,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
             create_table(:schools)
 
             create_table(:classes) do |t|
-              t.column :school_id, :integer
+              t.column :school_id, :bigint
             end
             add_foreign_key :classes, :schools
           end
diff --git a/activerecord/test/cases/migration/references_foreign_key_test.rb b/activerecord/test/cases/migration/references_foreign_key_test.rb
index 528811db49..4957ab8b3d 100644
--- a/activerecord/test/cases/migration/references_foreign_key_test.rb
+++ b/activerecord/test/cases/migration/references_foreign_key_test.rb
@@ -42,7 +42,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
 
         test "options hash can be passed" do
           @connection.change_table :testing_parents do |t|
-            t.integer :other_id
+            t.bigint :other_id
             t.index :other_id, unique: true
           end
           @connection.create_table :testings do |t|
@@ -92,7 +92,7 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
 
         test "foreign keys accept options when changing the table" do
           @connection.change_table :testing_parents do |t|
-            t.integer :other_id
+            t.bigint :other_id
             t.index :other_id, unique: true
           end
           @connection.create_table :testings
@@ -177,8 +177,8 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
 
         test "multiple foreign keys can be added to the same table" do
           @connection.create_table :testings do |t|
-            t.integer :col_1
-            t.integer :col_2
+            t.bigint :col_1
+            t.bigint :col_2
 
             t.foreign_key :testing_parents, column: :col_1
             t.foreign_key :testing_parents, column: :col_2
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index 22484ad678..082cfd3242 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -705,7 +705,7 @@ class MigrationTest < ActiveRecord::TestCase
     end
   end
 
-  protected
+  private
     # This is needed to isolate class_attribute assignments like `table_name_prefix`
     # for each test case.
     def new_isolated_reminder_class
diff --git a/activerecord/test/cases/primary_keys_test.rb b/activerecord/test/cases/primary_keys_test.rb
index eaaf50d14f..1d72899102 100644
--- a/activerecord/test/cases/primary_keys_test.rb
+++ b/activerecord/test/cases/primary_keys_test.rb
@@ -129,12 +129,6 @@ class PrimaryKeysTest < ActiveRecord::TestCase
     assert_nothing_raised { MixedCaseMonkey.find(1).destroy }
   end
 
-  def test_supports_primary_key
-    assert_nothing_raised do
-      ActiveRecord::Base.connection.supports_primary_key?
-    end
-  end
-
   if ActiveRecord::Base.connection.supports_primary_key?
     def test_primary_key_returns_value_if_it_exists
       klass = Class.new(ActiveRecord::Base) do
@@ -216,6 +210,43 @@ class PrimaryKeyWithNoConnectionTest < ActiveRecord::TestCase
   end
 end
 
+class PrimaryKeyWithAutoIncrementTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  class AutoIncrement < ActiveRecord::Base
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    @connection.drop_table(:auto_increments, if_exists: true)
+  end
+
+  def test_primary_key_with_auto_increment
+    @connection.create_table(:auto_increments, id: :integer, auto_increment: true, force: true)
+    assert_auto_incremented
+  end
+
+  def test_primary_key_with_auto_increment_and_bigint
+    @connection.create_table(:auto_increments, id: :bigint, auto_increment: true, force: true)
+    assert_auto_incremented
+  end
+
+  private
+    def assert_auto_incremented
+      record1 = AutoIncrement.create!
+      assert_not_nil record1.id
+
+      record1.destroy
+
+      record2 = AutoIncrement.create!
+      assert_not_nil record2.id
+      assert_operator record2.id, :>, record1.id
+    end
+end
+
 class PrimaryKeyAnyTypeTest < ActiveRecord::TestCase
   include SchemaDumpingHelper
 
@@ -289,85 +320,69 @@ class CompositePrimaryKeyTest < ActiveRecord::TestCase
 end
 
 if current_adapter?(:Mysql2Adapter)
-  class PrimaryKeyBigintNilDefaultTest < ActiveRecord::TestCase
+  class PrimaryKeyIntegerNilDefaultTest < ActiveRecord::TestCase
     include SchemaDumpingHelper
 
     self.use_transactional_tests = false
 
     def setup
       @connection = ActiveRecord::Base.connection
-      @connection.create_table(:bigint_defaults, id: :bigint, default: nil, force: true)
+      @connection.create_table(:int_defaults, id: :integer, default: nil, force: true)
     end
 
     def teardown
-      @connection.drop_table :bigint_defaults, if_exists: true
+      @connection.drop_table :int_defaults, if_exists: true
     end
 
-    test "primary key with bigint allows default override via nil" do
-      column = @connection.columns(:bigint_defaults).find { |c| c.name == "id" }
-      assert column.bigint?
+    test "primary key with integer allows default override via nil" do
+      column = @connection.columns(:int_defaults).find { |c| c.name == "id" }
+      assert_equal :integer, column.type
       assert_not column.auto_increment?
     end
 
-    test "schema dump primary key with bigint default nil" do
-      schema = dump_table_schema "bigint_defaults"
-      assert_match %r{create_table "bigint_defaults", id: :bigint, default: nil}, schema
+    test "schema dump primary key with int default nil" do
+      schema = dump_table_schema "int_defaults"
+      assert_match %r{create_table "int_defaults", id: :integer, default: nil}, schema
     end
   end
 end
 
-if current_adapter?(:PostgreSQLAdapter, :Mysql2Adapter)
-  class PrimaryKeyBigSerialTest < ActiveRecord::TestCase
-    include SchemaDumpingHelper
+class PrimaryKeyIntegerTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
 
-    self.use_transactional_tests = false
+  self.use_transactional_tests = false
 
-    class Widget < ActiveRecord::Base
-    end
+  class Widget < ActiveRecord::Base
+  end
 
-    setup do
-      @connection = ActiveRecord::Base.connection
-      if current_adapter?(:PostgreSQLAdapter)
-        @connection.create_table(:widgets, id: :bigserial, force: true)
-      else
-        @connection.create_table(:widgets, id: :bigint, force: true)
-      end
-    end
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table(:widgets, force: true)
+  end
 
-    teardown do
-      @connection.drop_table :widgets, if_exists: true
-      Widget.reset_column_information
-    end
+  teardown do
+    @connection.drop_table :widgets, if_exists: true
+    Widget.reset_column_information
+  end
 
-    test "primary key column type with bigserial" do
-      column_type = Widget.type_for_attribute(Widget.primary_key)
-      assert_equal :integer, column_type.type
-      assert_equal 8, column_type.limit
+  if current_adapter?(:PostgreSQLAdapter, :Mysql2Adapter)
+    test "schema dump primary key with bigserial" do
+      schema = dump_table_schema "widgets"
+      assert_match %r{create_table "widgets", force: :cascade}, schema
     end
+  end
 
-    test "primary key with bigserial are automatically numbered" do
-      widget = Widget.create!
-      assert_not_nil widget.id
-    end
+  test "primary key column type" do
+    column_type = Widget.type_for_attribute(Widget.primary_key)
+    assert_equal :integer, column_type.type
 
-    test "schema dump primary key with bigserial" do
-      schema = dump_table_schema "widgets"
-      if current_adapter?(:PostgreSQLAdapter)
-        assert_match %r{create_table "widgets", id: :bigserial, force: :cascade}, schema
-      else
-        assert_match %r{create_table "widgets", id: :bigint, force: :cascade}, schema
-      end
+    if current_adapter?(:PostgreSQLAdapter, :Mysql2Adapter)
+      assert_equal 8, column_type.limit
     end
 
     if current_adapter?(:Mysql2Adapter)
-      test "primary key column type with options" do
-        @connection.create_table(:widgets, id: :primary_key, limit: 8, unsigned: true, force: true)
-        column = @connection.columns(:widgets).find { |c| c.name == "id" }
-        assert column.auto_increment?
-        assert_equal :integer, column.type
-        assert_equal 8, column.limit
-        assert column.unsigned?
-      end
+      column = @connection.columns(:widgets).find { |c| c.name == "id" }
+      assert column.auto_increment?
     end
   end
 end
diff --git a/activerecord/test/cases/query_cache_test.rb b/activerecord/test/cases/query_cache_test.rb
index 90054ce83d..4a49bfe9b1 100644
--- a/activerecord/test/cases/query_cache_test.rb
+++ b/activerecord/test/cases/query_cache_test.rb
@@ -202,6 +202,20 @@ class QueryCacheTest < ActiveRecord::TestCase
     ActiveSupport::Notifications.unsubscribe subscriber
   end
 
+  def test_query_cache_does_not_allow_sql_key_mutation
+    subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+      payload[:sql].downcase!
+    end
+
+    assert_raises RuntimeError do
+      ActiveRecord::Base.cache do
+        assert_queries(1) { Task.find(1); Task.find(1) }
+      end
+    end
+  ensure
+    ActiveSupport::Notifications.unsubscribe subscriber
+  end
+
   def test_cache_is_flat
     Task.cache do
       assert_queries(1) { Topic.find(1); Topic.find(1); }
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index 5dac3d064b..a90058e8bb 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -86,8 +86,8 @@ class ReflectionTest < ActiveRecord::TestCase
     column = @first.column_for_attribute("attribute_that_doesnt_exist")
     assert_instance_of ActiveRecord::ConnectionAdapters::NullColumn, column
     assert_equal "attribute_that_doesnt_exist", column.name
-    assert_equal nil, column.sql_type
-    assert_equal nil, column.type
+    assert_nil column.sql_type
+    assert_nil column.type
   end
 
   def test_non_existent_types_are_identity_types
diff --git a/activerecord/test/cases/relation/or_test.rb b/activerecord/test/cases/relation/or_test.rb
index 2796595523..abb7ca72dd 100644
--- a/activerecord/test/cases/relation/or_test.rb
+++ b/activerecord/test/cases/relation/or_test.rb
@@ -79,7 +79,7 @@ module ActiveRecord
       expected = Post.where("id = 1 or id = 2").to_a
       p = Post.where("id = 1")
       p.load
-      assert_equal p.loaded?, true
+      assert_equal true, p.loaded?
       assert_equal expected, p.or(Post.where("id = 2")).to_a
     end
 
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 96833ad428..981c2d758d 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -442,7 +442,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_no_queries(ignore_none: false) do
       assert_equal 0, Developer.none.count
       assert_equal 0, Developer.none.calculate(:count, nil)
-      assert_equal nil, Developer.none.calculate(:average, "salary")
+      assert_nil Developer.none.calculate(:average, "salary")
     end
   end
 
@@ -485,28 +485,28 @@ class RelationTest < ActiveRecord::TestCase
   def test_null_relation_average
     ac = Aircraft.new
     assert_equal Hash.new, ac.engines.group(:car_id).average(:id)
-    assert_equal nil, ac.engines.average(:id)
+    assert_nil ac.engines.average(:id)
     ac.save
     assert_equal Hash.new, ac.engines.group(:car_id).average(:id)
-    assert_equal nil, ac.engines.average(:id)
+    assert_nil ac.engines.average(:id)
   end
 
   def test_null_relation_minimum
     ac = Aircraft.new
     assert_equal Hash.new, ac.engines.group(:car_id).minimum(:id)
-    assert_equal nil, ac.engines.minimum(:id)
+    assert_nil ac.engines.minimum(:id)
     ac.save
     assert_equal Hash.new, ac.engines.group(:car_id).minimum(:id)
-    assert_equal nil, ac.engines.minimum(:id)
+    assert_nil ac.engines.minimum(:id)
   end
 
   def test_null_relation_maximum
     ac = Aircraft.new
     assert_equal Hash.new, ac.engines.group(:car_id).maximum(:id)
-    assert_equal nil, ac.engines.maximum(:id)
+    assert_nil ac.engines.maximum(:id)
     ac.save
     assert_equal Hash.new, ac.engines.group(:car_id).maximum(:id)
-    assert_equal nil, ac.engines.maximum(:id)
+    assert_nil ac.engines.maximum(:id)
   end
 
   def test_null_relation_in_where_condition
@@ -1814,7 +1814,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   test "find_by returns nil if the record is missing" do
-    assert_equal nil, Post.all.find_by("1 = 0")
+    assert_nil Post.all.find_by("1 = 0")
   end
 
   test "find_by doesn't have implicit ordering" do
diff --git a/activerecord/test/cases/schema_dumper_test.rb b/activerecord/test/cases/schema_dumper_test.rb
index 007f976f2e..bea78d2a95 100644
--- a/activerecord/test/cases/schema_dumper_test.rb
+++ b/activerecord/test/cases/schema_dumper_test.rb
@@ -148,12 +148,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
       assert_match %r{c_int_4.*limit: 4}, output
     end
 
-    if current_adapter?(:SQLite3Adapter)
-      assert_match %r{c_int_5.*limit: 5}, output
-      assert_match %r{c_int_6.*limit: 6}, output
-      assert_match %r{c_int_7.*limit: 7}, output
-      assert_match %r{c_int_8.*limit: 8}, output
-    elsif current_adapter?(:OracleAdapter)
+    if current_adapter?(:SQLite3Adapter, :OracleAdapter)
       assert_match %r{c_int_5.*limit: 5}, output
       assert_match %r{c_int_6.*limit: 6}, output
       assert_match %r{c_int_7.*limit: 7}, output
@@ -346,7 +341,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
       create_table("dogs") do |t|
         t.column :name, :string
-        t.column :owner_id, :integer
+        t.column :owner_id, :bigint
         t.index [:name]
         t.foreign_key :dog_owners, column: "owner_id" if supports_foreign_keys?
       end
diff --git a/activerecord/test/cases/scoping/default_scoping_test.rb b/activerecord/test/cases/scoping/default_scoping_test.rb
index b3dc979720..b408a6000b 100644
--- a/activerecord/test/cases/scoping/default_scoping_test.rb
+++ b/activerecord/test/cases/scoping/default_scoping_test.rb
@@ -50,7 +50,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   def test_default_scope_with_conditions_string
     assert_equal Developer.where(name: "David").map(&:id).sort, DeveloperCalledDavid.all.map(&:id).sort
-    assert_equal nil, DeveloperCalledDavid.create!.name
+    assert_nil DeveloperCalledDavid.create!.name
   end
 
   def test_default_scope_with_conditions_hash
@@ -314,7 +314,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
   end
 
   def test_create_attribute_overwrites_default_values
-    assert_equal nil, PoorDeveloperCalledJamis.create!(salary: nil).salary
+    assert_nil PoorDeveloperCalledJamis.create!(salary: nil).salary
     assert_equal 50000, PoorDeveloperCalledJamis.create!(name: "David").salary
   end
 
diff --git a/activerecord/test/cases/scoping/relation_scoping_test.rb b/activerecord/test/cases/scoping/relation_scoping_test.rb
index 47310a151e..a1ae57fdbb 100644
--- a/activerecord/test/cases/scoping/relation_scoping_test.rb
+++ b/activerecord/test/cases/scoping/relation_scoping_test.rb
@@ -277,7 +277,7 @@ class NestedRelationScopingTest < ActiveRecord::TestCase
         assert_equal "David", Developer.first.name
 
         Developer.unscoped.where("name = 'Maiha'") do
-          assert_equal nil, Developer.first
+          assert_nil Developer.first
         end
 
         # ensure that scoping is restored
diff --git a/activerecord/test/cases/secure_token_test.rb b/activerecord/test/cases/secure_token_test.rb
index eda0229c26..7b9cbee40a 100644
--- a/activerecord/test/cases/secure_token_test.rb
+++ b/activerecord/test/cases/secure_token_test.rb
@@ -27,6 +27,6 @@ class SecureTokenTest < ActiveRecord::TestCase
     @user.token = "custom-secure-token"
     @user.save
 
-    assert_equal @user.token, "custom-secure-token"
+    assert_equal "custom-secure-token", @user.token
   end
 end
diff --git a/activerecord/test/cases/serialized_attribute_test.rb b/activerecord/test/cases/serialized_attribute_test.rb
index 1ccbf3ed4a..a469da0a5b 100644
--- a/activerecord/test/cases/serialized_attribute_test.rb
+++ b/activerecord/test/cases/serialized_attribute_test.rb
@@ -185,14 +185,14 @@ class SerializedAttributeTest < ActiveRecord::TestCase
     topic = Topic.new(content: true)
     assert topic.save
     topic = topic.reload
-    assert_equal topic.content, true
+    assert_equal true, topic.content
   end
 
   def test_serialized_boolean_value_false
     topic = Topic.new(content: false)
     assert topic.save
     topic = topic.reload
-    assert_equal topic.content, false
+    assert_equal false, topic.content
   end
 
   def test_serialize_with_coder
@@ -211,7 +211,7 @@ class SerializedAttributeTest < ActiveRecord::TestCase
     topic.save!
     topic.reload
     assert_kind_of some_class, topic.content
-    assert_equal topic.content, some_class.new("my value")
+    assert_equal some_class.new("my value"), topic.content
   end
 
   def test_serialize_attribute_via_select_method_when_time_zone_available
diff --git a/activerecord/test/cases/tasks/mysql_rake_test.rb b/activerecord/test/cases/tasks/mysql_rake_test.rb
index dbe935808e..285e718596 100644
--- a/activerecord/test/cases/tasks/mysql_rake_test.rb
+++ b/activerecord/test/cases/tasks/mysql_rake_test.rb
@@ -59,7 +59,7 @@ if current_adapter?(:Mysql2Adapter)
       def test_when_database_created_successfully_outputs_info_to_stdout
         ActiveRecord::Tasks::DatabaseTasks.create @configuration
 
-        assert_equal $stdout.string, "Created database 'my-app-db'\n"
+        assert_equal "Created database 'my-app-db'\n", $stdout.string
       end
 
       def test_create_when_database_exists_outputs_info_to_stderr
@@ -69,7 +69,7 @@ if current_adapter?(:Mysql2Adapter)
 
         ActiveRecord::Tasks::DatabaseTasks.create @configuration
 
-        assert_equal $stderr.string, "Database 'my-app-db' already exists\n"
+        assert_equal "Database 'my-app-db' already exists\n", $stderr.string
       end
     end
 
@@ -205,7 +205,7 @@ if current_adapter?(:Mysql2Adapter)
       def test_when_database_dropped_successfully_outputs_info_to_stdout
         ActiveRecord::Tasks::DatabaseTasks.drop @configuration
 
-        assert_equal $stdout.string, "Dropped database 'my-app-db'\n"
+        assert_equal "Dropped database 'my-app-db'\n", $stdout.string
       end
     end
 
diff --git a/activerecord/test/cases/tasks/postgresql_rake_test.rb b/activerecord/test/cases/tasks/postgresql_rake_test.rb
index b8c8ec88f0..1a73d410d0 100644
--- a/activerecord/test/cases/tasks/postgresql_rake_test.rb
+++ b/activerecord/test/cases/tasks/postgresql_rake_test.rb
@@ -74,7 +74,7 @@ if current_adapter?(:PostgreSQLAdapter)
       def test_when_database_created_successfully_outputs_info_to_stdout
         ActiveRecord::Tasks::DatabaseTasks.create @configuration
 
-        assert_equal $stdout.string, "Created database 'my-app-db'\n"
+        assert_equal "Created database 'my-app-db'\n", $stdout.string
       end
 
       def test_create_when_database_exists_outputs_info_to_stderr
@@ -84,7 +84,7 @@ if current_adapter?(:PostgreSQLAdapter)
 
         ActiveRecord::Tasks::DatabaseTasks.create @configuration
 
-        assert_equal $stderr.string, "Database 'my-app-db' already exists\n"
+        assert_equal "Database 'my-app-db' already exists\n", $stderr.string
       end
     end
 
@@ -126,7 +126,7 @@ if current_adapter?(:PostgreSQLAdapter)
       def test_when_database_dropped_successfully_outputs_info_to_stdout
         ActiveRecord::Tasks::DatabaseTasks.drop @configuration
 
-        assert_equal $stdout.string, "Dropped database 'my-app-db'\n"
+        assert_equal "Dropped database 'my-app-db'\n", $stdout.string
       end
     end
 
diff --git a/activerecord/test/cases/tasks/sqlite_rake_test.rb b/activerecord/test/cases/tasks/sqlite_rake_test.rb
index 141048bfe7..0d917f3f6c 100644
--- a/activerecord/test/cases/tasks/sqlite_rake_test.rb
+++ b/activerecord/test/cases/tasks/sqlite_rake_test.rb
@@ -34,7 +34,7 @@ if current_adapter?(:SQLite3Adapter)
       def test_when_db_created_successfully_outputs_info_to_stdout
         ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
 
-        assert_equal $stdout.string, "Created database '#{@database}'\n"
+        assert_equal "Created database '#{@database}'\n", $stdout.string
       end
 
       def test_db_create_when_file_exists
@@ -42,7 +42,7 @@ if current_adapter?(:SQLite3Adapter)
 
         ActiveRecord::Tasks::DatabaseTasks.create @configuration, "/rails/root"
 
-        assert_equal $stderr.string, "Database '#{@database}' already exists\n"
+        assert_equal "Database '#{@database}' already exists\n", $stderr.string
       end
 
       def test_db_create_with_file_does_nothing
@@ -128,7 +128,7 @@ if current_adapter?(:SQLite3Adapter)
       def test_when_db_dropped_successfully_outputs_info_to_stdout
         ActiveRecord::Tasks::DatabaseTasks.drop @configuration, "/rails/root"
 
-        assert_equal $stdout.string, "Dropped database '#{@database}'\n"
+        assert_equal "Dropped database '#{@database}'\n", $stdout.string
       end
     end
 
diff --git a/activerecord/test/cases/transaction_callbacks_test.rb b/activerecord/test/cases/transaction_callbacks_test.rb
index dba100f5c9..391bbe8877 100644
--- a/activerecord/test/cases/transaction_callbacks_test.rb
+++ b/activerecord/test/cases/transaction_callbacks_test.rb
@@ -449,6 +449,51 @@ class CallbacksOnMultipleActionsTest < ActiveRecord::TestCase
   end
 end
 
+class CallbacksOnDestroyUpdateActionRaceTest < ActiveRecord::TestCase
+  class TopicWithHistory < ActiveRecord::Base
+    self.table_name = :topics
+
+    def self.clear_history
+      @@history = []
+    end
+
+    def self.history
+      @@history ||= []
+    end
+  end
+
+  class TopicWithCallbacksOnDestroy < TopicWithHistory
+    after_commit(on: :destroy) { |record| record.class.history << :destroy }
+  end
+
+  class TopicWithCallbacksOnUpdate < TopicWithHistory
+    after_commit(on: :update) { |record| record.class.history << :update }
+  end
+
+  def test_trigger_once_on_multiple_deletions
+    TopicWithCallbacksOnDestroy.clear_history
+    topic = TopicWithCallbacksOnDestroy.new
+    topic.save
+    topic_clone = TopicWithCallbacksOnDestroy.find(topic.id)
+    topic.destroy
+    topic_clone.destroy
+
+    assert_equal [:destroy], TopicWithCallbacksOnDestroy.history
+  end
+
+  def test_trigger_on_update_where_row_was_deleted
+    TopicWithCallbacksOnUpdate.clear_history
+    topic = TopicWithCallbacksOnUpdate.new
+    topic.save
+    topic_clone = TopicWithCallbacksOnUpdate.find(topic.id)
+    topic.destroy
+    topic_clone.author_name = "Test Author"
+    topic_clone.save
+
+    assert_equal [], TopicWithCallbacksOnUpdate.history
+  end
+end
+
 class TransactionEnrollmentCallbacksTest < ActiveRecord::TestCase
   class TopicWithoutTransactionalEnrollmentCallbacks < ActiveRecord::Base
     self.table_name = :topics
diff --git a/activerecord/test/cases/type/unsigned_integer_test.rb b/activerecord/test/cases/type/unsigned_integer_test.rb
new file mode 100644
index 0000000000..1cd4dbc2c5
--- /dev/null
+++ b/activerecord/test/cases/type/unsigned_integer_test.rb
@@ -0,0 +1,17 @@
+require "cases/helper"
+
+module ActiveRecord
+  module Type
+    class UnsignedIntegerTest < ActiveRecord::TestCase
+      test "unsigned int max value is in range" do
+        assert_equal(4294967295, UnsignedInteger.new.serialize(4294967295))
+      end
+
+      test "minus value is out of range" do
+        assert_raises(ActiveModel::RangeError) do
+          UnsignedInteger.new.serialize(-1)
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/yaml_serialization_test.rb b/activerecord/test/cases/yaml_serialization_test.rb
index 5192e5050a..1571b31329 100644
--- a/activerecord/test/cases/yaml_serialization_test.rb
+++ b/activerecord/test/cases/yaml_serialization_test.rb
@@ -95,7 +95,7 @@ class YamlSerializationTest < ActiveRecord::TestCase
     topic = YAML.load(yaml_fixture("rails_4_1"))
 
     assert topic.new_record?
-    assert_equal nil, topic.id
+    assert_nil topic.id
     assert_equal "The First Topic", topic.title
     assert_equal({ omg: :lol }, topic.content)
   end