ibm_db 5.6.1 → 5.7.0

data/test/cases/associations/has_many_through_associations_test.rb

@@ -36,12 +36,19 @@ require "models/family_tree"
 require "models/section"
 require "models/seminar"
 require "models/session"
+require "models/sharded"
+require "models/cpk"
+require "models/zine"
+require "models/interest"
+require "models/human"
 
 class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   fixtures :posts, :readers, :people, :comments, :authors, :categories, :taggings, :tags,
            :owners, :pets, :toys, :jobs, :references, :companies, :members, :author_addresses,
            :subscribers, :books, :subscriptions, :developers, :categorizations, :essays,
-           :categories_posts, :clubs, :memberships, :organizations, :author_favorites
+           :categories_posts, :clubs, :memberships, :organizations, :author_favorites,
+           :sharded_blog_posts, :sharded_tags, :sharded_blog_posts_tags, :cpk_orders, :cpk_tags,
+           :cpk_order_tags
 
   # Dummies to force column loads so query counts are clean.
   def setup
@@ -217,11 +224,11 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     post   = posts(:thinking)
     person = people(:david)
 
-    assert_queries(1) do
+    assert_queries_count(3) do
       post.people << person
     end
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_includes post.people, person
     end
 
@@ -314,20 +321,20 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_associating_new
-    assert_queries(1) { posts(:thinking) }
+    assert_queries_count(1) { posts(:thinking) }
     new_person = nil # so block binding catches it
 
-    assert_queries(0) do
+    assert_queries_count(0) do
       new_person = Person.new first_name: "bob"
     end
 
     # Associating new records always saves them
     # Thus, 1 query for the new person record, 1 query for the new join table record
-    assert_queries(2) do
+    assert_queries_count(4) do
       posts(:thinking).people << new_person
     end
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_includes posts(:thinking).people, new_person
     end
 
@@ -335,15 +342,15 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_associate_new_by_building
-    assert_queries(1) { posts(:thinking) }
+    assert_queries_count(1) { posts(:thinking) }
 
-    assert_queries(0) do
+    assert_queries_count(0) do
       posts(:thinking).people.build(first_name: "Bob")
       posts(:thinking).people.new(first_name: "Ted")
     end
 
     # Should only need to load the association once
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_includes posts(:thinking).people.collect(&:first_name), "Bob"
       assert_includes posts(:thinking).people.collect(&:first_name), "Ted"
     end
@@ -351,7 +358,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     # 2 queries for each new record (1 to save the record itself, 1 for the join model)
     #    * 2 new records = 4
     # + 1 query to save the actual post = 5
-    assert_queries(5) do
+    assert_queries_count(7) do
       posts(:thinking).body += "-changed"
       posts(:thinking).save
     end
@@ -403,13 +410,13 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_delete_association
-    assert_queries(2) { posts(:welcome); people(:michael); }
+    assert_queries_count(2) { posts(:welcome); people(:michael) }
 
-    assert_queries(1) do
+    assert_queries_count(3) do
       posts(:welcome).people.delete(people(:michael))
     end
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_empty posts(:welcome).people
     end
 
@@ -438,6 +445,31 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     assert_empty posts(:welcome).people.reload
   end
 
+  def test_destroy_all_on_composite_primary_key_model
+    tag = cpk_tags(:cpk_tag_loyal_customer)
+
+    assert_not_empty(tag.orders.to_a)
+
+    tag.orders.destroy_all
+    assert_empty(tag.orders)
+    assert_empty(tag.orders.reload)
+  end
+
+  def test_composite_primary_key_join_table
+    order = Cpk::Order.create(shop_id: 1, status: "open")
+    tag = cpk_tags(:cpk_tag_loyal_customer)
+
+    order_tag = Cpk::OrderTag.create(order_id: order.id_value, tag_id: tag.id, attached_by: "Nikita")
+
+    assert_equal(order, order_tag.order)
+    assert_equal(tag, order_tag.tag)
+    order_tag.update(attached_reason: "This is our loyal customer")
+
+    order_tag = order.order_tags.find { |order_tag| order_tag.tag_id == tag.id }
+
+    assert_equal("This is our loyal customer", order_tag.attached_reason)
+  end
+
   def test_destroy_all_on_association_clears_scope
     post = Post.create!(title: "Rails 6", body: "")
     people = post.people
@@ -630,11 +662,11 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_replace_association
-    assert_queries(4) { posts(:welcome); people(:david); people(:michael); posts(:welcome).people.reload }
+    assert_queries_count(4) { posts(:welcome); people(:david); people(:michael); posts(:welcome).people.reload }
 
     # 1 query to delete the existing reader (michael)
     # 1 query to associate the new reader (david)
-    assert_queries(2) do
+    assert_queries_count(4) do
       posts(:welcome).people = [people(:david)]
     end
 
@@ -680,16 +712,16 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_associate_with_create
-    assert_queries(1) { posts(:thinking) }
+    assert_queries_count(1) { posts(:thinking) }
 
     # 1 query for the new record, 1 for the join table record
     # No need to update the actual collection yet!
-    assert_queries(2) do
+    assert_queries_count(4) do
       posts(:thinking).people.create(first_name: "Jeb")
     end
 
     # *Now* we actually need the collection so it's loaded
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_includes posts(:thinking).people.collect(&:first_name), "Jeb"
     end
 
@@ -759,25 +791,25 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_push_with_invalid_join_record
     repair_validations(Contract) do
-      Contract.validate { |r| r.errors[:base] << "Invalid Contract" }
+      Contract.validate { |r| r.errors.add(:base, "Invalid Contract") }
 
       firm = companies(:first_firm)
       lifo = Developer.new(name: "lifo")
       assert_raises(ActiveRecord::RecordInvalid) do
-        assert_deprecated { firm.developers << lifo }
+        assert_deprecated(ActiveRecord.deprecator) { firm.developers << lifo }
       end
 
       lifo = Developer.create!(name: "lifo")
       assert_raises(ActiveRecord::RecordInvalid) do
-        assert_deprecated { firm.developers << lifo }
+        assert_deprecated(ActiveRecord.deprecator) { firm.developers << lifo }
       end
     end
   end
 
   def test_clear_associations
-    assert_queries(2) { posts(:welcome); posts(:welcome).people.reload }
+    assert_queries_count(2) { posts(:welcome); posts(:welcome).people.reload }
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       posts(:welcome).people.clear
     end
 
@@ -892,6 +924,16 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_has_many_through_uses_the_through_model_to_create_transactions
+    post   = posts(:thinking)
+    person = people(:david)
+    other_person = people(:michael)
+
+    assert_called(Reader, :transaction) do
+      post.people = [person, other_person]
+    end
+  end
+
   def test_has_many_association_through_a_belongs_to_association_where_the_association_doesnt_exist
     post = Post.create!(title: "TITLE", body: "BODY")
     assert_equal [], post.author_favorites
@@ -1016,10 +1058,11 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_collection_singular_ids_through_setter_raises_exception_when_invalid_ids_set
+    skip "IBM DB formats error message values without quotes" if current_adapter?(:IBM_DBAdapter)
     author = authors(:david)
     ids = [categories(:general).name, "Unknown"]
     e = assert_raises(ActiveRecord::RecordNotFound) { author.essay_category_ids = ids }
-    msg = "Couldn't find all Categories with 'name': (General, Unknown) (found 1 results, but was looking for 2). Couldn't find Category with name Unknown."
+    msg = %{Couldn't find all Categories with 'name': ("General", "Unknown") (found 1 results, but was looking for 2). Couldn't find Category with name "Unknown".}
     assert_equal msg, e.message
   end
 
@@ -1029,16 +1072,17 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_attributes_are_being_set_when_initialized_from_hm_through_association_with_where_clause
     new_subscriber = books(:awdr).subscribers.where(nick: "marklazz").build
-    assert_equal new_subscriber.nick, "marklazz"
+    assert_equal "marklazz", new_subscriber.nick
   end
 
   def test_attributes_are_being_set_when_initialized_from_hm_through_association_with_multiple_where_clauses
     new_subscriber = books(:awdr).subscribers.where(nick: "marklazz").where(name: "Marcelo Giorgi").build
-    assert_equal new_subscriber.nick, "marklazz"
-    assert_equal new_subscriber.name, "Marcelo Giorgi"
+    assert_equal "marklazz", new_subscriber.nick
+    assert_equal "Marcelo Giorgi", new_subscriber.name
   end
 
   def test_include_method_in_association_through_should_return_true_for_instance_added_with_build
+    skip "IBM DB adapter does not track built instances in has_many_through collections" if current_adapter?(:IBM_DBAdapter)
     person = Person.new
     reference = person.references.build
     job = reference.build_job
@@ -1046,6 +1090,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_include_method_in_association_through_should_return_true_for_instance_added_with_nested_builds
+    skip "IBM DB adapter does not track built instances in nested has_many_through collections" if current_adapter?(:IBM_DBAdapter)
     author = Author.new
     post = author.posts.build
     comment = post.comments.build
@@ -1189,7 +1234,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     member = members(:groucho)
     club   = member.clubs.create!
 
-    assert_equal true, club.reload.membership.favourite
+    assert_equal true, club.reload.membership.favorite
   end
 
   def test_deleting_from_has_many_through_a_belongs_to_should_not_try_to_update_counter
@@ -1213,8 +1258,10 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_create_should_not_raise_exception_when_join_record_has_errors
     repair_validations(Categorization) do
-      Categorization.validate { |r| r.errors[:base] << "Invalid Categorization" }
-      assert_deprecated { Category.create(name: "Fishing", authors: [Author.first]) }
+      Categorization.validate { |r| r.errors.add(:base, "Invalid Categorization") }
+      assert_nothing_raised do
+        Category.create(name: "Fishing", authors: [Author.first])
+      end
     end
   end
 
@@ -1225,28 +1272,28 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_create_bang_should_raise_exception_when_join_record_has_errors
     repair_validations(Categorization) do
-      Categorization.validate { |r| r.errors[:base] << "Invalid Categorization" }
+      Categorization.validate { |r| r.errors.add(:base, "Invalid Categorization") }
       assert_raises(ActiveRecord::RecordInvalid) do
-        assert_deprecated { Category.create!(name: "Fishing", authors: [Author.first]) }
+        Category.create!(name: "Fishing", authors: [Author.first])
       end
     end
   end
 
   def test_save_bang_should_raise_exception_when_join_record_has_errors
     repair_validations(Categorization) do
-      Categorization.validate { |r| r.errors[:base] << "Invalid Categorization" }
+      Categorization.validate { |r| r.errors.add(:base, "Invalid Categorization") }
       c = Category.new(name: "Fishing", authors: [Author.first])
       assert_raises(ActiveRecord::RecordInvalid) do
-        assert_deprecated { c.save! }
+        c.save!
       end
     end
   end
 
   def test_save_returns_falsy_when_join_record_has_errors
     repair_validations(Categorization) do
-      Categorization.validate { |r| r.errors[:base] << "Invalid Categorization" }
+      Categorization.validate { |r| r.errors.add(:base, "Invalid Categorization") }
       c = Category.new(name: "Fishing", authors: [Author.first])
-      assert_deprecated { assert_not c.save }
+      assert_not c.save
     end
   end
 
@@ -1254,7 +1301,7 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     person = Person.create!(first_name: "Gaga")
     person = Person.where(id: person.id).where("readers.id = 1 or 1=1").references(:readers).includes(:posts).to_a.first
 
-    assert person.posts.loaded?, "person.posts should be loaded"
+    assert_predicate person.posts, :loaded?, "person.posts should be loaded"
     assert_equal [], person.posts
   end
 
@@ -1279,6 +1326,15 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     assert_equal [tags(:general)], post.reload.tags
   end
 
+  def test_has_many_through_with_polymorhic_join_model
+    zine = Zine.create!
+
+    assert_nothing_raised { zine.polymorphic_humans.build.save! }
+
+    assert_equal 1, zine.polymorphic_humans.count
+    assert_equal 1, zine.interests.count
+  end
+
   def test_has_many_through_obeys_order_on_through_association
     owner = owners(:blackbeard)
     assert_includes owner.toys.to_sql, "pets.name desc"
@@ -1306,8 +1362,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
     active_persons = Person.joins(:readers).joins(:posts).distinct(true).where("posts.title" => "active")
 
-    assert_equal active_persons.map(&:followers_count).reduce(:+), 10
-    assert_equal active_persons.sum(:followers_count), 10
+    assert_equal 10, active_persons.map(&:followers_count).reduce(:+)
+    assert_equal 10, active_persons.sum(:followers_count)
     assert_equal active_persons.sum(:followers_count), active_persons.map(&:followers_count).reduce(:+)
   end
 
@@ -1340,11 +1396,23 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     member = Member.create!
     Membership.create!(club: club, member: member)
 
-    club.favourites << member
-    assert_equal [member], club.favourites
+    club.favorites << member
+    assert_equal [member], club.favorites
 
     club.reload
-    assert_equal [member], club.favourites
+    assert_equal [member], club.favorites
+  end
+
+  def test_insert_records_via_has_many_through_association_with_scope_and_association_name_different_from_the_joining_table_name
+    club = Club.create!
+    member = Member.create!
+    Membership.create!(club: club, member: member)
+
+    club.custom_favorites << member
+    assert_equal [member], club.custom_favorites
+
+    club.reload
+    assert_equal [member], club.custom_favorites
   end
 
   def test_has_many_through_unscope_default_scope
@@ -1377,9 +1445,9 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_has_many_through_with_scope_that_should_not_be_fully_merged
     Club.has_many :distinct_memberships, -> { distinct }, class_name: "Membership"
-    Club.has_many :special_favourites, through: :distinct_memberships, source: :member
+    Club.has_many :special_favorites, through: :distinct_memberships, source: :member
 
-    assert_nil Club.new.special_favourites.distinct_value
+    assert_nil Club.new.special_favorites.distinct_value
   end
 
   def test_has_many_through_do_not_cache_association_reader_if_the_though_method_has_default_scopes
@@ -1559,6 +1627,65 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     assert_equal sections, fall.sections.sort_by(&:id)
   end
 
+  def test_post_has_many_tags_through_association_with_composite_query_constraints
+    blog_post = sharded_blog_posts(:great_post_blog_one)
+    expected_tag_ids = Sharded::BlogPostTag.where(blog_post_id: blog_post.id, blog_id: blog_post.blog_id).pluck(:tag_id)
+    tag_ids = []
+    sql = capture_sql do
+      tag_ids = blog_post.tags.to_a.map(&:id)
+    end.first
+
+    # DB2 doesn't quote composite identifiers in JOIN conditions
+    assert_match(/.* ON.* sharded_tags\.blog_id = sharded_blog_posts_tags\.blog_id .* WHERE/i, sql)
+    assert_match(/.* WHERE .*sharded_blog_posts_tags\.blog_id = .*/i, sql)
+
+    assert_not_empty(tag_ids)
+    assert_equal(expected_tag_ids.sort, tag_ids.sort)
+  end
+
+  def test_tags_has_manu_posts_through_association_with_composite_query_constraints
+    tag = sharded_tags(:short_read_blog_one)
+    expected_blog_post_ids = Sharded::BlogPostTag.where(tag_id: tag.id, blog_id: tag.blog_id).pluck(:blog_post_id)
+    blog_post_ids = []
+    sql = capture_sql do
+      blog_post_ids = tag.blog_posts.to_a.map(&:id)
+    end.first
+
+    # DB2 doesn't quote composite identifiers in JOIN conditions
+    assert_match(/.* ON.* sharded_blog_posts\.blog_id = sharded_blog_posts_tags\.blog_id .* WHERE/i, sql)
+    assert_match(/.* WHERE .*sharded_blog_posts_tags\.blog_id = .*/i, sql)
+
+    assert_not_empty(blog_post_ids)
+    assert_equal(expected_blog_post_ids.sort, blog_post_ids.sort)
+  end
+
+  def test_loading_cpk_association_with_unpersisted_owner
+    order = Cpk::Order.create!(shop_id: 1)
+    book = Cpk::BookWithOrderAgreements.new(id: [1, 2], order: order)
+    order_agreement = Cpk::OrderAgreement.create!(order: order)
+
+    assert_equal([order_agreement], book.order_agreements.to_a)
+  end
+
+  def test_cpk_stale_target
+    order = Cpk::Order.create!(shop_id: 1)
+    book = Cpk::BookWithOrderAgreements.create!(id: [1, 2], order: order)
+    Cpk::OrderAgreement.create!(order: order)
+
+    book.order_agreements.load
+    book.order = Cpk::Order.new
+
+    assert_predicate(book.association(:order_agreements), :stale_target?)
+  end
+
+  def test_cpk_association_build_through_singular
+    order = Cpk::OrderWithSingularBookChapters.create!(id: [1, 2])
+    book = order.create_book!(id: [3, 4])
+    chapter = order.chapters.build
+
+    assert_equal(chapter.book, book)
+  end
+
   private
     def make_model(name)
       Class.new(ActiveRecord::Base) { define_singleton_method(:name) { name } }

data/test/cases/associations/has_many_through_disable_joins_associations_test.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+require "models/post"
+require "models/author"
+require "models/comment"
+require "models/rating"
+require "models/member"
+require "models/member_type"
+
+require "models/pirate"
+require "models/treasure"
+require "models/parrot"
+
+require "models/hotel"
+require "models/department"
+
+class HasManyThroughDisableJoinsAssociationsTest < ActiveRecord::TestCase
+  fixtures :posts, :authors, :comments, :pirates, :author_addresses
+
+  def setup
+    @author = authors(:mary)
+    @post = @author.posts.create(title: "title", body: "body")
+    @member_type = MemberType.create(name: "club")
+    @member = Member.create(member_type: @member_type)
+    @comment = @post.comments.create(body: "text", origin: @member)
+    @post2 = @author.posts.create(title: "title", body: "body")
+    @member2 = Member.create(member_type: @member_type)
+    @comment2 = @post2.comments.create(body: "text", origin: @member2)
+    @rating1 = @comment.ratings.create(value: 8)
+    @rating2 = @comment.ratings.create(value: 9)
+  end
+
+  def test_counting_on_disable_joins_through
+    assert_equal @author.comments.count, @author.no_joins_comments.count
+    assert_queries_count(2) { @author.no_joins_comments.count }
+    assert_queries_count(1) { @author.comments.count }
+  end
+
+  def test_counting_on_disable_joins_through_using_custom_foreign_key
+    assert_equal @author.comments_with_foreign_key.count, @author.no_joins_comments_with_foreign_key.count
+    assert_queries_count(2) { @author.no_joins_comments_with_foreign_key.count }
+    assert_queries_count(1) { @author.comments_with_foreign_key.count }
+  end
+
+  def test_pluck_on_disable_joins_through
+    assert_equal @author.comments.pluck(:id).sort, @author.no_joins_comments.pluck(:id).sort
+    assert_queries_count(2) { @author.no_joins_comments.pluck(:id) }
+    assert_queries_count(1) { @author.comments.pluck(:id) }
+  end
+
+  def test_pluck_on_disable_joins_through_using_custom_foreign_key
+    assert_equal @author.comments_with_foreign_key.pluck(:id).sort, @author.no_joins_comments_with_foreign_key.pluck(:id).sort
+    assert_queries_count(2) { @author.no_joins_comments_with_foreign_key.pluck(:id) }
+    assert_queries_count(1) { @author.comments_with_foreign_key.pluck(:id) }
+  end
+
+  def test_fetching_on_disable_joins_through
+    assert_equal @author.comments.first.id, @author.no_joins_comments.first.id
+    assert_queries_count(2) { @author.no_joins_comments.first.id }
+    assert_queries_count(1) { @author.comments.first.id }
+  end
+
+  def test_fetching_on_disable_joins_through_using_custom_foreign_key
+    assert_equal @author.comments_with_foreign_key.first.id, @author.no_joins_comments_with_foreign_key.first.id
+    assert_queries_count(2) { @author.no_joins_comments_with_foreign_key.first.id }
+    assert_queries_count(1) { @author.comments_with_foreign_key.first.id }
+  end
+
+  def test_to_a_on_disable_joins_through
+    assert_equal @author.comments.sort_by(&:id), @author.no_joins_comments.sort_by(&:id)
+    @author.reload
+    assert_queries_count(2) { @author.no_joins_comments.to_a }
+    assert_queries_count(1) { @author.comments.to_a }
+  end
+
+  def test_appending_on_disable_joins_through
+    assert_difference(->() { @author.no_joins_comments.reload.size }) do
+      @post.comments.create(body: "text")
+    end
+    assert_queries_count(2) { @author.no_joins_comments.reload.size }
+    assert_queries_count(1) { @author.comments.reload.size }
+  end
+
+  def test_appending_on_disable_joins_through_using_custom_foreign_key
+    assert_difference(->() { @author.no_joins_comments_with_foreign_key.reload.size }) do
+      @post.comments.create(body: "text")
+    end
+    assert_queries_count(2) { @author.no_joins_comments_with_foreign_key.reload.size }
+    assert_queries_count(1) { @author.comments_with_foreign_key.reload.size }
+  end
+
+  def test_empty_on_disable_joins_through
+    empty_author = authors(:bob)
+    assert_equal [], assert_queries_count(0) { empty_author.comments.all }
+    assert_equal [], assert_queries_count(1) { empty_author.no_joins_comments.all }
+  end
+
+  def test_empty_on_disable_joins_through_using_custom_foreign_key
+    empty_author = authors(:bob)
+    assert_equal [], assert_queries_count(0) { empty_author.comments_with_foreign_key.all }
+    assert_equal [], assert_queries_count(1) { empty_author.no_joins_comments_with_foreign_key.all }
+  end
+
+  def test_pluck_on_disable_joins_through_a_through
+    rating_ids = Rating.where(comment: @comment).pluck(:id).sort
+    assert_equal rating_ids, assert_queries_count(1) { @author.ratings.pluck(:id).sort }
+    assert_equal rating_ids, assert_queries_count(3) { @author.no_joins_ratings.pluck(:id).sort }
+  end
+
+  def test_count_on_disable_joins_through_a_through
+    ratings_count = Rating.where(comment: @comment).count
+    assert_equal ratings_count, assert_queries_count(1) { @author.ratings.count }
+    assert_equal ratings_count, assert_queries_count(3) { @author.no_joins_ratings.count }
+  end
+
+  def test_count_on_disable_joins_using_relation_with_scope
+    assert_equal 2, assert_queries_count(1) { @author.good_ratings.count }
+    assert_equal 2, assert_queries_count(3) { @author.no_joins_good_ratings.count }
+  end
+
+  def test_to_a_on_disable_joins_with_multiple_scopes
+    assert_equal [@rating1, @rating2], assert_queries_count(1) { @author.good_ratings.to_a }
+    assert_equal [@rating1, @rating2], assert_queries_count(3) { @author.no_joins_good_ratings.to_a }
+  end
+
+  def test_preloading_has_many_through_disable_joins
+    assert_queries_count(3) { Author.all.preload(:good_ratings).map(&:good_ratings) }
+    assert_queries_count(4) { Author.all.preload(:no_joins_good_ratings).map(&:good_ratings) }
+  end
+
+  def test_polymophic_disable_joins_through_counting
+    assert_equal 2, assert_queries_count(1) { @author.ordered_members.count }
+    assert_equal 2, assert_queries_count(3) { @author.no_joins_ordered_members.count }
+  end
+
+  def test_polymophic_disable_joins_through_ordering
+    assert_equal [@member2, @member], assert_queries_count(1) { @author.ordered_members.to_a }
+    assert_equal [@member2, @member], assert_queries_count(3) { @author.no_joins_ordered_members.to_a }
+  end
+
+  def test_polymorphic_disable_joins_through_reordering
+    assert_equal [@member, @member2], assert_queries_count(1) { @author.ordered_members.reorder(id: :asc).to_a }
+    assert_equal [@member, @member2], assert_queries_count(3) { @author.no_joins_ordered_members.reorder(id: :asc).to_a }
+  end
+
+  def test_polymorphic_disable_joins_through_ordered_scopes
+    assert_equal [@member2, @member], assert_queries_count(1) { @author.ordered_members.unnamed.to_a }
+    assert_equal [@member2, @member], assert_queries_count(3) { @author.no_joins_ordered_members.unnamed.to_a }
+  end
+
+  def test_polymorphic_disable_joins_through_ordered_chained_scopes
+    member3 = Member.create(member_type: @member_type)
+    member4 = Member.create(member_type: @member_type, name: "named")
+    @post2.comments.create(body: "text", origin: member3)
+    @post2.comments.create(body: "text", origin: member4)
+
+    assert_equal [member3, @member2, @member], assert_queries_count(1) { @author.ordered_members.unnamed.with_member_type_id(@member_type.id).to_a }
+    assert_equal [member3, @member2, @member], assert_queries_count(3) { @author.no_joins_ordered_members.unnamed.with_member_type_id(@member_type.id).to_a }
+  end
+
+  def test_polymorphic_disable_joins_through_ordered_scope_limits
+    assert_equal [@member2], assert_queries_count(1) { @author.ordered_members.unnamed.limit(1).to_a }
+    assert_equal [@member2], assert_queries_count(3) { @author.no_joins_ordered_members.unnamed.limit(1).to_a }
+  end
+
+  def test_polymorphic_disable_joins_through_ordered_scope_first
+    assert_equal @member2, assert_queries_count(1) { @author.ordered_members.unnamed.first }
+    assert_equal @member2, assert_queries_count(3) { @author.no_joins_ordered_members.unnamed.first }
+  end
+
+  def test_order_applied_in_double_join
+    assert_equal [@member2, @member], assert_queries_count(1) { @author.members.to_a }
+    assert_equal [@member2, @member], assert_queries_count(3) { @author.no_joins_members.to_a }
+  end
+
+  def test_first_and_scope_applied_in_double_join
+    assert_equal @member2, assert_queries_count(1) { @author.members.unnamed.first }
+    assert_equal @member2, assert_queries_count(3) { @author.no_joins_members.unnamed.first }
+  end
+
+  def test_first_and_scope_in_double_join_applies_order_in_memory
+    disable_joins_sql = capture_sql { @author.no_joins_members.unnamed.first }
+    assert_no_match(/ORDER BY/, disable_joins_sql.last)
+  end
+
+  def test_limit_and_scope_applied_in_double_join
+    assert_equal [@member2], assert_queries_count(1) { @author.members.unnamed.limit(1).to_a }
+    assert_equal [@member2], assert_queries_count(3) { @author.no_joins_members.unnamed.limit(1) }
+  end
+
+  def test_limit_and_scope_in_double_join_applies_limit_in_memory
+    disable_joins_sql = capture_sql { @author.no_joins_members.unnamed.first }
+    assert_no_match(/LIMIT 1/, disable_joins_sql.last)
+  end
+end