ibm_db 5.6.1 → 5.7.0

data/test/cases/associations/inner_join_association_test.rb

@@ -10,14 +10,19 @@ require "models/categorization"
 require "models/person"
 require "models/tagging"
 require "models/tag"
+require "models/sharded/blog_post"
+require "models/sharded/comment"
+require "models/friendship"
+require "models/reference"
+require "models/job"
 
 class InnerJoinAssociationTest < ActiveRecord::TestCase
   fixtures :authors, :author_addresses, :essays, :posts, :comments, :categories, :categories_posts, :categorizations,
-           :taggings, :tags, :people
+           :taggings, :tags, :people, :sharded_comments, :sharded_blog_posts
 
   def test_construct_finder_sql_applies_aliases_tables_on_association_conditions
-    result = Author.joins(:thinking_posts, :welcome_posts).to_a
-    assert_equal authors(:david), result.first
+    result = Author.joins(:thinking_posts, :welcome_posts).first
+    assert_equal authors(:david), result
   end
 
   def test_construct_finder_sql_does_not_table_name_collide_on_duplicate_associations
@@ -41,7 +46,7 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
     SQL
 
     expected = people(:susan)
-    assert_sql(/agents_people_2/i) do
+    assert_queries_match(/agents_people_2/i) do
       assert_equal [expected], Person.joins(:agents).joins(string_join)
     end
   end
@@ -52,7 +57,7 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
     constraint = agents[:primary_contact_id].eq(agents_2[:id]).and(agents[:id].gt(agents_2[:id]))
 
     expected = people(:susan)
-    assert_sql(/agents_people_2/i) do
+    assert_queries_match(/agents_people_2/i) do
       assert_equal [expected], Person.joins(:agents).joins(agents.create_join(agents, agents.create_on(constraint)))
     end
   end
@@ -178,7 +183,7 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
 
   def test_find_with_conditions_on_reflection
     assert_not_empty posts(:welcome).comments
-    assert Post.joins(:nonexistent_comments).where(id: posts(:welcome).id).empty? # [sic!]
+    assert_predicate Post.joins(:nonexistent_comments).where(id: posts(:welcome).id), :empty? # [sic!]
   end
 
   def test_find_with_conditions_on_through_reflection
@@ -212,4 +217,29 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
     assert_equal 0, categories.first.special_categorizations.size
     assert_equal 1, categories.second.special_categorizations.size
   end
+
+  test "joins a belongs_to association with a composite foreign key" do
+    first_post_comments = Sharded::Comment.joins(:blog_post).where(blog_post: { title: "My first post in my Blog1!" }).to_a
+    expected_blog_post = sharded_blog_posts(:great_post_blog_one)
+
+    assert_not_empty comments
+    assert_equal(expected_blog_post.comments.to_a.sort, first_post_comments.sort)
+  end
+
+  test "joins a has_many association with a composite foreign key" do
+    blog_posts = Sharded::BlogPost.joins(:comments).where(comments: { body: "Your first blog post is great!" }).to_a
+
+    expected_comment = sharded_comments(:unique_comment_blog_post_one)
+
+    assert_not_empty blog_posts
+    assert_equal(expected_comment.blog_post, blog_posts.first)
+  end
+
+  def test_inner_joins_includes_all_nested_associations
+    sql, = capture_sql { Friendship.joins(:friend_favorite_reference_job, :follower_favorite_reference_job).to_a }
+
+    # DB2 doesn't quote composite identifiers in JOIN conditions
+    assert_match %r(friendships\.friend_id)i, sql
+    assert_match %r(friendships\.follower_id)i, sql
+  end
 end

data/test/cases/associations/inverse_associations_test.rb

@@ -20,21 +20,26 @@ require "models/developer"
 require "models/company"
 require "models/project"
 require "models/author"
-require "models/post"
 require "models/user"
 require "models/room"
+require "models/contract"
+require "models/subscription"
+require "models/subscriber"
+require "models/book"
+require "models/branch"
+require "models/cpk"
 
 class AutomaticInverseFindingTests < ActiveRecord::TestCase
-  fixtures :ratings, :comments, :cars
+  fixtures :ratings, :comments, :cars, :books
 
   def test_has_one_and_belongs_to_should_find_inverse_automatically_on_multiple_word_name
     monkey_reflection = MixedCaseMonkey.reflect_on_association(:human)
     human_reflection = Human.reflect_on_association(:mixed_case_monkey)
 
-    assert monkey_reflection.has_inverse?, "The monkey reflection should have an inverse"
+    assert_predicate monkey_reflection, :has_inverse?, "The monkey reflection should have an inverse"
     assert_equal human_reflection, monkey_reflection.inverse_of, "The monkey reflection's inverse should be the human reflection"
 
-    assert human_reflection.has_inverse?, "The human reflection should have an inverse"
+    assert_predicate human_reflection, :has_inverse?, "The human reflection should have an inverse"
     assert_equal monkey_reflection, human_reflection.inverse_of, "The human reflection's inverse should be the monkey reflection"
   end
 
@@ -42,7 +47,7 @@ class AutomaticInverseFindingTests < ActiveRecord::TestCase
     account_reflection = Admin::Account.reflect_on_association(:users)
     user_reflection = Admin::User.reflect_on_association(:account)
 
-    assert account_reflection.has_inverse?, "The Admin::Account reflection should have an inverse"
+    assert_predicate account_reflection, :has_inverse?, "The Admin::Account reflection should have an inverse"
     assert_equal user_reflection, account_reflection.inverse_of, "The Admin::Account reflection's inverse should be the Admin::User reflection"
   end
 
@@ -50,10 +55,10 @@ class AutomaticInverseFindingTests < ActiveRecord::TestCase
     car_reflection = Car.reflect_on_association(:bulb)
     bulb_reflection = Bulb.reflect_on_association(:car)
 
-    assert car_reflection.has_inverse?, "The Car reflection should have an inverse"
+    assert_predicate car_reflection, :has_inverse?, "The Car reflection should have an inverse"
     assert_equal bulb_reflection, car_reflection.inverse_of, "The Car reflection's inverse should be the Bulb reflection"
 
-    assert bulb_reflection.has_inverse?, "The Bulb reflection should have an inverse"
+    assert_predicate bulb_reflection, :has_inverse?, "The Bulb reflection should have an inverse"
     assert_equal car_reflection, bulb_reflection.inverse_of, "The Bulb reflection's inverse should be the Car reflection"
   end
 
@@ -61,7 +66,7 @@ class AutomaticInverseFindingTests < ActiveRecord::TestCase
     comment_reflection = Comment.reflect_on_association(:ratings)
     rating_reflection = Rating.reflect_on_association(:comment)
 
-    assert comment_reflection.has_inverse?, "The Comment reflection should have an inverse"
+    assert_predicate comment_reflection, :has_inverse?, "The Comment reflection should have an inverse"
     assert_equal rating_reflection, comment_reflection.inverse_of, "The Comment reflection's inverse should be the Rating reflection"
   end
 
@@ -79,11 +84,11 @@ class AutomaticInverseFindingTests < ActiveRecord::TestCase
     post_reflection = Post.reflect_on_association(:author)
 
     assert_respond_to author_reflection, :has_inverse?
-    assert author_reflection.has_inverse?, "The Author reflection should have an inverse"
+    assert_predicate author_reflection, :has_inverse?, "The Author reflection should have an inverse"
     assert_equal post_reflection, author_reflection.inverse_of, "The Author reflection's inverse should be the Post reflection"
 
     assert_respond_to author_child_reflection, :has_inverse?
-    assert author_child_reflection.has_inverse?, "The Author reflection should have an inverse"
+    assert_predicate author_child_reflection, :has_inverse?, "The Author reflection should have an inverse"
     assert_equal post_reflection, author_child_reflection.inverse_of, "The Author reflection's inverse should be the Post reflection"
   end
 
@@ -110,6 +115,51 @@ class AutomaticInverseFindingTests < ActiveRecord::TestCase
     assert_not_equal room_reflection, owner_reflection.inverse_of
   end
 
+  def test_has_many_and_belongs_to_with_a_scope_and_automatic_scope_inversing_should_find_inverse_automatically
+    contacts_reflection = Company.reflect_on_association(:special_contracts)
+    company_reflection = SpecialContract.reflect_on_association(:company)
+
+    assert contacts_reflection.scope
+    assert_not company_reflection.scope
+
+    with_automatic_scope_inversing(contacts_reflection, company_reflection) do
+      assert_predicate contacts_reflection, :has_inverse?
+      assert_equal company_reflection, contacts_reflection.inverse_of
+      assert_not_equal contacts_reflection, company_reflection.inverse_of
+    end
+  end
+
+  def test_has_one_and_belongs_to_with_a_scope_and_automatic_scope_inversing_should_find_inverse_automatically
+    post_reflection = Author.reflect_on_association(:recent_post)
+    author_reflection = Post.reflect_on_association(:author)
+
+    assert post_reflection.scope
+    assert_not author_reflection.scope
+
+    with_automatic_scope_inversing(post_reflection, author_reflection) do
+      assert_predicate post_reflection, :has_inverse?
+      assert_equal author_reflection, post_reflection.inverse_of
+      assert_not_equal post_reflection, author_reflection.inverse_of
+    end
+  end
+
+  def test_has_many_with_scoped_belongs_to_does_not_find_inverse_automatically
+    book = books(:tlg)
+    book.update_attribute(:author_visibility, :invisible)
+
+    assert_nil book.subscriptions.new.book
+
+    subscription_reflection = Book.reflect_on_association(:subscriptions)
+    book_reflection = Subscription.reflect_on_association(:book)
+
+    assert_not subscription_reflection.scope
+    assert book_reflection.scope
+
+    with_automatic_scope_inversing(book_reflection, subscription_reflection) do
+      assert_nil book.subscriptions.new.book
+    end
+  end
+
   def test_has_one_and_belongs_to_automatic_inverse_shares_objects
     car = Car.first
     bulb = Bulb.create!(car: car)
@@ -150,6 +200,18 @@ class AutomaticInverseFindingTests < ActiveRecord::TestCase
     assert_equal comment.body, rating.comment.body, "Changing the original Comment's body should change the Comment's body on the association"
   end
 
+  def test_belongs_to_should_find_inverse_has_many_automatically
+    assert_equal true, Subscription.automatically_invert_plural_associations
+
+    book = Book.create!
+    subscriber = book.subscribers.new nick: "Nickname"
+
+    subscriber.save!
+
+    assert_equal [subscriber], book.reload.subscribers
+    assert_equal 1, book.reload.subscribers.count
+  end
+
   def test_polymorphic_and_has_many_through_relationships_should_not_have_inverses
     sponsor_reflection = Sponsor.reflect_on_association(:sponsorable)
 
@@ -165,6 +227,20 @@ class AutomaticInverseFindingTests < ActiveRecord::TestCase
 
     assert_predicate human_reflection, :has_inverse?
   end
+
+  def test_has_many_inverse_of_derived_automatically_despite_of_composite_foreign_key
+    car_review_reflection = Cpk::Car.reflect_on_association(:car_reviews)
+
+    assert_predicate car_review_reflection, :has_inverse?
+    assert_equal Cpk::CarReview.reflect_on_association(:car), car_review_reflection.inverse_of
+  end
+
+  def test_belongs_to_inverse_of_derived_automatically_despite_of_composite_foreign_key
+    car_reflection = Cpk::CarReview.reflect_on_association(:car)
+
+    assert_predicate car_reflection, :has_inverse?
+    assert_equal Cpk::Car.reflect_on_association(:car_reviews), car_reflection.inverse_of
+  end
 end
 
 class InverseAssociationTests < ActiveRecord::TestCase
@@ -240,8 +316,8 @@ class InverseAssociationTests < ActiveRecord::TestCase
     Developer.create!(name: "Gorbypuff", firm: firm)
 
     new_project = Project.last
-    assert Project.reflect_on_association(:lead_developer).inverse_of.present?, "Expected inverse of to be present"
-    assert new_project.lead_developer.present?, "Expected lead developer to be present on the project"
+    assert_predicate Project.reflect_on_association(:lead_developer).inverse_of, :present?, "Expected inverse of to be present"
+    assert_predicate new_project.lead_developer, :present?, "Expected lead developer to be present on the project"
   end
 end
 
@@ -328,7 +404,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
     assert_equal face, human.face
     assert_equal face.description, human.face.description, "Description of the face should be the same before changes to child instance"
     face.description = "Bongo"
-    assert_equal face.description, human.face.description, "Description of the face should be the same after changes to chield instance"
+    assert_equal face.description, human.face.description, "Description of the face should be the same after changes to child instance"
     human.face.description = "Mungo"
     assert_equal face.description, human.face.description, "Description of the face should be the same after changes to replaced-parent-owned instance"
   end
@@ -337,15 +413,13 @@ class InverseHasOneTests < ActiveRecord::TestCase
     assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Human.first.confused_face }
   end
 
-  if defined?(DidYouMean) && DidYouMean.respond_to?(:correct_error)
-    def test_trying_to_use_inverses_that_dont_exist_should_have_suggestions_for_fix
-      error = assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) {
-        Human.first.confused_face
-      }
+  def test_trying_to_use_inverses_that_dont_exist_should_have_suggestions_for_fix
+    error = assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) {
+      Human.first.confused_face
+    }
 
-      assert_match "Did you mean?", error.message
-      assert_equal "super_human", error.corrections.first
-    end
+    assert_match "Did you mean?", error.detailed_message
+    assert_equal "confused_human", error.corrections.first
   end
 end
 
@@ -552,6 +626,15 @@ class InverseHasManyTests < ActiveRecord::TestCase
     end
   end
 
+  def test_inverse_should_be_set_on_composite_primary_key_child
+    author = Cpk::Author.new(name: "John")
+    book = author.books.build(id: [nil, 1], title: "The Rails Way")
+    Cpk::Order.new(book: book, status: "paid")
+    author.save!
+
+    assert_predicate book.association(:order), :loaded?
+  end
+
   def test_raise_record_not_found_error_when_invalid_ids_are_passed
     # delete all interest records to ensure that hard coded invalid_id(s)
     # are indeed invalid.
@@ -571,8 +654,8 @@ class InverseHasManyTests < ActiveRecord::TestCase
 
     exception = assert_raise(ActiveRecord::RecordNotFound) { human.interests.load.find() }
 
-    assert_equal exception.model, "Interest"
-    assert_equal exception.primary_key, "id"
+    assert_equal "Interest", exception.model
+    assert_equal "id", exception.primary_key
   end
 
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
@@ -619,6 +702,18 @@ class InverseHasManyTests < ActiveRecord::TestCase
     comment.body = "OMG"
     assert_equal comment.body, comment.children.first.parent.body
   end
+
+  def test_changing_the_association_id_makes_the_inversed_association_target_stale
+    post1 = Post.first
+    post2 = Post.second
+    comment = post1.comments.first
+
+    assert_same post1, comment.post
+
+    comment.update!(post_id: post2.id)
+
+    assert_equal post2, comment.post
+  end
 end
 
 class InverseBelongsToTests < ActiveRecord::TestCase
@@ -688,7 +783,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_with_has_many_inversing_should_try_to_set_inverse_instances_when_the_inverse_is_a_has_many
-    with_has_many_inversing do
+    with_has_many_inversing(Interest) do
       interest = interests(:trainspotting)
       human = interest.human
       assert_not_nil human.interests
@@ -703,7 +798,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_with_has_many_inversing_should_have_single_record_when_setting_record_through_attribute_in_build_method
-    with_has_many_inversing do
+    with_has_many_inversing(Interest) do
       human = Human.create!
       human.interests.build(
         human: human
@@ -715,14 +810,14 @@ class InverseBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_with_has_many_inversing_does_not_trigger_association_callbacks_on_set_when_the_inverse_is_a_has_many
-    with_has_many_inversing do
+    with_has_many_inversing(Interest) do
       human = interests(:trainspotting).human_with_callbacks
       assert_not_predicate human, :add_callback_called?
     end
   end
 
-  def test_with_hash_many_inversing_does_not_add_duplicate_associated_objects
-    with_has_many_inversing do
+  def test_with_has_many_inversing_does_not_add_duplicate_associated_objects
+    with_has_many_inversing(Interest) do
       human = Human.new
       interest = Interest.new(human: human)
       human.interests << interest
@@ -730,6 +825,50 @@ class InverseBelongsToTests < ActiveRecord::TestCase
     end
   end
 
+  def test_with_has_many_inversing_does_not_add_unsaved_duplicate_records_when_collection_is_loaded
+    with_has_many_inversing(Interest) do
+      human = Human.create!
+      human.interests.load
+      interest = Interest.new(human: human)
+      human.interests << interest
+      assert_equal 1, human.interests.size
+    end
+  end
+
+  def test_with_has_many_inversing_does_not_add_saved_duplicate_records_when_collection_is_loaded
+    with_has_many_inversing(Interest) do
+      human = Human.create!
+      human.interests.load
+      interest = Interest.create!(human: human)
+      human.interests << interest
+      assert_equal 1, human.interests.size
+    end
+  end
+
+  def test_recursive_model_has_many_inversing
+    with_has_many_inversing do
+      main = Branch.create!
+      feature = main.branches.create!
+      topic = feature.branches.build
+
+      assert_equal(main, topic.branch.branch)
+    end
+  end
+
+  def test_recursive_inverse_on_recursive_model_has_many_inversing
+    with_has_many_inversing do
+      main = BrokenBranch.create!
+      feature = main.branches.create!
+      topic = feature.branches.build
+
+      error = assert_raises(ActiveRecord::InverseOfAssociationRecursiveError) do
+        topic.branch.branch
+      end
+
+      assert_equal("Inverse association branch (:branch in BrokenBranch) is recursive.", error.message)
+    end
+  end
+
   def test_unscope_does_not_set_inverse_when_incorrect
     interest = interests(:trainspotting)
     human = interest.human
@@ -761,22 +900,20 @@ class InverseBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.puzzled_human }
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.confused_human }
   end
 
-  if defined?(DidYouMean) && DidYouMean.respond_to?(:correct_error)
-    def test_trying_to_use_inverses_that_dont_exist_should_have_suggestions_for_fix
-      error = assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) {
-        Face.first.puzzled_human
-      }
+  def test_trying_to_use_inverses_that_dont_exist_should_have_suggestions_for_fix
+    error = assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) {
+      Face.first.confused_human
+    }
 
-      assert_match "Did you mean?", error.message
-      assert_equal "confused_face", error.corrections.first
-    end
+    assert_match "Did you mean?", error.detailed_message
+    assert_equal "confused_face", error.corrections.first
   end
 
   def test_building_has_many_parent_association_inverses_one_record
-    with_has_many_inversing do
+    with_has_many_inversing(Interest) do
       interest = Interest.new
       interest.build_human
       assert_equal 1, interest.human.interests.size
@@ -878,7 +1015,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_with_has_many_inversing_should_try_to_set_inverse_instances_when_the_inverse_is_a_has_many
-    with_has_many_inversing do
+    with_has_many_inversing(Interest) do
       interest = interests(:llama_wrangling)
       human = interest.polymorphic_human
       assert_not_nil human.polymorphic_interests
@@ -893,7 +1030,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_with_has_many_inversing_does_not_trigger_association_callbacks_on_set_when_the_inverse_is_a_has_many
-    with_has_many_inversing do
+    with_has_many_inversing(Interest) do
       human = interests(:llama_wrangling).polymorphic_human_with_callbacks
       assert_not_predicate human, :add_callback_called?
     end

data/test/cases/associations/join_model_test.rb

@@ -45,9 +45,9 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   def test_has_many_distinct_through_count
     author = authors(:mary)
     assert_not_predicate authors(:mary).unique_categorized_posts, :loaded?
-    assert_queries(1) { assert_equal 1, author.unique_categorized_posts.count }
-    assert_queries(1) { assert_equal 1, author.unique_categorized_posts.count(:title) }
-    assert_queries(1) { assert_equal 0, author.unique_categorized_posts.where(title: nil).count(:title) }
+    assert_queries_count(1) { assert_equal 1, author.unique_categorized_posts.count }
+    assert_queries_count(1) { assert_equal 1, author.unique_categorized_posts.count(:title) }
+    assert_queries_count(1) { assert_equal 0, author.unique_categorized_posts.where(title: nil).count(:title) }
     assert_not_predicate authors(:mary).unique_categorized_posts, :loaded?
   end
 
@@ -341,13 +341,11 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_raise(ActiveRecord::HasManyThroughAssociationNotFoundError) { authors(:david).nothings }
   end
 
-  if defined?(DidYouMean) && DidYouMean.respond_to?(:correct_error)
-    def test_exceptions_have_suggestions_for_fix
-      error = assert_raise(ActiveRecord::HasManyThroughAssociationNotFoundError) {
-        authors(:david).nothings
-      }
-      assert_match "Did you mean?", error.message
-    end
+  def test_exceptions_have_suggestions_for_fix
+    error = assert_raise(ActiveRecord::HasManyThroughAssociationNotFoundError) {
+      authors(:david).nothings
+    }
+    assert_match "Did you mean?", error.detailed_message
   end
 
   def test_has_many_through_join_model_with_conditions
@@ -476,7 +474,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     new_tag = Tag.new(name: "new")
 
     saved_post.tags << new_tag
-    assert new_tag.persisted? # consistent with habtm!
+    assert_predicate new_tag, :persisted? # consistent with habtm!
     assert_predicate saved_post, :persisted?
     assert_includes saved_post.tags, new_tag
 
@@ -730,7 +728,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
     david.reload
     assert_not_predicate david.categories, :loaded?
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_includes david.categories, category
     end
     assert_not_predicate david.categories, :loaded?
@@ -774,6 +772,13 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_equal("Can't join 'Post' to association named 'nonexistent_relation'; perhaps you misspelled it?", includes_and_eager_load_error.message)
   end
 
+  def test_eager_association_with_scope_with_string_joins
+    skip "DB2-specific: string-based joins in eager association scope are unsupported in this scenario" if (defined?(ibm_db?) && ibm_db?) || current_adapter?(:IBM_DBAdapter)
+    assert_nothing_raised do
+      Post.joins(:very_special_comment_with_string_joins).first
+    end
+  end
+
   private
     # create dynamic Post models to allow different dependency options
     def find_post_with_dependency(post_id, association, association_name, dependency)

data/test/cases/associations/left_outer_join_association_test.rb

@@ -9,6 +9,9 @@ require "models/essay"
 require "models/category"
 require "models/categorization"
 require "models/person"
+require "models/friendship"
+require "models/reference"
+require "models/job"
 
 class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
   fixtures :authors, :author_addresses, :essays, :posts, :comments, :ratings, :categorizations, :people
@@ -22,8 +25,8 @@ class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
   end
 
   def test_construct_finder_sql_applies_aliases_tables_on_association_conditions
-    result = Author.left_outer_joins(:thinking_posts, :welcome_posts).to_a
-    assert_equal authors(:david), result.first
+    result = Author.left_outer_joins(:thinking_posts, :welcome_posts).first
+    assert_equal authors(:david), result
   end
 
   def test_construct_finder_sql_does_not_table_name_collide_on_duplicate_associations
@@ -94,7 +97,7 @@ class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
 
   def test_join_conditions_added_to_join_clause
     queries = capture_sql { Author.left_outer_joins(:essays).to_a }
-    assert queries.any? { |sql| /writer_type.*?=.*?(Author|\?|\$1|\:a1)/i.match?(sql) }
+    assert queries.any? { |sql| /writer_type.*?=.*?(Author|\?|\$1|:a1)/i.match?(sql) }
     assert queries.none? { |sql| /WHERE/i.match?(sql) }
   end
 
@@ -120,4 +123,12 @@ class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
 
     assert_equal [author], Author.where(id: author).left_outer_joins(:special_categorizations)
   end
+
+  def test_left_outer_joins_includes_all_nested_associations
+    sql, = capture_sql { Friendship.left_outer_joins(:friend_favorite_reference_job, :follower_favorite_reference_job).to_a }
+
+    # DB2 doesn't quote composite identifiers in JOIN conditions
+    assert_match %r(friendships\.friend_id)i, sql
+    assert_match %r(friendships\.follower_id)i, sql
+  end
 end