Use assert_empty and assert_not_empty

27 files changed, 127 insertions, 127 deletions

diff --git a/activerecord/test/cases/adapter_test.rb b/activerecord/test/cases/adapter_test.rb
index fdf9841054..0092146e09 100644
--- a/activerecord/test/cases/adapter_test.rb
+++ b/activerecord/test/cases/adapter_test.rb
@@ -78,7 +78,7 @@ module ActiveRecord
       idx_name = "accounts_idx"
 
       indexes = @connection.indexes("accounts")
-      assert_predicate indexes, :empty?
+      assert_empty indexes
 
       @connection.add_index :accounts, :firm_id, name: idx_name
       indexes = @connection.indexes("accounts")
diff --git a/activerecord/test/cases/associations/callbacks_test.rb b/activerecord/test/cases/associations/callbacks_test.rb
index 1db851cbc2..25d55dc4c9 100644
--- a/activerecord/test/cases/associations/callbacks_test.rb
+++ b/activerecord/test/cases/associations/callbacks_test.rb
@@ -15,7 +15,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
     @david = authors(:david)
     @thinking = posts(:thinking)
     @authorless = posts(:authorless)
-    assert_predicate @david.post_log, :empty?
+    assert_empty @david.post_log
   end
 
   def test_adding_macro_callbacks
@@ -96,7 +96,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
   def test_has_and_belongs_to_many_add_callback
     david = developers(:david)
     ar = projects(:active_record)
-    assert_predicate ar.developers_log, :empty?
+    assert_empty ar.developers_log
     ar.developers_with_callbacks << david
     assert_equal ["before_adding#{david.id}", "after_adding#{david.id}"], ar.developers_log
     ar.developers_with_callbacks << david
@@ -127,7 +127,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
 
   def test_has_and_belongs_to_many_after_add_called_after_save
     ar = projects(:active_record)
-    assert_predicate ar.developers_log, :empty?
+    assert_empty ar.developers_log
     alice = Developer.new(name: "alice")
     ar.developers_with_callbacks << alice
     assert_equal "after_adding#{alice.id}", ar.developers_log.last
@@ -143,7 +143,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
     david = developers(:david)
     jamis = developers(:jamis)
     activerecord = projects(:active_record)
-    assert_predicate activerecord.developers_log, :empty?
+    assert_empty activerecord.developers_log
     activerecord.developers_with_callbacks.delete(david)
     assert_equal ["before_removing#{david.id}", "after_removing#{david.id}"], activerecord.developers_log
 
@@ -154,7 +154,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
 
   def test_has_and_belongs_to_many_does_not_fire_callbacks_on_clear
     activerecord = projects(:active_record)
-    assert_predicate activerecord.developers_log, :empty?
+    assert_empty activerecord.developers_log
     if activerecord.developers_with_callbacks.size == 0
       activerecord.developers << developers(:david)
       activerecord.developers << developers(:jamis)
@@ -163,7 +163,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
     end
     activerecord.developers_with_callbacks.flat_map { |d| ["before_removing#{d.id}", "after_removing#{d.id}"] }.sort
     assert activerecord.developers_with_callbacks.clear
-    assert_predicate activerecord.developers_log, :empty?
+    assert_empty activerecord.developers_log
   end
 
   def test_has_many_and_belongs_to_many_callbacks_for_save_on_parent
@@ -183,7 +183,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
       @david.unchangeable_posts << @authorless
     rescue Exception
     end
-    assert_predicate @david.post_log, :empty?
+    assert_empty @david.post_log
     assert_not_includes @david.unchangeable_posts, @authorless
     @david.reload
     assert_not_includes @david.unchangeable_posts, @authorless
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index b8b64bf629..cb07ca5cd3 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -284,7 +284,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_loading_from_an_association_that_has_a_hash_of_conditions
-    assert_not_predicate Author.all.merge!(includes: :hello_posts_with_hash_conditions).find(authors(:david).id).hello_posts, :empty?
+    assert_not_empty Author.all.merge!(includes: :hello_posts_with_hash_conditions).find(authors(:david).id).hello_posts
   end
 
   def test_loading_with_no_associations
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 89b7e9ddda..54ec9be684 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
@@ -180,11 +180,11 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_has_and_belongs_to_many
     david = Developer.find(1)
 
-    assert_not_predicate david.projects, :empty?
+    assert_not_empty david.projects
     assert_equal 2, david.projects.size
 
     active_record = Project.find(1)
-    assert_not_predicate active_record.developers, :empty?
+    assert_not_empty active_record.developers
     assert_equal 3, active_record.developers.size
     assert_includes active_record.developers, david
   end
@@ -441,10 +441,10 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
   def test_removing_associations_on_destroy
     david = DeveloperWithBeforeDestroyRaise.find(1)
-    assert_not_predicate david.projects, :empty?
+    assert_not_empty david.projects
     david.destroy
-    assert_predicate david.projects, :empty?
-    assert_predicate DeveloperWithBeforeDestroyRaise.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = 1"), :empty?
+    assert_empty david.projects
+    assert_empty DeveloperWithBeforeDestroyRaise.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = 1")
   end
 
   def test_destroying
@@ -459,7 +459,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     end
 
     join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id} AND project_id = #{project.id}")
-    assert_predicate join_records, :empty?
+    assert_empty join_records
 
     assert_equal 1, david.reload.projects.size
     assert_equal 1, david.projects.reload.size
@@ -475,7 +475,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     end
 
     join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id}")
-    assert_predicate join_records, :empty?
+    assert_empty join_records
 
     assert_equal 0, david.reload.projects.size
     assert_equal 0, david.projects.reload.size
@@ -484,23 +484,23 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_destroy_all
     david = Developer.find(1)
     david.projects.reload
-    assert_not_predicate david.projects, :empty?
+    assert_not_empty david.projects
 
     assert_no_difference "Project.count" do
       david.projects.destroy_all
     end
 
     join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id}")
-    assert_predicate join_records, :empty?
+    assert_empty join_records
 
-    assert_predicate david.projects, :empty?
-    assert_predicate david.projects.reload, :empty?
+    assert_empty david.projects
+    assert_empty david.projects.reload
   end
 
   def test_destroy_associations_destroys_multiple_associations
     george = parrots(:george)
-    assert_not_predicate george.pirates, :empty?
-    assert_not_predicate george.treasures, :empty?
+    assert_not_empty george.pirates
+    assert_not_empty george.treasures
 
     assert_no_difference "Pirate.count" do
       assert_no_difference "Treasure.count" do
@@ -509,12 +509,12 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     end
 
     join_records = Parrot.connection.select_all("SELECT * FROM parrots_pirates WHERE parrot_id = #{george.id}")
-    assert_predicate join_records, :empty?
-    assert_predicate george.pirates.reload, :empty?
+    assert_empty join_records
+    assert_empty george.pirates.reload
 
     join_records = Parrot.connection.select_all("SELECT * FROM parrots_treasures WHERE parrot_id = #{george.id}")
-    assert_predicate join_records, :empty?
-    assert_predicate george.treasures.reload, :empty?
+    assert_empty join_records
+    assert_empty george.treasures.reload
   end
 
   def test_associations_with_conditions
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 42e80014d3..b506280d4e 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -982,9 +982,9 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_collection_not_empty_after_building
     company = companies(:first_firm)
-    assert_predicate company.contracts, :empty?
+    assert_empty company.contracts
     company.contracts.build
-    assert_not_predicate company.contracts, :empty?
+    assert_not_empty company.contracts
   end
 
   def test_collection_size_twice_for_regressions
@@ -1199,7 +1199,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_calling_empty_with_counter_cache
     post = posts(:welcome)
     assert_queries(0) do
-      assert_not_predicate post.comments, :empty?
+      assert_not_empty post.comments
     end
   end
 
@@ -1570,7 +1570,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm = companies(:first_firm)
     assert_equal 3, firm.clients.size
     firm.destroy
-    assert_predicate Client.all.merge!(where: "firm_id=#{firm.id}").to_a, :empty?
+    assert_empty Client.all.merge!(where: "firm_id=#{firm.id}").to_a
   end
 
   def test_dependence_for_associations_with_hash_condition
@@ -1633,7 +1633,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm = RestrictedWithExceptionFirm.create!(name: "restrict")
     firm.companies.create(name: "child")
 
-    assert_not_predicate firm.companies, :empty?
+    assert_not_empty firm.companies
     assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
     assert RestrictedWithExceptionFirm.exists?(name: "restrict")
     assert firm.companies.exists?(name: "child")
@@ -1643,11 +1643,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm = RestrictedWithErrorFirm.create!(name: "restrict")
     firm.companies.create(name: "child")
 
-    assert_not_predicate firm.companies, :empty?
+    assert_not_empty firm.companies
 
     firm.destroy
 
-    assert_not_predicate firm.errors, :empty?
+    assert_not_empty firm.errors
 
     assert_equal "Cannot delete record because dependent companies exist", firm.errors[:base].first
     assert RestrictedWithErrorFirm.exists?(name: "restrict")
@@ -1660,11 +1660,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm = RestrictedWithErrorFirm.create!(name: "restrict")
     firm.companies.create(name: "child")
 
-    assert_not_predicate firm.companies, :empty?
+    assert_not_empty firm.companies
 
     firm.destroy
 
-    assert_not_predicate firm.errors, :empty?
+    assert_not_empty firm.errors
 
     assert_equal "Cannot delete record because dependent client companies exist", firm.errors[:base].first
     assert RestrictedWithErrorFirm.exists?(name: "restrict")
@@ -1717,7 +1717,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     orig_accounts = firm.accounts.to_a
 
     assert_not_predicate account, :valid?
-    assert_not_predicate orig_accounts, :empty?
+    assert_not_empty orig_accounts
     error = assert_raise ActiveRecord::RecordNotSaved do
       firm.accounts = [account]
     end
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 37d506cec1..25118b26f5 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -353,10 +353,10 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     end
 
     assert_queries(1) do
-      assert_predicate posts(:welcome).people, :empty?
+      assert_empty posts(:welcome).people
     end
 
-    assert_predicate posts(:welcome).reload.people.reload, :empty?
+    assert_empty posts(:welcome).reload.people.reload
   end
 
   def test_destroy_association
@@ -366,8 +366,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
       end
     end
 
-    assert_predicate posts(:welcome).reload.people, :empty?
-    assert_predicate posts(:welcome).people.reload, :empty?
+    assert_empty posts(:welcome).reload.people
+    assert_empty posts(:welcome).people.reload
   end
 
   def test_destroy_all
@@ -377,8 +377,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
       end
     end
 
-    assert_predicate posts(:welcome).reload.people, :empty?
-    assert_predicate posts(:welcome).people.reload, :empty?
+    assert_empty posts(:welcome).reload.people
+    assert_empty posts(:welcome).people.reload
   end
 
   def test_should_raise_exception_for_destroying_mismatching_records
@@ -685,10 +685,10 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     end
 
     assert_queries(0) do
-      assert_predicate posts(:welcome).people, :empty?
+      assert_empty posts(:welcome).people
     end
 
-    assert_predicate posts(:welcome).reload.people.reload, :empty?
+    assert_empty posts(:welcome).reload.people.reload
   end
 
   def test_association_callback_ordering
@@ -862,7 +862,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     category = author.named_categories.create(name: "Primary")
     author.named_categories.delete(category)
     assert !Categorization.exists?(author_id: author.id, named_category_name: category.name)
-    assert_predicate author.named_categories.reload, :empty?
+    assert_empty author.named_categories.reload
   end
 
   def test_collection_singular_ids_getter_with_string_primary_keys
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index db06746c43..60b599d968 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -197,7 +197,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
     firm.destroy
 
-    assert_not_predicate firm.errors, :empty?
+    assert_not_empty firm.errors
     assert_equal "Cannot delete record because a dependent account exists", firm.errors[:base].first
     assert RestrictedWithErrorFirm.exists?(name: "restrict")
     assert_predicate firm.account, :present?
@@ -213,7 +213,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
     firm.destroy
 
-    assert_not_predicate firm.errors, :empty?
+    assert_not_empty firm.errors
     assert_equal "Cannot delete record because a dependent firm account exists", firm.errors[:base].first
     assert RestrictedWithErrorFirm.exists?(name: "restrict")
     assert_predicate firm.account, :present?
diff --git a/activerecord/test/cases/associations/inner_join_association_test.rb b/activerecord/test/cases/associations/inner_join_association_test.rb
index be0f5714f3..ca0620dc3b 100644
--- a/activerecord/test/cases/associations/inner_join_association_test.rb
+++ b/activerecord/test/cases/associations/inner_join_association_test.rb
@@ -115,19 +115,19 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
     scope = Post.joins(:special_comments).where(id: posts(:sti_comments).id)
 
     # The join should match SpecialComment and its subclasses only
-    assert_predicate scope.where("comments.type" => "Comment"), :empty?
-    assert_not_predicate scope.where("comments.type" => "SpecialComment"), :empty?
-    assert_not_predicate scope.where("comments.type" => "SubSpecialComment"), :empty?
+    assert_empty scope.where("comments.type" => "Comment")
+    assert_not_empty scope.where("comments.type" => "SpecialComment")
+    assert_not_empty scope.where("comments.type" => "SubSpecialComment")
   end
 
   def test_find_with_conditions_on_reflection
-    assert_not_predicate posts(:welcome).comments, :empty?
+    assert_not_empty posts(:welcome).comments
     assert Post.joins(:nonexistent_comments).where(id: posts(:welcome).id).empty? # [sic!]
   end
 
   def test_find_with_conditions_on_through_reflection
-    assert_not_predicate posts(:welcome).tags, :empty?
-    assert_predicate Post.joins(:misc_tags).where(id: posts(:welcome).id), :empty?
+    assert_not_empty posts(:welcome).tags
+    assert_empty Post.joins(:misc_tags).where(id: posts(:welcome).id)
   end
 
   test "the default scope of the target is applied when joining associations" do
diff --git a/activerecord/test/cases/associations/left_outer_join_association_test.rb b/activerecord/test/cases/associations/left_outer_join_association_test.rb
index 6814360ac3..7b5c394177 100644
--- a/activerecord/test/cases/associations/left_outer_join_association_test.rb
+++ b/activerecord/test/cases/associations/left_outer_join_association_test.rb
@@ -69,9 +69,9 @@ class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
     scope = Post.left_outer_joins(:special_comments).where(id: posts(:sti_comments).id)
 
     # The join should match SpecialComment and its subclasses only
-    assert_predicate scope.where("comments.type" => "Comment"), :empty?
-    assert_not_predicate scope.where("comments.type" => "SpecialComment"), :empty?
-    assert_not_predicate scope.where("comments.type" => "SubSpecialComment"), :empty?
+    assert_empty scope.where("comments.type" => "Comment")
+    assert_not_empty scope.where("comments.type" => "SpecialComment")
+    assert_not_empty scope.where("comments.type" => "SubSpecialComment")
   end
 
   def test_does_not_override_select
diff --git a/activerecord/test/cases/associations/nested_through_associations_test.rb b/activerecord/test/cases/associations/nested_through_associations_test.rb
index ca48e8dc0e..03ed1c1d47 100644
--- a/activerecord/test/cases/associations/nested_through_associations_test.rb
+++ b/activerecord/test/cases/associations/nested_through_associations_test.rb
@@ -78,7 +78,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
     # This ensures that the polymorphism of taggings is being observed correctly
     authors = Author.joins(:tags).where("taggings.taggable_type" => "FakeModel")
-    assert_predicate authors, :empty?
+    assert_empty authors
   end
 
   # has_many through
@@ -177,7 +177,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
     members = Member.joins(:organization_member_details).
                      where("member_details.id" => 9)
-    assert_predicate members, :empty?
+    assert_empty members
   end
 
   # has_many through
@@ -209,7 +209,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
     members = Member.joins(:organization_member_details_2).
                      where("member_details.id" => 9)
-    assert_predicate members, :empty?
+    assert_empty members
   end
 
   # has_many through
@@ -425,9 +425,9 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
     # Check the polymorphism of taggings is being observed correctly (in both joins)
     authors = Author.joins(:similar_posts).where("taggings.taggable_type" => "FakeModel")
-    assert_predicate authors, :empty?
+    assert_empty authors
     authors = Author.joins(:similar_posts).where("taggings_authors_join.taggable_type" => "FakeModel")
-    assert_predicate authors, :empty?
+    assert_empty authors
   end
 
   def test_nested_has_many_through_with_scope_on_polymorphic_reflection
@@ -456,9 +456,9 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
     # Ensure STI is respected in the join
     scope = Post.joins(:special_comments_ratings).where(id: posts(:sti_comments).id)
-    assert_predicate scope.where("comments.type" => "Comment"), :empty?
-    assert_not_predicate scope.where("comments.type" => "SpecialComment"), :empty?
-    assert_not_predicate scope.where("comments.type" => "SubSpecialComment"), :empty?
+    assert_empty scope.where("comments.type" => "Comment")
+    assert_not_empty scope.where("comments.type" => "SpecialComment")
+    assert_not_empty scope.where("comments.type" => "SubSpecialComment")
   end
 
   def test_has_many_through_with_sti_on_nested_through_reflection
@@ -466,8 +466,8 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     assert_equal [taggings(:special_comment_rating)], taggings
 
     scope = Post.joins(:special_comments_ratings_taggings).where(id: posts(:sti_comments).id)
-    assert_predicate scope.where("comments.type" => "Comment"), :empty?
-    assert_not_predicate scope.where("comments.type" => "SpecialComment"), :empty?
+    assert_empty scope.where("comments.type" => "Comment")
+    assert_not_empty scope.where("comments.type" => "SpecialComment")
   end
 
   def test_nested_has_many_through_writers_should_raise_error
@@ -517,7 +517,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_nested_has_many_through_with_conditions_on_through_associations_preload
-    assert_predicate Author.where("tags.id" => 100).joins(:misc_post_first_blue_tags), :empty?
+    assert_empty Author.where("tags.id" => 100).joins(:misc_post_first_blue_tags)
 
     authors = assert_queries(3) { Author.includes(:misc_post_first_blue_tags).to_a.sort_by(&:id) }
     blue = tags(:blue)
@@ -574,9 +574,9 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     c = Categorization.new
     c.author = authors(:david)
     c.post_taggings.to_a
-    assert_not_predicate c.post_taggings, :empty?
+    assert_not_empty c.post_taggings
     c.save
-    assert_not_predicate c.post_taggings, :empty?
+    assert_not_empty c.post_taggings
   end
 
   def test_polymorphic_has_many_through_when_through_association_has_not_loaded
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index 2fe6715242..09684520d1 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -881,7 +881,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
     ids.each { |id| assert klass.find_by_id(id) }
 
     @pirate.save
-    assert_predicate @pirate.reload.birds, :empty?
+    assert_empty @pirate.reload.birds
     ids.each { |id| assert_nil klass.find_by_id(id) }
   end
 
@@ -889,7 +889,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
     @pirate.birds.create!(name: :parrot)
     @pirate.birds.first.destroy
     @pirate.save!
-    assert_predicate @pirate.reload.birds, :empty?
+    assert_empty @pirate.reload.birds
   end
 
   def test_should_skip_validation_on_has_many_if_marked_for_destruction
@@ -1010,10 +1010,10 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
       @pirate.save
     end
 
-    assert_predicate @pirate.reload.parrots, :empty?
+    assert_empty @pirate.reload.parrots
 
     join_records = Pirate.connection.select_all("SELECT * FROM parrots_pirates WHERE pirate_id = #{@pirate.id}")
-    assert_predicate join_records, :empty?
+    assert_empty join_records
   end
 
   def test_should_skip_validation_on_habtm_if_marked_for_destruction
@@ -1028,7 +1028,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
     end
 
     @pirate.save!
-    assert_predicate @pirate.reload.parrots, :empty?
+    assert_empty @pirate.reload.parrots
   end
 
   def test_should_skip_validation_on_habtm_if_destroyed
@@ -1405,7 +1405,7 @@ module AutosaveAssociationOnACollectionAssociationTests
 
     assert_not_predicate @pirate, :valid?
     assert_equal ["can't be blank"], @pirate.errors["#{@association_name}.name"]
-    assert_predicate @pirate.errors[@association_name], :empty?
+    assert_empty @pirate.errors[@association_name]
   end
 
   def test_should_not_use_default_invalid_error_on_associated_models
@@ -1413,7 +1413,7 @@ module AutosaveAssociationOnACollectionAssociationTests
 
     assert_not_predicate @pirate, :valid?
     assert_equal ["can't be blank"], @pirate.errors["#{@association_name}.name"]
-    assert_predicate @pirate.errors[@association_name], :empty?
+    assert_empty @pirate.errors[@association_name]
   end
 
   def test_should_default_invalid_error_from_i18n
@@ -1426,7 +1426,7 @@ module AutosaveAssociationOnACollectionAssociationTests
     assert_not_predicate @pirate, :valid?
     assert_equal ["cannot be blank"], @pirate.errors["#{@association_name}.name"]
     assert_equal ["#{@association_name.to_s.humanize} name cannot be blank"], @pirate.errors.full_messages
-    assert_predicate @pirate.errors[@association_name], :empty?
+    assert_empty @pirate.errors[@association_name]
   ensure
     I18n.backend = I18n::Backend::Simple.new
   end
diff --git a/activerecord/test/cases/explain_subscriber_test.rb b/activerecord/test/cases/explain_subscriber_test.rb
index 5713091b67..82cc891970 100644
--- a/activerecord/test/cases/explain_subscriber_test.rb
+++ b/activerecord/test/cases/explain_subscriber_test.rb
@@ -15,20 +15,20 @@ if ActiveRecord::Base.connection.supports_explain?
 
     def test_collects_nothing_if_the_payload_has_an_exception
       SUBSCRIBER.finish(nil, nil, exception: Exception.new)
-      assert_predicate queries, :empty?
+      assert_empty queries
     end
 
     def test_collects_nothing_for_ignored_payloads
       ActiveRecord::ExplainSubscriber::IGNORED_PAYLOADS.each do |ip|
         SUBSCRIBER.finish(nil, nil, name: ip)
       end
-      assert_predicate queries, :empty?
+      assert_empty queries
     end
 
     def test_collects_nothing_if_collect_is_false
       ActiveRecord::ExplainRegistry.collect = false
       SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "select 1 from users", binds: [1, 2])
-      assert_predicate queries, :empty?
+      assert_empty queries
     end
 
     def test_collects_pairs_of_queries_and_binds
@@ -42,12 +42,12 @@ if ActiveRecord::Base.connection.supports_explain?
 
     def test_collects_nothing_if_the_statement_is_not_whitelisted
       SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "SHOW max_identifier_length")
-      assert_predicate queries, :empty?
+      assert_empty queries
     end
 
     def test_collects_nothing_if_the_statement_is_only_partially_matched
       SUBSCRIBER.finish(nil, nil, name: "SQL", sql: "select_db yo_mama")
-      assert_predicate queries, :empty?
+      assert_empty queries
     end
 
     def test_collects_cte_queries
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
index a3b160b423..c88b90c8eb 100644
--- a/activerecord/test/cases/fixtures_test.rb
+++ b/activerecord/test/cases/fixtures_test.rb
@@ -393,7 +393,7 @@ class FixturesTest < ActiveRecord::TestCase
     nonexistent_fixture_path = FIXTURES_ROOT + "/imnothere"
 
     # sanity check to make sure that this file never exists
-    assert_predicate Dir[nonexistent_fixture_path + "*"], :empty?
+    assert_empty Dir[nonexistent_fixture_path + "*"]
 
     assert_raise(Errno::ENOENT) do
       ActiveRecord::FixtureSet.new(Account.connection, "companies", Company, nonexistent_fixture_path)
diff --git a/activerecord/test/cases/habtm_destroy_order_test.rb b/activerecord/test/cases/habtm_destroy_order_test.rb
index eda1cd75e4..b15e1b48c4 100644
--- a/activerecord/test/cases/habtm_destroy_order_test.rb
+++ b/activerecord/test/cases/habtm_destroy_order_test.rb
@@ -42,7 +42,7 @@ class HabtmDestroyOrderTest < ActiveRecord::TestCase
       ben.lessons << sicp
       ben.save!
       ben.destroy
-      assert_not_predicate ben.reload.lessons, :empty?
+      assert_not_empty ben.reload.lessons
     ensure
       # get rid of it so Student is still like it was
       Student.reset_callbacks(:destroy)
@@ -58,6 +58,6 @@ class HabtmDestroyOrderTest < ActiveRecord::TestCase
     assert_raises LessonError do
       sicp.destroy
     end
-    assert_not_predicate sicp.reload.students, :empty?
+    assert_not_empty sicp.reload.students
   end
 end
diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index 6f33ac06ea..bb76137ef5 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -446,10 +446,10 @@ class OptimisticLockingTest < ActiveRecord::TestCase
   def test_removing_has_and_belongs_to_many_associations_upon_destroy
     p = RichPerson.create! first_name: "Jon"
     p.treasures.create!
-    assert_not_predicate p.treasures, :empty?
+    assert_not_empty p.treasures
     p.destroy
-    assert_predicate p.treasures, :empty?
-    assert_predicate RichPerson.connection.select_all("SELECT * FROM peoples_treasures WHERE rich_person_id = 1"), :empty?
+    assert_empty p.treasures
+    assert_empty RichPerson.connection.select_all("SELECT * FROM peoples_treasures WHERE rich_person_id = 1")
   end
 
   def test_yaml_dumping_with_lock_column
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index 39a2478c3a..a4b8664a85 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -955,7 +955,7 @@ class CopyMigrationsTest < ActiveRecord::TestCase
     files_count = Dir[@migrations_path + "/*.rb"].length
     copied = ActiveRecord::Migration.copy(@migrations_path, bukkits: MIGRATIONS_ROOT + "/to_copy")
     assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
-    assert_predicate copied, :empty?
+    assert_empty copied
   ensure
     clear
   end
@@ -996,7 +996,7 @@ class CopyMigrationsTest < ActiveRecord::TestCase
       files_count = Dir[@migrations_path + "/*.rb"].length
       copied = ActiveRecord::Migration.copy(@migrations_path, bukkits: MIGRATIONS_ROOT + "/to_copy_with_timestamps")
       assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
-      assert_predicate copied, :empty?
+      assert_empty copied
     end
   ensure
     clear
@@ -1038,7 +1038,7 @@ class CopyMigrationsTest < ActiveRecord::TestCase
       files_count = Dir[@migrations_path + "/*.rb"].length
       copied = ActiveRecord::Migration.copy(@migrations_path, bukkits: MIGRATIONS_ROOT + "/to_copy_with_timestamps")
       assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
-      assert_predicate copied, :empty?
+      assert_empty copied
     end
   ensure
     clear
@@ -1059,7 +1059,7 @@ class CopyMigrationsTest < ActiveRecord::TestCase
     files_count = Dir[@migrations_path + "/*.rb"].length
     copied = ActiveRecord::Migration.copy(@migrations_path, bukkits: MIGRATIONS_ROOT + "/magic")
     assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
-    assert_predicate copied, :empty?
+    assert_empty copied
   ensure
     clear
   end
diff --git a/activerecord/test/cases/nested_attributes_test.rb b/activerecord/test/cases/nested_attributes_test.rb
index 5d9642f4ea..dd3d84aa53 100644
--- a/activerecord/test/cases/nested_attributes_test.rb
+++ b/activerecord/test/cases/nested_attributes_test.rb
@@ -36,7 +36,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     pirate.birds_with_reject_all_blank_attributes = [{ name: "", color: "", _destroy: "0" }]
     pirate.save!
 
-    assert_predicate pirate.birds_with_reject_all_blank, :empty?
+    assert_empty pirate.birds_with_reject_all_blank
   end
 
   def test_should_not_build_a_new_record_if_reject_all_blank_returns_false
@@ -44,7 +44,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     pirate.birds_with_reject_all_blank_attributes = [{ name: "", color: "" }]
     pirate.save!
 
-    assert_predicate pirate.birds_with_reject_all_blank, :empty?
+    assert_empty pirate.birds_with_reject_all_blank
   end
 
   def test_should_build_a_new_record_if_reject_all_blank_does_not_return_false
@@ -152,7 +152,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     man = Man.create(name: "Jon")
     interest = man.interests.create(topic: "the ladies")
     man.update(interests_attributes: { _destroy: "1", id: interest.id })
-    assert_predicate man.reload.interests, :empty?
+    assert_empty man.reload.interests
   end
 
   def test_reject_if_is_not_short_circuited_if_allow_destroy_is_false
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index 441371a1d3..daccd9da05 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -217,7 +217,7 @@ class PersistenceTest < ActiveRecord::TestCase
   def test_destroy_all
     conditions = "author_name = 'Mary'"
     topics_by_mary = Topic.all.merge!(where: conditions, order: "id").to_a
-    assert_not_predicate  topics_by_mary, :empty?
+    assert_not_empty  topics_by_mary
 
     assert_difference("Topic.count", -topics_by_mary.size) do
       destroyed = Topic.where(conditions).destroy_all.sort_by(&:id)
diff --git a/activerecord/test/cases/readonly_test.rb b/activerecord/test/cases/readonly_test.rb
index 75d902ad29..383e43ed55 100644
--- a/activerecord/test/cases/readonly_test.rb
+++ b/activerecord/test/cases/readonly_test.rb
@@ -54,7 +54,7 @@ class ReadOnlyTest < ActiveRecord::TestCase
 
   def test_has_many_find_readonly
     post = Post.find(1)
-    assert_not_predicate post.comments, :empty?
+    assert_not_empty post.comments
     assert !post.comments.any?(&:readonly?)
     assert !post.comments.to_a.any?(&:readonly?)
     assert post.comments.readonly(true).all?(&:readonly?)
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index 60668d745b..ee343ba380 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -149,7 +149,7 @@ class ReflectionTest < ActiveRecord::TestCase
     expected = Pirate.reflect_on_all_associations.select { |r| r.options[:autosave] }
     received = Pirate.reflect_on_all_autosave_associations
 
-    assert_not_predicate received, :empty?
+    assert_not_empty received
     assert_not_equal Pirate.reflect_on_all_associations.length, received.length
     assert_equal expected, received
   end
diff --git a/activerecord/test/cases/relation/merging_test.rb b/activerecord/test/cases/relation/merging_test.rb
index a8891c96c6..074ce9454f 100644
--- a/activerecord/test/cases/relation/merging_test.rb
+++ b/activerecord/test/cases/relation/merging_test.rb
@@ -113,9 +113,9 @@ class RelationMergingTest < ActiveRecord::TestCase
 
   def test_merging_with_from_clause
     relation = Post.all
-    assert_predicate relation.from_clause, :empty?
+    assert_empty relation.from_clause
     relation = relation.merge(Post.from("posts"))
-    assert_not_predicate relation.from_clause, :empty?
+    assert_not_empty relation.from_clause
   end
 end
 
diff --git a/activerecord/test/cases/relation/where_clause_test.rb b/activerecord/test/cases/relation/where_clause_test.rb
index 2f9ad4d996..8703d238a0 100644
--- a/activerecord/test/cases/relation/where_clause_test.rb
+++ b/activerecord/test/cases/relation/where_clause_test.rb
@@ -75,8 +75,8 @@ class ActiveRecord::Relation
     end
 
     test "a clause knows if it is empty" do
-      assert_predicate WhereClause.empty, :empty?
-      assert_not_predicate WhereClause.new(["anything"]), :empty?
+      assert_empty WhereClause.empty
+      assert_not_empty WhereClause.new(["anything"])
     end
 
     test "invert cannot handle nil" do
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 7f8764b502..f83916c588 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -904,7 +904,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal 11, posts.size
     assert_predicate posts, :any?
     assert_predicate posts, :many?
-    assert_not_predicate posts, :empty?
+    assert_not_empty posts
   end
 
   def test_select_takes_a_variable_list_of_args
@@ -950,7 +950,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal author.posts.where(author_id: author.id).size, posts.count
 
     assert_equal 0, author.posts.where(author_id: another_author.id).size
-    assert_predicate author.posts.where(author_id: another_author.id), :empty?
+    assert_empty author.posts.where(author_id: another_author.id)
   end
 
   def test_count_with_distinct
@@ -1528,10 +1528,10 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_doesnt_add_having_values_if_options_are_blank
     scope = Post.having("")
-    assert_predicate scope.having_clause, :empty?
+    assert_empty scope.having_clause
 
     scope = Post.having([])
-    assert_predicate scope.having_clause, :empty?
+    assert_empty scope.having_clause
   end
 
   def test_having_with_binds_for_both_where_and_having
diff --git a/activerecord/test/cases/scoping/default_scoping_test.rb b/activerecord/test/cases/scoping/default_scoping_test.rb
index 70d1aa5fff..0804de1fb3 100644
--- a/activerecord/test/cases/scoping/default_scoping_test.rb
+++ b/activerecord/test/cases/scoping/default_scoping_test.rb
@@ -302,8 +302,8 @@ class DefaultScopingTest < ActiveRecord::TestCase
 
   def test_unscope_merging
     merged = Developer.where(name: "Jamis").merge(Developer.unscope(:where))
-    assert_predicate merged.where_clause, :empty?
-    assert_not_predicate merged.where(name: "Jon").where_clause, :empty?
+    assert_empty merged.where_clause
+    assert_not_empty merged.where(name: "Jon").where_clause
   end
 
   def test_order_in_default_scope_should_not_prevail
diff --git a/activerecord/test/cases/scoping/named_scoping_test.rb b/activerecord/test/cases/scoping/named_scoping_test.rb
index 7d206054ca..ea71a5ce28 100644
--- a/activerecord/test/cases/scoping/named_scoping_test.rb
+++ b/activerecord/test/cases/scoping/named_scoping_test.rb
@@ -13,7 +13,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   fixtures :posts, :authors, :topics, :comments, :author_addresses
 
   def test_implements_enumerable
-    assert_not_predicate Topic.all, :empty?
+    assert_not_empty Topic.all
 
     assert_equal Topic.all.to_a, Topic.base
     assert_equal Topic.all.to_a, Topic.base.to_a
@@ -40,7 +40,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_delegates_finds_and_calculations_to_the_base_class
-    assert_not_predicate Topic.all, :empty?
+    assert_not_empty Topic.all
 
     assert_equal Topic.all.to_a,                Topic.base.to_a
     assert_equal Topic.first,                   Topic.base.first
@@ -71,7 +71,7 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_scopes_with_options_limit_finds_to_those_matching_the_criteria_specified
-    assert_not_predicate Topic.all.merge!(where: { approved: true }).to_a, :empty?
+    assert_not_empty Topic.all.merge!(where: { approved: true }).to_a
 
     assert_equal Topic.all.merge!(where: { approved: true }).to_a, Topic.approved
     assert_equal Topic.where(approved: true).count, Topic.approved.count
@@ -87,7 +87,7 @@ class NamedScopingTest < ActiveRecord::TestCase
     assert_equal((approved = Topic.all.merge!(where: { approved: true }).to_a), Topic.approved)
     assert_equal((replied = Topic.all.merge!(where: "replies_count > 0").to_a), Topic.replied)
     assert !(approved == replied)
-    assert_not_predicate (approved & replied), :empty?
+    assert_not_empty (approved & replied)
 
     assert_equal approved & replied, Topic.approved.replied
   end
@@ -115,7 +115,7 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_has_many_associations_have_access_to_scopes
     assert_not_equal Post.containing_the_letter_a, authors(:david).posts
-    assert_not_predicate Post.containing_the_letter_a, :empty?
+    assert_not_empty Post.containing_the_letter_a
 
     expected = authors(:david).posts & Post.containing_the_letter_a
     assert_equal expected.sort_by(&:id), authors(:david).posts.containing_the_letter_a.sort_by(&:id)
@@ -128,15 +128,15 @@ class NamedScopingTest < ActiveRecord::TestCase
 
   def test_has_many_through_associations_have_access_to_scopes
     assert_not_equal Comment.containing_the_letter_e, authors(:david).comments
-    assert_not_predicate Comment.containing_the_letter_e, :empty?
+    assert_not_empty Comment.containing_the_letter_e
 
     expected = authors(:david).comments & Comment.containing_the_letter_e
     assert_equal expected.sort_by(&:id), authors(:david).comments.containing_the_letter_e.sort_by(&:id)
   end
 
   def test_scopes_honor_current_scopes_from_when_defined
-    assert_not_predicate Post.ranked_by_comments.limit_by(5), :empty?
-    assert_not_predicate authors(:david).posts.ranked_by_comments.limit_by(5), :empty?
+    assert_not_empty Post.ranked_by_comments.limit_by(5)
+    assert_not_empty authors(:david).posts.ranked_by_comments.limit_by(5)
     assert_not_equal Post.ranked_by_comments.limit_by(5), authors(:david).posts.ranked_by_comments.limit_by(5)
     assert_not_equal Post.top(5), authors(:david).posts.top(5)
     # Oracle sometimes sorts differently if WHERE condition is changed
@@ -168,14 +168,14 @@ class NamedScopingTest < ActiveRecord::TestCase
   end
 
   def test_active_records_have_scope_named__all__
-    assert_not_predicate Topic.all, :empty?
+    assert_not_empty Topic.all
 
     assert_equal Topic.all.to_a, Topic.base
   end
 
   def test_active_records_have_scope_named__scoped__
     scope = Topic.where("content LIKE '%Have%'")
-    assert_not_predicate scope, :empty?
+    assert_not_empty scope
 
     assert_equal scope, Topic.all.merge!(where: "content LIKE '%Have%'")
   end
diff --git a/activerecord/test/cases/transaction_callbacks_test.rb b/activerecord/test/cases/transaction_callbacks_test.rb
index 316cac748f..1c7cec4dad 100644
--- a/activerecord/test/cases/transaction_callbacks_test.rb
+++ b/activerecord/test/cases/transaction_callbacks_test.rb
@@ -158,13 +158,13 @@ class TransactionCallbacksTest < ActiveRecord::TestCase
 
   def test_only_call_after_commit_on_top_level_transactions
     @first.after_commit_block { |r| r.history << :after_commit }
-    assert_predicate @first.history, :empty?
+    assert_empty @first.history
 
     @first.transaction do
       @first.transaction(requires_new: true) do
         @first.touch
       end
-      assert_predicate @first.history, :empty?
+      assert_empty @first.history
     end
     assert_equal [:after_commit], @first.history
   end
@@ -518,7 +518,7 @@ class TransactionEnrollmentCallbacksTest < ActiveRecord::TestCase
       @topic.content = "foo"
       @topic.save!
     end
-    assert_predicate @topic.history, :empty?
+    assert_empty @topic.history
   end
 
   def test_commit_run_transactions_callbacks_with_explicit_enrollment
@@ -538,7 +538,7 @@ class TransactionEnrollmentCallbacksTest < ActiveRecord::TestCase
       @topic.save!
       raise ActiveRecord::Rollback
     end
-    assert_predicate @topic.history, :empty?
+    assert_empty @topic.history
   end
 
   def test_rollback_run_transactions_callbacks_with_explicit_enrollment
diff --git a/activerecord/test/cases/validations/uniqueness_validation_test.rb b/activerecord/test/cases/validations/uniqueness_validation_test.rb
index 2ea3325a7d..1fa94a5b75 100644
--- a/activerecord/test/cases/validations/uniqueness_validation_test.rb
+++ b/activerecord/test/cases/validations/uniqueness_validation_test.rb
@@ -266,7 +266,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     t2.title = "I'm truly UNIQUE!"
     assert !t2.valid?, "Shouldn't be valid"
     assert !t2.save, "Shouldn't save t2 as unique"
-    assert_predicate t2.errors[:title], :empty?
+    assert_empty t2.errors[:title]
     assert_predicate t2.errors[:parent_id], :any?
 
     t2.parent_id = 4
@@ -326,15 +326,15 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     t2 = Topic.new("title" => "I'M UNIQUE!")
     assert t2.valid?, "Should be valid"
     assert t2.save, "Should save t2 as unique"
-    assert_predicate t2.errors[:title], :empty?
-    assert_predicate t2.errors[:parent_id], :empty?
+    assert_empty t2.errors[:title]
+    assert_empty t2.errors[:parent_id]
     assert_not_equal ["has already been taken"], t2.errors[:title]
 
     t3 = Topic.new("title" => "I'M uNiQUe!")
     assert t3.valid?, "Should be valid"
     assert t3.save, "Should save t2 as unique"
-    assert_predicate t3.errors[:title], :empty?
-    assert_predicate t3.errors[:parent_id], :empty?
+    assert_empty t3.errors[:title]
+    assert_empty t3.errors[:parent_id]
     assert_not_equal ["has already been taken"], t3.errors[:title]
   end