From a9aed2ac94d2e0d1a233a3c193985ae78d7e79e9 Mon Sep 17 00:00:00 2001
From: Michael Grosser <michael@grosser.it>
Date: Fri, 16 Sep 2016 09:44:05 -0700
Subject: 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
---
 .../test/cases/associations/callbacks_test.rb      |  6 +--
 .../associations/cascaded_eager_loading_test.rb    |  4 +-
 activerecord/test/cases/associations/eager_test.rb | 22 +++++-----
 .../has_and_belongs_to_many_associations_test.rb   | 20 ++++-----
 .../associations/has_many_associations_test.rb     |  2 +-
 .../has_many_through_associations_test.rb          | 48 +++++++++++-----------
 .../has_one_through_associations_test.rb           | 10 ++---
 .../test/cases/associations/join_model_test.rb     | 26 ++++++------
 8 files changed, 69 insertions(+), 69 deletions(-)

(limited to 'activerecord/test/cases/associations')

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
-- 
cgit v1.2.3