improve error message when include assertions fail

assert [1, 3].includes?(2) fails with unhelpful "Asserting failed" message

assert_includes [1, 3], 2 fails with "Expected [1, 3] to include 2" which makes it easier to debug and more obvious what went wrong

34 files changed, 141 insertions, 141 deletions

diff --git a/activerecord/test/cases/adapter_test.rb b/activerecord/test/cases/adapter_test.rb
index a72981e4d5..8fa0645b0f 100644
--- a/activerecord/test/cases/adapter_test.rb
+++ b/activerecord/test/cases/adapter_test.rb
@@ -33,10 +33,10 @@ module ActiveRecord
     def test_tables
       tables = nil
       ActiveSupport::Deprecation.silence { tables = @connection.tables }
-      assert tables.include?("accounts")
-      assert tables.include?("authors")
-      assert tables.include?("tasks")
-      assert tables.include?("topics")
+      assert_includes tables, "accounts"
+      assert_includes tables, "authors"
+      assert_includes tables, "tasks"
+      assert_includes tables, "topics"
     end
 
     def test_table_exists?
@@ -53,10 +53,10 @@ module ActiveRecord
 
     def test_data_sources
       data_sources = @connection.data_sources
-      assert data_sources.include?("accounts")
-      assert data_sources.include?("authors")
-      assert data_sources.include?("tasks")
-      assert data_sources.include?("topics")
+      assert_includes data_sources, "accounts"
+      assert_includes data_sources, "authors"
+      assert_includes data_sources, "tasks"
+      assert_includes data_sources, "topics"
     end
 
     def test_data_source_exists?
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
index 3a8fcf388a..9236a67b11 100644
--- a/activerecord/test/cases/adapters/postgresql/hstore_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -38,7 +38,7 @@ if ActiveRecord::Base.connection.supports_extensions?
 
     def test_hstore_included_in_extensions
       assert @connection.respond_to?(:extensions), "connection should have a list of extensions"
-      assert @connection.extensions.include?("hstore"), "extension list should include hstore"
+      assert_includes @connection.extensions, "hstore", "extension list should include hstore"
     end
 
     def test_disable_enable_hstore
diff --git a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
index 22f935f24e..7193f23880 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
@@ -100,10 +100,10 @@ class SchemaAuthorizationTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_tables_in_current_schemas
-    assert !@connection.tables.include?(TABLE_NAME)
+    assert_not_includes @connection.tables, TABLE_NAME
     USERS.each do |u|
       set_session_auth u
-      assert @connection.tables.include?(TABLE_NAME)
+      assert_includes @connection.tables, TABLE_NAME
       set_session_auth
     end
   end
diff --git a/activerecord/test/cases/adapters/postgresql/schema_test.rb b/activerecord/test/cases/adapters/postgresql/schema_test.rb
index b0be25de0c..51a2306c59 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_test.rb
@@ -130,7 +130,7 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
     ensure
       @connection.drop_schema "test_schema3"
     end
-    assert !@connection.schema_names.include?("test_schema3")
+    assert_not_includes @connection.schema_names, "test_schema3"
   end
 
   def test_drop_schema_if_exists
diff --git a/activerecord/test/cases/associations/callbacks_test.rb b/activerecord/test/cases/associations/callbacks_test.rb
index c3d560cb56..2f62d0367e 100644
--- a/activerecord/test/cases/associations/callbacks_test.rb
+++ b/activerecord/test/cases/associations/callbacks_test.rb
@@ -176,14 +176,14 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
   end
 
   def test_dont_add_if_before_callback_raises_exception
-    assert !@david.unchangeable_posts.include?(@authorless)
+    assert_not_includes @david.unchangeable_posts, @authorless
     begin
       @david.unchangeable_posts << @authorless
     rescue Exception
     end
     assert @david.post_log.empty?
-    assert !@david.unchangeable_posts.include?(@authorless)
+    assert_not_includes @david.unchangeable_posts, @authorless
     @david.reload
-    assert !@david.unchangeable_posts.include?(@authorless)
+    assert_not_includes @david.unchangeable_posts, @authorless
   end
 end
diff --git a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
index 9ae1558dc9..e87431bf32 100644
--- a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
+++ b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
@@ -134,8 +134,8 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
 
   def test_eager_association_loading_with_belongs_to_sti
     replies = Reply.all.merge!(includes: :topic, order: "topics.id").to_a
-    assert replies.include?(topics(:second))
-    assert !replies.include?(topics(:first))
+    assert_includes replies, topics(:second)
+    assert_not_includes replies, topics(:first)
     assert_equal topics(:first), assert_no_queries { replies.first.topic }
   end
 
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 6011c552b2..d1c4c1cef8 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -42,11 +42,11 @@ class EagerAssociationTest < ActiveRecord::TestCase
     posts = Post.all.merge!(includes: :comments).to_a
     post = posts.find { |p| p.id == 1 }
     assert_equal 2, post.comments.size
-    assert post.comments.include?(comments(:greetings))
+    assert_includes post.comments, comments(:greetings)
 
     post = Post.all.merge!(includes: :comments, where: "posts.title = 'Welcome to the weblog'").first
     assert_equal 2, post.comments.size
-    assert post.comments.include?(comments(:greetings))
+    assert_includes post.comments, comments(:greetings)
 
     posts = Post.all.merge!(includes: :last_comment).to_a
     post = posts.find { |p| p.id == 1 }
@@ -103,7 +103,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     posts = Post.all.merge!(includes: [ :comments, :author, :categories ], order: "posts.id").to_a
     assert_equal 2, posts.first.comments.size
     assert_equal 2, posts.first.categories.size
-    assert posts.first.comments.include?(comments(:greetings))
+    assert_includes posts.first.comments, comments(:greetings)
   end
 
   def test_duplicate_middle_objects
@@ -349,8 +349,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
     comments = Comment.all.merge!(includes: :post).to_a
     assert_equal 11, comments.length
     titles = comments.map { |c| c.post.title }
-    assert titles.include?(posts(:welcome).title)
-    assert titles.include?(posts(:sti_post_and_comments).title)
+    assert_includes titles, posts(:welcome).title
+    assert_includes titles, posts(:sti_post_and_comments).title
   end
 
   def test_eager_association_loading_with_belongs_to_and_limit
@@ -630,8 +630,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_equal 2, posts[0].categories.size
     assert_equal 1, posts[1].categories.size
     assert_equal 0, posts[2].categories.size
-    assert posts[0].categories.include?(categories(:technology))
-    assert posts[1].categories.include?(categories(:general))
+    assert_includes posts[0].categories, categories(:technology)
+    assert_includes posts[1].categories, categories(:general)
   end
 
   # Since the preloader for habtm gets raw row hashes from the database and then
@@ -695,8 +695,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_equal 2, posts[0].categories.size
     assert_equal 1, posts[1].categories.size
     assert_equal 0, posts[2].categories.size
-    assert posts[0].categories.include?(categories(:technology))
-    assert posts[1].categories.include?(categories(:general))
+    assert_includes posts[0].categories, categories(:technology)
+    assert_includes posts[1].categories, categories(:general)
   end
 
   def test_eager_with_inheritance
@@ -895,9 +895,9 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_polymorphic_type_condition
     post = Post.all.merge!(includes: :taggings).find(posts(:thinking).id)
-    assert post.taggings.include?(taggings(:thinking_general))
+    assert_includes post.taggings, taggings(:thinking_general)
     post = SpecialPost.all.merge!(includes: :taggings).find(posts(:thinking).id)
-    assert post.taggings.include?(taggings(:thinking_general))
+    assert_includes post.taggings, taggings(:thinking_general)
   end
 
   def test_eager_with_multiple_associations_with_same_table_has_many_and_habtm
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 36f541a506..06fc7a4388 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
@@ -169,7 +169,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     active_record = Project.find(1)
     assert !active_record.developers.empty?
     assert_equal 3, active_record.developers.size
-    assert active_record.developers.include?(david)
+    assert_includes active_record.developers, david
   end
 
   def test_adding_single
@@ -544,7 +544,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
     assert_no_queries(ignore_none: false) do
       assert project.developers.loaded?
-      assert project.developers.include?(developer)
+      assert_includes project.developers, developer
     end
   end
 
@@ -555,7 +555,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     project.reload
     assert ! project.developers.loaded?
     assert_queries(1) do
-      assert project.developers.include?(developer)
+      assert_includes project.developers, developer
     end
     assert ! project.developers.loaded?
   end
@@ -600,8 +600,8 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     project.save!
     project.reload
 
-    assert project.developers.include?(jamis)
-    assert project.developers.include?(david)
+    assert_includes project.developers, jamis
+    assert_includes project.developers, david
   end
 
   def test_find_in_association_with_options
@@ -628,7 +628,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     david.projects = [projects(:action_controller), Project.new("name" => "ActionWebSearch")]
     david.save
     assert_equal 2, david.projects.length
-    assert !david.projects.include?(projects(:active_record))
+    assert_not_includes david.projects, projects(:active_record)
   end
 
   def test_replace_on_new_object
@@ -646,9 +646,9 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     developer.special_projects << special_project
     developer.reload
 
-    assert developer.projects.include?(special_project)
-    assert developer.special_projects.include?(special_project)
-    assert !developer.special_projects.include?(other_project)
+    assert_includes developer.projects, special_project
+    assert_includes developer.special_projects, special_project
+    assert_not_includes developer.special_projects, other_project
   end
 
   def test_symbol_join_table
@@ -854,7 +854,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_include_method_in_has_and_belongs_to_many_association_should_return_true_for_instance_added_with_build
     project = Project.new
     developer = project.developers.build
-    assert project.developers.include?(developer)
+    assert_includes project.developers, developer
   end
 
   def test_destruction_does_not_error_without_primary_key
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 1bfb1ea0c8..fed59c2ab3 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -870,7 +870,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     rescue Client::RaisedOnSave
     end
 
-    assert !companies(:first_firm).clients_of_firm.reload.include?(good)
+    assert_not_includes companies(:first_firm).clients_of_firm.reload, good
   end
 
   def test_transactions_when_adding_to_new_record
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 3508793122..9f716d7820 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -175,7 +175,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     person = Person.new
     post = Post.new
     person.posts << post
-    assert person.posts.include?(post)
+    assert_includes person.posts, post
   end
 
   def test_associate_existing
@@ -187,10 +187,10 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     end
 
     assert_queries(1) do
-      assert post.people.include?(person)
+      assert_includes post.people, person
     end
 
-    assert post.reload.people.reload.include?(person)
+    assert_includes post.reload.people.reload, person
   end
 
   def test_delete_all_for_with_dependent_option_destroy
@@ -266,7 +266,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
       post.people.delete(person)
     end
 
-    assert !post.people.reload.include?(person)
+    assert_not_includes post.people.reload, person
   end
 
   def test_associating_new
@@ -284,10 +284,10 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     end
 
     assert_queries(1) do
-      assert posts(:thinking).people.include?(new_person)
+      assert_includes posts(:thinking).people, new_person
     end
 
-    assert posts(:thinking).reload.people.reload.include?(new_person)
+    assert_includes posts(:thinking).reload.people.reload, new_person
   end
 
   def test_associate_new_by_building
@@ -300,8 +300,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
     # Should only need to load the association once
     assert_queries(1) do
-      assert posts(:thinking).people.collect(&:first_name).include?("Bob")
-      assert posts(:thinking).people.collect(&:first_name).include?("Ted")
+      assert_includes posts(:thinking).people.collect(&:first_name), "Bob"
+      assert_includes posts(:thinking).people.collect(&:first_name), "Ted"
     end
 
     # 2 queries for each new record (1 to save the record itself, 1 for the join model)
@@ -312,8 +312,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
       posts(:thinking).save
     end
 
-    assert posts(:thinking).reload.people.reload.collect(&:first_name).include?("Bob")
-    assert posts(:thinking).reload.people.reload.collect(&:first_name).include?("Ted")
+    assert_includes posts(:thinking).reload.people.reload.collect(&:first_name), "Bob"
+    assert_includes posts(:thinking).reload.people.reload.collect(&:first_name), "Ted"
   end
 
   def test_build_then_save_with_has_many_inverse
@@ -322,7 +322,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     person.save
     post.reload
 
-    assert post.people.include?(person)
+    assert_includes post.people, person
   end
 
   def test_build_then_save_with_has_one_inverse
@@ -331,7 +331,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     person.save
     post.reload
 
-    assert post.single_people.include?(person)
+    assert_includes post.single_people, person
   end
 
   def test_both_parent_ids_set_when_saving_new
@@ -550,12 +550,12 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     end
 
     assert_queries(0) {
-      assert posts(:welcome).people.include?(people(:david))
-      assert !posts(:welcome).people.include?(people(:michael))
+      assert_includes posts(:welcome).people, people(:david)
+      assert_not_includes posts(:welcome).people, people(:michael)
     }
 
-    assert posts(:welcome).reload.people.reload.include?(people(:david))
-    assert !posts(:welcome).reload.people.reload.include?(people(:michael))
+    assert_includes posts(:welcome).reload.people.reload, people(:david)
+    assert_not_includes posts(:welcome).reload.people.reload, people(:michael)
   end
 
   def test_replace_order_is_preserved
@@ -591,10 +591,10 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
     # *Now* we actually need the collection so it's loaded
     assert_queries(1) do
-      assert posts(:thinking).people.collect(&:first_name).include?("Jeb")
+      assert_includes posts(:thinking).people.collect(&:first_name), "Jeb"
     end
 
-    assert posts(:thinking).reload.people.reload.collect(&:first_name).include?("Jeb")
+    assert_includes posts(:thinking).reload.people.reload.collect(&:first_name), "Jeb"
   end
 
   def test_through_record_is_built_when_created_with_where
@@ -832,14 +832,14 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     category = author.named_categories.build(name: "Primary")
     author.save
     assert Categorization.exists?(author_id: author.id, named_category_name: category.name)
-    assert author.named_categories.reload.include?(category)
+    assert_includes author.named_categories.reload, category
   end
 
   def test_collection_create_with_nonstandard_primary_key_on_belongs_to
     author   = authors(:mary)
     category = author.named_categories.create(name: "Primary")
     assert Categorization.exists?(author_id: author.id, named_category_name: category.name)
-    assert author.named_categories.reload.include?(category)
+    assert_includes author.named_categories.reload, category
   end
 
   def test_collection_exists
@@ -908,14 +908,14 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     person = Person.new
     reference = person.references.build
     job = reference.build_job
-    assert person.jobs.include?(job)
+    assert_includes person.jobs, job
   end
 
   def test_include_method_in_association_through_should_return_true_for_instance_added_with_nested_builds
     author = Author.new
     post = author.posts.build
     comment = post.comments.build
-    assert author.comments.include?(comment)
+    assert_includes author.comments, comment
   end
 
   def test_through_association_readonly_should_be_false
@@ -1022,7 +1022,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     post    = posts(:welcome)
     address = author_addresses(:david_address)
 
-    assert post.author_addresses.include?(address)
+    assert_includes post.author_addresses, address
     post.author_addresses.delete(address)
     assert post[:author_count].nil?
   end
@@ -1107,7 +1107,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_many_through_obeys_order_on_through_association
     owner = owners(:blackbeard)
-    assert owner.toys.to_sql.include?("pets.name desc")
+    assert_includes owner.toys.to_sql, "pets.name desc"
     assert_equal ["parrot", "bulbul"], owner.toys.map { |r| r.pet.name }
   end
 
diff --git a/activerecord/test/cases/associations/has_one_through_associations_test.rb b/activerecord/test/cases/associations/has_one_through_associations_test.rb
index e95eeb64db..b2f47d2daf 100644
--- a/activerecord/test/cases/associations/has_one_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_through_associations_test.rb
@@ -182,7 +182,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
       @member.organization = @organization
     end
     assert_equal @organization, @member.organization
-    assert @organization.members.include?(@member)
+    assert_includes @organization.members, @member
     assert_equal "Extra", @member.member_detail.extra_data
   end
 
@@ -197,16 +197,16 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     end
     assert_equal @organization, @member.organization
     assert_equal "Extra", @member.member_detail.extra_data
-    assert @organization.members.include?(@member)
-    assert !@new_organization.members.include?(@member)
+    assert_includes @organization.members, @member
+    assert_not_includes @new_organization.members, @member
 
     assert_no_difference "MemberDetail.count" do
       @member.organization = @new_organization
     end
     assert_equal @new_organization, @member.organization
     assert_equal "Extra", @member.member_detail.extra_data
-    assert !@organization.members.include?(@member)
-    assert @new_organization.members.include?(@member)
+    assert_not_includes @organization.members, @member
+    assert_includes @new_organization.members, @member
   end
 
   def test_preloading_has_one_through_on_belongs_to
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index 61678ae210..15a7ae941a 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -24,15 +24,15 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     :edges
 
   def test_has_many
-    assert authors(:david).categories.include?(categories(:general))
+    assert_includes authors(:david).categories, categories(:general)
   end
 
   def test_has_many_inherited
-    assert authors(:mary).categories.include?(categories(:sti_test))
+    assert_includes authors(:mary).categories, categories(:sti_test)
   end
 
   def test_inherited_has_many
-    assert categories(:sti_test).authors.include?(authors(:mary))
+    assert_includes categories(:sti_test).authors, authors(:mary)
   end
 
   def test_has_many_distinct_through_join_model
@@ -467,10 +467,10 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     saved_post.tags << new_tag
     assert new_tag.persisted? #consistent with habtm!
     assert saved_post.persisted?
-    assert saved_post.tags.include?(new_tag)
+    assert_includes saved_post.tags, new_tag
 
     assert new_tag.persisted?
-    assert saved_post.reload.tags.reload.include?(new_tag)
+    assert_includes saved_post.reload.tags.reload, new_tag
 
     new_post = Post.new(title: "Association replacement works!", body: "You best believe it.")
     saved_tag = tags(:general)
@@ -478,11 +478,11 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     new_post.tags << saved_tag
     assert !new_post.persisted?
     assert saved_tag.persisted?
-    assert new_post.tags.include?(saved_tag)
+    assert_includes new_post.tags, saved_tag
 
     new_post.save!
     assert new_post.persisted?
-    assert new_post.reload.tags.reload.include?(saved_tag)
+    assert_includes new_post.reload.tags.reload, saved_tag
 
     assert !posts(:thinking).tags.build.persisted?
     assert !posts(:thinking).tags.new.persisted?
@@ -642,8 +642,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   def test_polymorphic_has_many
     expected = taggings(:welcome_general)
     p = Post.all.merge!(includes: :taggings).find(posts(:welcome).id)
-    assert_no_queries { assert p.taggings.include?(expected) }
-    assert posts(:welcome).taggings.include?(taggings(:welcome_general))
+    assert_no_queries { assert_includes p.taggings, expected }
+    assert_includes posts(:welcome).taggings, taggings(:welcome_general)
   end
 
   def test_polymorphic_has_one
@@ -675,8 +675,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     end
 
     taggables = taggings.map(&:taggable)
-    assert taggables.include?(items(:dvd))
-    assert taggables.include?(posts(:welcome))
+    assert_includes taggables, items(:dvd)
+    assert_includes taggables, posts(:welcome)
   end
 
   def test_preload_nil_polymorphic_belongs_to
@@ -709,7 +709,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
     assert_no_queries do
       assert david.categories.loaded?
-      assert david.categories.include?(category)
+      assert_includes david.categories, category
     end
   end
 
@@ -720,7 +720,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     david.reload
     assert ! david.categories.loaded?
     assert_queries(1) do
-      assert david.categories.include?(category)
+      assert_includes david.categories, category
     end
     assert ! david.categories.loaded?
   end
diff --git a/activerecord/test/cases/associations_test.rb b/activerecord/test/cases/associations_test.rb
index 5222703570..c095b3a91c 100644
--- a/activerecord/test/cases/associations_test.rb
+++ b/activerecord/test/cases/associations_test.rb
@@ -131,7 +131,7 @@ class AssociationProxyTest < ActiveRecord::TestCase
 
     david.posts << (post = Post.new(title: "New on Edge", body: "More cool stuff!"))
     assert !david.posts.loaded?
-    assert david.posts.include?(post)
+    assert_includes david.posts, post
   end
 
   def test_push_has_many_through_does_not_load_target
@@ -139,7 +139,7 @@ class AssociationProxyTest < ActiveRecord::TestCase
 
     david.categories << categories(:technology)
     assert !david.categories.loaded?
-    assert david.categories.include?(categories(:technology))
+    assert_includes david.categories, categories(:technology)
   end
 
   def test_push_followed_by_save_does_not_load_target
@@ -149,7 +149,7 @@ class AssociationProxyTest < ActiveRecord::TestCase
     assert !david.posts.loaded?
     david.save
     assert !david.posts.loaded?
-    assert david.posts.include?(post)
+    assert_includes david.posts, post
   end
 
   def test_push_does_not_lose_additions_to_new_record
diff --git a/activerecord/test/cases/attribute_methods/read_test.rb b/activerecord/test/cases/attribute_methods/read_test.rb
index 074cfe7ffb..a8592bd179 100644
--- a/activerecord/test/cases/attribute_methods/read_test.rb
+++ b/activerecord/test/cases/attribute_methods/read_test.rb
@@ -39,13 +39,13 @@ module ActiveRecord
         instance = @klass.new
 
         @klass.attribute_names.each do |name|
-          assert !instance.methods.map(&:to_s).include?(name)
+          assert_not_includes instance.methods.map(&:to_s), name
         end
 
         @klass.define_attribute_methods
 
         @klass.attribute_names.each do |name|
-          assert instance.methods.map(&:to_s).include?(name), "#{name} is not defined"
+          assert_includes instance.methods.map(&:to_s), name, "#{name} is not defined"
         end
       end
 
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index 993d9f8b94..4c77ecab7c 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -755,7 +755,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     topic = @target.new(title: "The pros and cons of programming naked.")
     assert !topic.respond_to?(:title)
     exception = assert_raise(NoMethodError) { topic.title }
-    assert exception.message.include?("private method")
+    assert_includes exception.message, "private method"
     assert_equal "I'm private", topic.send(:title)
   end
 
@@ -765,7 +765,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     topic = @target.new
     assert !topic.respond_to?(:title=)
     exception = assert_raise(NoMethodError) { topic.title = "Pants" }
-    assert exception.message.include?("private method")
+    assert_includes exception.message, "private method"
     topic.send(:title=, "Very large pants")
   end
 
@@ -775,7 +775,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     topic = @target.new(title: "Isaac Newton's pants")
     assert !topic.respond_to?(:title?)
     exception = assert_raise(NoMethodError) { topic.title? }
-    assert exception.message.include?("private method")
+    assert_includes exception.message, "private method"
     assert topic.send(:title?)
   end
 
diff --git a/activerecord/test/cases/attributes_test.rb b/activerecord/test/cases/attributes_test.rb
index c18851257e..f4620ae2da 100644
--- a/activerecord/test/cases/attributes_test.rb
+++ b/activerecord/test/cases/attributes_test.rb
@@ -112,7 +112,7 @@ module ActiveRecord
 
       assert_equal 7, klass.attribute_types.length
       assert_equal 7, klass.column_defaults.length
-      assert klass.attribute_types.include?("wibble")
+      assert_includes klass.attribute_types, "wibble"
     end
 
     test "the given default value is cast from user" do
@@ -253,7 +253,7 @@ module ActiveRecord
     test "attributes not backed by database columns appear in inspect" do
       inspection = OverloadedType.new.inspect
 
-      assert inspection.include?("non_existent_decimal")
+      assert_includes inspection, "non_existent_decimal"
     end
   end
 end
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index 08df945063..c6e983a106 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -585,7 +585,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
     firm.save
     firm.reload
     assert_equal 2, firm.clients.length
-    assert firm.clients.include?(companies(:second_client))
+    assert_includes firm.clients, companies(:second_client)
   end
 
   def test_assign_ids_for_through_a_belongs_to
@@ -594,7 +594,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
     post.save
     post.reload
     assert_equal 2, post.people.length
-    assert post.people.include?(people(:david))
+    assert_includes post.people, people(:david)
   end
 
   def test_build_before_save
@@ -647,7 +647,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
     assert firm.save
     firm.reload
     assert_equal 2, firm.clients.length
-    assert firm.clients.include?(Client.find_by_name("New Client"))
+    assert_includes firm.clients, Client.find_by_name("New Client")
   end
 end
 
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index c03c3f9546..fafa144c6f 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -1519,7 +1519,7 @@ class BasicsTest < ActiveRecord::TestCase
   test "ignored columns are not present in columns_hash" do
     cache_columns = Developer.connection.schema_cache.columns_hash(Developer.table_name)
     assert_includes cache_columns.keys, "first_name"
-    refute_includes Developer.columns_hash.keys, "first_name"
+    assert_not_includes Developer.columns_hash.keys, "first_name"
   end
 
   test "ignored columns have no attribute methods" do
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index bacf93d275..db2871d383 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -93,20 +93,20 @@ class CalculationsTest < ActiveRecord::TestCase
   def test_should_group_by_field
     c = Account.group(:firm_id).sum(:credit_limit)
     [1,6,2].each do |firm_id|
-      assert c.keys.include?(firm_id), "Group #{c.inspect} does not contain firm_id #{firm_id}"
+      assert_includes c.keys, firm_id, "Group #{c.inspect} does not contain firm_id #{firm_id}"
     end
   end
 
   def test_should_group_by_arel_attribute
     c = Account.group(Account.arel_table[:firm_id]).sum(:credit_limit)
     [1,6,2].each do |firm_id|
-      assert c.keys.include?(firm_id), "Group #{c.inspect} does not contain firm_id #{firm_id}"
+      assert_includes c.keys, firm_id, "Group #{c.inspect} does not contain firm_id #{firm_id}"
     end
   end
 
   def test_should_group_by_multiple_fields
     c = Account.group("firm_id", :credit_limit).count(:all)
-    [ [nil, 50], [1, 50], [6, 50], [6, 55], [9, 53], [2, 60] ].each { |firm_and_limit| assert c.keys.include?(firm_and_limit) }
+    [ [nil, 50], [1, 50], [6, 50], [6, 55], [9, 53], [2, 60] ].each { |firm_and_limit| assert_includes c.keys, firm_and_limit }
   end
 
   def test_should_group_by_multiple_fields_having_functions
@@ -453,7 +453,7 @@ class CalculationsTest < ActiveRecord::TestCase
   def test_should_count_field_in_joined_table_with_group_by
     c = Account.group("accounts.firm_id").joins(:firm).count("companies.id")
 
-    [1,6,2,9].each { |firm_id| assert c.keys.include?(firm_id) }
+    [1,6,2,9].each { |firm_id| assert_includes c.keys, firm_id }
   end
 
   def test_should_count_field_of_root_table_with_conflicting_group_by_column
diff --git a/activerecord/test/cases/dirty_test.rb b/activerecord/test/cases/dirty_test.rb
index 6a7d333766..09bd00291d 100644
--- a/activerecord/test/cases/dirty_test.rb
+++ b/activerecord/test/cases/dirty_test.rb
@@ -495,8 +495,8 @@ class DirtyTest < ActiveRecord::TestCase
     assert_equal 4, pirate.previous_changes.size
     assert_equal [nil, "arrr"], pirate.previous_changes["catchphrase"]
     assert_equal [nil, pirate.id], pirate.previous_changes["id"]
-    assert pirate.previous_changes.include?("updated_on")
-    assert pirate.previous_changes.include?("created_on")
+    assert_includes pirate.previous_changes, "updated_on"
+    assert_includes pirate.previous_changes, "created_on"
     assert !pirate.previous_changes.key?("parrot_id")
 
     pirate.catchphrase = "Yar!!"
@@ -631,7 +631,7 @@ class DirtyTest < ActiveRecord::TestCase
     assert_equal("arrrr", pirate.catchphrase_was)
     assert pirate.catchphrase_changed?(from: "arrrr")
     assert_not pirate.catchphrase_changed?(from: "anything else")
-    assert pirate.changed_attributes.include?(:catchphrase)
+    assert_includes pirate.changed_attributes, :catchphrase
 
     pirate.save!
     pirate.reload
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 31bc4fa1f2..51563b347c 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -1008,8 +1008,8 @@ class FinderTest < ActiveRecord::TestCase
       where("project_id=1").to_a
     assert_equal 3, developers_on_project_one.length
     developer_names = developers_on_project_one.map(&:name)
-    assert developer_names.include?("David")
-    assert developer_names.include?("Jamis")
+    assert_includes developer_names, "David"
+    assert_includes developer_names, "Jamis"
   end
 
   def test_joins_dont_clobber_id
@@ -1092,7 +1092,7 @@ class FinderTest < ActiveRecord::TestCase
       order("client_of DESC").
       map(&:client_of)
 
-    assert client_of.include?(nil)
+    assert_includes client_of, nil
     assert_equal [2, 1].sort, client_of.compact.sort
   end
 
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
index 66b230d9d2..3f111447ff 100644
--- a/activerecord/test/cases/fixtures_test.rb
+++ b/activerecord/test/cases/fixtures_test.rb
@@ -923,7 +923,7 @@ class FoxyFixturesTest < ActiveRecord::TestCase
   end
 
   def test_namespaced_models
-    assert admin_accounts(:signals37).users.include?(admin_users(:david))
+    assert_includes admin_accounts(:signals37).users, admin_users(:david)
     assert_equal 2, admin_accounts(:signals37).users.size
   end
 
diff --git a/activerecord/test/cases/json_serialization_test.rb b/activerecord/test/cases/json_serialization_test.rb
index 814d3b63b2..b06fed4f0d 100644
--- a/activerecord/test/cases/json_serialization_test.rb
+++ b/activerecord/test/cases/json_serialization_test.rb
@@ -51,7 +51,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
       assert_match %r{^\{"contact":\{}, json
       assert_match %r{"name":"Konata Izumi"}, json
       assert_match %r{"age":16}, json
-      assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+      assert_includes json, %("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))})
       assert_match %r{"awesome":true}, json
       assert_match %r{"preferences":\{"shows":"anime"\}}, json
     end
@@ -62,7 +62,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
 
     assert_match %r{"name":"Konata Izumi"}, json
     assert_match %r{"age":16}, json
-    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_includes json, %("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))})
     assert_match %r{"awesome":true}, json
     assert_match %r{"preferences":\{"shows":"anime"\}}, json
   end
@@ -73,7 +73,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
     assert_match %r{"name":"Konata Izumi"}, json
     assert_match %r{"age":16}, json
     assert_no_match %r{"awesome":true}, json
-    assert !json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_not_includes json, %("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))})
     assert_no_match %r{"preferences":\{"shows":"anime"\}}, json
   end
 
@@ -83,7 +83,7 @@ class JsonSerializationTest < ActiveRecord::TestCase
     assert_no_match %r{"name":"Konata Izumi"}, json
     assert_no_match %r{"age":16}, json
     assert_match %r{"awesome":true}, json
-    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_includes json, %("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))})
     assert_match %r{"preferences":\{"shows":"anime"\}}, json
   end
 
@@ -275,7 +275,7 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
 
     ['"name":"David"', '"posts":[', '{"id":1}', '{"id":2}', '{"id":4}',
      '{"id":5}', '{"id":6}', '"name":"Mary"', '"posts":[', '{"id":7}', '{"id":9}'].each do |fragment|
-       assert json.include?(fragment), json
+       assert_includes json, fragment, json
      end
   end
 
diff --git a/activerecord/test/cases/migration/columns_test.rb b/activerecord/test/cases/migration/columns_test.rb
index 870a7f4fa7..55c06da411 100644
--- a/activerecord/test/cases/migration/columns_test.rb
+++ b/activerecord/test/cases/migration/columns_test.rb
@@ -32,7 +32,7 @@ module ActiveRecord
 
         rename_column :test_models, :first_name, :nick_name
         TestModel.reset_column_information
-        assert TestModel.column_names.include?("nick_name")
+        assert_includes TestModel.column_names, "nick_name"
         assert_equal ["foo"], TestModel.all.map(&:nick_name)
       end
 
@@ -45,7 +45,7 @@ module ActiveRecord
 
         rename_column "test_models", "first_name", "nick_name"
         TestModel.reset_column_information
-        assert TestModel.column_names.include?("nick_name")
+        assert_includes TestModel.column_names, "nick_name"
         assert_equal ["foo"], TestModel.all.map(&:nick_name)
       end
 
@@ -57,7 +57,7 @@ module ActiveRecord
 
         rename_column "test_models", "salary", "annual_salary"
 
-        assert TestModel.column_names.include?("annual_salary")
+        assert_includes TestModel.column_names, "annual_salary"
         default_after = connection.columns("test_models").find { |c| c.name == "annual_salary" }.default
         assert_equal "70000", default_after
       end
@@ -88,7 +88,7 @@ module ActiveRecord
         add_column "test_models", "first_name", :string
         rename_column "test_models", "first_name", "group"
 
-        assert TestModel.column_names.include?("group")
+        assert_includes TestModel.column_names, "group"
       end
 
       def test_rename_column_with_an_index
diff --git a/activerecord/test/cases/migration/rename_table_test.rb b/activerecord/test/cases/migration/rename_table_test.rb
index 5474c9ce71..fc4f700916 100644
--- a/activerecord/test/cases/migration/rename_table_test.rb
+++ b/activerecord/test/cases/migration/rename_table_test.rb
@@ -57,7 +57,7 @@ module ActiveRecord
 
           assert_equal "http://www.foreverflying.com/octopus-black7.jpg", connection.select_value("SELECT url FROM octopi WHERE id=1")
           index = connection.indexes(:octopi).first
-          assert index.columns.include?("url")
+          assert_includes index.columns, "url"
           assert_equal "index_octopi_on_url", index.name
         end
 
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index cb47237e4b..5dac3d064b 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -127,9 +127,9 @@ class ReflectionTest < ActiveRecord::TestCase
       :gps_location, nil, {}, Customer
     )
 
-    assert Customer.reflect_on_all_aggregations.include?(reflection_for_gps_location)
-    assert Customer.reflect_on_all_aggregations.include?(reflection_for_balance)
-    assert Customer.reflect_on_all_aggregations.include?(reflection_for_address)
+    assert_includes Customer.reflect_on_all_aggregations, reflection_for_gps_location
+    assert_includes Customer.reflect_on_all_aggregations, reflection_for_balance
+    assert_includes Customer.reflect_on_all_aggregations, reflection_for_address
 
     assert_equal reflection_for_address, Customer.reflect_on_aggregation(:address)
 
diff --git a/activerecord/test/cases/relation/merging_test.rb b/activerecord/test/cases/relation/merging_test.rb
index bc3b1de697..278dac8171 100644
--- a/activerecord/test/cases/relation/merging_test.rb
+++ b/activerecord/test/cases/relation/merging_test.rb
@@ -86,9 +86,9 @@ class RelationMergingTest < ActiveRecord::TestCase
     merged   = left.merge(right)
 
     assert_equal expected, merged.bound_attributes
-    assert !merged.to_sql.include?("omg")
-    assert merged.to_sql.include?("wtf")
-    assert merged.to_sql.include?("bbq")
+    assert_not_includes merged.to_sql, "omg"
+    assert_includes merged.to_sql, "wtf"
+    assert_includes merged.to_sql, "bbq"
   end
 
   def test_merging_reorders_bind_params
diff --git a/activerecord/test/cases/relation/mutation_test.rb b/activerecord/test/cases/relation/mutation_test.rb
index e7dc06c106..966ae83a3f 100644
--- a/activerecord/test/cases/relation/mutation_test.rb
+++ b/activerecord/test/cases/relation/mutation_test.rb
@@ -71,7 +71,7 @@ module ActiveRecord
 
     test "#references!" do
       assert relation.references!(:foo).equal?(relation)
-      assert relation.references_values.include?("foo")
+      assert_includes relation.references_values, "foo"
     end
 
     test "extending!" do
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 3efaace69d..dcaae5b462 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -530,8 +530,8 @@ class RelationTest < ActiveRecord::TestCase
 
     assert_equal 3, developers_on_project_one.length
     developer_names = developers_on_project_one.map(&:name)
-    assert developer_names.include?("David")
-    assert developer_names.include?("Jamis")
+    assert_includes developer_names, "David"
+    assert_includes developer_names, "Jamis"
   end
 
   def test_find_on_hash_conditions
@@ -748,11 +748,11 @@ class RelationTest < ActiveRecord::TestCase
     posts = Post.preload(:comments)
     post = posts.find { |p| p.id == 1 }
     assert_equal 2, post.comments.size
-    assert post.comments.include?(comments(:greetings))
+    assert_includes post.comments, comments(:greetings)
 
     post = Post.where("posts.title = 'Welcome to the weblog'").preload(:comments).first
     assert_equal 2, post.comments.size
-    assert post.comments.include?(comments(:greetings))
+    assert_includes post.comments, comments(:greetings)
 
     posts = Post.preload(:last_comment)
     post = posts.find { |p| p.id == 1 }
diff --git a/activerecord/test/cases/scoping/default_scoping_test.rb b/activerecord/test/cases/scoping/default_scoping_test.rb
index 6cfe4b9581..61062da3e1 100644
--- a/activerecord/test/cases/scoping/default_scoping_test.rb
+++ b/activerecord/test/cases/scoping/default_scoping_test.rb
@@ -63,7 +63,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
     def test_default_scoping_with_threads
       2.times do
         Thread.new {
-          assert DeveloperOrderedBySalary.all.to_sql.include?("salary DESC")
+          assert_includes DeveloperOrderedBySalary.all.to_sql, "salary DESC"
           DeveloperOrderedBySalary.connection.close
         }.join
       end
@@ -368,7 +368,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
   def test_unscoped_with_named_scope_should_not_have_default_scope
     assert_equal [DeveloperCalledJamis.find(developers(:poor_jamis).id)], DeveloperCalledJamis.poor
 
-    assert DeveloperCalledJamis.unscoped.poor.include?(developers(:david).becomes(DeveloperCalledJamis))
+    assert_includes DeveloperCalledJamis.unscoped.poor, developers(:david).becomes(DeveloperCalledJamis)
 
     assert_equal 11, DeveloperCalledJamis.unscoped.length
     assert_equal 1,  DeveloperCalledJamis.poor.length
diff --git a/activerecord/test/cases/scoping/named_scoping_test.rb b/activerecord/test/cases/scoping/named_scoping_test.rb
index 2f328e6e70..58e1310ab0 100644
--- a/activerecord/test/cases/scoping/named_scoping_test.rb
+++ b/activerecord/test/cases/scoping/named_scoping_test.rb
@@ -33,8 +33,8 @@ class NamedScopingTest < ActiveRecord::TestCase
     all_posts.to_a
 
     new_post = Topic.create!
-    assert !all_posts.include?(new_post)
-    assert all_posts.reload.include?(new_post)
+    assert_not_includes all_posts, new_post
+    assert_includes all_posts.reload, new_post
   end
 
   def test_delegates_finds_and_calculations_to_the_base_class
diff --git a/activerecord/test/cases/scoping/relation_scoping_test.rb b/activerecord/test/cases/scoping/relation_scoping_test.rb
index a46123f451..27b4583457 100644
--- a/activerecord/test/cases/scoping/relation_scoping_test.rb
+++ b/activerecord/test/cases/scoping/relation_scoping_test.rb
@@ -133,8 +133,8 @@ class RelationScopingTest < ActiveRecord::TestCase
     scoped_developers = Developer.includes(:projects).scoping do
       Developer.where("projects.id" => 2).to_a
     end
-    assert scoped_developers.include?(developers(:david))
-    assert !scoped_developers.include?(developers(:jamis))
+    assert_includes scoped_developers, developers(:david)
+    assert_not_includes scoped_developers, developers(:jamis)
     assert_equal 1, scoped_developers.size
   end
 
@@ -143,8 +143,8 @@ class RelationScopingTest < ActiveRecord::TestCase
       Developer.where("developers_projects.project_id = 2").to_a
     end
 
-    assert scoped_developers.include?(developers(:david))
-    assert !scoped_developers.include?(developers(:jamis))
+    assert_includes scoped_developers, developers(:david)
+    assert_not_includes scoped_developers, developers(:jamis)
     assert_equal 1, scoped_developers.size
     assert_equal developers(:david).attributes, scoped_developers.first.attributes
   end
@@ -155,7 +155,7 @@ class RelationScopingTest < ActiveRecord::TestCase
     end
 
     assert_equal 1, new_comment.post_id
-    assert Post.find(1).comments.include?(new_comment)
+    assert_includes Post.find(1).comments, new_comment
   end
 
   def test_scoped_create_with_create_with
@@ -164,7 +164,7 @@ class RelationScopingTest < ActiveRecord::TestCase
     end
 
     assert_equal 1, new_comment.post_id
-    assert Post.find(1).comments.include?(new_comment)
+    assert_includes Post.find(1).comments, new_comment
   end
 
   def test_scoped_create_with_create_with_has_higher_priority
@@ -173,7 +173,7 @@ class RelationScopingTest < ActiveRecord::TestCase
     end
 
     assert_equal 1, new_comment.post_id
-    assert Post.find(1).comments.include?(new_comment)
+    assert_includes Post.find(1).comments, new_comment
   end
 
   def test_ensure_that_method_scoping_is_correctly_restored
diff --git a/activerecord/test/cases/tasks/database_tasks_test.rb b/activerecord/test/cases/tasks/database_tasks_test.rb
index 079db3fe8b..d847a02679 100644
--- a/activerecord/test/cases/tasks/database_tasks_test.rb
+++ b/activerecord/test/cases/tasks/database_tasks_test.rb
@@ -30,7 +30,7 @@ module ActiveRecord
 
       protected_environments = ActiveRecord::Base.protected_environments.dup
       current_env            = ActiveRecord::Migrator.current_environment
-      assert !protected_environments.include?(current_env)
+      assert_not_includes protected_environments, current_env
       # Assert no error
       ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
 
diff --git a/activerecord/test/cases/transactions_test.rb b/activerecord/test/cases/transactions_test.rb
index 4f80b3ac9b..834365660f 100644
--- a/activerecord/test/cases/transactions_test.rb
+++ b/activerecord/test/cases/transactions_test.rb
@@ -631,11 +631,11 @@ class TransactionTest < ActiveRecord::TestCase
     assert_nothing_raised do
       Topic.reset_column_information
       Topic.connection.add_column("topics", "stuff", :string)
-      assert Topic.column_names.include?("stuff")
+      assert_includes Topic.column_names, "stuff"
 
       Topic.reset_column_information
       Topic.connection.remove_column("topics", "stuff")
-      assert !Topic.column_names.include?("stuff")
+      assert_not_includes Topic.column_names, "stuff"
     end
 
     if Topic.connection.supports_ddl_transactions?