1 files changed, 39 insertions, 25 deletions

diff --git a/activerecord/test/cases/associations_test.rb b/activerecord/test/cases/associations_test.rb
index 26056f6f63..739eb02e0c 100644
--- a/activerecord/test/cases/associations_test.rb
+++ b/activerecord/test/cases/associations_test.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/computer"
 require "models/developer"
@@ -22,7 +24,7 @@ require "models/interest"
 
 class AssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :developers, :projects, :developers_projects,
-           :computers, :people, :readers, :authors, :author_favorites
+           :computers, :people, :readers, :authors, :author_addresses, :author_favorites
 
   def test_eager_loading_should_not_change_count_of_children
     liquid = Liquid.create(name: "salty")
@@ -45,7 +47,7 @@ class AssociationsTest < ActiveRecord::TestCase
     ship = Ship.create!(name: "The good ship Dollypop")
     part = ship.parts.create!(name: "Mast")
     part.mark_for_destruction
-    assert ship.parts[0].marked_for_destruction?
+    assert_predicate ship.parts[0], :marked_for_destruction?
   end
 
   def test_loading_the_association_target_should_load_most_recent_attributes_for_child_records_marked_for_destruction
@@ -90,7 +92,7 @@ class AssociationsTest < ActiveRecord::TestCase
 
     firm.clients.reload
 
-    assert !firm.clients.empty?, "New firm should have reloaded client objects"
+    assert_not firm.clients.empty?, "New firm should have reloaded client objects"
     assert_equal 1, firm.clients.size, "New firm should have reloaded clients count"
   end
 
@@ -100,8 +102,8 @@ class AssociationsTest < ActiveRecord::TestCase
     has_many_reflections = [Tag.reflect_on_association(:taggings), Developer.reflect_on_association(:projects)]
     mixed_reflections = (belongs_to_reflections + has_many_reflections).uniq
     assert using_limitable_reflections.call(belongs_to_reflections), "Belong to associations are limitable"
-    assert !using_limitable_reflections.call(has_many_reflections), "All has many style associations are not limitable"
-    assert !using_limitable_reflections.call(mixed_reflections), "No collection associations (has many style) should pass"
+    assert_not using_limitable_reflections.call(has_many_reflections), "All has many style associations are not limitable"
+    assert_not using_limitable_reflections.call(mixed_reflections), "No collection associations (has many style) should pass"
   end
 
   def test_association_with_references
@@ -111,13 +113,13 @@ class AssociationsTest < ActiveRecord::TestCase
 end
 
 class AssociationProxyTest < ActiveRecord::TestCase
-  fixtures :authors, :posts, :categorizations, :categories, :developers, :projects, :developers_projects
+  fixtures :authors, :author_addresses, :posts, :categorizations, :categories, :developers, :projects, :developers_projects
 
   def test_push_does_not_load_target
     david = authors(:david)
 
     david.posts << (post = Post.new(title: "New on Edge", body: "More cool stuff!"))
-    assert !david.posts.loaded?
+    assert_not_predicate david.posts, :loaded?
     assert_includes david.posts, post
   end
 
@@ -125,7 +127,7 @@ class AssociationProxyTest < ActiveRecord::TestCase
     david = authors(:david)
 
     david.categories << categories(:technology)
-    assert !david.categories.loaded?
+    assert_not_predicate david.categories, :loaded?
     assert_includes david.categories, categories(:technology)
   end
 
@@ -133,23 +135,23 @@ class AssociationProxyTest < ActiveRecord::TestCase
     david = authors(:david)
 
     david.posts << (post = Post.new(title: "New on Edge", body: "More cool stuff!"))
-    assert !david.posts.loaded?
+    assert_not_predicate david.posts, :loaded?
     david.save
-    assert !david.posts.loaded?
+    assert_not_predicate david.posts, :loaded?
     assert_includes david.posts, post
   end
 
   def test_push_does_not_lose_additions_to_new_record
     josh = Author.new(name: "Josh")
     josh.posts << Post.new(title: "New on Edge", body: "More cool stuff!")
-    assert josh.posts.loaded?
+    assert_predicate josh.posts, :loaded?
     assert_equal 1, josh.posts.size
   end
 
   def test_append_behaves_like_push
     josh = Author.new(name: "Josh")
     josh.posts.append Post.new(title: "New on Edge", body: "More cool stuff!")
-    assert josh.posts.loaded?
+    assert_predicate josh.posts, :loaded?
     assert_equal 1, josh.posts.size
   end
 
@@ -161,22 +163,22 @@ class AssociationProxyTest < ActiveRecord::TestCase
   def test_save_on_parent_does_not_load_target
     david = developers(:david)
 
-    assert !david.projects.loaded?
+    assert_not_predicate david.projects, :loaded?
     david.update_columns(created_at: Time.now)
-    assert !david.projects.loaded?
+    assert_not_predicate david.projects, :loaded?
   end
 
   def test_load_does_load_target
     david = developers(:david)
 
-    assert !david.projects.loaded?
+    assert_not_predicate david.projects, :loaded?
     david.projects.load
-    assert david.projects.loaded?
+    assert_predicate david.projects, :loaded?
   end
 
   def test_inspect_does_not_reload_a_not_yet_loaded_target
     andreas = Developer.new name: "Andreas", log: "new developer added"
-    assert !andreas.audit_logs.loaded?
+    assert_not_predicate andreas.audit_logs, :loaded?
     assert_match(/message: "new developer added"/, andreas.audit_logs.inspect)
   end
 
@@ -220,6 +222,18 @@ class AssociationProxyTest < ActiveRecord::TestCase
     assert_equal david.projects, david.projects.scope
   end
 
+  test "proxy object is cached" do
+    david = developers(:david)
+    assert_same david.projects, david.projects
+  end
+
+  test "proxy object can be stubbed" do
+    david = developers(:david)
+    david.projects.define_singleton_method(:extra_method) { 42 }
+
+    assert_equal 42, david.projects.extra_method
+  end
+
   test "inverses get set of subsets of the association" do
     man = Man.create
     man.interests.create
@@ -233,25 +247,25 @@ class AssociationProxyTest < ActiveRecord::TestCase
 
   test "first! works on loaded associations" do
     david = authors(:david)
-    assert_equal david.posts.first, david.posts.reload.first!
-    assert david.posts.loaded?
-    assert_no_queries { david.posts.first! }
+    assert_equal david.first_posts.first, david.first_posts.reload.first!
+    assert_predicate david.first_posts, :loaded?
+    assert_no_queries { david.first_posts.first! }
   end
 
   def test_pluck_uses_loaded_target
     david = authors(:david)
-    assert_equal david.posts.pluck(:title), david.posts.load.pluck(:title)
-    assert david.posts.loaded?
-    assert_no_queries { david.posts.pluck(:title) }
+    assert_equal david.first_posts.pluck(:title), david.first_posts.load.pluck(:title)
+    assert_predicate david.first_posts, :loaded?
+    assert_no_queries { david.first_posts.pluck(:title) }
   end
 
   def test_reset_unloads_target
     david = authors(:david)
     david.posts.reload
 
-    assert david.posts.loaded?
+    assert_predicate david.posts, :loaded?
     david.posts.reset
-    assert !david.posts.loaded?
+    assert_not_predicate david.posts, :loaded?
   end
 end