Merge branch 'master' into bug/filtered_parameters_class

62 files changed, 896 insertions, 820 deletions

diff --git a/activerecord/test/cases/adapters/mysql2/json_test.rb b/activerecord/test/cases/adapters/mysql2/json_test.rb
index 6954006003..26c69edc7b 100644
--- a/activerecord/test/cases/adapters/mysql2/json_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/json_test.rb
@@ -1,195 +1,22 @@
 require "cases/helper"
-require "support/schema_dumping_helper"
+require "cases/json_shared_test_cases"
 
 if ActiveRecord::Base.connection.supports_json?
   class Mysql2JSONTest < ActiveRecord::Mysql2TestCase
-    include SchemaDumpingHelper
+    include JSONSharedTestCases
     self.use_transactional_tests = false
 
-    class JsonDataType < ActiveRecord::Base
-      self.table_name = "json_data_type"
-
-      store_accessor :settings, :resolution
-    end
-
     def setup
-      @connection = ActiveRecord::Base.connection
-      begin
-        @connection.create_table("json_data_type") do |t|
-          t.json "payload"
-          t.json "settings"
-        end
+      super
+      @connection.create_table("json_data_type") do |t|
+        t.json "payload"
+        t.json "settings"
       end
     end
 
-    def teardown
-      @connection.drop_table :json_data_type, if_exists: true
-      JsonDataType.reset_column_information
-    end
-
-    def test_column
-      column = JsonDataType.columns_hash["payload"]
-      assert_equal :json, column.type
-      assert_equal "json", column.sql_type
-
-      type = JsonDataType.type_for_attribute("payload")
-      assert_not type.binary?
-    end
-
-    def test_change_table_supports_json
-      @connection.change_table("json_data_type") do |t|
-        t.json "users"
+    private
+      def column_type
+        :json
       end
-      JsonDataType.reset_column_information
-      column = JsonDataType.columns_hash["users"]
-      assert_equal :json, column.type
-    end
-
-    def test_schema_dumping
-      output = dump_table_schema("json_data_type")
-      assert_match(/t\.json\s+"settings"/, output)
-    end
-
-    def test_cast_value_on_write
-      x = JsonDataType.new payload: { "string" => "foo", :symbol => :bar }
-      assert_equal({ "string" => "foo", :symbol => :bar }, x.payload_before_type_cast)
-      assert_equal({ "string" => "foo", "symbol" => "bar" }, x.payload)
-      x.save
-      assert_equal({ "string" => "foo", "symbol" => "bar" }, x.reload.payload)
-    end
-
-    def test_type_cast_json
-      type = JsonDataType.type_for_attribute("payload")
-
-      data = "{\"a_key\":\"a_value\"}"
-      hash = type.deserialize(data)
-      assert_equal({ "a_key" => "a_value" }, hash)
-      assert_equal({ "a_key" => "a_value" }, type.deserialize(data))
-
-      assert_equal({}, type.deserialize("{}"))
-      assert_equal({ "key" => nil }, type.deserialize('{"key": null}'))
-      assert_equal({ "c" => "}", '"a"' => 'b "a b' }, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
-    end
-
-    def test_rewrite
-      @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
-      x = JsonDataType.first
-      x.payload = { '"a\'' => "b" }
-      assert x.save!
-    end
-
-    def test_select
-      @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
-      x = JsonDataType.first
-      assert_equal({ "k" => "v" }, x.payload)
-    end
-
-    def test_select_multikey
-      @connection.execute %q|insert into json_data_type (payload) VALUES ('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}')|
-      x = JsonDataType.first
-      assert_equal({ "k1" => "v1", "k2" => "v2", "k3" => [1, 2, 3] }, x.payload)
-    end
-
-    def test_null_json
-      @connection.execute "insert into json_data_type (payload) VALUES(null)"
-      x = JsonDataType.first
-      assert_nil(x.payload)
-    end
-
-    def test_select_array_json_value
-      @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
-      x = JsonDataType.first
-      assert_equal(["v0", { "k1" => "v1" }], x.payload)
-    end
-
-    def test_select_nil_json_after_create
-      json = JsonDataType.create(payload: nil)
-      x = JsonDataType.where(payload: nil).first
-      assert_equal(json, x)
-    end
-
-    def test_select_nil_json_after_update
-      json = JsonDataType.create(payload: "foo")
-      x = JsonDataType.where(payload: nil).first
-      assert_nil(x)
-
-      json.update_attributes payload: nil
-      x = JsonDataType.where(payload: nil).first
-      assert_equal(json.reload, x)
-    end
-
-    def test_rewrite_array_json_value
-      @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
-      x = JsonDataType.first
-      x.payload = ["v1", { "k2" => "v2" }, "v3"]
-      assert x.save!
-    end
-
-    def test_with_store_accessors
-      x = JsonDataType.new(resolution: "320×480")
-      assert_equal "320×480", x.resolution
-
-      x.save!
-      x = JsonDataType.first
-      assert_equal "320×480", x.resolution
-
-      x.resolution = "640×1136"
-      x.save!
-
-      x = JsonDataType.first
-      assert_equal "640×1136", x.resolution
-    end
-
-    def test_duplication_with_store_accessors
-      x = JsonDataType.new(resolution: "320×480")
-      assert_equal "320×480", x.resolution
-
-      y = x.dup
-      assert_equal "320×480", y.resolution
-    end
-
-    def test_yaml_round_trip_with_store_accessors
-      x = JsonDataType.new(resolution: "320×480")
-      assert_equal "320×480", x.resolution
-
-      y = YAML.load(YAML.dump(x))
-      assert_equal "320×480", y.resolution
-    end
-
-    def test_changes_in_place
-      json = JsonDataType.new
-      assert_not json.changed?
-
-      json.payload = { "one" => "two" }
-      assert json.changed?
-      assert json.payload_changed?
-
-      json.save!
-      assert_not json.changed?
-
-      json.payload["three"] = "four"
-      assert json.payload_changed?
-
-      json.save!
-      json.reload
-
-      assert_equal({ "one" => "two", "three" => "four" }, json.payload)
-      assert_not json.changed?
-    end
-
-    def test_assigning_string_literal
-      json = JsonDataType.create(payload: "foo")
-      assert_equal "foo", json.payload
-    end
-
-    def test_assigning_number
-      json = JsonDataType.create(payload: 1.234)
-      assert_equal 1.234, json.payload
-    end
-
-    def test_assigning_boolean
-      json = JsonDataType.create(payload: true)
-      assert_equal true, json.payload
-    end
   end
 end
diff --git a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
deleted file mode 100644
index 2c778b1150..0000000000
--- a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
+++ /dev/null
@@ -1,151 +0,0 @@
-require "cases/helper"
-
-# a suite of tests to ensure the ConnectionAdapters#MysqlAdapter can handle tables with
-# reserved word names (ie: group, order, values, etc...)
-class Mysql2ReservedWordTest < ActiveRecord::Mysql2TestCase
-  class Group < ActiveRecord::Base
-    Group.table_name = "group"
-    belongs_to :select
-    has_one :values
-  end
-
-  class Select < ActiveRecord::Base
-    Select.table_name = "select"
-    has_many :groups
-  end
-
-  class Values < ActiveRecord::Base
-    Values.table_name = "values"
-  end
-
-  class Distinct < ActiveRecord::Base
-    Distinct.table_name = "distinct"
-    has_and_belongs_to_many :selects
-    has_many :values, through: :groups
-  end
-
-  def setup
-    @connection = ActiveRecord::Base.connection
-
-    # we call execute directly here (and do similar below) because ActiveRecord::Base#create_table()
-    # will fail with these table names if these test cases fail
-
-    create_tables_directly "group" => "id int auto_increment primary key, `order` varchar(255), select_id int",
-      "select" => "id int auto_increment primary key",
-      "values" => "id int auto_increment primary key, group_id int",
-      "distinct" => "id int auto_increment primary key",
-      "distinct_select" => "distinct_id int, select_id int"
-  end
-
-  teardown do
-    drop_tables_directly ["group", "select", "values", "distinct", "distinct_select", "order"]
-  end
-
-  # create tables with reserved-word names and columns
-  def test_create_tables
-    assert_nothing_raised {
-      @connection.create_table :order do |t|
-        t.column :group, :string
-      end
-    }
-  end
-
-  # rename tables with reserved-word names
-  def test_rename_tables
-    assert_nothing_raised { @connection.rename_table(:group, :order) }
-  end
-
-  # alter column with a reserved-word name in a table with a reserved-word name
-  def test_change_columns
-    assert_nothing_raised { @connection.change_column_default(:group, :order, "whatever") }
-    #the quoting here will reveal any double quoting issues in change_column's interaction with the column method in the adapter
-    assert_nothing_raised { @connection.change_column("group", "order", :Int, default: 0) }
-    assert_nothing_raised { @connection.rename_column(:group, :order, :values) }
-  end
-
-  # introspect table with reserved word name
-  def test_introspect
-    assert_nothing_raised { @connection.columns(:group) }
-    assert_nothing_raised { @connection.indexes(:group) }
-  end
-
-  #fixtures
-  self.use_instantiated_fixtures = true
-  self.use_transactional_tests = false
-
-  #activerecord model class with reserved-word table name
-  def test_activerecord_model
-    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
-    x = nil
-    assert_nothing_raised { x = Group.new }
-    x.order = "x"
-    assert_nothing_raised { x.save }
-    x.order = "y"
-    assert_nothing_raised { x.save }
-    assert_nothing_raised { Group.find_by_order("y") }
-    assert_nothing_raised { Group.find(1) }
-  end
-
-  # has_one association with reserved-word table name
-  def test_has_one_associations
-    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
-    v = nil
-    assert_nothing_raised { v = Group.find(1).values }
-    assert_equal 2, v.id
-  end
-
-  # belongs_to association with reserved-word table name
-  def test_belongs_to_associations
-    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
-    gs = nil
-    assert_nothing_raised { gs = Select.find(2).groups }
-    assert_equal gs.length, 2
-    assert(gs.collect(&:id).sort == [2, 3])
-  end
-
-  # has_and_belongs_to_many with reserved-word table name
-  def test_has_and_belongs_to_many
-    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
-    s = nil
-    assert_nothing_raised { s = Distinct.find(1).selects }
-    assert_equal s.length, 2
-    assert(s.collect(&:id).sort == [1, 2])
-  end
-
-  # activerecord model introspection with reserved-word table and column names
-  def test_activerecord_introspection
-    assert_nothing_raised { Group.table_exists? }
-    assert_nothing_raised { Group.columns }
-  end
-
-  # Calculations
-  def test_calculations_work_with_reserved_words
-    assert_nothing_raised { Group.count }
-  end
-
-  def test_associations_work_with_reserved_words
-    assert_nothing_raised { Select.all.merge!(includes: [:groups]).to_a }
-  end
-
-  #the following functions were added to DRY test cases
-
-  private
-    # custom fixture loader, uses FixtureSet#create_fixtures and appends base_path to the current file's path
-    def create_test_fixtures(*fixture_names)
-      ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT + "/reserved_words", fixture_names)
-    end
-
-    # custom drop table, uses execute on connection to drop a table if it exists. note: escapes table_name
-    def drop_tables_directly(table_names, connection = @connection)
-      table_names.each do |name|
-        connection.drop_table name, if_exists: true
-      end
-    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)
-      tables.each do |table_name, column_properties|
-        connection.execute("CREATE TABLE `#{table_name}` ( #{column_properties} )")
-      end
-    end
-end
diff --git a/activerecord/test/cases/adapters/postgresql/bytea_test.rb b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
index 99175e8091..539c90f0bc 100644
--- a/activerecord/test/cases/adapters/postgresql/bytea_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
@@ -96,7 +96,7 @@ class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_write_binary
-    data = File.read(File.join(File.dirname(__FILE__), "..", "..", "..", "assets", "example.log"))
+    data = File.read(File.join(__dir__, "..", "..", "..", "assets", "example.log"))
     assert(data.size > 1)
     record = ByteaDataType.create(payload: data)
     assert_not record.new_record?
diff --git a/activerecord/test/cases/adapters/postgresql/connection_test.rb b/activerecord/test/cases/adapters/postgresql/connection_test.rb
index 3deb007513..32afe331fa 100644
--- a/activerecord/test/cases/adapters/postgresql/connection_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/connection_test.rb
@@ -31,15 +31,21 @@ module ActiveRecord
     end
 
     def test_encoding
-      assert_not_nil @connection.encoding
+      assert_queries(1) do
+        assert_not_nil @connection.encoding
+      end
     end
 
     def test_collation
-      assert_not_nil @connection.collation
+      assert_queries(1) do
+        assert_not_nil @connection.collation
+      end
     end
 
     def test_ctype
-      assert_not_nil @connection.ctype
+      assert_queries(1) do
+        assert_not_nil @connection.ctype
+      end
     end
 
     def test_default_client_min_messages
diff --git a/activerecord/test/cases/adapters/postgresql/geometric_test.rb b/activerecord/test/cases/adapters/postgresql/geometric_test.rb
index c1f3a4ae2c..3b6840a1c9 100644
--- a/activerecord/test/cases/adapters/postgresql/geometric_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/geometric_test.rb
@@ -93,8 +93,6 @@ class PostgresqlPointTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_empty_string_assignment
-    assert_nothing_raised { PostgresqlPoint.new(x: "") }
-
     p = PostgresqlPoint.new(x: "")
     assert_nil p.x
   end
diff --git a/activerecord/test/cases/adapters/postgresql/json_test.rb b/activerecord/test/cases/adapters/postgresql/json_test.rb
index d4e627001c..6aa60630c2 100644
--- a/activerecord/test/cases/adapters/postgresql/json_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/json_test.rb
@@ -1,223 +1,36 @@
 require "cases/helper"
-require "support/schema_dumping_helper"
+require "cases/json_shared_test_cases"
 
 module PostgresqlJSONSharedTestCases
-  include SchemaDumpingHelper
-
-  class JsonDataType < ActiveRecord::Base
-    self.table_name = "json_data_type"
-
-    store_accessor :settings, :resolution
-  end
+  include JSONSharedTestCases
 
   def setup
-    @connection = ActiveRecord::Base.connection
-    begin
-      @connection.create_table("json_data_type") do |t|
-        t.public_send column_type, "payload", default: {} # t.json 'payload', default: {}
-        t.public_send column_type, "settings"             # t.json 'settings'
-        t.public_send column_type, "objects", array: true # t.json 'objects', array: true
-      end
-    rescue ActiveRecord::StatementInvalid
-      skip "do not test on PostgreSQL without #{column_type} type."
+    super
+    @connection.create_table("json_data_type") do |t|
+      t.public_send column_type, "payload", default: {} # t.json 'payload', default: {}
+      t.public_send column_type, "settings"             # t.json 'settings'
+      t.public_send column_type, "objects", array: true # t.json 'objects', array: true
     end
-  end
-
-  def teardown
-    @connection.drop_table :json_data_type, if_exists: true
-    JsonDataType.reset_column_information
-  end
-
-  def test_column
-    column = JsonDataType.columns_hash["payload"]
-    assert_equal column_type, column.type
-    assert_equal column_type.to_s, column.sql_type
-    assert_not column.array?
-
-    type = JsonDataType.type_for_attribute("payload")
-    assert_not type.binary?
+  rescue ActiveRecord::StatementInvalid
+    skip "do not test on PostgreSQL without #{column_type} type."
   end
 
   def test_default
     @connection.add_column "json_data_type", "permissions", column_type, default: { "users": "read", "posts": ["read", "write"] }
-    JsonDataType.reset_column_information
+    klass.reset_column_information
 
     assert_equal({ "users" => "read", "posts" => ["read", "write"] }, JsonDataType.column_defaults["permissions"])
     assert_equal({ "users" => "read", "posts" => ["read", "write"] }, JsonDataType.new.permissions)
-  ensure
-    JsonDataType.reset_column_information
-  end
-
-  def test_change_table_supports_json
-    @connection.transaction do
-      @connection.change_table("json_data_type") do |t|
-        t.public_send column_type, "users", default: "{}" # t.json 'users', default: '{}'
-      end
-      JsonDataType.reset_column_information
-      column = JsonDataType.columns_hash["users"]
-      assert_equal column_type, column.type
-
-      raise ActiveRecord::Rollback # reset the schema change
-    end
-  ensure
-    JsonDataType.reset_column_information
-  end
-
-  def test_schema_dumping
-    output = dump_table_schema("json_data_type")
-    assert_match(/t\.#{column_type.to_s}\s+"payload",\s+default: {}/, output)
-  end
-
-  def test_cast_value_on_write
-    x = JsonDataType.new payload: { "string" => "foo", :symbol => :bar }
-    assert_equal({ "string" => "foo", :symbol => :bar }, x.payload_before_type_cast)
-    assert_equal({ "string" => "foo", "symbol" => "bar" }, x.payload)
-    x.save
-    assert_equal({ "string" => "foo", "symbol" => "bar" }, x.reload.payload)
   end
 
   def test_deserialize_with_array
-    x = JsonDataType.new(objects: ["foo" => "bar"])
+    x = klass.new(objects: ["foo" => "bar"])
     assert_equal ["foo" => "bar"], x.objects
     x.save!
     assert_equal ["foo" => "bar"], x.objects
     x.reload
     assert_equal ["foo" => "bar"], x.objects
   end
-
-  def test_type_cast_json
-    type = JsonDataType.type_for_attribute("payload")
-
-    data = "{\"a_key\":\"a_value\"}"
-    hash = type.deserialize(data)
-    assert_equal({ "a_key" => "a_value" }, hash)
-    assert_equal({ "a_key" => "a_value" }, type.deserialize(data))
-
-    assert_equal({}, type.deserialize("{}"))
-    assert_equal({ "key" => nil }, type.deserialize('{"key": null}'))
-    assert_equal({ "c" => "}", '"a"' => 'b "a b' }, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
-  end
-
-  def test_rewrite
-    @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
-    x = JsonDataType.first
-    x.payload = { '"a\'' => "b" }
-    assert x.save!
-  end
-
-  def test_select
-    @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
-    x = JsonDataType.first
-    assert_equal({ "k" => "v" }, x.payload)
-  end
-
-  def test_select_multikey
-    @connection.execute %q|insert into json_data_type (payload) VALUES ('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}')|
-    x = JsonDataType.first
-    assert_equal({ "k1" => "v1", "k2" => "v2", "k3" => [1, 2, 3] }, x.payload)
-  end
-
-  def test_null_json
-    @connection.execute "insert into json_data_type (payload) VALUES(null)"
-    x = JsonDataType.first
-    assert_nil(x.payload)
-  end
-
-  def test_select_nil_json_after_create
-    json = JsonDataType.create(payload: nil)
-    x = JsonDataType.where(payload: nil).first
-    assert_equal(json, x)
-  end
-
-  def test_select_nil_json_after_update
-    json = JsonDataType.create(payload: "foo")
-    x = JsonDataType.where(payload: nil).first
-    assert_nil(x)
-
-    json.update_attributes payload: nil
-    x = JsonDataType.where(payload: nil).first
-    assert_equal(json.reload, x)
-  end
-
-  def test_select_array_json_value
-    @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
-    x = JsonDataType.first
-    assert_equal(["v0", { "k1" => "v1" }], x.payload)
-  end
-
-  def test_rewrite_array_json_value
-    @connection.execute %q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|
-    x = JsonDataType.first
-    x.payload = ["v1", { "k2" => "v2" }, "v3"]
-    assert x.save!
-  end
-
-  def test_with_store_accessors
-    x = JsonDataType.new(resolution: "320×480")
-    assert_equal "320×480", x.resolution
-
-    x.save!
-    x = JsonDataType.first
-    assert_equal "320×480", x.resolution
-
-    x.resolution = "640×1136"
-    x.save!
-
-    x = JsonDataType.first
-    assert_equal "640×1136", x.resolution
-  end
-
-  def test_duplication_with_store_accessors
-    x = JsonDataType.new(resolution: "320×480")
-    assert_equal "320×480", x.resolution
-
-    y = x.dup
-    assert_equal "320×480", y.resolution
-  end
-
-  def test_yaml_round_trip_with_store_accessors
-    x = JsonDataType.new(resolution: "320×480")
-    assert_equal "320×480", x.resolution
-
-    y = YAML.load(YAML.dump(x))
-    assert_equal "320×480", y.resolution
-  end
-
-  def test_changes_in_place
-    json = JsonDataType.new
-    assert_not json.changed?
-
-    json.payload = { "one" => "two" }
-    assert json.changed?
-    assert json.payload_changed?
-
-    json.save!
-    assert_not json.changed?
-
-    json.payload["three"] = "four"
-    assert json.payload_changed?
-
-    json.save!
-    json.reload
-
-    assert_equal({ "one" => "two", "three" => "four" }, json.payload)
-    assert_not json.changed?
-  end
-
-  def test_assigning_string_literal
-    json = JsonDataType.create(payload: "foo")
-    assert_equal "foo", json.payload
-  end
-
-  def test_assigning_number
-    json = JsonDataType.create(payload: 1.234)
-    assert_equal 1.234, json.payload
-  end
-
-  def test_assigning_boolean
-    json = JsonDataType.create(payload: true)
-    assert_equal true, json.payload
-  end
 end
 
 class PostgresqlJSONTest < ActiveRecord::PostgreSQLTestCase
diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
index bfc763e1ef..76e0ad60fe 100644
--- a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
@@ -324,13 +324,13 @@ module ActiveRecord
         reset_connection
       end
 
-      def test_only_reload_type_map_once_for_every_unknown_type
+      def test_only_reload_type_map_once_for_every_unrecognized_type
         silence_warnings do
           assert_queries 2, ignore_none: true do
-            @connection.select_all "SELECT NULL::anyelement"
+            @connection.select_all "select 'pg_catalog.pg_class'::regclass"
           end
           assert_queries 1, ignore_none: true do
-            @connection.select_all "SELECT NULL::anyelement"
+            @connection.select_all "select 'pg_catalog.pg_class'::regclass"
           end
           assert_queries 2, ignore_none: true do
             @connection.select_all "SELECT NULL::anyarray"
@@ -340,13 +340,13 @@ module ActiveRecord
         reset_connection
       end
 
-      def test_only_warn_on_first_encounter_of_unknown_oid
+      def test_only_warn_on_first_encounter_of_unrecognized_oid
         warning = capture(:stderr) {
-          @connection.select_all "SELECT NULL::anyelement"
-          @connection.select_all "SELECT NULL::anyelement"
-          @connection.select_all "SELECT NULL::anyelement"
+          @connection.select_all "select 'pg_catalog.pg_class'::regclass"
+          @connection.select_all "select 'pg_catalog.pg_class'::regclass"
+          @connection.select_all "select 'pg_catalog.pg_class'::regclass"
         }
-        assert_match(/\Aunknown OID \d+: failed to recognize type of 'anyelement'\. It will be treated as String\.\n\z/, warning)
+        assert_match(/\Aunknown OID \d+: failed to recognize type of 'regclass'\. It will be treated as String\.\n\z/, warning)
       ensure
         reset_connection
       end
diff --git a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
index bf570176f4..f86a76e08a 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
@@ -75,17 +75,6 @@ class SchemaAuthorizationTest < ActiveRecord::PostgreSQLTestCase
     end
   end
 
-  def test_schema_uniqueness
-    assert_nothing_raised do
-      set_session_auth
-      USERS.each do |u|
-        set_session_auth u
-        assert_equal u, @connection.select_value("SELECT name FROM #{TABLE_NAME} WHERE id = 1")
-        set_session_auth
-      end
-    end
-  end
-
   def test_sequence_schema_caching
     assert_nothing_raised do
       USERS.each do |u|
diff --git a/activerecord/test/cases/adapters/postgresql/uuid_test.rb b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
index 52e4a38cae..8eddd81c38 100644
--- a/activerecord/test/cases/adapters/postgresql/uuid_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/uuid_test.rb
@@ -40,7 +40,8 @@ class PostgresqlUUIDTest < ActiveRecord::PostgreSQLTestCase
     drop_table "uuid_data_type"
   end
 
-  if ActiveRecord::Base.connection.supports_pgcrypto_uuid?
+  if ActiveRecord::Base.connection.respond_to?(:supports_pgcrypto_uuid?) &&
+      ActiveRecord::Base.connection.supports_pgcrypto_uuid?
     def test_uuid_column_default
       connection.add_column :uuid_data_type, :thingy, :uuid, null: false, default: "gen_random_uuid()"
       UUIDType.reset_column_information
@@ -63,6 +64,16 @@ class PostgresqlUUIDTest < ActiveRecord::PostgreSQLTestCase
     UUIDType.reset_column_information
   end
 
+  def test_add_column_with_null_true_and_default_nil
+    connection.add_column :uuid_data_type, :thingy, :uuid, null: true, default: nil
+
+    UUIDType.reset_column_information
+    column = UUIDType.columns_hash["thingy"]
+
+    assert column.null
+    assert_nil column.default
+  end
+
   def test_data_type_of_uuid_types
     column = UUIDType.columns_hash["guid"]
     assert_equal :uuid, column.type
diff --git a/activerecord/test/cases/associations/callbacks_test.rb b/activerecord/test/cases/associations/callbacks_test.rb
index 7721bd5cd9..f9d1e44595 100644
--- a/activerecord/test/cases/associations/callbacks_test.rb
+++ b/activerecord/test/cases/associations/callbacks_test.rb
@@ -128,7 +128,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
     assert ar.developers_log.empty?
     alice = Developer.new(name: "alice")
     ar.developers_with_callbacks << alice
-    assert_equal"after_adding#{alice.id}", ar.developers_log.last
+    assert_equal "after_adding#{alice.id}", ar.developers_log.last
 
     bob = ar.developers_with_callbacks.create(name: "bob")
     assert_equal "after_adding#{bob.id}", ar.developers_log.last
diff --git a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
index 3638c87968..7b0445025c 100644
--- a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
+++ b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
@@ -34,18 +34,12 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_hmt_does_not_table_name_collide_when_joining_associations
-    assert_nothing_raised do
-      Author.joins(:posts).eager_load(:comments).where(posts: { tags_count: 1 }).to_a
-    end
     authors = Author.joins(:posts).eager_load(:comments).where(posts: { tags_count: 1 }).to_a
     assert_equal 1, assert_no_queries { authors.size }
     assert_equal 10, assert_no_queries { authors[0].comments.size }
   end
 
   def test_eager_association_loading_grafts_stashed_associations_to_correct_parent
-    assert_nothing_raised do
-      Person.eager_load(primary_contact: :primary_contact).where("primary_contacts_people_2.first_name = ?", "Susan").order("people.id").to_a
-    end
     assert_equal people(:michael), Person.eager_load(primary_contact: :primary_contact).where("primary_contacts_people_2.first_name = ?", "Susan").order("people.id").first
   end
 
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 36238dd088..55b294cfaa 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -271,9 +271,6 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_loading_from_an_association_that_has_a_hash_of_conditions
-    assert_nothing_raised do
-      Author.all.merge!(includes: :hello_posts_with_hash_conditions).to_a
-    end
     assert !Author.all.merge!(includes: :hello_posts_with_hash_conditions).find(authors(:david).id).hello_posts.empty?
   end
 
@@ -1094,12 +1091,6 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_equal authors(:david), assert_no_queries { posts[0].author }
 
     posts = assert_queries(2) do
-      Post.all.merge!(select: "distinct posts.*", includes: :author, joins: [:comments], where: "comments.body like 'Thank you%'", order: "posts.id").to_a
-    end
-    assert_equal [posts(:welcome)], posts
-    assert_equal authors(:david), assert_no_queries { posts[0].author }
-
-    posts = assert_queries(2) do
       Post.all.merge!(includes: :author, joins: { taggings: :tag }, where: "tags.name = 'General'", order: "posts.id").to_a
     end
     assert_equal posts(:welcome, :thinking), posts
diff --git a/activerecord/test/cases/associations/extension_test.rb b/activerecord/test/cases/associations/extension_test.rb
index 87d842f21d..f707a170f5 100644
--- a/activerecord/test/cases/associations/extension_test.rb
+++ b/activerecord/test/cases/associations/extension_test.rb
@@ -78,6 +78,12 @@ class AssociationsExtensionsTest < ActiveRecord::TestCase
     assert_equal post.association(:comments), post.comments.where("1=1").the_association
   end
 
+  def test_association_with_default_scope
+    assert_raises OopsError do
+      posts(:welcome).comments.destroy_all
+    end
+  end
+
   private
 
     def extend!(model)
diff --git a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
index 8060790594..f73005b3cb 100644
--- a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
@@ -367,19 +367,6 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal Developer.find(1).projects.sort_by(&:id).last, proj  # prove join table is updated
   end
 
-  def test_create_by_new_record
-    devel = Developer.new(name: "Marcel", salary: 75000)
-    devel.projects.build(name: "Make bed")
-    proj2 = devel.projects.build(name: "Lie in it")
-    assert_equal devel.projects.last, proj2
-    assert !proj2.persisted?
-    devel.save
-    assert devel.persisted?
-    assert proj2.persisted?
-    assert_equal devel.projects.last, proj2
-    assert_equal Developer.find_by_name("Marcel").projects.last, proj2  # prove join table is updated
-  end
-
   def test_creation_respects_hash_condition
     # in Oracle '' is saved as null therefore need to save ' ' in not null column
     post = categories(:general).post_with_conditions.build(body: " ")
@@ -954,7 +941,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_not_nil Developer._reflections["shared_computers"]
     # Checking the fixture for named association is important here, because it's the only way
     # we've been able to reproduce this bug
-    assert_not_nil File.read(File.expand_path("../../../fixtures/developers.yml", __FILE__)).index("shared_computers")
+    assert_not_nil File.read(File.expand_path("../../fixtures/developers.yml", __dir__)).index("shared_computers")
     assert_equal developers(:david).shared_computers.first, computers(:laptop)
   end
 
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 6a479a344c..590d3642bd 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -1355,7 +1355,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     Client.create(client_of: firm.id, name: "SmallTime Inc.")
     # only one of two clients is included in the association due to the :conditions key
     assert_equal 2, Client.where(client_of: firm.id).size
-    assert_equal 1, firm.dependent_sanitized_conditional_clients_of_firm.size
+    assert_equal 1, firm.dependent_hash_conditional_clients_of_firm.size
     firm.destroy
     # only the correctly associated client should have been deleted
     assert_equal 1, Client.where(client_of: firm.id).size
@@ -2251,7 +2251,15 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   test "association with extend option with multiple extensions" do
     post = posts(:welcome)
     assert_equal "lifo",  post.comments_with_extend_2.author
-    assert_equal "hello", post.comments_with_extend_2.greeting
+    assert_equal "hullo", post.comments_with_extend_2.greeting
+  end
+
+  test "extend option affects per association" do
+    post = posts(:welcome)
+    assert_equal "lifo",  post.comments_with_extend.author
+    assert_equal "lifo",  post.comments_with_extend_2.author
+    assert_equal "hello", post.comments_with_extend.greeting
+    assert_equal "hullo", post.comments_with_extend_2.greeting
   end
 
   test "delete record with complex joins" do
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 ea52fb5a67..9156f6d57a 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -64,10 +64,6 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
                  club1.members.sort_by(&:id)
   end
 
-  def make_model(name)
-    Class.new(ActiveRecord::Base) { define_singleton_method(:name) { name } }
-  end
-
   def test_ordered_has_many_through
     person_prime = Class.new(ActiveRecord::Base) do
       def self.name; "Person"; end
@@ -152,20 +148,6 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     assert after_destroy_called, "after destroy should be called"
   end
 
-  def make_no_pk_hm_t
-    lesson = make_model "Lesson"
-    student = make_model "Student"
-
-    lesson_student = make_model "LessonStudent"
-    lesson_student.table_name = "lessons_students"
-
-    lesson_student.belongs_to :lesson, anonymous_class: lesson
-    lesson_student.belongs_to :student, anonymous_class: student
-    lesson.has_many :lesson_students, anonymous_class: lesson_student
-    lesson.has_many :students, through: :lesson_students, anonymous_class: student
-    [lesson, lesson_student, student]
-  end
-
   def test_pk_is_not_required_for_join
     post  = Post.includes(:scategories).first
     post2 = Post.includes(:categories).first
@@ -1252,4 +1234,23 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
       )
     end
   end
+
+  private
+    def make_model(name)
+      Class.new(ActiveRecord::Base) { define_singleton_method(:name) { name } }
+    end
+
+    def make_no_pk_hm_t
+      lesson = make_model "Lesson"
+      student = make_model "Student"
+
+      lesson_student = make_model "LessonStudent"
+      lesson_student.table_name = "lessons_students"
+
+      lesson_student.belongs_to :lesson, anonymous_class: lesson
+      lesson_student.belongs_to :student, anonymous_class: student
+      lesson.has_many :lesson_students, anonymous_class: lesson_student
+      lesson.has_many :students, through: :lesson_students, anonymous_class: student
+      [lesson, lesson_student, student]
+    end
 end
diff --git a/activerecord/test/cases/associations/inverse_associations_test.rb b/activerecord/test/cases/associations/inverse_associations_test.rb
index 287b3e9ebc..467cc73ecd 100644
--- a/activerecord/test/cases/associations/inverse_associations_test.rb
+++ b/activerecord/test/cases/associations/inverse_associations_test.rb
@@ -651,20 +651,6 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
     assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
   end
 
-  def test_child_instance_should_be_shared_with_replaced_via_method_parent
-    face = faces(:confused)
-    new_man = Man.new
-
-    assert_not_nil face.polymorphic_man
-    face.polymorphic_man = new_man
-
-    assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same before changes to parent instance"
-    face.description = "Bongo"
-    assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same after changes to parent instance"
-    new_man.polymorphic_face.description = "Mungo"
-    assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
-  end
-
   def test_inversed_instance_should_not_be_reloaded_after_stale_state_changed
     new_man = Man.new
     face = Face.new
diff --git a/activerecord/test/cases/associations_test.rb b/activerecord/test/cases/associations_test.rb
index 4ab690bfc6..2eb31326a5 100644
--- a/activerecord/test/cases/associations_test.rb
+++ b/activerecord/test/cases/associations_test.rb
@@ -220,6 +220,18 @@ class AssociationProxyTest < ActiveRecord::TestCase
     assert_equal david.projects, david.projects.scope
   end
 
+  test "proxy object is cached" do
+    david = developers(:david)
+    assert_same david.projects, david.projects
+  end
+
+  test "proxy object can be stubbed" do
+    david = developers(:david)
+    david.projects.define_singleton_method(:extra_method) { 42 }
+
+    assert_equal 42, david.projects.extra_method
+  end
+
   test "inverses get set of subsets of the association" do
     man = Man.create
     man.interests.create
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 15c253890b..dc32e995a4 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -907,80 +907,6 @@ class BasicsTest < ActiveRecord::TestCase
     end
   end
 
-  class NumericData < ActiveRecord::Base
-    self.table_name = "numeric_data"
-
-    attribute :my_house_population, :integer
-    attribute :atoms_in_universe, :integer
-  end
-
-  def test_big_decimal_conditions
-    m = NumericData.new(
-      bank_balance: 1586.43,
-      big_bank_balance: BigDecimal("1000234000567.95"),
-      world_population: 6000000000,
-      my_house_population: 3
-    )
-    assert m.save
-    assert_equal 0, NumericData.where("bank_balance > ?", 2000.0).count
-  end
-
-  def test_numeric_fields
-    m = NumericData.new(
-      bank_balance: 1586.43,
-      big_bank_balance: BigDecimal("1000234000567.95"),
-      world_population: 6000000000,
-      my_house_population: 3
-    )
-    assert m.save
-
-    m1 = NumericData.find(m.id)
-    assert_not_nil m1
-
-    # As with migration_test.rb, we should make world_population >= 2**62
-    # to cover 64-bit platforms and test it is a Bignum, but the main thing
-    # is that it's an Integer.
-    assert_kind_of Integer, m1.world_population
-    assert_equal 6000000000, m1.world_population
-
-    assert_kind_of Integer, m1.my_house_population
-    assert_equal 3, m1.my_house_population
-
-    assert_kind_of BigDecimal, m1.bank_balance
-    assert_equal BigDecimal("1586.43"), m1.bank_balance
-
-    assert_kind_of BigDecimal, m1.big_bank_balance
-    assert_equal BigDecimal("1000234000567.95"), m1.big_bank_balance
-  end
-
-  def test_numeric_fields_with_scale
-    m = NumericData.new(
-      bank_balance: 1586.43122334,
-      big_bank_balance: BigDecimal("234000567.952344"),
-      world_population: 6000000000,
-      my_house_population: 3
-    )
-    assert m.save
-
-    m1 = NumericData.find(m.id)
-    assert_not_nil m1
-
-    # As with migration_test.rb, we should make world_population >= 2**62
-    # to cover 64-bit platforms and test it is a Bignum, but the main thing
-    # is that it's an Integer.
-    assert_kind_of Integer, m1.world_population
-    assert_equal 6000000000, m1.world_population
-
-    assert_kind_of Integer, m1.my_house_population
-    assert_equal 3, m1.my_house_population
-
-    assert_kind_of BigDecimal, m1.bank_balance
-    assert_equal BigDecimal("1586.43"), m1.bank_balance
-
-    assert_kind_of BigDecimal, m1.big_bank_balance
-    assert_equal BigDecimal("234000567.95"), m1.big_bank_balance
-  end
-
   def test_auto_id
     auto = AutoId.new
     auto.save
diff --git a/activerecord/test/cases/cache_key_test.rb b/activerecord/test/cases/cache_key_test.rb
index 2c6a38ec35..7b8264e6e8 100644
--- a/activerecord/test/cases/cache_key_test.rb
+++ b/activerecord/test/cases/cache_key_test.rb
@@ -4,15 +4,23 @@ module ActiveRecord
   class CacheKeyTest < ActiveRecord::TestCase
     self.use_transactional_tests = false
 
-    class CacheMe < ActiveRecord::Base; end
+    class CacheMe < ActiveRecord::Base
+      self.cache_versioning = false
+    end
+
+    class CacheMeWithVersion < ActiveRecord::Base
+      self.cache_versioning = true
+    end
 
     setup do
       @connection = ActiveRecord::Base.connection
-      @connection.create_table(:cache_mes) { |t| t.timestamps }
+      @connection.create_table(:cache_mes, force: true) { |t| t.timestamps }
+      @connection.create_table(:cache_me_with_versions, force: true) { |t| t.timestamps }
     end
 
     teardown do
       @connection.drop_table :cache_mes, if_exists: true
+      @connection.drop_table :cache_me_with_versions, if_exists: true
     end
 
     test "cache_key format is not too precise" do
@@ -21,5 +29,23 @@ module ActiveRecord
 
       assert_equal key, record.reload.cache_key
     end
+
+    test "cache_key has no version when versioning is on" do
+      record = CacheMeWithVersion.create
+      assert_equal "active_record/cache_key_test/cache_me_with_versions/#{record.id}", record.cache_key
+    end
+
+    test "cache_version is only there when versioning is on" do
+      assert CacheMeWithVersion.create.cache_version.present?
+      assert_not CacheMe.create.cache_version.present?
+    end
+
+    test "cache_key_with_version always has both key and version" do
+      r1 = CacheMeWithVersion.create
+      assert_equal "active_record/cache_key_test/cache_me_with_versions/#{r1.id}-#{r1.updated_at.to_s(:usec)}", r1.cache_key_with_version
+
+      r2 = CacheMe.create
+      assert_equal "active_record/cache_key_test/cache_mes/#{r2.id}-#{r2.updated_at.to_s(:usec)}", r2.cache_key_with_version
+    end
   end
 end
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index 3214d778d4..80baaac30a 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -8,6 +8,7 @@ require "models/organization"
 require "models/possession"
 require "models/topic"
 require "models/reply"
+require "models/numeric_data"
 require "models/minivan"
 require "models/speedometer"
 require "models/ship_part"
@@ -17,14 +18,6 @@ require "models/post"
 require "models/comment"
 require "models/rating"
 
-class NumericData < ActiveRecord::Base
-  self.table_name = "numeric_data"
-
-  attribute :world_population, :integer
-  attribute :my_house_population, :integer
-  attribute :atoms_in_universe, :integer
-end
-
 class CalculationsTest < ActiveRecord::TestCase
   fixtures :companies, :accounts, :topics, :speedometers, :minivans, :books
 
@@ -587,8 +580,11 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_pluck_without_column_names
-    assert_equal [[1, "Firm", 1, nil, "37signals", nil, 1, nil, ""]],
-      Company.order(:id).limit(1).pluck
+    if current_adapter?(:OracleAdapter)
+      assert_equal [[1, "Firm", 1, nil, "37signals", nil, 1, nil, nil]], Company.order(:id).limit(1).pluck
+    else
+      assert_equal [[1, "Firm", 1, nil, "37signals", nil, 1, nil, ""]], Company.order(:id).limit(1).pluck
+    end
   end
 
   def test_pluck_type_cast
@@ -809,4 +805,16 @@ class CalculationsTest < ActiveRecord::TestCase
   def test_group_by_attribute_with_custom_type
     assert_equal({ "proposed" => 2, "published" => 2 }, Book.group(:status).count)
   end
+
+  def test_deprecate_count_with_block_and_column_name
+    assert_deprecated do
+      assert_equal 6, Account.count(:firm_id) { true }
+    end
+  end
+
+  def test_deprecate_sum_with_block_and_column_name
+    assert_deprecated do
+      assert_equal 6, Account.sum(:firm_id) { 1 }
+    end
+  end
 end
diff --git a/activerecord/test/cases/connection_adapters/connection_handler_test.rb b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
index 681399c8bb..2a71f08d90 100644
--- a/activerecord/test/cases/connection_adapters/connection_handler_test.rb
+++ b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
@@ -9,6 +9,17 @@ module ActiveRecord
         @pool = @handler.establish_connection(ActiveRecord::Base.configurations["arunit"])
       end
 
+      def test_default_env_fall_back_to_default_env_when_rails_env_or_rack_env_is_empty_string
+        original_rails_env = ENV["RAILS_ENV"]
+        original_rack_env  = ENV["RACK_ENV"]
+        ENV["RAILS_ENV"]   = ENV["RACK_ENV"] = ""
+
+        assert_equal "default_env", ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+      ensure
+        ENV["RAILS_ENV"] = original_rails_env
+        ENV["RACK_ENV"]  = original_rack_env
+      end
+
       def test_establish_connection_uses_spec_name
         config = { "readonly" => { "adapter" => "sqlite3" } }
         resolver = ConnectionAdapters::ConnectionSpecification::Resolver.new(config)
diff --git a/activerecord/test/cases/dirty_test.rb b/activerecord/test/cases/dirty_test.rb
index 721861975a..f72e0d2ead 100644
--- a/activerecord/test/cases/dirty_test.rb
+++ b/activerecord/test/cases/dirty_test.rb
@@ -4,10 +4,7 @@ require "models/pirate"   # For timestamps
 require "models/parrot"
 require "models/person"   # For optimistic locking
 require "models/aircraft"
-
-class NumericData < ActiveRecord::Base
-  self.table_name = "numeric_data"
-end
+require "models/numeric_data"
 
 class DirtyTest < ActiveRecord::TestCase
   include InTimeZone
diff --git a/activerecord/test/cases/enum_test.rb b/activerecord/test/cases/enum_test.rb
index 7f63bb2473..4ef9a125e6 100644
--- a/activerecord/test/cases/enum_test.rb
+++ b/activerecord/test/cases/enum_test.rb
@@ -6,7 +6,6 @@ class EnumTest < ActiveRecord::TestCase
   fixtures :books, :authors
 
   setup do
-    @author = authors(:david)
     @book = books(:awdr)
   end
 
@@ -39,6 +38,8 @@ class EnumTest < ActiveRecord::TestCase
     assert_equal @book, Book.author_visibility_visible.first
     assert_equal @book, Book.illustrator_visibility_visible.first
     assert_equal @book, Book.medium_to_read.first
+    assert_equal books(:ddd), Book.forgotten.first
+    assert_equal books(:rfr), authors(:david).unpublished_books.first
   end
 
   test "find via where with values" do
@@ -57,9 +58,9 @@ class EnumTest < ActiveRecord::TestCase
     assert_not_equal @book, Book.where(status: :written).first
     assert_equal @book, Book.where(status: [:published]).first
     assert_not_equal @book, Book.where(status: [:written]).first
-    assert_not @author.unpublished_books.include?(@book)
     assert_not_equal @book, Book.where.not(status: :published).first
     assert_equal @book, Book.where.not(status: :written).first
+    assert_equal books(:ddd), Book.where(read_status: :forgotten).first
   end
 
   test "find via where with strings" do
@@ -69,6 +70,7 @@ class EnumTest < ActiveRecord::TestCase
     assert_not_equal @book, Book.where(status: ["written"]).first
     assert_not_equal @book, Book.where.not(status: "published").first
     assert_equal @book, Book.where.not(status: "written").first
+    assert_equal books(:ddd), Book.where(read_status: "forgotten").first
   end
 
   test "build from scope" do
diff --git a/activerecord/test/cases/errors_test.rb b/activerecord/test/cases/errors_test.rb
index 73feb831d0..e90669e0c7 100644
--- a/activerecord/test/cases/errors_test.rb
+++ b/activerecord/test/cases/errors_test.rb
@@ -1,4 +1,4 @@
-require_relative "../cases/helper"
+require "cases/helper"
 
 class ErrorsTest < ActiveRecord::TestCase
   def test_can_be_instantiated_with_no_args
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index a7b6333010..420f552ef6 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -743,7 +743,6 @@ class FinderTest < ActiveRecord::TestCase
     assert Topic.where(author_name: "David", title: "The First Topic", replies_count: 1, approved: false).find(1)
     assert_raise(ActiveRecord::RecordNotFound) { Topic.where(author_name: "David", title: "The First Topic", replies_count: 1, approved: true).find(1) }
     assert_raise(ActiveRecord::RecordNotFound) { Topic.where(author_name: "David", title: "HHC", replies_count: 1, approved: false).find(1) }
-    assert_raise(ActiveRecord::RecordNotFound) { Topic.where(author_name: "David", title: "The First Topic", replies_count: 1, approved: true).find(1) }
   end
 
   def test_condition_interpolation
@@ -1024,16 +1023,6 @@ class FinderTest < ActiveRecord::TestCase
     assert_raise(ActiveRecord::StatementInvalid) { Topic.find_by_sql "select 1 from badtable" }
   end
 
-  def test_find_all_with_join
-    developers_on_project_one = Developer.
-      joins("LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id").
-      where("project_id=1").to_a
-    assert_equal 3, developers_on_project_one.length
-    developer_names = developers_on_project_one.map(&:name)
-    assert_includes developer_names, "David"
-    assert_includes developer_names, "Jamis"
-  end
-
   def test_joins_dont_clobber_id
     first = Firm.
       joins("INNER JOIN companies clients ON clients.firm_id = companies.id").
diff --git a/activerecord/test/cases/inheritance_test.rb b/activerecord/test/cases/inheritance_test.rb
index d70572d6eb..fb5a7bcc31 100644
--- a/activerecord/test/cases/inheritance_test.rb
+++ b/activerecord/test/cases/inheritance_test.rb
@@ -1,6 +1,7 @@
 require "cases/helper"
 require "models/author"
 require "models/company"
+require "models/membership"
 require "models/person"
 require "models/post"
 require "models/project"
@@ -29,7 +30,7 @@ end
 
 class InheritanceTest < ActiveRecord::TestCase
   include InheritanceTestHelper
-  fixtures :companies, :projects, :subscribers, :accounts, :vegetables
+  fixtures :companies, :projects, :subscribers, :accounts, :vegetables, :memberships
 
   def test_class_with_store_full_sti_class_returns_full_name
     with_store_full_sti_class do
@@ -316,7 +317,7 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_new_with_autoload_paths
-    path = File.expand_path("../../models/autoloadable", __FILE__)
+    path = File.expand_path("../models/autoloadable", __dir__)
     ActiveSupport::Dependencies.autoload_paths << path
 
     firm = Company.new(type: "ExtraFirm")
@@ -435,6 +436,10 @@ class InheritanceTest < ActiveRecord::TestCase
     assert_nothing_raised { Company.of_first_firm }
     assert_nothing_raised { Client.of_first_firm }
   end
+
+  def test_inheritance_with_default_scope
+    assert_equal 1, SelectedMembership.count(:all)
+  end
 end
 
 class InheritanceComputeTypeTest < ActiveRecord::TestCase
diff --git a/activerecord/test/cases/integration_test.rb b/activerecord/test/cases/integration_test.rb
index 0678bb714f..9104976126 100644
--- a/activerecord/test/cases/integration_test.rb
+++ b/activerecord/test/cases/integration_test.rb
@@ -168,13 +168,65 @@ class IntegrationTest < ActiveRecord::TestCase
   end
 
   def test_named_timestamps_for_cache_key
-    owner = owners(:blackbeard)
-    assert_equal "owners/#{owner.id}-#{owner.happy_at.utc.to_s(:usec)}", owner.cache_key(:updated_at, :happy_at)
+    assert_deprecated do
+      owner = owners(:blackbeard)
+      assert_equal "owners/#{owner.id}-#{owner.happy_at.utc.to_s(:usec)}", owner.cache_key(:updated_at, :happy_at)
+    end
   end
 
   def test_cache_key_when_named_timestamp_is_nil
-    owner = owners(:blackbeard)
-    owner.happy_at = nil
-    assert_equal "owners/#{owner.id}", owner.cache_key(:happy_at)
+    assert_deprecated do
+      owner = owners(:blackbeard)
+      owner.happy_at = nil
+      assert_equal "owners/#{owner.id}", owner.cache_key(:happy_at)
+    end
+  end
+
+  def test_cache_key_is_stable_with_versioning_on
+    Developer.cache_versioning = true
+
+    developer = Developer.first
+    first_key = developer.cache_key
+
+    developer.touch
+    second_key = developer.cache_key
+
+    assert_equal first_key, second_key
+  ensure
+    Developer.cache_versioning = false
+  end
+
+  def test_cache_version_changes_with_versioning_on
+    Developer.cache_versioning = true
+
+    developer     = Developer.first
+    first_version = developer.cache_version
+
+    travel 10.seconds do
+      developer.touch
+    end
+
+    second_version = developer.cache_version
+
+    assert_not_equal first_version, second_version
+  ensure
+    Developer.cache_versioning = false
+  end
+
+  def test_cache_key_retains_version_when_custom_timestamp_is_used
+    Developer.cache_versioning = true
+
+    developer = Developer.first
+    first_key = developer.cache_key_with_version
+
+    travel 10.seconds do
+      developer.touch
+    end
+
+    second_key = developer.cache_key_with_version
+
+    assert_not_equal first_key, second_key
+  ensure
+    Developer.cache_versioning = false
   end
 end
diff --git a/activerecord/test/cases/json_attribute_test.rb b/activerecord/test/cases/json_attribute_test.rb
new file mode 100644
index 0000000000..e5848b45f8
--- /dev/null
+++ b/activerecord/test/cases/json_attribute_test.rb
@@ -0,0 +1,33 @@
+require "cases/helper"
+require "cases/json_shared_test_cases"
+
+class JsonAttributeTest < ActiveRecord::TestCase
+  include JSONSharedTestCases
+  self.use_transactional_tests = false
+
+  class JsonDataTypeOnText < ActiveRecord::Base
+    self.table_name = "json_data_type"
+
+    attribute :payload,  :json
+    attribute :settings, :json
+
+    store_accessor :settings, :resolution
+  end
+
+  def setup
+    super
+    @connection.create_table("json_data_type") do |t|
+      t.text "payload"
+      t.text "settings"
+    end
+  end
+
+  private
+    def column_type
+      :text
+    end
+
+    def klass
+      JsonDataTypeOnText
+    end
+end
diff --git a/activerecord/test/cases/json_shared_test_cases.rb b/activerecord/test/cases/json_shared_test_cases.rb
new file mode 100644
index 0000000000..5aa41b9d6d
--- /dev/null
+++ b/activerecord/test/cases/json_shared_test_cases.rb
@@ -0,0 +1,202 @@
+require "support/schema_dumping_helper"
+
+module JSONSharedTestCases
+  include SchemaDumpingHelper
+
+  class JsonDataType < ActiveRecord::Base
+    self.table_name = "json_data_type"
+
+    store_accessor :settings, :resolution
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    @connection.drop_table :json_data_type, if_exists: true
+    klass.reset_column_information
+  end
+
+  def test_column
+    column = klass.columns_hash["payload"]
+    assert_equal column_type, column.type
+    assert_equal column_type.to_s, column.sql_type
+
+    type = klass.type_for_attribute("payload")
+    assert_not type.binary?
+  end
+
+  def test_change_table_supports_json
+    @connection.change_table("json_data_type") do |t|
+      t.public_send column_type, "users"
+    end
+    klass.reset_column_information
+    column = klass.columns_hash["users"]
+    assert_equal column_type, column.type
+    assert_equal column_type.to_s, column.sql_type
+  end
+
+  def test_schema_dumping
+    output = dump_table_schema("json_data_type")
+    assert_match(/t\.#{column_type}\s+"settings"/, output)
+  end
+
+  def test_cast_value_on_write
+    x = klass.new(payload: { "string" => "foo", :symbol => :bar })
+    assert_equal({ "string" => "foo", :symbol => :bar }, x.payload_before_type_cast)
+    assert_equal({ "string" => "foo", "symbol" => "bar" }, x.payload)
+    x.save!
+    assert_equal({ "string" => "foo", "symbol" => "bar" }, x.reload.payload)
+  end
+
+  def test_type_cast_json
+    type = klass.type_for_attribute("payload")
+
+    data = '{"a_key":"a_value"}'
+    hash = type.deserialize(data)
+    assert_equal({ "a_key" => "a_value" }, hash)
+    assert_equal({ "a_key" => "a_value" }, type.deserialize(data))
+
+    assert_equal({}, type.deserialize("{}"))
+    assert_equal({ "key" => nil }, type.deserialize('{"key": null}'))
+    assert_equal({ "c" => "}", '"a"' => 'b "a b' }, type.deserialize(%q({"c":"}", "\"a\"":"b \"a b"})))
+  end
+
+  def test_rewrite
+    @connection.execute(%q|insert into json_data_type (payload) VALUES ('{"k":"v"}')|)
+    x = klass.first
+    x.payload = { '"a\'' => "b" }
+    assert x.save!
+  end
+
+  def test_select
+    @connection.execute(%q|insert into json_data_type (payload) VALUES ('{"k":"v"}')|)
+    x = klass.first
+    assert_equal({ "k" => "v" }, x.payload)
+  end
+
+  def test_select_multikey
+    @connection.execute(%q|insert into json_data_type (payload) VALUES ('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}')|)
+    x = klass.first
+    assert_equal({ "k1" => "v1", "k2" => "v2", "k3" => [1, 2, 3] }, x.payload)
+  end
+
+  def test_null_json
+    @connection.execute("insert into json_data_type (payload) VALUES(null)")
+    x = klass.first
+    assert_nil(x.payload)
+  end
+
+  def test_select_nil_json_after_create
+    json = klass.create!(payload: nil)
+    x = klass.where(payload: nil).first
+    assert_equal(json, x)
+  end
+
+  def test_select_nil_json_after_update
+    json = klass.create!(payload: "foo")
+    x = klass.where(payload: nil).first
+    assert_nil(x)
+
+    json.update_attributes(payload: nil)
+    x = klass.where(payload: nil).first
+    assert_equal(json.reload, x)
+  end
+
+  def test_select_array_json_value
+    @connection.execute(%q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|)
+    x = klass.first
+    assert_equal(["v0", { "k1" => "v1" }], x.payload)
+  end
+
+  def test_rewrite_array_json_value
+    @connection.execute(%q|insert into json_data_type (payload) VALUES ('["v0",{"k1":"v1"}]')|)
+    x = klass.first
+    x.payload = ["v1", { "k2" => "v2" }, "v3"]
+    assert x.save!
+  end
+
+  def test_with_store_accessors
+    x = klass.new(resolution: "320×480")
+    assert_equal "320×480", x.resolution
+
+    x.save!
+    x = klass.first
+    assert_equal "320×480", x.resolution
+
+    x.resolution = "640×1136"
+    x.save!
+
+    x = klass.first
+    assert_equal "640×1136", x.resolution
+  end
+
+  def test_duplication_with_store_accessors
+    x = klass.new(resolution: "320×480")
+    assert_equal "320×480", x.resolution
+
+    y = x.dup
+    assert_equal "320×480", y.resolution
+  end
+
+  def test_yaml_round_trip_with_store_accessors
+    x = klass.new(resolution: "320×480")
+    assert_equal "320×480", x.resolution
+
+    y = YAML.load(YAML.dump(x))
+    assert_equal "320×480", y.resolution
+  end
+
+  def test_changes_in_place
+    json = klass.new
+    assert_not json.changed?
+
+    json.payload = { "one" => "two" }
+    assert json.changed?
+    assert json.payload_changed?
+
+    json.save!
+    assert_not json.changed?
+
+    json.payload["three"] = "four"
+    assert json.payload_changed?
+
+    json.save!
+    json.reload
+
+    assert_equal({ "one" => "two", "three" => "four" }, json.payload)
+    assert_not json.changed?
+  end
+
+  def test_changes_in_place_with_ruby_object
+    time = Time.now.utc
+    json = klass.create!(payload: time)
+
+    json.reload
+    assert_not json.changed?
+
+    json.payload = time
+    assert_not json.changed?
+  end
+
+  def test_assigning_string_literal
+    json = klass.create!(payload: "foo")
+    assert_equal "foo", json.payload
+  end
+
+  def test_assigning_number
+    json = klass.create!(payload: 1.234)
+    assert_equal 1.234, json.payload
+  end
+
+  def test_assigning_boolean
+    json = klass.create!(payload: true)
+    assert_equal true, json.payload
+  end
+
+  private
+    def klass
+      JsonDataType
+    end
+end
diff --git a/activerecord/test/cases/migration/command_recorder_test.rb b/activerecord/test/cases/migration/command_recorder_test.rb
index 802a969cb7..007926f1b9 100644
--- a/activerecord/test/cases/migration/command_recorder_test.rb
+++ b/activerecord/test/cases/migration/command_recorder_test.rb
@@ -211,11 +211,6 @@ module ActiveRecord
         assert_equal [:remove_index, [:table, { name: "new_index" }]], remove
       end
 
-      def test_invert_add_index_with_no_options
-        remove = @recorder.inverse_of :add_index, [:table, [:one, :two]]
-        assert_equal [:remove_index, [:table, { column: [:one, :two] }]], remove
-      end
-
       def test_invert_remove_index
         add = @recorder.inverse_of :remove_index, [:table, :one]
         assert_equal [:add_index, [:table, :one]], add
diff --git a/activerecord/test/cases/migration/compatibility_test.rb b/activerecord/test/cases/migration/compatibility_test.rb
index 7a80bfb899..596a21dcbc 100644
--- a/activerecord/test/cases/migration/compatibility_test.rb
+++ b/activerecord/test/cases/migration/compatibility_test.rb
@@ -90,6 +90,21 @@ module ActiveRecord
         connection.drop_table :more_testings rescue nil
       end
 
+      def test_timestamps_have_null_constraints_if_not_present_in_migration_of_change_table
+        migration = Class.new(ActiveRecord::Migration[4.2]) {
+          def migrate(x)
+            change_table :testings do |t|
+              t.timestamps
+            end
+          end
+        }.new
+
+        ActiveRecord::Migrator.new(:up, [migration]).migrate
+
+        assert connection.columns(:testings).find { |c| c.name == "created_at" }.null
+        assert connection.columns(:testings).find { |c| c.name == "updated_at" }.null
+      end
+
       def test_timestamps_have_null_constraints_if_not_present_in_migration_for_adding_timestamps_to_existing_table
         migration = Class.new(ActiveRecord::Migration[4.2]) {
           def migrate(x)
diff --git a/activerecord/test/cases/migration/references_statements_test.rb b/activerecord/test/cases/migration/references_statements_test.rb
index 06c44c8c52..e9eb9968cb 100644
--- a/activerecord/test/cases/migration/references_statements_test.rb
+++ b/activerecord/test/cases/migration/references_statements_test.rb
@@ -50,6 +50,14 @@ module ActiveRecord
         assert column_exists?(table_name, :taggable_type, :string, default: "Photo")
       end
 
+      def test_creates_reference_type_column_with_not_null
+        connection.create_table table_name, force: true do |t|
+          t.references :taggable, null: false, polymorphic: true
+        end
+        assert column_exists?(table_name, :taggable_id, :integer, null: false)
+        assert column_exists?(table_name, :taggable_type, :string, null: false)
+      end
+
       def test_does_not_share_options_with_reference_type_column
         add_reference table_name, :taggable, type: :integer, limit: 2, polymorphic: true
         assert column_exists?(table_name, :taggable_id, :integer, limit: 2)
diff --git a/activerecord/test/cases/migration/rename_table_test.rb b/activerecord/test/cases/migration/rename_table_test.rb
index 7bcabd0cc6..5da3ad33a3 100644
--- a/activerecord/test/cases/migration/rename_table_test.rb
+++ b/activerecord/test/cases/migration/rename_table_test.rb
@@ -79,10 +79,33 @@ module ActiveRecord
           assert_equal ConnectionAdapters::PostgreSQL::Name.new("public", "octopi_#{pk}_seq"), seq
         end
 
+        def test_renaming_table_renames_primary_key
+          connection.create_table :cats, id: :uuid, default: "uuid_generate_v4()"
+          rename_table :cats, :felines
+
+          assert connection.table_exists? :felines
+          refute connection.table_exists? :cats
+
+          primary_key_name = connection.select_values(<<-SQL.strip_heredoc, "SCHEMA")[0]
+            SELECT c.relname
+              FROM pg_class c
+              JOIN pg_index i
+                ON c.oid = i.indexrelid
+             WHERE i.indisprimary
+               AND i.indrelid = 'felines'::regclass
+          SQL
+
+          assert_equal "felines_pkey", primary_key_name
+        ensure
+          connection.drop_table :cats, if_exists: true
+          connection.drop_table :felines, if_exists: true
+        end
+
         def test_renaming_table_doesnt_attempt_to_rename_non_existent_sequences
           connection.create_table :cats, id: :uuid, default: "uuid_generate_v4()"
           assert_nothing_raised { rename_table :cats, :felines }
           assert connection.table_exists? :felines
+          refute connection.table_exists? :cats
         ensure
           connection.drop_table :cats, if_exists: true
           connection.drop_table :felines, if_exists: true
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index da7875187a..57f94950f9 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -402,33 +402,6 @@ class MigrationTest < ActiveRecord::TestCase
     ActiveRecord::Migrator.up(migrations_path)
   end
 
-  def test_migration_sets_internal_metadata_even_when_fully_migrated
-    current_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
-    migrations_path = MIGRATIONS_ROOT + "/valid"
-    old_path        = ActiveRecord::Migrator.migrations_paths
-    ActiveRecord::Migrator.migrations_paths = migrations_path
-
-    ActiveRecord::Migrator.up(migrations_path)
-    assert_equal current_env, ActiveRecord::InternalMetadata[:environment]
-
-    original_rails_env  = ENV["RAILS_ENV"]
-    original_rack_env   = ENV["RACK_ENV"]
-    ENV["RAILS_ENV"]    = ENV["RACK_ENV"] = "foofoo"
-    new_env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
-
-    refute_equal current_env, new_env
-
-    sleep 1 # mysql by default does not store fractional seconds in the database
-
-    ActiveRecord::Migrator.up(migrations_path)
-    assert_equal new_env, ActiveRecord::InternalMetadata[:environment]
-  ensure
-    ActiveRecord::Migrator.migrations_paths = old_path
-    ENV["RAILS_ENV"] = original_rails_env
-    ENV["RACK_ENV"]  = original_rack_env
-    ActiveRecord::Migrator.up(migrations_path)
-  end
-
   def test_internal_metadata_stores_environment_when_other_data_exists
     ActiveRecord::InternalMetadata.delete_all
     ActiveRecord::InternalMetadata[:foo] = "bar"
diff --git a/activerecord/test/cases/nested_attributes_test.rb b/activerecord/test/cases/nested_attributes_test.rb
index b87419d203..5a62cbd3a6 100644
--- a/activerecord/test/cases/nested_attributes_test.rb
+++ b/activerecord/test/cases/nested_attributes_test.rb
@@ -752,7 +752,7 @@ module NestedAttributesOnACollectionAssociationTests
     exception = assert_raise ArgumentError do
       @pirate.send(association_setter, "foo")
     end
-    assert_equal 'Hash or Array expected, got String ("foo")', exception.message
+    assert_equal %{Hash or Array expected for attribute `#{@association_name}`, got String ("foo")}, exception.message
   end
 
   def test_should_work_with_update_as_well
diff --git a/activerecord/test/cases/numeric_data_test.rb b/activerecord/test/cases/numeric_data_test.rb
new file mode 100644
index 0000000000..76b97033af
--- /dev/null
+++ b/activerecord/test/cases/numeric_data_test.rb
@@ -0,0 +1,71 @@
+require "cases/helper"
+require "models/numeric_data"
+
+class NumericDataTest < ActiveRecord::TestCase
+  def test_big_decimal_conditions
+    m = NumericData.new(
+      bank_balance: 1586.43,
+      big_bank_balance: BigDecimal("1000234000567.95"),
+      world_population: 6000000000,
+      my_house_population: 3
+    )
+    assert m.save
+    assert_equal 0, NumericData.where("bank_balance > ?", 2000.0).count
+  end
+
+  def test_numeric_fields
+    m = NumericData.new(
+      bank_balance: 1586.43,
+      big_bank_balance: BigDecimal("1000234000567.95"),
+      world_population: 6000000000,
+      my_house_population: 3
+    )
+    assert m.save
+
+    m1 = NumericData.find(m.id)
+    assert_not_nil m1
+
+    # As with migration_test.rb, we should make world_population >= 2**62
+    # to cover 64-bit platforms and test it is a Bignum, but the main thing
+    # is that it's an Integer.
+    assert_kind_of Integer, m1.world_population
+    assert_equal 6000000000, m1.world_population
+
+    assert_kind_of Integer, m1.my_house_population
+    assert_equal 3, m1.my_house_population
+
+    assert_kind_of BigDecimal, m1.bank_balance
+    assert_equal BigDecimal("1586.43"), m1.bank_balance
+
+    assert_kind_of BigDecimal, m1.big_bank_balance
+    assert_equal BigDecimal("1000234000567.95"), m1.big_bank_balance
+  end
+
+  def test_numeric_fields_with_scale
+    m = NumericData.new(
+      bank_balance: 1586.43122334,
+      big_bank_balance: BigDecimal("234000567.952344"),
+      world_population: 6000000000,
+      my_house_population: 3
+    )
+    assert m.save
+
+    m1 = NumericData.find(m.id)
+    assert_not_nil m1
+
+    # As with migration_test.rb, we should make world_population >= 2**62
+    # to cover 64-bit platforms and test it is a Bignum, but the main thing
+    # is that it's an Integer.
+    assert_kind_of Integer, m1.world_population
+    assert_equal 6000000000, m1.world_population
+
+    assert_kind_of Integer, m1.my_house_population
+    assert_equal 3, m1.my_house_population
+
+    assert_kind_of BigDecimal, m1.bank_balance
+    assert_equal BigDecimal("1586.43"), m1.bank_balance
+
+    assert_kind_of BigDecimal, m1.big_bank_balance
+    assert_equal BigDecimal("234000567.95"), m1.big_bank_balance
+  end
+end
diff --git a/activerecord/test/cases/primary_keys_test.rb b/activerecord/test/cases/primary_keys_test.rb
index 5ded619716..56229b70bc 100644
--- a/activerecord/test/cases/primary_keys_test.rb
+++ b/activerecord/test/cases/primary_keys_test.rb
@@ -46,7 +46,7 @@ class PrimaryKeysTest < ActiveRecord::TestCase
     topic = Topic.new
     topic.title = "New Topic"
     assert_nil topic.id
-    assert_nothing_raised { topic.save! }
+    topic.save!
     id = topic.id
 
     topicReloaded = Topic.find(id)
@@ -56,23 +56,36 @@ class PrimaryKeysTest < ActiveRecord::TestCase
   def test_customized_primary_key_auto_assigns_on_save
     Keyboard.delete_all
     keyboard = Keyboard.new(name: "HHKB")
-    assert_nothing_raised { keyboard.save! }
+    keyboard.save!
     assert_equal keyboard.id, Keyboard.find_by_name("HHKB").id
   end
 
   def test_customized_primary_key_can_be_get_before_saving
     keyboard = Keyboard.new
     assert_nil keyboard.id
-    assert_nothing_raised { assert_nil keyboard.key_number }
+    assert_nil keyboard.key_number
   end
 
   def test_customized_string_primary_key_settable_before_save
     subscriber = Subscriber.new
-    assert_nothing_raised { subscriber.id = "webster123" }
+    subscriber.id = "webster123"
     assert_equal "webster123", subscriber.id
     assert_equal "webster123", subscriber.nick
   end
 
+  def test_update_with_non_primary_key_id_column
+    subscriber = Subscriber.first
+    subscriber.update(update_count: 1)
+    subscriber.reload
+    assert_equal 1, subscriber.update_count
+  end
+
+  def test_update_columns_with_non_primary_key_id_column
+    subscriber = Subscriber.first
+    subscriber.update_columns(id: 1)
+    assert_not_equal 1, subscriber.nick
+  end
+
   def test_string_key
     subscriber = Subscriber.find(subscribers(:first).nick)
     assert_equal(subscribers(:first).name, subscriber.name)
@@ -83,7 +96,7 @@ class PrimaryKeysTest < ActiveRecord::TestCase
     subscriber.id = "jdoe"
     assert_equal("jdoe", subscriber.id)
     subscriber.name = "John Doe"
-    assert_nothing_raised { subscriber.save! }
+    subscriber.save!
     assert_equal("jdoe", subscriber.id)
 
     subscriberReloaded = Subscriber.find("jdoe")
diff --git a/activerecord/test/cases/relation/merging_test.rb b/activerecord/test/cases/relation/merging_test.rb
index 64866eaf2d..c3b39a9295 100644
--- a/activerecord/test/cases/relation/merging_test.rb
+++ b/activerecord/test/cases/relation/merging_test.rb
@@ -56,7 +56,7 @@ class RelationMergingTest < ActiveRecord::TestCase
 
   def test_relation_merging_with_locks
     devs = Developer.lock.where("salary >= 80000").order("id DESC").merge(Developer.limit(2))
-    assert devs.locked.present?
+    assert devs.locked?
   end
 
   def test_relation_merging_with_preload
diff --git a/activerecord/test/cases/relation/mutation_test.rb b/activerecord/test/cases/relation/mutation_test.rb
index 11ef0d8743..dea787c07f 100644
--- a/activerecord/test/cases/relation/mutation_test.rb
+++ b/activerecord/test/cases/relation/mutation_test.rb
@@ -36,7 +36,7 @@ module ActiveRecord
       @relation ||= Relation.new FakeKlass.new("posts"), Post.arel_table, Post.predicate_builder
     end
 
-    (Relation::MULTI_VALUE_METHODS - [:references, :extending, :order, :unscope, :select, :left_joins]).each do |method|
+    (Relation::MULTI_VALUE_METHODS - [:references, :extending, :order, :unscope, :select]).each do |method|
       test "##{method}!" do
         assert relation.public_send("#{method}!", :foo).equal?(relation)
         assert_equal [:foo], relation.public_send("#{method}_values")
diff --git a/activerecord/test/cases/relation/where_test.rb b/activerecord/test/cases/relation/where_test.rb
index cbc466d6b8..42dae4d569 100644
--- a/activerecord/test/cases/relation/where_test.rb
+++ b/activerecord/test/cases/relation/where_test.rb
@@ -15,7 +15,7 @@ require "models/vertex"
 
 module ActiveRecord
   class WhereTest < ActiveRecord::TestCase
-    fixtures :posts, :edges, :authors, :author_addresses, :binaries, :essays, :cars, :treasures, :price_estimates
+    fixtures :posts, :edges, :authors, :author_addresses, :binaries, :essays, :cars, :treasures, :price_estimates, :topics
 
     def test_where_copies_bind_params
       author = authors(:david)
@@ -48,6 +48,10 @@ module ActiveRecord
       assert_equal [chef], chefs.to_a
     end
 
+    def test_where_with_casted_value_is_nil
+      assert_equal 4, Topic.where(last_read: "").count
+    end
+
     def test_rewhere_on_root
       assert_equal posts(:welcome), Post.rewhere(title: "Welcome to the weblog").first
     end
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 81173945a3..86f3b0b962 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -695,16 +695,6 @@ class RelationTest < ActiveRecord::TestCase
     end
   end
 
-  def test_default_scope_with_conditions_string
-    assert_equal Developer.where(name: "David").map(&:id).sort, DeveloperCalledDavid.all.map(&:id).sort
-    assert_nil DeveloperCalledDavid.create!.name
-  end
-
-  def test_default_scope_with_conditions_hash
-    assert_equal Developer.where(name: "Jamis").map(&:id).sort, DeveloperCalledJamis.all.map(&:id).sort
-    assert_equal "Jamis", DeveloperCalledJamis.create!.name
-  end
-
   def test_default_scoping_finder_methods
     developers = DeveloperCalledDavid.order("id").map(&:id).sort
     assert_equal Developer.where(name: "David").map(&:id).sort, developers
diff --git a/activerecord/test/cases/reload_models_test.rb b/activerecord/test/cases/reload_models_test.rb
index 5dc9d6d8b7..3f4c0c03e3 100644
--- a/activerecord/test/cases/reload_models_test.rb
+++ b/activerecord/test/cases/reload_models_test.rb
@@ -13,7 +13,7 @@ class ReloadModelsTest < ActiveRecord::TestCase
     # development environment. Note that meanwhile the class Pet is not
     # reloaded, simulating a class that is present in a plugin.
     Object.class_eval { remove_const :Owner }
-    Kernel.load(File.expand_path(File.join(File.dirname(__FILE__), "../models/owner.rb")))
+    Kernel.load(File.expand_path("../models/owner.rb", __dir__))
 
     pet = Pet.find_by_name("parrot")
     pet.owner = Owner.find_by_name("ashley")
diff --git a/activerecord/test/cases/reserved_word_test.rb b/activerecord/test/cases/reserved_word_test.rb
new file mode 100644
index 0000000000..f3019a5326
--- /dev/null
+++ b/activerecord/test/cases/reserved_word_test.rb
@@ -0,0 +1,132 @@
+require "cases/helper"
+
+class ReservedWordTest < ActiveRecord::TestCase
+  self.use_instantiated_fixtures = true
+  self.use_transactional_tests = false
+
+  class Group < ActiveRecord::Base
+    Group.table_name = "group"
+    belongs_to :select
+    has_one :values
+  end
+
+  class Select < ActiveRecord::Base
+    Select.table_name = "select"
+    has_many :groups
+  end
+
+  class Values < ActiveRecord::Base
+    Values.table_name = "values"
+  end
+
+  class Distinct < ActiveRecord::Base
+    Distinct.table_name = "distinct"
+    has_and_belongs_to_many :selects
+    has_many :values, through: :groups
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table :select, force: true
+    @connection.create_table :distinct, force: true
+    @connection.create_table :distinct_select, id: false, force: true do |t|
+      t.belongs_to :distinct
+      t.belongs_to :select
+    end
+    @connection.create_table :group, force: true do |t|
+      t.string :order
+      t.belongs_to :select
+    end
+    @connection.create_table :values, force: true do |t|
+      t.belongs_to :group
+    end
+  end
+
+  def teardown
+    @connection.drop_table :select, if_exists: true
+    @connection.drop_table :distinct, if_exists: true
+    @connection.drop_table :distinct_select, if_exists: true
+    @connection.drop_table :group, if_exists: true
+    @connection.drop_table :values, if_exists: true
+    @connection.drop_table :order, if_exists: true
+  end
+
+  def test_create_tables
+    assert_not @connection.table_exists?(:order)
+
+    @connection.create_table :order do |t|
+      t.string :group
+    end
+
+    assert @connection.table_exists?(:order)
+  end
+
+  def test_rename_tables
+    assert_nothing_raised { @connection.rename_table(:group, :order) }
+  end
+
+  def test_change_columns
+    assert_nothing_raised { @connection.change_column_default(:group, :order, "whatever") }
+    assert_nothing_raised { @connection.change_column("group", "order", :text, default: nil) }
+    assert_nothing_raised { @connection.rename_column(:group, :order, :values) }
+  end
+
+  def test_introspect
+    assert_equal ["id", "order", "select_id"], @connection.columns(:group).map(&:name).sort
+    assert_equal ["index_group_on_select_id"], @connection.indexes(:group).map(&:name).sort
+  end
+
+  def test_activerecord_model
+    x = Group.new
+    x.order = "x"
+    x.save!
+    x.order = "y"
+    x.save!
+    assert_equal x, Group.find_by_order("y")
+    assert_equal x, Group.find(x.id)
+  end
+
+  def test_has_one_associations
+    create_test_fixtures :group, :values
+    v = Group.find(1).values
+    assert_equal 2, v.id
+  end
+
+  def test_belongs_to_associations
+    create_test_fixtures :select, :group
+    gs = Select.find(2).groups
+    assert_equal 2, gs.length
+    assert_equal [2, 3], gs.collect(&:id).sort
+  end
+
+  def test_has_and_belongs_to_many
+    create_test_fixtures :select, :distinct, :distinct_select
+    s = Distinct.find(1).selects
+    assert_equal 2, s.length
+    assert_equal [1, 2], s.collect(&:id).sort
+  end
+
+  def test_activerecord_introspection
+    assert Group.table_exists?
+    assert_equal ["id", "order", "select_id"], Group.columns.map(&:name).sort
+  end
+
+  def test_calculations_work_with_reserved_words
+    create_test_fixtures :group
+    assert_equal 3, Group.count
+  end
+
+  def test_associations_work_with_reserved_words
+    create_test_fixtures :select, :group
+    selects = Select.all.merge!(includes: [:groups]).to_a
+    assert_no_queries do
+      selects.each { |select| select.groups }
+    end
+  end
+
+  private
+    # custom fixture loader, uses FixtureSet#create_fixtures and appends base_path to the current file's path
+    def create_test_fixtures(*fixture_names)
+      ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT + "/reserved_words", fixture_names)
+    end
+end
diff --git a/activerecord/test/cases/schema_dumper_test.rb b/activerecord/test/cases/schema_dumper_test.rb
index cb8d449ba9..4c81e825fa 100644
--- a/activerecord/test/cases/schema_dumper_test.rb
+++ b/activerecord/test/cases/schema_dumper_test.rb
@@ -17,6 +17,12 @@ class SchemaDumperTest < ActiveRecord::TestCase
     dump_all_table_schema []
   end
 
+  def test_dump_schema_information_with_empty_versions
+    ActiveRecord::SchemaMigration.delete_all
+    schema_info = ActiveRecord::Base.connection.dump_schema_information
+    assert_no_match(/INSERT INTO/, schema_info)
+  end
+
   def test_dump_schema_information_outputs_lexically_ordered_versions
     versions = %w{ 20100101010101 20100201010101 20100301010101 }
     versions.reverse_each do |v|
@@ -116,32 +122,22 @@ class SchemaDumperTest < ActiveRecord::TestCase
   def test_schema_dump_includes_limit_constraint_for_integer_columns
     output = dump_all_table_schema([/^(?!integer_limits)/])
 
-    assert_match %r{c_int_without_limit}, output
+    assert_match %r{"c_int_without_limit"(?!.*limit)}, output
 
     if current_adapter?(:PostgreSQLAdapter)
-      assert_no_match %r{c_int_without_limit.*limit:}, output
-
       assert_match %r{c_int_1.*limit: 2}, output
       assert_match %r{c_int_2.*limit: 2}, output
 
       # int 3 is 4 bytes in postgresql
-      assert_match %r{c_int_3.*}, output
-      assert_no_match %r{c_int_3.*limit:}, output
-
-      assert_match %r{c_int_4.*}, output
-      assert_no_match %r{c_int_4.*limit:}, output
+      assert_match %r{"c_int_3"(?!.*limit)}, output
+      assert_match %r{"c_int_4"(?!.*limit)}, output
     elsif current_adapter?(:Mysql2Adapter)
-      assert_match %r{c_int_without_limit"$}, output
-
       assert_match %r{c_int_1.*limit: 1}, output
       assert_match %r{c_int_2.*limit: 2}, output
       assert_match %r{c_int_3.*limit: 3}, output
 
-      assert_match %r{c_int_4.*}, output
-      assert_no_match %r{c_int_4.*:limit}, output
+      assert_match %r{"c_int_4"(?!.*limit)}, output
     elsif current_adapter?(:SQLite3Adapter)
-      assert_no_match %r{c_int_without_limit.*limit:}, output
-
       assert_match %r{c_int_1.*limit: 1}, output
       assert_match %r{c_int_2.*limit: 2}, output
       assert_match %r{c_int_3.*limit: 3}, output
@@ -330,7 +326,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
   def test_schema_dump_keeps_id_false_when_id_is_false_and_unique_not_null_column_added
     output = standard_dump
-    assert_match %r{create_table "subscribers", id: false}, output
+    assert_match %r{create_table "string_key_objects", id: false}, output
   end
 
   if ActiveRecord::Base.connection.supports_foreign_keys?
diff --git a/activerecord/test/cases/scoping/named_scoping_test.rb b/activerecord/test/cases/scoping/named_scoping_test.rb
index 0c2cffe0d3..483ea7128d 100644
--- a/activerecord/test/cases/scoping/named_scoping_test.rb
+++ b/activerecord/test/cases/scoping/named_scoping_test.rb
@@ -551,6 +551,12 @@ class NamedScopingTest < ActiveRecord::TestCase
     assert_equal 1, SpecialComment.where(body: "go crazy").created.count
   end
 
+  def test_model_class_should_respond_to_extending
+    assert_raises OopsError do
+      Comment.unscoped.oops_comments.destroy_all
+    end
+  end
+
   def test_model_class_should_respond_to_none
     assert !Topic.none?
     Topic.delete_all
diff --git a/activerecord/test/cases/scoping/relation_scoping_test.rb b/activerecord/test/cases/scoping/relation_scoping_test.rb
index 3fbff7664b..8535be8402 100644
--- a/activerecord/test/cases/scoping/relation_scoping_test.rb
+++ b/activerecord/test/cases/scoping/relation_scoping_test.rb
@@ -229,12 +229,19 @@ class RelationScopingTest < ActiveRecord::TestCase
     end
   end
 
-  def test_circular_joins_with_current_scope_does_not_crash
+  def test_circular_joins_with_scoping_does_not_crash
     posts = Post.joins(comments: :post).scoping do
-      Post.current_scope.first(10)
+      Post.first(10)
     end
     assert_equal posts, Post.joins(comments: :post).first(10)
   end
+
+  def test_circular_left_joins_with_scoping_does_not_crash
+    posts = Post.left_joins(comments: :post).scoping do
+      Post.first(10)
+    end
+    assert_equal posts, Post.left_joins(comments: :post).first(10)
+  end
 end
 
 class NestedRelationScopingTest < ActiveRecord::TestCase
diff --git a/activerecord/test/cases/serialized_attribute_test.rb b/activerecord/test/cases/serialized_attribute_test.rb
index 673392b4c4..e1bdaab5cf 100644
--- a/activerecord/test/cases/serialized_attribute_test.rb
+++ b/activerecord/test/cases/serialized_attribute_test.rb
@@ -349,4 +349,32 @@ class SerializedAttributeTest < ActiveRecord::TestCase
     topic.foo
     refute topic.changed?
   end
+
+  def test_serialized_attribute_works_under_concurrent_initial_access
+    model = Topic.dup
+
+    topic = model.last
+    topic.update group: "1"
+
+    model.serialize :group, JSON
+    model.reset_column_information
+
+    # This isn't strictly necessary for the test, but a little bit of
+    # knowledge of internals allows us to make failures far more likely.
+    model.define_singleton_method(:define_attribute) do |*args|
+      Thread.pass
+      super(*args)
+    end
+
+    threads = 4.times.map do
+      Thread.new do
+        topic.reload.group
+      end
+    end
+
+    # All the threads should retrieve the value knowing it is JSON, and
+    # thus decode it. If this fails, some threads will instead see the
+    # raw string ("1"), or raise an exception.
+    assert_equal [1] * threads.size, threads.map(&:value)
+  end
 end
diff --git a/activerecord/test/cases/tasks/mysql_rake_test.rb b/activerecord/test/cases/tasks/mysql_rake_test.rb
index 33da3d11fc..c22d974536 100644
--- a/activerecord/test/cases/tasks/mysql_rake_test.rb
+++ b/activerecord/test/cases/tasks/mysql_rake_test.rb
@@ -294,13 +294,6 @@ if current_adapter?(:Mysql2Adapter)
         ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
       end
 
-      def test_structure_dump
-        filename = "awesome-file.sql"
-        Kernel.expects(:system).with("mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db").returns(true)
-
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
-      end
-
       def test_structure_dump_with_extra_flags
         filename = "awesome-file.sql"
         expected_command = ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "--noop", "test-db"]
diff --git a/activerecord/test/cases/transactions_test.rb b/activerecord/test/cases/transactions_test.rb
index 5c6d78b574..79ba306ef5 100644
--- a/activerecord/test/cases/transactions_test.rb
+++ b/activerecord/test/cases/transactions_test.rb
@@ -595,6 +595,52 @@ class TransactionTest < ActiveRecord::TestCase
     assert_not topic.frozen?
   end
 
+  def test_restore_id_after_rollback
+    topic = Topic.new
+
+    Topic.transaction do
+      topic.save!
+      raise ActiveRecord::Rollback
+    end
+
+    assert_nil topic.id
+  end
+
+  def test_restore_custom_primary_key_after_rollback
+    movie = Movie.new(name: "foo")
+
+    Movie.transaction do
+      movie.save!
+      raise ActiveRecord::Rollback
+    end
+
+    assert_nil movie.id
+  end
+
+  def test_assign_id_after_rollback
+    topic = Topic.create!
+
+    Topic.transaction do
+      topic.save!
+      raise ActiveRecord::Rollback
+    end
+
+    topic.id = nil
+    assert_nil topic.id
+  end
+
+  def test_assign_custom_primary_key_after_rollback
+    movie = Movie.create!(name: "foo")
+
+    Movie.transaction do
+      movie.save!
+      raise ActiveRecord::Rollback
+    end
+
+    movie.id = nil
+    assert_nil movie.id
+  end
+
   def test_rollback_of_frozen_records
     topic = Topic.create.freeze
     Topic.transaction do
diff --git a/activerecord/test/cases/validations_test.rb b/activerecord/test/cases/validations_test.rb
index 5d9aa99497..a305aa295a 100644
--- a/activerecord/test/cases/validations_test.rb
+++ b/activerecord/test/cases/validations_test.rb
@@ -167,6 +167,20 @@ class ValidationsTest < ActiveRecord::TestCase
     assert topic.valid?
   end
 
+  def test_numericality_validation_checks_against_raw_value
+    klass = Class.new(Topic) do
+      def self.model_name
+        ActiveModel::Name.new(self, nil, "Topic")
+      end
+      attribute :wibble, :decimal, scale: 2, precision: 9
+      validates_numericality_of :wibble, greater_than_or_equal_to: BigDecimal.new("97.18")
+    end
+
+    assert_not klass.new(wibble: "97.179").valid?
+    assert_not klass.new(wibble: 97.179).valid?
+    assert_not klass.new(wibble: BigDecimal.new("97.179")).valid?
+  end
+
   def test_acceptance_validator_doesnt_require_db_connection
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = "posts"
diff --git a/activerecord/test/cases/yaml_serialization_test.rb b/activerecord/test/cases/yaml_serialization_test.rb
index ab0e67cd9d..bfc13d683d 100644
--- a/activerecord/test/cases/yaml_serialization_test.rb
+++ b/activerecord/test/cases/yaml_serialization_test.rb
@@ -123,8 +123,8 @@ class YamlSerializationTest < ActiveRecord::TestCase
 
     def yaml_fixture(file_name)
       path = File.expand_path(
-        "../../support/yaml_compatibility_fixtures/#{file_name}.yml",
-        __FILE__
+        "../support/yaml_compatibility_fixtures/#{file_name}.yml",
+        __dir__
       )
       File.read(path)
     end
diff --git a/activerecord/test/config.rb b/activerecord/test/config.rb
index 6e2e8b2145..a65e6ff776 100644
--- a/activerecord/test/config.rb
+++ b/activerecord/test/config.rb
@@ -1,4 +1,4 @@
-TEST_ROOT       = File.expand_path(File.dirname(__FILE__))
+TEST_ROOT       = __dir__
 ASSETS_ROOT     = TEST_ROOT + "/assets"
 FIXTURES_ROOT   = TEST_ROOT + "/fixtures"
 MIGRATIONS_ROOT = TEST_ROOT + "/migrations"
diff --git a/activerecord/test/fixtures/books.yml b/activerecord/test/fixtures/books.yml
index b3625ee72e..699623a6f9 100644
--- a/activerecord/test/fixtures/books.yml
+++ b/activerecord/test/fixtures/books.yml
@@ -25,6 +25,7 @@ ddd:
   name: "Domain-Driven Design"
   format: "hardcover"
   status: 2
+  read_status: "forgotten"
 
 tlg:
   author_id: 1
diff --git a/activerecord/test/models/book.rb b/activerecord/test/models/book.rb
index 5f8a8a96dd..6466e1b341 100644
--- a/activerecord/test/models/book.rb
+++ b/activerecord/test/models/book.rb
@@ -8,7 +8,7 @@ class Book < ActiveRecord::Base
   has_many :subscribers, through: :subscriptions
 
   enum status: [:proposed, :written, :published]
-  enum read_status: { unread: 0, reading: 2, read: 3 }
+  enum read_status: { unread: 0, reading: 2, read: 3, forgotten: nil }
   enum nullable_status: [:single, :married]
   enum language: [:english, :spanish, :french], _prefix: :in
   enum author_visibility: [:visible, :invisible], _prefix: true
diff --git a/activerecord/test/models/category.rb b/activerecord/test/models/category.rb
index e8654dca01..4b2840c653 100644
--- a/activerecord/test/models/category.rb
+++ b/activerecord/test/models/category.rb
@@ -29,6 +29,15 @@ class Category < ActiveRecord::Base
   has_many :authors_with_select, -> { select "authors.*, categorizations.post_id" }, through: :categorizations, source: :author
 
   scope :general, -> { where(name: "General") }
+
+  # Should be delegated `ast` and `locked` to `arel`.
+  def self.ast
+    raise
+  end
+
+  def self.locked
+    raise
+  end
 end
 
 class SpecialCategory < Category
diff --git a/activerecord/test/models/comment.rb b/activerecord/test/models/comment.rb
index 76b484e616..d227f6fe86 100644
--- a/activerecord/test/models/comment.rb
+++ b/activerecord/test/models/comment.rb
@@ -19,6 +19,18 @@ class Comment < ActiveRecord::Base
   has_many :children, class_name: "Comment", foreign_key: :parent_id
   belongs_to :parent, class_name: "Comment", counter_cache: :children_count
 
+  class ::OopsError < RuntimeError; end
+
+  module OopsExtension
+    def destroy_all(*)
+      raise OopsError
+    end
+  end
+
+  default_scope { extending OopsExtension }
+
+  scope :oops_comments, -> { extending OopsExtension }
+
   # Should not be called if extending modules that having the method exists on an association.
   def self.greeting
     raise
diff --git a/activerecord/test/models/company.rb b/activerecord/test/models/company.rb
index d269a95e8c..c6a5bf1c92 100644
--- a/activerecord/test/models/company.rb
+++ b/activerecord/test/models/company.rb
@@ -175,6 +175,7 @@ end
 class ExclusivelyDependentFirm < Company
   has_one :account, foreign_key: "firm_id", dependent: :delete
   has_many :dependent_sanitized_conditional_clients_of_firm, -> { order("id").where("name = 'BigShot Inc.'") }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
+  has_many :dependent_hash_conditional_clients_of_firm, -> { order("id").where(name: "BigShot Inc.") }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
   has_many :dependent_conditional_clients_of_firm, -> { order("id").where("name = ?", "BigShot Inc.") }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
 end
 
diff --git a/activerecord/test/models/numeric_data.rb b/activerecord/test/models/numeric_data.rb
new file mode 100644
index 0000000000..c6e025a9ce
--- /dev/null
+++ b/activerecord/test/models/numeric_data.rb
@@ -0,0 +1,8 @@
+class NumericData < ActiveRecord::Base
+  self.table_name = "numeric_data"
+  # Decimal columns with 0 scale being automatically treated as integers
+  # is deprecated, and will be removed in a future version of Rails.
+  attribute :world_population, :big_integer
+  attribute :my_house_population, :big_integer
+  attribute :atoms_in_universe, :big_integer
+end
diff --git a/activerecord/test/models/post.rb b/activerecord/test/models/post.rb
index a2028b3eb9..4c913b3b72 100644
--- a/activerecord/test/models/post.rb
+++ b/activerecord/test/models/post.rb
@@ -13,7 +13,7 @@ class Post < ActiveRecord::Base
 
   module NamedExtension2
     def greeting
-      "hello"
+      "hullo"
     end
   end
 
diff --git a/activerecord/test/models/topic.rb b/activerecord/test/models/topic.rb
index 0420e2d15c..d9381ac9cf 100644
--- a/activerecord/test/models/topic.rb
+++ b/activerecord/test/models/topic.rb
@@ -14,7 +14,7 @@ class Topic < ActiveRecord::Base
   scope :replied, -> { where "replies_count > 0" }
 
   scope "approved_as_string", -> { where(approved: true) }
-  scope :anonymous_extension, -> { all } do
+  scope :anonymous_extension, -> {} do
     def one
       1
     end
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index 50f1d9bfe7..8863736943 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -807,16 +807,18 @@ ActiveRecord::Schema.define do
     t.string :sponsorable_type
   end
 
-  create_table :string_key_objects, id: false, primary_key: :id, force: true do |t|
-    t.string     :id
-    t.string     :name
-    t.integer    :lock_version, null: false, default: 0
+  create_table :string_key_objects, id: false, force: true do |t|
+    t.string :id, null: false
+    t.string :name
+    t.integer :lock_version, null: false, default: 0
+    t.index :id, unique: true
   end
 
-  create_table :subscribers, force: true, id: false do |t|
+  create_table :subscribers, force: true do |t|
     t.string :nick, null: false
     t.string :name
-    t.column :books_count, :integer, null: false, default: 0
+    t.integer :books_count, null: false, default: 0
+    t.integer :update_count, null: false, default: 0
     t.index :nick, unique: true
   end