ibm_db 5.1.0-x86-mingw32 → 5.3.2-x86-mingw32

data/test/cases/associations/has_one_through_associations_test.rb

@@ -1,29 +1,31 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/club'
-require 'models/member_type'
-require 'models/member'
-require 'models/membership'
-require 'models/sponsor'
-require 'models/organization'
-require 'models/member_detail'
-require 'models/minivan'
-require 'models/dashboard'
-require 'models/speedometer'
-require 'models/category'
-require 'models/author'
-require 'models/essay'
-require 'models/owner'
-require 'models/post'
-require 'models/comment'
-require 'models/categorization'
-require 'models/customer'
-require 'models/carrier'
-require 'models/shop_account'
-require 'models/customer_carrier'
+require "models/club"
+require "models/member_type"
+require "models/member"
+require "models/membership"
+require "models/sponsor"
+require "models/organization"
+require "models/member_detail"
+require "models/minivan"
+require "models/dashboard"
+require "models/speedometer"
+require "models/category"
+require "models/author"
+require "models/essay"
+require "models/owner"
+require "models/post"
+require "models/comment"
+require "models/categorization"
+require "models/customer"
+require "models/carrier"
+require "models/shop_account"
+require "models/customer_carrier"
 
 class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   fixtures :member_types, :members, :clubs, :memberships, :sponsors, :organizations, :minivans,
-           :dashboards, :speedometers, :authors, :posts, :comments, :categories, :essays, :owners
+           :dashboards, :speedometers, :authors, :author_addresses, :posts, :comments, :categories, :essays, :owners
 
   def setup
     @member = members(:groucho)
@@ -33,15 +35,34 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     assert_equal clubs(:boring_club), @member.club
   end
 
+  def test_has_one_through_executes_limited_query
+    boring_club = clubs(:boring_club)
+    assert_sql(/LIMIT|ROWNUM <=|FETCH FIRST/) do
+      assert_equal boring_club, @member.general_club
+    end
+  end
+
   def test_creating_association_creates_through_record
-    new_member = Member.create(:name => "Chris")
-    new_member.club = Club.create(:name => "LRUG")
+    new_member = Member.create(name: "Chris")
+    new_member.club = Club.create(name: "LRUG")
     assert_not_nil new_member.current_membership
     assert_not_nil new_member.club
   end
 
+  def test_creating_association_builds_through_record
+    new_member = Member.create(name: "Chris")
+    new_club = new_member.association(:club).build
+    assert new_member.current_membership
+    assert_equal new_club, new_member.club
+    assert_predicate new_club, :new_record?
+    assert_predicate new_member.current_membership, :new_record?
+    assert new_member.save
+    assert_predicate new_club, :persisted?
+    assert_predicate new_member.current_membership, :persisted?
+  end
+
   def test_creating_association_builds_through_record_for_new
-    new_member = Member.new(:name => "Jane")
+    new_member = Member.new(name: "Jane")
     new_member.club = clubs(:moustache_club)
     assert new_member.current_membership
     assert_equal clubs(:moustache_club), new_member.current_membership.club
@@ -50,9 +71,27 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     assert_equal clubs(:moustache_club), new_member.club
   end
 
+  def test_building_multiple_associations_builds_through_record
+    member_type = MemberType.create!
+    member = Member.create!
+    member_detail_with_one_association = MemberDetail.new(member_type: member_type)
+    assert_predicate member_detail_with_one_association.member, :new_record?
+    member_detail_with_two_associations = MemberDetail.new(member_type: member_type, admittable: member)
+    assert_predicate member_detail_with_two_associations.member, :new_record?
+  end
+
+  def test_creating_multiple_associations_creates_through_record
+    member_type = MemberType.create!
+    member = Member.create!
+    member_detail_with_one_association = MemberDetail.create!(member_type: member_type)
+    assert_not_predicate member_detail_with_one_association.member, :new_record?
+    member_detail_with_two_associations = MemberDetail.create!(member_type: member_type, admittable: member)
+    assert_not_predicate member_detail_with_two_associations.member, :new_record?
+  end
+
   def test_creating_association_sets_both_parent_ids_for_new
-    member = Member.new(name: 'Sean Griffin')
-    club = Club.new(name: 'Da Club')
+    member = Member.new(name: "Sean Griffin")
+    club = Club.new(name: "Da Club")
 
     member.club = club
 
@@ -65,7 +104,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_replace_target_record
-    new_club = Club.create(:name => "Marx Bros")
+    new_club = Club.create(name: "Marx Bros")
     @member.club = new_club
     @member.reload
     assert_equal new_club, @member.club
@@ -73,7 +112,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_replacing_target_record_deletes_old_association
     assert_no_difference "Membership.count" do
-      new_club = Club.create(:name => "Bananarama")
+      new_club = Club.create(name: "Bananarama")
       @member.club = new_club
       @member.reload
     end
@@ -82,40 +121,47 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   def test_set_record_to_nil_should_delete_association
     @member.club = nil
     @member.reload
-    assert_equal nil, @member.current_membership
+    assert_nil @member.current_membership
     assert_nil @member.club
   end
 
+  def test_set_record_after_delete_association
+    @member.club = nil
+    @member.club = clubs(:moustache_club)
+    @member.reload
+    assert_equal clubs(:moustache_club), @member.club
+  end
+
   def test_has_one_through_polymorphic
     assert_equal clubs(:moustache_club), @member.sponsor_club
   end
 
   def test_has_one_through_eager_loading
-    members = assert_queries(3) do #base table, through table, clubs table
-      Member.all.merge!(:includes => :club, :where => ["name = ?", "Groucho Marx"]).to_a
+    members = assert_queries(3) do # base table, through table, clubs table
+      Member.all.merge!(includes: :club, where: ["name = ?", "Groucho Marx"]).to_a
     end
     assert_equal 1, members.size
-    assert_not_nil assert_no_queries {members[0].club}
+    assert_not_nil assert_no_queries { members[0].club }
   end
 
   def test_has_one_through_eager_loading_through_polymorphic
-    members = assert_queries(3) do #base table, through table, clubs table
-      Member.all.merge!(:includes => :sponsor_club, :where => ["name = ?", "Groucho Marx"]).to_a
+    members = assert_queries(3) do # base table, through table, clubs table
+      Member.all.merge!(includes: :sponsor_club, where: ["name = ?", "Groucho Marx"]).to_a
     end
     assert_equal 1, members.size
-    assert_not_nil assert_no_queries {members[0].sponsor_club}
+    assert_not_nil assert_no_queries { members[0].sponsor_club }
   end
 
   def test_has_one_through_with_conditions_eager_loading
     # conditions on the through table
-    assert_equal clubs(:moustache_club), Member.all.merge!(:includes => :favourite_club).find(@member.id).favourite_club
+    assert_equal clubs(:moustache_club), Member.all.merge!(includes: :favourite_club).find(@member.id).favourite_club
     memberships(:membership_of_favourite_club).update_columns(favourite: false)
-    assert_equal nil,                    Member.all.merge!(:includes => :favourite_club).find(@member.id).reload.favourite_club
+    assert_nil Member.all.merge!(includes: :favourite_club).find(@member.id).reload.favourite_club
 
     # conditions on the source table
-    assert_equal clubs(:moustache_club), Member.all.merge!(:includes => :hairy_club).find(@member.id).hairy_club
+    assert_equal clubs(:moustache_club), Member.all.merge!(includes: :hairy_club).find(@member.id).hairy_club
     clubs(:moustache_club).update_columns(name: "Association of Clean-Shaven Persons")
-    assert_equal nil,                    Member.all.merge!(:includes => :hairy_club).find(@member.id).reload.hairy_club
+    assert_nil Member.all.merge!(includes: :hairy_club).find(@member.id).reload.hairy_club
   end
 
   def test_has_one_through_polymorphic_with_source_type
@@ -123,31 +169,31 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_eager_has_one_through_polymorphic_with_source_type
-    clubs = Club.all.merge!(:includes => :sponsored_member, :where => ["name = ?","Moustache and Eyebrow Fancier Club"]).to_a
+    clubs = Club.all.merge!(includes: :sponsored_member, where: ["name = ?", "Moustache and Eyebrow Fancier Club"]).to_a
     # Only the eyebrow fanciers club has a sponsored_member
-    assert_not_nil assert_no_queries {clubs[0].sponsored_member}
+    assert_not_nil assert_no_queries { clubs[0].sponsored_member }
   end
 
   def test_has_one_through_nonpreload_eagerloading
     members = assert_queries(1) do
-      Member.all.merge!(:includes => :club, :where => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name').to_a #force fallback
+      Member.all.merge!(includes: :club, where: ["members.name = ?", "Groucho Marx"], order: "clubs.name").to_a # force fallback
     end
     assert_equal 1, members.size
-    assert_not_nil assert_no_queries {members[0].club}
+    assert_not_nil assert_no_queries { members[0].club }
   end
 
   def test_has_one_through_nonpreload_eager_loading_through_polymorphic
     members = assert_queries(1) do
-      Member.all.merge!(:includes => :sponsor_club, :where => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name').to_a #force fallback
+      Member.all.merge!(includes: :sponsor_club, where: ["members.name = ?", "Groucho Marx"], order: "clubs.name").to_a # force fallback
     end
     assert_equal 1, members.size
-    assert_not_nil assert_no_queries {members[0].sponsor_club}
+    assert_not_nil assert_no_queries { members[0].sponsor_club }
   end
 
   def test_has_one_through_nonpreload_eager_loading_through_polymorphic_with_more_than_one_through_record
-    Sponsor.new(:sponsor_club => clubs(:crazy_club), :sponsorable => members(:groucho)).save!
+    Sponsor.new(sponsor_club: clubs(:crazy_club), sponsorable: members(:groucho)).save!
     members = assert_queries(1) do
-      Member.all.merge!(:includes => :sponsor_club, :where => ["members.name = ?", "Groucho Marx"], :order => 'clubs.name DESC').to_a #force fallback
+      Member.all.merge!(includes: :sponsor_club, where: ["members.name = ?", "Groucho Marx"], order: "clubs.name DESC").to_a # force fallback
     end
     assert_equal 1, members.size
     assert_not_nil assert_no_queries { members[0].sponsor_club }
@@ -159,8 +205,8 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_assigning_association_correctly_assigns_target
-    new_member = Member.create(:name => "Chris")
-    new_member.club = new_club = Club.create(:name => "LRUG")
+    new_member = Member.create(name: "Chris")
+    new_member.club = new_club = Club.create(name: "LRUG")
     assert_equal new_club, new_member.association(:club).target
   end
 
@@ -176,37 +222,37 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
   def test_assigning_to_has_one_through_preserves_decorated_join_record
     @organization = organizations(:nsa)
-    assert_difference 'MemberDetail.count', 1 do
-      @member_detail = MemberDetail.new(:extra_data => 'Extra')
+    assert_difference "MemberDetail.count", 1 do
+      @member_detail = MemberDetail.new(extra_data: "Extra")
       @member.member_detail = @member_detail
       @member.organization = @organization
     end
     assert_equal @organization, @member.organization
-    assert @organization.members.include?(@member)
-    assert_equal 'Extra', @member.member_detail.extra_data
+    assert_includes @organization.members, @member
+    assert_equal "Extra", @member.member_detail.extra_data
   end
 
   def test_reassigning_has_one_through
     @organization = organizations(:nsa)
     @new_organization = organizations(:discordians)
 
-    assert_difference 'MemberDetail.count', 1 do
-      @member_detail = MemberDetail.new(:extra_data => 'Extra')
+    assert_difference "MemberDetail.count", 1 do
+      @member_detail = MemberDetail.new(extra_data: "Extra")
       @member.member_detail = @member_detail
       @member.organization = @organization
     end
     assert_equal @organization, @member.organization
-    assert_equal 'Extra', @member.member_detail.extra_data
-    assert @organization.members.include?(@member)
-    assert !@new_organization.members.include?(@member)
+    assert_equal "Extra", @member.member_detail.extra_data
+    assert_includes @organization.members, @member
+    assert_not_includes @new_organization.members, @member
 
-    assert_no_difference 'MemberDetail.count' do
+    assert_no_difference "MemberDetail.count" do
       @member.organization = @new_organization
     end
     assert_equal @new_organization, @member.organization
-    assert_equal 'Extra', @member.member_detail.extra_data
-    assert !@organization.members.include?(@member)
-    assert @new_organization.members.include?(@member)
+    assert_equal "Extra", @member.member_detail.extra_data
+    assert_not_includes @organization.members, @member
+    assert_includes @new_organization.members, @member
   end
 
   def test_preloading_has_one_through_on_belongs_to
@@ -217,10 +263,10 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     @member.member_detail = @member_detail
     @member.organization = @organization
     @member_details = assert_queries(3) do
-      MemberDetail.all.merge!(:includes => :member_type).to_a
+      MemberDetail.all.merge!(includes: :member_type).to_a
     end
     @new_detail = @member_details[0]
-    assert @new_detail.send(:association, :member_type).loaded?
+    assert_predicate @new_detail.send(:association, :member_type), :loaded?
     assert_no_queries { @new_detail.member_type }
   end
 
@@ -230,19 +276,19 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
     assert_nothing_raised do
       Club.find(@club.id).save!
-      Club.all.merge!(:includes => :sponsored_member).find(@club.id).save!
+      Club.all.merge!(includes: :sponsored_member).find(@club.id).save!
     end
 
     @club.sponsor.destroy
 
     assert_nothing_raised do
       Club.find(@club.id).save!
-      Club.all.merge!(:includes => :sponsored_member).find(@club.id).save!
+      Club.all.merge!(includes: :sponsored_member).find(@club.id).save!
     end
   end
 
   def test_through_belongs_to_after_destroy
-    @member_detail = MemberDetail.new(:extra_data => 'Extra')
+    @member_detail = MemberDetail.new(extra_data: "Extra")
     @member.member_detail = @member_detail
     @member.save!
 
@@ -261,7 +307,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_value_is_properly_quoted
-    minivan = Minivan.find('m1')
+    minivan = Minivan.find("m1")
     assert_nothing_raised do
       minivan.dashboard
     end
@@ -270,7 +316,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   def test_has_one_through_polymorphic_with_primary_key_option
     assert_equal categories(:general), authors(:david).essay_category
 
-    authors = Author.joins(:essay_category).where('categories.id' => categories(:general).id)
+    authors = Author.joins(:essay_category).where("categories.id" => categories(:general).id)
     assert_equal authors(:david), authors.first
 
     assert_equal owners(:blackbeard), authors(:david).essay_owner
@@ -282,12 +328,12 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   def test_has_one_through_with_primary_key_option
     assert_equal categories(:general), authors(:david).essay_category_2
 
-    authors = Author.joins(:essay_category_2).where('categories.id' => categories(:general).id)
+    authors = Author.joins(:essay_category_2).where("categories.id" => categories(:general).id)
     assert_equal authors(:david), authors.first
   end
 
   def test_has_one_through_with_default_scope_on_join_model
-    assert_equal posts(:welcome).comments.order('id').first, authors(:david).comment_on_first_post
+    assert_equal posts(:welcome).comments.order("id").first, authors(:david).comment_on_first_post
   end
 
   def test_has_one_through_many_raises_exception
@@ -308,12 +354,12 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     minivan.dashboard
     proxy = minivan.send(:association_instance_get, :dashboard)
 
-    assert !proxy.stale_target?
+    assert_not_predicate proxy, :stale_target?
     assert_equal dashboards(:cool_first), minivan.dashboard
 
     minivan.speedometer_id = speedometers(:second).id
 
-    assert proxy.stale_target?
+    assert_predicate proxy, :stale_target?
     assert_equal dashboards(:second), minivan.dashboard
   end
 
@@ -325,7 +371,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
 
     minivan.speedometer_id = speedometers(:second).id
 
-    assert proxy.stale_target?
+    assert_predicate proxy, :stale_target?
     assert_equal dashboards(:second), minivan.dashboard
   end
 

data/test/cases/associations/inner_join_association_test.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/post'
-require 'models/comment'
-require 'models/author'
-require 'models/essay'
-require 'models/category'
-require 'models/categorization'
-require 'models/person'
-require 'models/tagging'
-require 'models/tag'
+require "models/post"
+require "models/comment"
+require "models/author"
+require "models/essay"
+require "models/category"
+require "models/categorization"
+require "models/person"
+require "models/tagging"
+require "models/tag"
 
 class InnerJoinAssociationTest < ActiveRecord::TestCase
-  fixtures :authors, :essays, :posts, :comments, :categories, :categories_posts, :categorizations,
-           :taggings, :tags
+  fixtures :authors, :author_addresses, :essays, :posts, :comments, :categories, :categories_posts, :categorizations,
+           :taggings, :tags, :people
 
   def test_construct_finder_sql_applies_aliases_tables_on_association_conditions
     result = Author.joins(:thinking_posts, :welcome_posts).to_a
@@ -20,11 +22,80 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
 
   def test_construct_finder_sql_does_not_table_name_collide_on_duplicate_associations
     assert_nothing_raised do
-      sql = Person.joins(:agents => {:agents => :agents}).joins(:agents => {:agents => {:primary_contact => :agents}}).to_sql
+      sql = Person.joins(agents: { agents: :agents }).joins(agents: { agents: { primary_contact: :agents } }).to_sql
       assert_match(/agents_people_4/i, sql)
     end
   end
 
+  def test_construct_finder_sql_does_not_table_name_collide_on_duplicate_associations_with_left_outer_joins
+    sql = Person.joins(agents: :agents).left_outer_joins(agents: :agents).to_sql
+    assert_match(/agents_people_2/i, sql)
+    assert_match(/INNER JOIN/i, sql)
+    assert_no_match(/agents_people_4/i, sql)
+    assert_no_match(/LEFT OUTER JOIN/i, sql)
+  end
+
+  def test_construct_finder_sql_does_not_table_name_collide_with_string_joins
+    string_join = <<~SQL
+      JOIN people agents_people ON agents_people.primary_contact_id = agents_people_2.id AND agents_people.id > agents_people_2.id
+    SQL
+
+    expected = people(:susan)
+    assert_sql(/agents_people_2/i) do
+      assert_equal [expected], Person.joins(:agents).joins(string_join)
+    end
+  end
+
+  def test_construct_finder_sql_does_not_table_name_collide_with_aliased_joins
+    agents = Person.arel_table.alias("agents_people")
+    agents_2 = Person.arel_table.alias("agents_people_2")
+    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_equal [expected], Person.joins(:agents).joins(agents.create_join(agents, agents.create_on(constraint)))
+    end
+  end
+
+  def test_user_supplied_joins_order_should_be_preserved
+    string_join = <<~SQL
+      JOIN people agents_people_2 ON agents_people_2.primary_contact_id = people.id
+    SQL
+    agents = Person.arel_table.alias("agents_people")
+    agents_2 = Person.arel_table.alias("agents_people_2")
+    constraint = agents[:primary_contact_id].eq(agents_2[:id]).and(agents[:id].gt(agents_2[:id]))
+
+    expected = people(:susan)
+    assert_equal [expected], Person.joins(string_join).joins(agents.create_join(agents, agents.create_on(constraint)))
+  end
+
+  def test_deduplicate_joins
+    posts = Post.arel_table
+    constraint = posts[:author_id].eq(Author.arel_table[:id])
+
+    authors = Author.joins(posts.create_join(posts, posts.create_on(constraint)))
+    authors = authors.joins(:author_address).merge(authors.where("posts.type": "SpecialPost"))
+
+    assert_equal [authors(:david)], authors
+  end
+
+  def test_eager_load_with_string_joins
+    string_join = <<~SQL
+      LEFT JOIN people agents_people ON agents_people.primary_contact_id = agents_people_2.id AND agents_people.id > agents_people_2.id
+    SQL
+
+    assert_equal 3, Person.eager_load(:agents).joins(string_join).count
+  end
+
+  def test_eager_load_with_arel_joins
+    agents = Person.arel_table.alias("agents_people")
+    agents_2 = Person.arel_table.alias("agents_people_2")
+    constraint = agents[:primary_contact_id].eq(agents_2[:id]).and(agents[:id].gt(agents_2[:id]))
+    arel_join = agents.create_join(agents, agents.create_on(constraint), Arel::Nodes::OuterJoin)
+
+    assert_equal 3, Person.eager_load(:agents).joins(arel_join).count
+  end
+
   def test_construct_finder_sql_ignores_empty_joins_hash
     sql = Author.joins({}).to_sql
     assert_no_match(/JOIN/i, sql)
@@ -47,8 +118,13 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
   end
 
   def test_join_conditions_allow_nil_associations
-    authors = Author.includes(:essays).where(:essays => {:id => nil})
-    assert_equal 2, authors.count
+    authors = Author.includes(:essays).where(essays: { id: nil })
+    assert_equal 1, authors.count
+  end
+
+  def test_join_with_reserved_word
+    assert_equal [categories_posts(:technology_welcome)],
+      Post::CategoryPost.joins(:group).where("group.id": categories(:technology))
   end
 
   def test_find_with_implicit_inner_joins_without_select_does_not_imply_readonly
@@ -58,56 +134,56 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
   end
 
   def test_find_with_implicit_inner_joins_honors_readonly_with_select
-    authors = Author.joins(:posts).select('authors.*').to_a
-    assert !authors.empty?, "expected authors to be non-empty"
-    assert authors.all? {|a| !a.readonly? }, "expected no authors to be readonly"
+    authors = Author.joins(:posts).select("authors.*").to_a
+    assert_not authors.empty?, "expected authors to be non-empty"
+    assert authors.all? { |a| !a.readonly? }, "expected no authors to be readonly"
   end
 
   def test_find_with_implicit_inner_joins_honors_readonly_false
     authors = Author.joins(:posts).readonly(false).to_a
-    assert !authors.empty?, "expected authors to be non-empty"
-    assert authors.all? {|a| !a.readonly? }, "expected no authors to be readonly"
+    assert_not authors.empty?, "expected authors to be non-empty"
+    assert authors.all? { |a| !a.readonly? }, "expected no authors to be readonly"
   end
 
   def test_find_with_implicit_inner_joins_does_not_set_associations
-    authors = Author.joins(:posts).select('authors.*').to_a
-    assert !authors.empty?, "expected authors to be non-empty"
+    authors = Author.joins(:posts).select("authors.*").to_a
+    assert_not authors.empty?, "expected authors to be non-empty"
     assert authors.all? { |a| !a.instance_variable_defined?(:@posts) }, "expected no authors to have the @posts association loaded"
   end
 
   def test_count_honors_implicit_inner_joins
-    real_count = Author.all.to_a.sum{|a| a.posts.count }
+    real_count = Author.all.to_a.sum { |a| a.posts.count }
     assert_equal real_count, Author.joins(:posts).count, "plain inner join count should match the number of referenced posts records"
   end
 
   def test_calculate_honors_implicit_inner_joins
-    real_count = Author.all.to_a.sum{|a| a.posts.count }
-    assert_equal real_count, Author.joins(:posts).calculate(:count, 'authors.id'), "plain inner join count should match the number of referenced posts records"
+    real_count = Author.all.to_a.sum { |a| a.posts.count }
+    assert_equal real_count, Author.joins(:posts).calculate(:count, "authors.id"), "plain inner join count should match the number of referenced posts records"
   end
 
   def test_calculate_honors_implicit_inner_joins_and_distinct_and_conditions
-    real_count = Author.all.to_a.select {|a| a.posts.any? {|p| p.title =~ /^Welcome/} }.length
-    authors_with_welcoming_post_titles = Author.all.merge!(joins: :posts, where: "posts.title like 'Welcome%'").distinct.calculate(:count, 'authors.id')
+    real_count = Author.all.to_a.select { |a| a.posts.any? { |p| p.title.start_with?("Welcome") } }.length
+    authors_with_welcoming_post_titles = Author.all.merge!(joins: :posts, where: "posts.title like 'Welcome%'").distinct.calculate(:count, "authors.id")
     assert_equal real_count, authors_with_welcoming_post_titles, "inner join and conditions should have only returned authors posting titles starting with 'Welcome'"
   end
 
   def test_find_with_sti_join
-    scope = Post.joins(:special_comments).where(:id => posts(:sti_comments).id)
+    scope = Post.joins(:special_comments).where(id: posts(:sti_comments).id)
 
     # The join should match SpecialComment and its subclasses only
-    assert scope.where("comments.type" => "Comment").empty?
-    assert !scope.where("comments.type" => "SpecialComment").empty?
-    assert !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 !posts(:welcome).comments.empty?
-    assert Post.joins(:nonexistent_comments).where(:id => posts(:welcome).id).empty? # [sic!]
+    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 !posts(:welcome).tags.empty?
-    assert 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
@@ -120,8 +196,8 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
 
   test "the default scope of the target is correctly aliased when joining associations" do
     author = Author.create! name: "Jon"
-    author.categories.create! name: 'Not Special'
-    author.special_categories.create! name: 'Special'
+    author.categories.create! name: "Not Special"
+    author.special_categories.create! name: "Special"
 
     categories = author.categories.includes(:special_categorizations).references(:special_categorizations).to_a
     assert_equal 2, categories.size
@@ -129,8 +205,8 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
 
   test "the correct records are loaded when including an aliased association" do
     author = Author.create! name: "Jon"
-    author.categories.create! name: 'Not Special'
-    author.special_categories.create! name: 'Special'
+    author.categories.create! name: "Not Special"
+    author.special_categories.create! name: "Special"
 
     categories = author.categories.eager_load(:special_categorizations).order(:name).to_a
     assert_equal 0, categories.first.special_categorizations.size