ibm_db 5.2.0-x86-mingw32 → 5.4.0-x86-mingw32

data/test/cases/associations/has_many_associations_test.rb

@@ -1,61 +1,63 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/developer'
-require 'models/computer'
-require 'models/project'
-require 'models/company'
-require 'models/contract'
-require 'models/topic'
-require 'models/reply'
-require 'models/category'
-require 'models/image'
-require 'models/post'
-require 'models/author'
-require 'models/essay'
-require 'models/comment'
-require 'models/person'
-require 'models/reader'
-require 'models/tagging'
-require 'models/tag'
-require 'models/invoice'
-require 'models/line_item'
-require 'models/car'
-require 'models/bulb'
-require 'models/engine'
-require 'models/categorization'
-require 'models/minivan'
-require 'models/speedometer'
-require 'models/reference'
-require 'models/job'
-require 'models/college'
-require 'models/student'
-require 'models/pirate'
-require 'models/ship'
-require 'models/ship_part'
-require 'models/treasure'
-require 'models/parrot'
-require 'models/tyre'
-require 'models/subscriber'
-require 'models/subscription'
-require 'models/zine'
-require 'models/interest'
+require "models/developer"
+require "models/computer"
+require "models/project"
+require "models/company"
+require "models/contract"
+require "models/topic"
+require "models/reply"
+require "models/category"
+require "models/image"
+require "models/post"
+require "models/author"
+require "models/essay"
+require "models/comment"
+require "models/person"
+require "models/reader"
+require "models/tagging"
+require "models/tag"
+require "models/invoice"
+require "models/line_item"
+require "models/car"
+require "models/bulb"
+require "models/engine"
+require "models/categorization"
+require "models/minivan"
+require "models/speedometer"
+require "models/reference"
+require "models/job"
+require "models/college"
+require "models/student"
+require "models/pirate"
+require "models/ship"
+require "models/ship_part"
+require "models/treasure"
+require "models/parrot"
+require "models/tyre"
+require "models/subscriber"
+require "models/subscription"
+require "models/zine"
+require "models/interest"
 
 class HasManyAssociationsTestForReorderWithJoinDependency < ActiveRecord::TestCase
-  fixtures :authors, :posts, :comments
+  fixtures :authors, :author_addresses, :posts, :comments
 
   def test_should_generate_valid_sql
     author = authors(:david)
     # this can fail on adapters which require ORDER BY expressions to be included in the SELECT expression
     # if the reorder clauses are not correctly handled
-    assert author.posts_with_comments_sorted_by_comment_id.where('comments.id > 0').reorder('posts.comments_count DESC', 'posts.tags_count DESC').last
+    assert author.posts_with_comments_sorted_by_comment_id.where("comments.id > 0").reorder("posts.comments_count": :desc, "posts.tags_count": :desc).last
   end
 end
 
 class HasManyAssociationsTestPrimaryKeys < ActiveRecord::TestCase
-  fixtures :authors, :essays, :subscribers, :subscriptions, :people
+  fixtures :authors, :author_addresses, :essays, :subscribers, :subscriptions, :people
 
   def test_custom_primary_key_on_new_record_should_fetch_with_query
-    subscriber = Subscriber.new(nick: 'webster132')
-    assert !subscriber.subscriptions.loaded?
+    subscriber = Subscriber.new(nick: "webster132")
+    assert_not_predicate subscriber.subscriptions, :loaded?
 
     assert_queries 1 do
       assert_equal 2, subscriber.subscriptions.size
@@ -65,8 +67,8 @@ class HasManyAssociationsTestPrimaryKeys < ActiveRecord::TestCase
   end
 
   def test_association_primary_key_on_new_record_should_fetch_with_query
-    author = Author.new(:name => "David")
-    assert !author.essays.loaded?
+    author = Author.new(name: "David")
+    assert_not_predicate author.essays, :loaded?
 
     assert_queries 1 do
       assert_equal 1, author.essays.size
@@ -95,13 +97,13 @@ class HasManyAssociationsTestPrimaryKeys < ActiveRecord::TestCase
     david = people(:david)
 
     assert_equal ["A Modest Proposal"], david.essays.map(&:name)
-    david.essays = [Essay.create!(name: "Remote Work" )]
+    david.essays = [Essay.create!(name: "Remote Work")]
     assert_equal ["Remote Work"], david.essays.map(&:name)
   end
 
   def test_blank_custom_primary_key_on_new_record_should_not_run_queries
     author = Author.new
-    assert !author.essays.loaded?
+    assert_not_predicate author.essays, :loaded?
 
     assert_queries 0 do
       assert_equal 0, author.essays.size
@@ -111,8 +113,8 @@ end
 
 class HasManyAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :categories, :companies, :developers, :projects,
-           :developers_projects, :topics, :authors, :comments,
-           :posts, :readers, :taggings, :cars, :jobs, :tags,
+           :developers_projects, :topics, :authors, :author_addresses, :comments,
+           :posts, :readers, :taggings, :cars, :tags,
            :categorizations, :zines, :interests
 
   def setup
@@ -127,14 +129,14 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_anonymous_has_many
     developer = Class.new(ActiveRecord::Base) {
-      self.table_name = 'developers'
+      self.table_name = "developers"
       dev = self
 
       developer_project = Class.new(ActiveRecord::Base) {
-        self.table_name = 'developers_projects'
-        belongs_to :developer, :anonymous_class => dev
+        self.table_name = "developers_projects"
+        belongs_to :developer, anonymous_class: dev
       }
-      has_many :developer_projects, :anonymous_class => developer_project, :foreign_key => 'developer_id'
+      has_many :developer_projects, anonymous_class: developer_project, foreign_key: "developer_id"
     }
     dev = developer.first
     named = Developer.find(dev.id)
@@ -146,20 +148,20 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_default_scope_on_relations_is_not_cached
     counter = 0
     posts = Class.new(ActiveRecord::Base) {
-      self.table_name = 'posts'
-      self.inheritance_column = 'not_there'
+      self.table_name = "posts"
+      self.inheritance_column = "not_there"
       post = self
 
       comments = Class.new(ActiveRecord::Base) {
-        self.table_name = 'comments'
-        self.inheritance_column = 'not_there'
-        belongs_to :post, :anonymous_class => post
+        self.table_name = "comments"
+        self.inheritance_column = "not_there"
+        belongs_to :post, anonymous_class: post
         default_scope -> {
           counter += 1
-          where("id = :inc", :inc => counter)
+          where("id = :inc", inc: counter)
         }
       }
-      has_many :comments, :anonymous_class => comments, :foreign_key => 'post_id'
+      has_many :comments, anonymous_class: comments, foreign_key: "post_id"
     }
     assert_equal 0, counter
     post = posts.first
@@ -170,15 +172,15 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_has_many_build_with_options
-    college = College.create(name: 'UFMT')
-    Student.create(active: true, college_id: college.id, name: 'Sarah')
+    college = College.create(name: "UFMT")
+    Student.create(active: true, college_id: college.id, name: "Sarah")
 
     assert_equal college.students, Student.where(active: true, college_id: college.id)
   end
 
   def test_add_record_to_collection_should_change_its_updated_at
-    ship = Ship.create(name: 'dauntless')
-    part = ShipPart.create(name: 'cockpit')
+    ship = Ship.create(name: "dauntless")
+    part = ShipPart.create(name: "cockpit")
     updated_at = part.updated_at
 
     travel(1.second) do
@@ -192,80 +194,131 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_clear_collection_should_not_change_updated_at
     # GH#17161: .clear calls delete_all (and returns the association),
     # which is intended to not touch associated objects's updated_at field
-    ship = Ship.create(name: 'dauntless')
-    part = ShipPart.create(name: 'cockpit', ship_id: ship.id)
+    ship = Ship.create(name: "dauntless")
+    part = ShipPart.create(name: "cockpit", ship_id: ship.id)
 
     ship.parts.clear
     part.reload
 
-    assert_equal nil, part.ship
-    assert !part.updated_at_changed?
+    assert_nil part.ship
+    assert_not_predicate part, :updated_at_changed?
   end
 
   def test_create_from_association_should_respect_default_scope
-    car = Car.create(:name => 'honda')
-    assert_equal 'honda', car.name
+    car = Car.create(name: "honda")
+    assert_equal "honda", car.name
 
     bulb = Bulb.create
-    assert_equal 'defaulty', bulb.name
+    assert_equal "defaulty", bulb.name
 
     bulb = car.bulbs.build
-    assert_equal 'defaulty', bulb.name
+    assert_equal "defaulty", bulb.name
 
     bulb = car.bulbs.create
-    assert_equal 'defaulty', bulb.name
+    assert_equal "defaulty", bulb.name
+
+    bulb = car.bulbs.create!
+    assert_equal "defaulty", bulb.name
   end
 
   def test_build_and_create_from_association_should_respect_passed_attributes_over_default_scope
-    car = Car.create(name: 'honda')
+    car = Car.create(name: "honda")
+
+    bulb = car.bulbs.where(name: "exotic").build
+    assert_equal "exotic", bulb.name
+    assert_nil bulb.count_after_create
+
+    bulb = car.bulbs.where(name: "exotic").create
+    assert_equal "exotic", bulb.name
+    assert_equal 1, bulb.count_after_create
+
+    bulb = car.bulbs.where(name: "exotic").create!
+    assert_equal "exotic", bulb.name
+    assert_equal 2, bulb.count_after_create
+
+    bulb = car.bulbs.build(name: "exotic")
+    assert_equal "exotic", bulb.name
 
-    bulb = car.bulbs.build(name: 'exotic')
-    assert_equal 'exotic', bulb.name
+    bulb = car.bulbs.create(name: "exotic")
+    assert_equal "exotic", bulb.name
 
-    bulb = car.bulbs.create(name: 'exotic')
-    assert_equal 'exotic', bulb.name
+    bulb = car.bulbs.create!(name: "exotic")
+    assert_equal "exotic", bulb.name
 
     bulb = car.awesome_bulbs.build(frickinawesome: false)
     assert_equal false, bulb.frickinawesome
 
     bulb = car.awesome_bulbs.create(frickinawesome: false)
     assert_equal false, bulb.frickinawesome
+
+    bulb = car.awesome_bulbs.create!(frickinawesome: false)
+    assert_equal false, bulb.frickinawesome
+  end
+
+  def test_build_and_create_from_association_should_respect_unscope_over_default_scope
+    car = Car.create(name: "honda")
+
+    bulb = car.bulbs.unscope(where: :name).build
+    assert_nil bulb.name
+
+    bulb = car.bulbs.unscope(where: :name).create
+    assert_nil bulb.name
+
+    bulb = car.bulbs.unscope(where: :name).create!
+    assert_nil bulb.name
+
+    bulb = car.awesome_bulbs.unscope(where: :frickinawesome).build
+    assert_equal false, bulb.frickinawesome
+
+    bulb = car.awesome_bulbs.unscope(where: :frickinawesome).create
+    assert_equal false, bulb.frickinawesome
+
+    bulb = car.awesome_bulbs.unscope(where: :frickinawesome).create!
+    assert_equal false, bulb.frickinawesome
   end
 
   def test_build_from_association_should_respect_scope
     author = Author.new
 
     post = author.thinking_posts.build
-    assert_equal 'So I was thinking', post.title
+    assert_equal "So I was thinking", post.title
   end
 
   def test_create_from_association_with_nil_values_should_work
-    car = Car.create(:name => 'honda')
+    car = Car.create(name: "honda")
 
     bulb = car.bulbs.new(nil)
-    assert_equal 'defaulty', bulb.name
+    assert_equal "defaulty", bulb.name
 
     bulb = car.bulbs.build(nil)
-    assert_equal 'defaulty', bulb.name
+    assert_equal "defaulty", bulb.name
 
     bulb = car.bulbs.create(nil)
-    assert_equal 'defaulty', bulb.name
+    assert_equal "defaulty", bulb.name
+  end
+
+  def test_build_from_association_sets_inverse_instance
+    car = Car.new(name: "honda")
+
+    bulb = car.bulbs.build
+    assert_equal car, bulb.car
   end
 
   def test_do_not_call_callbacks_for_delete_all
-    car = Car.create(:name => 'honda')
+    car = Car.create(name: "honda")
     car.funky_bulbs.create!
-    assert_nothing_raised { car.reload.funky_bulbs.delete_all }
-    assert_equal 0, Bulb.count, "bulbs should have been deleted using :delete_all strategy"
+    assert_equal 1, car.funky_bulbs.count
+    assert_equal 1, car.reload.funky_bulbs.delete_all
+    assert_equal 0, car.funky_bulbs.count, "bulbs should have been deleted using :delete_all strategy"
   end
 
   def test_delete_all_on_association_is_the_same_as_not_loaded
     author = authors :david
-    author.thinking_posts.create!(:body => "test")
+    author.thinking_posts.create!(body: "test")
     author.reload
     expected_sql = capture_sql { author.thinking_posts.delete_all }
 
-    author.thinking_posts.create!(:body => "test")
+    author.thinking_posts.create!(body: "test")
     author.reload
     author.thinking_posts.inspect
     loaded_sql = capture_sql { author.thinking_posts.delete_all }
@@ -274,17 +327,25 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_delete_all_on_association_with_nil_dependency_is_the_same_as_not_loaded
     author = authors :david
-    author.posts.create!(:title => "test", :body => "body")
+    author.posts.create!(title: "test", body: "body")
     author.reload
     expected_sql = capture_sql { author.posts.delete_all }
 
-    author.posts.create!(:title => "test", :body => "body")
+    author.posts.create!(title: "test", body: "body")
     author.reload
     author.posts.to_a
     loaded_sql = capture_sql { author.posts.delete_all }
     assert_equal(expected_sql, loaded_sql)
   end
 
+  def test_delete_all_on_association_clears_scope
+    author = Author.create!(name: "Gannon")
+    posts = author.posts
+    posts.create!(title: "test", body: "body")
+    posts.delete_all
+    assert_nil posts.first
+  end
+
   def test_building_the_associated_object_with_implicit_sti_base_class
     firm = DependentFirm.new
     company = firm.companies.build
@@ -293,55 +354,99 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_building_the_associated_object_with_explicit_sti_base_class
     firm = DependentFirm.new
-    company = firm.companies.build(:type => "Company")
+    company = firm.companies.build(type: "Company")
     assert_kind_of Company, company, "Expected #{company.class} to be a Company"
   end
 
   def test_building_the_associated_object_with_sti_subclass
     firm = DependentFirm.new
-    company = firm.companies.build(:type => "Client")
+    company = firm.companies.build(type: "Client")
     assert_kind_of Client, company, "Expected #{company.class} to be a Client"
   end
 
   def test_building_the_associated_object_with_an_invalid_type
     firm = DependentFirm.new
-    assert_raise(ActiveRecord::SubclassNotFound) { firm.companies.build(:type => "Invalid") }
+    assert_raise(ActiveRecord::SubclassNotFound) { firm.companies.build(type: "Invalid") }
   end
 
   def test_building_the_associated_object_with_an_unrelated_type
     firm = DependentFirm.new
-    assert_raise(ActiveRecord::SubclassNotFound) { firm.companies.build(:type => "Account") }
+    assert_raise(ActiveRecord::SubclassNotFound) { firm.companies.build(type: "Account") }
+  end
+
+  test "build the association with an array" do
+    speedometer = Speedometer.new(speedometer_id: "a")
+    data = [{ name: "first" }, { name: "second" }]
+    speedometer.minivans.where(color: "blue").build(data)
+
+    assert_equal 2, speedometer.minivans.size
+    assert speedometer.save
+
+    speedometer.reload
+
+    assert_equal ["first", "second"], speedometer.minivans.map(&:name)
+    assert_equal ["blue", "blue"], speedometer.minivans.map(&:color)
   end
 
-  test "building the association with an array" do
+  test "new the association with an array" do
     speedometer = Speedometer.new(speedometer_id: "a")
-    data = [{name: "first"}, {name: "second"}]
-    speedometer.minivans.build(data)
+    data = [{ name: "first" }, { name: "second" }]
+    speedometer.minivans.where(color: "blue").new(data)
 
     assert_equal 2, speedometer.minivans.size
     assert speedometer.save
-    assert_equal ["first", "second"], speedometer.reload.minivans.map(&:name)
+
+    speedometer.reload
+
+    assert_equal ["first", "second"], speedometer.minivans.map(&:name)
+    assert_equal ["blue", "blue"], speedometer.minivans.map(&:color)
+  end
+
+  test "create the association with an array" do
+    speedometer = Speedometer.create!(speedometer_id: "a")
+    data = [{ name: "first" }, { name: "second" }]
+    speedometer.minivans.where(color: "blue").create(data)
+
+    assert_equal 2, speedometer.minivans.size
+
+    speedometer.reload
+
+    assert_equal ["first", "second"], speedometer.minivans.map(&:name)
+    assert_equal ["blue", "blue"], speedometer.minivans.map(&:color)
+  end
+
+  test "create! the association with an array" do
+    speedometer = Speedometer.create!(speedometer_id: "a")
+    data = [{ name: "first" }, { name: "second" }]
+    speedometer.minivans.where(color: "blue").create!(data)
+
+    assert_equal 2, speedometer.minivans.size
+
+    speedometer.reload
+
+    assert_equal ["first", "second"], speedometer.minivans.map(&:name)
+    assert_equal ["blue", "blue"], speedometer.minivans.map(&:color)
   end
 
   def test_association_keys_bypass_attribute_protection
-    car = Car.create(:name => 'honda')
+    car = Car.create(name: "honda")
 
     bulb = car.bulbs.new
     assert_equal car.id, bulb.car_id
 
-    bulb = car.bulbs.new :car_id => car.id + 1
+    bulb = car.bulbs.new car_id: car.id + 1
     assert_equal car.id, bulb.car_id
 
     bulb = car.bulbs.build
     assert_equal car.id, bulb.car_id
 
-    bulb = car.bulbs.build :car_id => car.id + 1
+    bulb = car.bulbs.build car_id: car.id + 1
     assert_equal car.id, bulb.car_id
 
     bulb = car.bulbs.create
     assert_equal car.id, bulb.car_id
 
-    bulb = car.bulbs.create :car_id => car.id + 1
+    bulb = car.bulbs.create car_id: car.id + 1
     assert_equal car.id, bulb.car_id
   end
 
@@ -351,22 +456,43 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     line_item = invoice.line_items.new
     assert_equal invoice.id, line_item.invoice_id
 
-    line_item = invoice.line_items.new :invoice_id => invoice.id + 1
+    line_item = invoice.line_items.new invoice_id: invoice.id + 1
     assert_equal invoice.id, line_item.invoice_id
 
     line_item = invoice.line_items.build
     assert_equal invoice.id, line_item.invoice_id
 
-    line_item = invoice.line_items.build :invoice_id => invoice.id + 1
+    line_item = invoice.line_items.build invoice_id: invoice.id + 1
     assert_equal invoice.id, line_item.invoice_id
 
     line_item = invoice.line_items.create
     assert_equal invoice.id, line_item.invoice_id
 
-    line_item = invoice.line_items.create :invoice_id => invoice.id + 1
+    line_item = invoice.line_items.create invoice_id: invoice.id + 1
     assert_equal invoice.id, line_item.invoice_id
   end
 
+  class SpecialAuthor < ActiveRecord::Base
+    self.table_name = "authors"
+    has_many :books, class_name: "SpecialBook", foreign_key: :author_id
+  end
+
+  class SpecialBook < ActiveRecord::Base
+    self.table_name = "books"
+
+    belongs_to :author
+    enum last_read: { unread: 0, reading: 2, read: 3, forgotten: nil }
+  end
+
+  def test_association_enum_works_properly
+    author = SpecialAuthor.create!(name: "Test")
+    book = SpecialBook.create!(last_read: "reading")
+    author.books << book
+
+    assert_equal "reading", book.last_read
+    assert_not_equal 0, SpecialAuthor.joins(:books).where(books: { last_read: "reading" }).count
+  end
+
   # When creating objects on the association, we must not do it within a scope (even though it
   # would be convenient), because this would cause that scope to be applied to any callbacks etc.
   def test_build_and_create_should_not_happen_within_scope
@@ -384,64 +510,100 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_no_sql_should_be_fired_if_association_already_loaded
-    Car.create(:name => 'honda')
+    Car.create(name: "honda")
     bulbs = Car.first.bulbs
     bulbs.to_a # to load all instances of bulbs
 
     assert_no_queries do
       bulbs.first()
-      bulbs.first({})
     end
 
     assert_no_queries do
       bulbs.second()
-      bulbs.second({})
     end
 
     assert_no_queries do
       bulbs.third()
-      bulbs.third({})
     end
 
     assert_no_queries do
       bulbs.fourth()
-      bulbs.fourth({})
     end
 
     assert_no_queries do
       bulbs.fifth()
-      bulbs.fifth({})
     end
 
     assert_no_queries do
       bulbs.forty_two()
-      bulbs.forty_two({})
     end
 
     assert_no_queries do
       bulbs.third_to_last()
-      bulbs.third_to_last({})
     end
 
     assert_no_queries do
       bulbs.second_to_last()
-      bulbs.second_to_last({})
     end
 
     assert_no_queries do
       bulbs.last()
-      bulbs.last({})
+    end
+  end
+
+  def test_finder_method_with_dirty_target
+    company = companies(:first_firm)
+    new_clients = []
+
+    assert_queries(0) do
+      new_clients << company.clients_of_firm.build(name: "Another Client")
+      new_clients << company.clients_of_firm.build(name: "Another Client II")
+      new_clients << company.clients_of_firm.build(name: "Another Client III")
+    end
+
+    assert_not_predicate company.clients_of_firm, :loaded?
+    assert_queries(1) do
+      assert_same new_clients[0], company.clients_of_firm.third
+      assert_same new_clients[1], company.clients_of_firm.fourth
+      assert_same new_clients[2], company.clients_of_firm.fifth
+      assert_same new_clients[0], company.clients_of_firm.third_to_last
+      assert_same new_clients[1], company.clients_of_firm.second_to_last
+      assert_same new_clients[2], company.clients_of_firm.last
+    end
+  end
+
+  def test_finder_bang_method_with_dirty_target
+    company = companies(:first_firm)
+    new_clients = []
+
+    assert_queries(0) do
+      new_clients << company.clients_of_firm.build(name: "Another Client")
+      new_clients << company.clients_of_firm.build(name: "Another Client II")
+      new_clients << company.clients_of_firm.build(name: "Another Client III")
+    end
+
+    assert_not_predicate company.clients_of_firm, :loaded?
+    assert_queries(1) do
+      assert_same new_clients[0], company.clients_of_firm.third!
+      assert_same new_clients[1], company.clients_of_firm.fourth!
+      assert_same new_clients[2], company.clients_of_firm.fifth!
+      assert_same new_clients[0], company.clients_of_firm.third_to_last!
+      assert_same new_clients[1], company.clients_of_firm.second_to_last!
+      assert_same new_clients[2], company.clients_of_firm.last!
     end
   end
 
   def test_create_resets_cached_counters
-    person = Person.create!(:first_name => 'tenderlove')
+    Reader.delete_all
+
+    person = Person.create!(first_name: "tenderlove")
+
     post   = Post.first
 
     assert_equal [], person.readers
     assert_nil person.readers.find_by_post_id(post.id)
 
-    person.readers.create(:post_id => post.id)
+    person.readers.create(post_id: post.id)
 
     assert_equal 1, person.readers.count
     assert_equal 1, person.readers.length
@@ -451,43 +613,34 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_update_all_respects_association_scope
     person = Person.new
-    person.first_name = 'Naruto'
+    person.first_name = "Naruto"
     person.references << Reference.new
-    person.id = 10
-    person.references
     person.save!
     assert_equal 1, person.references.update_all(favourite: true)
   end
 
   def test_exists_respects_association_scope
     person = Person.new
-    person.first_name = 'Sasuke'
+    person.first_name = "Sasuke"
     person.references << Reference.new
-    person.id = 10
-    person.references
     person.save!
     assert_predicate person.references, :exists?
   end
 
-  def force_signal37_to_load_all_clients_of_firm
-    companies(:first_firm).clients_of_firm.each {|f| }
-  end
-
-  # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
   def test_counting_with_counter_sql
-    assert_equal 3, Firm.all.merge!(:order => "id").first.clients.count
+    assert_equal 3, Firm.first.clients.count
   end
 
   def test_counting
-    assert_equal 3, Firm.all.merge!(:order => "id").first.plain_clients.count
+    assert_equal 3, Firm.first.plain_clients.count
   end
 
   def test_counting_with_single_hash
-    assert_equal 1, Firm.all.merge!(:order => "id").first.plain_clients.where(:name => "Microsoft").count
+    assert_equal 1, Firm.first.plain_clients.where(name: "Microsoft").count
   end
 
   def test_counting_with_column_name_and_hash
-    assert_equal 3, Firm.all.merge!(:order => "id").first.plain_clients.count(:name)
+    assert_equal 3, Firm.first.plain_clients.count(:name)
   end
 
   def test_counting_with_association_limit
@@ -497,11 +650,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_finding
-    assert_equal 3, Firm.all.merge!(:order => "id").first.clients.length
+    assert_equal 3, Firm.first.clients.length
   end
 
   def test_finding_array_compatibility
-    assert_equal 3, Firm.order(:id).find{|f| f.id > 0}.clients.length
+    assert_equal 3, Firm.order(:id).find { |f| f.id > 0 }.clients.length
   end
 
   def test_find_many_with_merged_options
@@ -511,13 +664,13 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_should_append_to_association_order
-    ordered_clients =  companies(:first_firm).clients_sorted_desc.order('companies.id')
-    assert_equal ['id DESC', 'companies.id'], ordered_clients.order_values
+    ordered_clients = companies(:first_firm).clients_sorted_desc.order("companies.id")
+    assert_equal ["id DESC", "companies.id"], ordered_clients.order_values
   end
 
   def test_dynamic_find_should_respect_association_order
     assert_equal companies(:another_first_firm_client), companies(:first_firm).clients_sorted_desc.where("type = 'Client'").first
-    assert_equal companies(:another_first_firm_client), companies(:first_firm).clients_sorted_desc.find_by_type('Client')
+    assert_equal companies(:another_first_firm_client), companies(:first_firm).clients_sorted_desc.find_by_type("Client")
   end
 
   def test_taking
@@ -537,16 +690,28 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_taking_with_a_number
+    klass = Class.new(Author) do
+      has_many :posts, -> { order(:id) }
+
+      def self.name
+        "Author"
+      end
+    end
+
     # taking from unloaded Relation
-    bob = Author.find(authors(:bob).id)
+    bob = klass.find(authors(:bob).id)
+    new_post = bob.posts.build
+    assert_not_predicate bob.posts, :loaded?
     assert_equal [posts(:misc_by_bob)], bob.posts.take(1)
-    bob = Author.find(authors(:bob).id)
     assert_equal [posts(:misc_by_bob), posts(:other_by_bob)], bob.posts.take(2)
+    assert_equal [posts(:misc_by_bob), posts(:other_by_bob), new_post], bob.posts.take(3)
 
     # taking from loaded Relation
-    bob.posts.to_a
-    assert_equal [posts(:misc_by_bob)], authors(:bob).posts.take(1)
-    assert_equal [posts(:misc_by_bob), posts(:other_by_bob)], authors(:bob).posts.take(2)
+    bob.posts.load
+    assert_predicate bob.posts, :loaded?
+    assert_equal [posts(:misc_by_bob)], bob.posts.take(1)
+    assert_equal [posts(:misc_by_bob), posts(:other_by_bob)], bob.posts.take(2)
+    assert_equal [posts(:misc_by_bob), posts(:other_by_bob), new_post], bob.posts.take(3)
   end
 
   def test_taking_with_inverse_of
@@ -565,27 +730,27 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_finding_default_orders
-    assert_equal "Summit", Firm.all.merge!(:order => "id").first.clients.first.name
+    assert_equal "Summit", Firm.first.clients.first.name
   end
 
   def test_finding_with_different_class_name_and_order
-    assert_equal "Apex", Firm.all.merge!(:order => "id").first.clients_sorted_desc.first.name
+    assert_equal "Apex", Firm.first.clients_sorted_desc.first.name
   end
 
   def test_finding_with_foreign_key
-    assert_equal "Microsoft", Firm.all.merge!(:order => "id").first.clients_of_firm.first.name
+    assert_equal "Microsoft", Firm.first.clients_of_firm.first.name
   end
 
   def test_finding_with_condition
-    assert_equal "Microsoft", Firm.all.merge!(:order => "id").first.clients_like_ms.first.name
+    assert_equal "Microsoft", Firm.first.clients_like_ms.first.name
   end
 
   def test_finding_with_condition_hash
-    assert_equal "Microsoft", Firm.all.merge!(:order => "id").first.clients_like_ms_with_hash_conditions.first.name
+    assert_equal "Microsoft", Firm.first.clients_like_ms_with_hash_conditions.first.name
   end
 
   def test_finding_using_primary_key
-    assert_equal "Summit", Firm.all.merge!(:order => "id").first.clients_using_primary_key.first.name
+    assert_equal "Summit", Firm.first.clients_using_primary_key.first.name
   end
 
   def test_update_all_on_association_accessed_before_save
@@ -608,7 +773,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_ids
-    firm = Firm.all.merge!(:order => "id").first
+    firm = Firm.first
 
     assert_raise(ActiveRecord::RecordNotFound) { firm.clients.find }
 
@@ -628,7 +793,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_one_message_on_primary_key
-    firm = Firm.all.merge!(order: "id").first
+    firm = Firm.first
 
     e = assert_raises(ActiveRecord::RecordNotFound) do
       firm.clients.find(0)
@@ -642,6 +807,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_find_ids_and_inverse_of
     force_signal37_to_load_all_clients_of_firm
 
+    assert_predicate companies(:first_firm).clients_of_firm, :loaded?
+
     firm = companies(:first_firm)
     client = firm.clients_of_firm.find(3)
     assert_kind_of Client, client
@@ -652,7 +819,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_all
-    firm = Firm.all.merge!(:order => "id").first
+    firm = Firm.first
     assert_equal 3, firm.clients.where("#{QUOTED_TYPE} = 'Client'").to_a.length
     assert_equal 1, firm.clients.where("name = 'Summit'").to_a.length
   end
@@ -660,67 +827,143 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_find_each
     firm = companies(:first_firm)
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
 
     assert_queries(4) do
-      firm.clients.find_each(:batch_size => 1) {|c| assert_equal firm.id, c.firm_id }
+      firm.clients.find_each(batch_size: 1) { |c| assert_equal firm.id, c.firm_id }
     end
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_find_each_with_conditions
     firm = companies(:first_firm)
 
     assert_queries(2) do
-      firm.clients.where(name: 'Microsoft').find_each(batch_size: 1) do |c|
+      firm.clients.where(name: "Microsoft").find_each(batch_size: 1) do |c|
         assert_equal firm.id, c.firm_id
         assert_equal "Microsoft", c.name
       end
     end
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_find_in_batches
     firm = companies(:first_firm)
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
 
     assert_queries(2) do
-      firm.clients.find_in_batches(:batch_size => 2) do |clients|
-        clients.each {|c| assert_equal firm.id, c.firm_id }
+      firm.clients.find_in_batches(batch_size: 2) do |clients|
+        clients.each { |c| assert_equal firm.id, c.firm_id }
       end
     end
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_find_all_sanitized
-    # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
-    firm = Firm.all.merge!(:order => "id").first
+    firm = Firm.first
     summit = firm.clients.where("name = 'Summit'").to_a
     assert_equal summit, firm.clients.where("name = ?", "Summit").to_a
-    assert_equal summit, firm.clients.where("name = :name", { :name => "Summit" }).to_a
+    assert_equal summit, firm.clients.where("name = :name", name: "Summit").to_a
   end
 
   def test_find_first
-    firm = Firm.all.merge!(:order => "id").first
+    firm = Firm.first
     client2 = Client.find(2)
     assert_equal firm.clients.first, firm.clients.order("id").first
     assert_equal client2, firm.clients.where("#{QUOTED_TYPE} = 'Client'").order("id").first
   end
 
   def test_find_first_sanitized
-    firm = Firm.all.merge!(:order => "id").first
+    firm = Firm.first
     client2 = Client.find(2)
-    assert_equal client2, firm.clients.merge!(:where => ["#{QUOTED_TYPE} = ?", 'Client'], :order => "id").first
-    assert_equal client2, firm.clients.merge!(:where => ["#{QUOTED_TYPE} = :type", { :type => 'Client' }], :order => "id").first
+    assert_equal client2, firm.clients.where("#{QUOTED_TYPE} = ?", "Client").first
+    assert_equal client2, firm.clients.where("#{QUOTED_TYPE} = :type", type: "Client").first
+  end
+
+  def test_find_first_after_reset_scope
+    firm = Firm.first
+    collection = firm.clients
+
+    original_object = collection.first
+    assert_same original_object, collection.first, "Expected second call to #first to cache the same object"
+
+    # It should return a different object, since the association has been reloaded
+    assert_not_same original_object, firm.clients.first, "Expected #first to return a new object"
+  end
+
+  def test_find_first_after_reset
+    firm = Firm.first
+    collection = firm.clients
+
+    original_object = collection.first
+    assert_same original_object, collection.first, "Expected second call to #first to cache the same object"
+    collection.reset
+
+    # It should return a different object, since the association has been reloaded
+    assert_not_same original_object, collection.first, "Expected #first after #reset to return a new object"
+  end
+
+  def test_find_first_after_reload
+    firm = Firm.first
+    collection = firm.clients
+
+    original_object = collection.first
+    assert_same original_object, collection.first, "Expected second call to #first to cache the same object"
+    collection.reload
+
+    # It should return a different object, since the association has been reloaded
+    assert_not_same original_object, collection.first, "Expected #first after #reload to return a new object"
+  end
+
+  def test_reload_with_query_cache
+    connection = ActiveRecord::Base.connection
+    connection.enable_query_cache!
+    connection.clear_query_cache
+
+    # Populate the cache with a query
+    firm = Firm.first
+    # Populate the cache with a second query
+    firm.clients.load
+
+    assert_equal 2, connection.query_cache.size
+
+    # Clear the cache and fetch the clients again, populating the cache with a query
+    assert_queries(1) { firm.clients.reload }
+    # This query is cached, so it shouldn't make a real SQL query
+    assert_queries(0) { firm.clients.load }
+
+    assert_equal 1, connection.query_cache.size
+  ensure
+    ActiveRecord::Base.connection.disable_query_cache!
+  end
+
+  def test_reloading_unloaded_associations_with_query_cache
+    connection = ActiveRecord::Base.connection
+    connection.enable_query_cache!
+    connection.clear_query_cache
+
+    firm = Firm.create!(name: "firm name")
+    client = firm.clients.create!(name: "client name")
+    firm.clients.to_a # add request to cache
+
+    connection.uncached do
+      client.update!(name: "new client name")
+    end
+
+    firm = Firm.find(firm.id)
+
+    assert_equal [client.name], firm.clients.reload.map(&:name)
+  ensure
+    ActiveRecord::Base.connection.disable_query_cache!
   end
 
   def test_find_all_with_include_and_conditions
     assert_nothing_raised do
-      Developer.all.merge!(:joins => :audit_logs, :where => {'audit_logs.message' => nil, :name => 'Smith'}).to_a
+      Developer.all.merge!(joins: :audit_logs, where: { "audit_logs.message" => nil, :name => "Smith" }).to_a
     end
   end
 
@@ -730,8 +973,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_grouped
-    all_clients_of_firm1 = Client.all.merge!(:where => "firm_id = 1").to_a
-    grouped_clients_of_firm1 = Client.all.merge!(:where => "firm_id = 1", :group => "firm_id", :select => 'firm_id, count(id) as clients_count').to_a
+    all_clients_of_firm1 = Client.all.merge!(where: "firm_id = 1").to_a
+    grouped_clients_of_firm1 = Client.all.merge!(where: "firm_id = 1", group: "firm_id", select: "firm_id, count(id) as clients_count").to_a
     assert_equal 3, all_clients_of_firm1.size
     assert_equal 1, grouped_clients_of_firm1.size
   end
@@ -744,7 +987,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_scoped_grouped_having
-    assert_equal 1, authors(:david).popular_grouped_posts.length
+    assert_equal 2, authors(:david).popular_grouped_posts.length
     assert_equal 0, authors(:mary).popular_grouped_posts.length
   end
 
@@ -753,19 +996,28 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_select_query_method
-    assert_equal ['id', 'body'], posts(:welcome).comments.select(:id, :body).first.attributes.keys
+    assert_equal ["id", "body"], posts(:welcome).comments.select(:id, :body).first.attributes.keys
   end
 
   def test_select_with_block
     assert_equal [1], posts(:welcome).comments.select { |c| c.id == 1 }.map(&:id)
   end
 
+  def test_select_with_block_and_dirty_target
+    assert_equal 2, posts(:welcome).comments.select { true }.size
+    posts(:welcome).comments.build
+    assert_equal 3, posts(:welcome).comments.select { true }.size
+  end
+
   def test_select_without_foreign_key
     assert_equal companies(:first_firm).accounts.first.credit_limit, companies(:first_firm).accounts.select(:credit_limit).first.credit_limit
   end
 
   def test_adding
     force_signal37_to_load_all_clients_of_firm
+
+    assert_predicate companies(:first_firm).clients_of_firm, :loaded?
+
     natural = Client.new("name" => "Natural Company")
     companies(:first_firm).clients_of_firm << natural
     assert_equal 3, companies(:first_firm).clients_of_firm.size # checking via the collection
@@ -776,7 +1028,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_adding_using_create
     first_firm = companies(:first_firm)
     assert_equal 3, first_firm.plain_clients.size
-    first_firm.plain_clients.create(:name => "Natural Company")
+    first_firm.plain_clients.create(name: "Natural Company")
     assert_equal 4, first_firm.plain_clients.length
     assert_equal 4, first_firm.plain_clients.size
   end
@@ -784,7 +1036,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_create_with_bang_on_has_many_when_parent_is_new_raises
     error = assert_raise(ActiveRecord::RecordNotSaved) do
       firm = Firm.new
-      firm.plain_clients.create! :name=>"Whoever"
+      firm.plain_clients.create! name: "Whoever"
     end
 
     assert_equal "You cannot call create unless the parent is saved", error.message
@@ -793,7 +1045,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_regular_create_on_has_many_when_parent_is_new_raises
     error = assert_raise(ActiveRecord::RecordNotSaved) do
       firm = Firm.new
-      firm.plain_clients.create :name=>"Whoever"
+      firm.plain_clients.create name: "Whoever"
     end
 
     assert_equal "You cannot call create unless the parent is saved", error.message
@@ -801,7 +1053,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_create_with_bang_on_has_many_raises_when_record_not_saved
     assert_raise(ActiveRecord::RecordInvalid) do
-      firm = Firm.all.merge!(:order => "id").first
+      firm = Firm.first
       firm.plain_clients.create!
     end
   end
@@ -822,26 +1074,30 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_adding_a_collection
     force_signal37_to_load_all_clients_of_firm
-    companies(:first_firm).clients_of_firm.concat([Client.new("name" => "Natural Company"), Client.new("name" => "Apple")])
+
+    assert_predicate companies(:first_firm).clients_of_firm, :loaded?
+
+    result = companies(:first_firm).clients_of_firm.concat([Client.new("name" => "Natural Company"), Client.new("name" => "Apple")])
     assert_equal 4, companies(:first_firm).clients_of_firm.size
     assert_equal 4, companies(:first_firm).clients_of_firm.reload.size
+    assert_equal companies(:first_firm).clients_of_firm, result
   end
 
   def test_transactions_when_adding_to_persisted
-    good = Client.new(:name => "Good")
-    bad  = Client.new(:name => "Bad", :raise_on_save => true)
+    good = Client.new(name: "Good")
+    bad  = Client.new(name: "Bad", raise_on_save: true)
 
     begin
       companies(:first_firm).clients_of_firm.concat(good, bad)
     rescue Client::RaisedOnSave
     end
 
-    assert !companies(:first_firm).clients_of_firm.reload.include?(good)
+    assert_not_includes companies(:first_firm).clients_of_firm.reload, good
   end
 
   def test_transactions_when_adding_to_new_record
-    assert_no_queries(ignore_none: false) do
-      firm = Firm.new
+    firm = Firm.new
+    assert_queries(0) do
       firm.clients_of_firm.concat(Client.new("name" => "Natural Company"))
     end
   end
@@ -855,21 +1111,23 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_new_aliased_to_build
     company = companies(:first_firm)
-    new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.new("name" => "Another Client") }
-    assert !company.clients_of_firm.loaded?
+
+    new_client = assert_queries(0) { company.clients_of_firm.new("name" => "Another Client") }
+    assert_not_predicate company.clients_of_firm, :loaded?
 
     assert_equal "Another Client", new_client.name
-    assert !new_client.persisted?
+    assert_not_predicate new_client, :persisted?
     assert_equal new_client, company.clients_of_firm.last
   end
 
   def test_build
     company = companies(:first_firm)
-    new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build("name" => "Another Client") }
-    assert !company.clients_of_firm.loaded?
+
+    new_client = assert_queries(0) { company.clients_of_firm.build("name" => "Another Client") }
+    assert_not_predicate company.clients_of_firm, :loaded?
 
     assert_equal "Another Client", new_client.name
-    assert !new_client.persisted?
+    assert_not_predicate new_client, :persisted?
     assert_equal new_client, company.clients_of_firm.last
   end
 
@@ -878,13 +1136,34 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     company.clients_of_firm.build("name" => "Another Client")
     company.clients_of_firm.build("name" => "Yet Another Client")
     assert_equal 4, company.clients_of_firm.size
+    assert_equal 4, company.clients_of_firm.uniq.size
   end
 
   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_with_dirty_target
+    post = posts(:thinking)
+    assert_equal [], post.reader_ids
+    assert_equal 0, post.readers.size
+    post.readers.reset
+    post.readers.build
+    assert_equal [nil], post.reader_ids
+    assert_equal 1, post.readers.size
+  end
+
+  def test_collection_empty_with_dirty_target
+    post = posts(:thinking)
+    assert_equal [], post.reader_ids
+    assert_empty post.readers
+    post.readers.reset
+    post.readers.build
+    assert_equal [nil], post.reader_ids
+    assert_not_empty post.readers
   end
 
   def test_collection_size_twice_for_regressions
@@ -901,24 +1180,24 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_build_many
     company = companies(:first_firm)
-    new_clients = assert_no_queries(ignore_none: false) { company.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) }
+
+    new_clients = assert_queries(0) { company.clients_of_firm.build([{ "name" => "Another Client" }, { "name" => "Another Client II" }]) }
     assert_equal 2, new_clients.size
   end
 
   def test_build_followed_by_save_does_not_load_target
     companies(:first_firm).clients_of_firm.build("name" => "Another Client")
     assert companies(:first_firm).save
-    assert !companies(:first_firm).clients_of_firm.loaded?
+    assert_not_predicate companies(:first_firm).clients_of_firm, :loaded?
   end
 
   def test_build_without_loading_association
     first_topic = topics(:first)
-    Reply.column_names
 
     assert_equal 1, first_topic.replies.length
 
-    assert_no_queries do
-      first_topic.replies.build(:title => "Not saved", :content => "Superstars")
+    assert_queries(0) do
+      first_topic.replies.build(title: "Not saved", content: "Superstars")
       assert_equal 2, first_topic.replies.size
     end
 
@@ -927,18 +1206,20 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_build_via_block
     company = companies(:first_firm)
-    new_client = assert_no_queries(ignore_none: false) { company.clients_of_firm.build {|client| client.name = "Another Client" } }
-    assert !company.clients_of_firm.loaded?
+
+    new_client = assert_queries(0) { company.clients_of_firm.build { |client| client.name = "Another Client" } }
+    assert_not_predicate company.clients_of_firm, :loaded?
 
     assert_equal "Another Client", new_client.name
-    assert !new_client.persisted?
+    assert_not_predicate new_client, :persisted?
     assert_equal new_client, company.clients_of_firm.last
   end
 
   def test_build_many_via_block
     company = companies(:first_firm)
-    new_clients = assert_no_queries(ignore_none: false) do
-      company.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) do |client|
+
+    new_clients = assert_queries(0) do
+      company.clients_of_firm.build([{ "name" => "Another Client" }, { "name" => "Another Client II" }]) do |client|
         client.name = "changed"
       end
     end
@@ -949,15 +1230,13 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_create_without_loading_association
-    first_firm  = companies(:first_firm)
-    Firm.column_names
-    Client.column_names
+    first_firm = companies(:first_firm)
 
     assert_equal 2, first_firm.clients_of_firm.size
     first_firm.clients_of_firm.reset
 
     assert_queries(1) do
-      first_firm.clients_of_firm.create(:name => "Superstars")
+      first_firm.clients_of_firm.create(name: "Superstars")
     end
 
     assert_equal 3, first_firm.clients_of_firm.size
@@ -965,25 +1244,31 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_create
     force_signal37_to_load_all_clients_of_firm
+
+    assert_predicate companies(:first_firm).clients_of_firm, :loaded?
+
     new_client = companies(:first_firm).clients_of_firm.create("name" => "Another Client")
-    assert new_client.persisted?
+    assert_predicate new_client, :persisted?
     assert_equal new_client, companies(:first_firm).clients_of_firm.last
     assert_equal new_client, companies(:first_firm).clients_of_firm.reload.last
   end
 
   def test_create_many
-    companies(:first_firm).clients_of_firm.create([{"name" => "Another Client"}, {"name" => "Another Client II"}])
+    companies(:first_firm).clients_of_firm.create([{ "name" => "Another Client" }, { "name" => "Another Client II" }])
     assert_equal 4, companies(:first_firm).clients_of_firm.reload.size
   end
 
   def test_create_followed_by_save_does_not_load_target
     companies(:first_firm).clients_of_firm.create("name" => "Another Client")
     assert companies(:first_firm).save
-    assert !companies(:first_firm).clients_of_firm.loaded?
+    assert_not_predicate companies(:first_firm).clients_of_firm, :loaded?
   end
 
   def test_deleting
     force_signal37_to_load_all_clients_of_firm
+
+    assert_predicate companies(:first_firm).clients_of_firm, :loaded?
+
     companies(:first_firm).clients_of_firm.delete(companies(:first_firm).clients_of_firm.first)
     assert_equal 1, companies(:first_firm).clients_of_firm.size
     assert_equal 1, companies(:first_firm).clients_of_firm.reload.size
@@ -1000,15 +1285,15 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_has_many_without_counter_cache_option
     # Ship has a conventionally named `treasures_count` column, but the counter_cache
     # option is not given on the association.
-    ship = Ship.create(name: 'Countless', treasures_count: 10)
+    ship = Ship.create!(name: "Countless", treasures_count: 10)
 
-    assert_not Ship.reflect_on_association(:treasures).has_cached_counter?
+    assert_not_predicate Ship.reflect_on_association(:treasures), :has_cached_counter?
 
     # Count should come from sql count() of treasures rather than treasures_count attribute
     assert_equal ship.treasures.size, 0
 
     assert_no_difference lambda { ship.reload.treasures_count }, "treasures_count should not be changed" do
-      ship.treasures.create(name: 'Gold')
+      ship.treasures.create(name: "Gold")
     end
 
     assert_no_difference lambda { ship.reload.treasures_count }, "treasures_count should not be changed" do
@@ -1055,6 +1340,38 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 2, topic.reload.replies.size
   end
 
+  def test_counter_cache_updates_in_memory_after_update_with_inverse_of_disabled
+    topic = Topic.create!(title: "Zoom-zoom-zoom")
+
+    assert_equal 0, topic.replies_count
+
+    reply1 = Reply.create!(title: "re: zoom", content: "speedy quick!")
+    reply2 = Reply.create!(title: "re: zoom 2", content: "OMG lol!")
+
+    assert_queries(4) do
+      topic.replies << [reply1, reply2]
+    end
+
+    assert_equal 2, topic.replies_count
+    assert_equal 2, topic.reload.replies_count
+  end
+
+  def test_counter_cache_updates_in_memory_after_update_with_inverse_of_enabled
+    category = Category.create!(name: "Counter Cache")
+
+    assert_nil category.categorizations_count
+
+    categorization1 = Categorization.create!
+    categorization2 = Categorization.create!
+
+    assert_queries(4) do
+      category.categorizations << [categorization1, categorization2]
+    end
+
+    assert_equal 2, category.categorizations_count
+    assert_equal 2, category.reload.categorizations_count
+  end
+
   def test_pushing_association_updates_counter_cache
     topic = Topic.order("id ASC").first
     reply = Reply.create!
@@ -1092,8 +1409,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_calling_empty_with_counter_cache
     post = posts(:welcome)
-    assert_queries(0) do
-      assert_not post.comments.empty?
+    assert_no_queries do
+      assert_not_empty post.comments
     end
   end
 
@@ -1105,20 +1422,20 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_calling_update_attributes_on_id_changes_the_counter_cache
+  def test_calling_update_on_id_changes_the_counter_cache
     topic = Topic.order("id ASC").first
     original_count = topic.replies.to_a.size
     assert_equal original_count, topic.replies_count
 
     first_reply = topic.replies.first
-    first_reply.update_attributes(:parent_id => nil)
+    first_reply.update(parent_id: nil)
     assert_equal original_count - 1, topic.reload.replies_count
 
-    first_reply.update_attributes(:parent_id => topic.id)
+    first_reply.update(parent_id: topic.id)
     assert_equal original_count, topic.reload.replies_count
   end
 
-  def test_calling_update_attributes_changing_ids_doesnt_change_counter_cache
+  def test_calling_update_changing_ids_doesnt_change_counter_cache
     topic1 = Topic.find(1)
     topic2 = Topic.find(3)
     original_count1 = topic1.replies.to_a.size
@@ -1127,17 +1444,20 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     reply1 = topic1.replies.first
     reply2 = topic2.replies.first
 
-    reply1.update_attributes(:parent_id => topic2.id)
+    reply1.update(parent_id: topic2.id)
     assert_equal original_count1 - 1, topic1.reload.replies_count
     assert_equal original_count2 + 1, topic2.reload.replies_count
 
-    reply2.update_attributes(:parent_id => topic1.id)
+    reply2.update(parent_id: topic1.id)
     assert_equal original_count1, topic1.reload.replies_count
     assert_equal original_count2, topic2.reload.replies_count
   end
 
   def test_deleting_a_collection
     force_signal37_to_load_all_clients_of_firm
+
+    assert_predicate companies(:first_firm).clients_of_firm, :loaded?
+
     companies(:first_firm).clients_of_firm.create("name" => "Another Client")
     assert_equal 3, companies(:first_firm).clients_of_firm.size
     companies(:first_firm).clients_of_firm.delete([companies(:first_firm).clients_of_firm[0], companies(:first_firm).clients_of_firm[1], companies(:first_firm).clients_of_firm[2]])
@@ -1147,17 +1467,23 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_delete_all
     force_signal37_to_load_all_clients_of_firm
+
+    assert_predicate companies(:first_firm).clients_of_firm, :loaded?
+
     companies(:first_firm).dependent_clients_of_firm.create("name" => "Another Client")
     clients = companies(:first_firm).dependent_clients_of_firm.to_a
     assert_equal 3, clients.count
 
     assert_difference "Client.count", -(clients.count) do
-      companies(:first_firm).dependent_clients_of_firm.delete_all
+      assert_equal clients.count, companies(:first_firm).dependent_clients_of_firm.delete_all
     end
   end
 
   def test_delete_all_with_not_yet_loaded_association_collection
     force_signal37_to_load_all_clients_of_firm
+
+    assert_predicate companies(:first_firm).clients_of_firm, :loaded?
+
     companies(:first_firm).clients_of_firm.create("name" => "Another Client")
     assert_equal 3, companies(:first_firm).clients_of_firm.size
     companies(:first_firm).clients_of_firm.reset
@@ -1167,8 +1493,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_transaction_when_deleting_persisted
-    good = Client.new(:name => "Good")
-    bad  = Client.new(:name => "Bad", :raise_on_destroy => true)
+    good = Client.new(name: "Good")
+    bad  = Client.new(name: "Bad", raise_on_destroy: true)
 
     companies(:first_firm).clients_of_firm = [good, bad]
 
@@ -1181,8 +1507,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_transaction_when_deleting_new_record
-    assert_no_queries(ignore_none: false) do
-      firm = Firm.new
+    firm = Firm.new
+    assert_queries(0) do
       client = Client.new("name" => "New Client")
       firm.clients_of_firm << client
       firm.clients_of_firm.destroy(client)
@@ -1209,7 +1535,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_clearing_updates_counter_cache
     topic = Topic.first
 
-    assert_difference 'topic.reload.replies_count', -1 do
+    assert_difference "topic.reload.replies_count", -1 do
       topic.replies.clear
     end
   end
@@ -1218,7 +1544,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     car = Car.first
     car.engines.create!
 
-    assert_difference 'car.reload.engines_count', -1 do
+    assert_difference "car.reload.engines_count", -1 do
       car.engines.clear
     end
   end
@@ -1243,10 +1569,20 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_delete_all_with_option_delete_all
     firm = companies(:first_firm)
     client_id = firm.dependent_clients_of_firm.first.id
-    firm.dependent_clients_of_firm.delete_all(:delete_all)
+    count = firm.dependent_clients_of_firm.count
+    assert_equal count, firm.dependent_clients_of_firm.delete_all(:delete_all)
     assert_nil Client.find_by_id(client_id)
   end
 
+  def test_delete_all_with_option_nullify
+    firm = companies(:first_firm)
+    client_id = firm.dependent_clients_of_firm.first.id
+    count = firm.dependent_clients_of_firm.count
+    assert_equal firm, Client.find(client_id).firm
+    assert_equal count, firm.dependent_clients_of_firm.delete_all(:nullify)
+    assert_nil Client.find(client_id).firm
+  end
+
   def test_delete_all_accepts_limited_parameters
     firm = companies(:first_firm)
     assert_raise(ArgumentError) do
@@ -1276,8 +1612,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_dependent_association_respects_optional_conditions_on_delete
     firm = companies(:odegy)
-    Client.create(:client_of => firm.id, :name => "BigShot Inc.")
-    Client.create(:client_of => firm.id, :name => "SmallTime Inc.")
+    Client.create(client_of: firm.id, name: "BigShot Inc.")
+    Client.create(client_of: firm.id, name: "SmallTime Inc.")
     # only one of two clients is included in the association due to the :conditions key
     assert_equal 2, Client.where(client_of: firm.id).size
     assert_equal 1, firm.dependent_conditional_clients_of_firm.size
@@ -1288,8 +1624,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_dependent_association_respects_optional_sanitized_conditions_on_delete
     firm = companies(:odegy)
-    Client.create(:client_of => firm.id, :name => "BigShot Inc.")
-    Client.create(:client_of => firm.id, :name => "SmallTime Inc.")
+    Client.create(client_of: firm.id, name: "BigShot Inc.")
+    Client.create(client_of: firm.id, name: "SmallTime Inc.")
     # only one of two clients is included in the association due to the :conditions key
     assert_equal 2, Client.where(client_of: firm.id).size
     assert_equal 1, firm.dependent_sanitized_conditional_clients_of_firm.size
@@ -1300,11 +1636,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_dependent_association_respects_optional_hash_conditions_on_delete
     firm = companies(:odegy)
-    Client.create(:client_of => firm.id, :name => "BigShot Inc.")
-    Client.create(:client_of => firm.id, :name => "SmallTime Inc.")
+    Client.create(client_of: firm.id, name: "BigShot Inc.")
+    Client.create(client_of: firm.id, name: "SmallTime Inc.")
     # only one of two clients is included in the association due to the :conditions key
     assert_equal 2, Client.where(client_of: firm.id).size
-    assert_equal 1, firm.dependent_sanitized_conditional_clients_of_firm.size
+    assert_equal 1, firm.dependent_hash_conditional_clients_of_firm.size
     firm.destroy
     # only the correctly associated client should have been deleted
     assert_equal 1, Client.where(client_of: firm.id).size
@@ -1326,13 +1662,13 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_creation_respects_hash_condition
     ms_client = companies(:first_firm).clients_like_ms_with_hash_conditions.build
 
-    assert        ms_client.save
-    assert_equal  'Microsoft', ms_client.name
+    assert ms_client.save
+    assert_equal "Microsoft", ms_client.name
 
     another_ms_client = companies(:first_firm).clients_like_ms_with_hash_conditions.create
 
-    assert        another_ms_client.persisted?
-    assert_equal  'Microsoft', another_ms_client.name
+    assert_predicate another_ms_client, :persisted?
+    assert_equal "Microsoft", another_ms_client.name
   end
 
   def test_clearing_without_initial_access
@@ -1346,7 +1682,10 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_deleting_a_item_which_is_not_in_the_collection
     force_signal37_to_load_all_clients_of_firm
-    summit = Client.find_by_name('Summit')
+
+    assert_predicate companies(:first_firm).clients_of_firm, :loaded?
+
+    summit = Client.find_by_name("Summit")
     companies(:first_firm).clients_of_firm.delete(summit)
     assert_equal 2, companies(:first_firm).clients_of_firm.size
     assert_equal 2, companies(:first_firm).clients_of_firm.reload.size
@@ -1356,7 +1695,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_deleting_by_integer_id
     david = Developer.find(1)
 
-    assert_difference 'david.projects.count', -1 do
+    assert_difference "david.projects.count", -1 do
       assert_equal 1, david.projects.delete(1).size
     end
 
@@ -1366,8 +1705,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_deleting_by_string_id
     david = Developer.find(1)
 
-    assert_difference 'david.projects.count', -1 do
-      assert_equal 1, david.projects.delete('1').size
+    assert_difference "david.projects.count", -1 do
+      assert_equal 1, david.projects.delete("1").size
     end
 
     assert_equal 1, david.projects.size
@@ -1382,6 +1721,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_destroying
     force_signal37_to_load_all_clients_of_firm
 
+    assert_predicate companies(:first_firm).clients_of_firm, :loaded?
+
     assert_difference "Client.count", -1 do
       companies(:first_firm).clients_of_firm.destroy(companies(:first_firm).clients_of_firm.first)
     end
@@ -1393,6 +1734,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_destroying_by_integer_id
     force_signal37_to_load_all_clients_of_firm
 
+    assert_predicate companies(:first_firm).clients_of_firm, :loaded?
+
     assert_difference "Client.count", -1 do
       companies(:first_firm).clients_of_firm.destroy(companies(:first_firm).clients_of_firm.first.id)
     end
@@ -1404,6 +1747,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_destroying_by_string_id
     force_signal37_to_load_all_clients_of_firm
 
+    assert_predicate companies(:first_firm).clients_of_firm, :loaded?
+
     assert_difference "Client.count", -1 do
       companies(:first_firm).clients_of_firm.destroy(companies(:first_firm).clients_of_firm.first.id.to_s)
     end
@@ -1414,6 +1759,9 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_destroying_a_collection
     force_signal37_to_load_all_clients_of_firm
+
+    assert_predicate companies(:first_firm).clients_of_firm, :loaded?
+
     companies(:first_firm).clients_of_firm.create("name" => "Another Client")
     assert_equal 3, companies(:first_firm).clients_of_firm.size
 
@@ -1427,8 +1775,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_destroy_all
     force_signal37_to_load_all_clients_of_firm
+
+    assert_predicate companies(:first_firm).clients_of_firm, :loaded?
+
     clients = companies(:first_firm).clients_of_firm.to_a
-    assert !clients.empty?, "37signals has clients after load"
+    assert_not clients.empty?, "37signals has clients after load"
     destroyed = companies(:first_firm).clients_of_firm.destroy_all
     assert_equal clients.sort_by(&:id), destroyed.sort_by(&:id)
     assert destroyed.all?(&:frozen?), "destroyed clients should be frozen"
@@ -1436,21 +1787,52 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert companies(:first_firm).clients_of_firm.reload.empty?, "37signals has no clients after destroy all and refresh"
   end
 
+  def test_destroy_all_on_association_clears_scope
+    author = Author.create!(name: "Gannon")
+    posts = author.posts
+    posts.create!(title: "test", body: "body")
+    posts.destroy_all
+    assert_nil posts.first
+  end
+
+  def test_destroy_all_on_desynced_counter_cache_association
+    category = categories(:general)
+    assert_operator category.categorizations.count, :>, 0
+
+    category.categorizations.destroy_all
+    assert_equal 0, category.categorizations.count
+  end
+
+  def test_destroy_on_association_clears_scope
+    author = Author.create!(name: "Gannon")
+    posts = author.posts
+    post = posts.create!(title: "test", body: "body")
+    posts.destroy(post)
+    assert_nil posts.first
+  end
+
+  def test_delete_on_association_clears_scope
+    author = Author.create!(name: "Gannon")
+    posts = author.posts
+    post = posts.create!(title: "test", body: "body")
+    posts.delete(post)
+    assert_nil posts.first
+  end
+
   def test_dependence
     firm = companies(:first_firm)
     assert_equal 3, firm.clients.size
     firm.destroy
-    assert 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
     david = authors(:david)
-    assert_difference('Post.count', -1) { assert david.destroy }
+    assert_difference("Post.count", -1) { assert david.destroy }
   end
 
   def test_destroy_dependent_when_deleted_from_association
-    # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
-    firm = Firm.all.merge!(:order => "id").first
+    firm = Firm.first
     assert_equal 3, firm.clients.size
 
     client = firm.clients.first
@@ -1477,7 +1859,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
     firm.destroy rescue "do nothing"
 
-    assert_equal 3, Client.all.merge!(:where => "firm_id=#{firm.id}").to_a.size
+    assert_equal 3, Client.all.merge!(where: "firm_id=#{firm.id}").to_a.size
   end
 
   def test_dependence_on_account
@@ -1491,7 +1873,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
     core = companies(:rails_core)
     assert_equal accounts(:rails_core_account), core.account
-    assert_equal companies(:leetsoft, :jadedpixel), core.companies
+    assert_equal companies(:leetsoft, :jadedpixel).sort_by(&:id), core.companies.sort_by(&:id)
     core.destroy
     assert_nil accounts(:rails_core_account).reload.firm_id
     assert_nil companies(:leetsoft).reload.client_of
@@ -1500,66 +1882,62 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal num_accounts, Account.count
   end
 
-  def test_restrict_with_exception
-    firm = RestrictedWithExceptionFirm.create!(:name => 'restrict')
-    firm.companies.create(:name => 'child')
-
-    assert !firm.companies.empty?
-    assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
-    assert RestrictedWithExceptionFirm.exists?(:name => 'restrict')
-    assert firm.companies.exists?(:name => 'child')
-  end
-
-  def test_restrict_with_error_is_deprecated_using_key_many
-    I18n.backend = I18n::Backend::Simple.new
-    I18n.backend.store_translations :en, activerecord: { errors: { messages: { restrict_dependent_destroy: { many: 'message for deprecated key' } } } }
+  def test_depends_and_nullify_on_polymorphic_assoc
+    author = PersonWithPolymorphicDependentNullifyComments.create!(first_name: "Laertis")
+    comment = posts(:welcome).comments.first
+    comment.author = author
+    comment.save!
 
-    firm = RestrictedWithErrorFirm.create!(name: 'restrict')
-    firm.companies.create(name: 'child')
+    assert_equal comment.author_id, author.id
+    assert_equal comment.author_type, author.class.name
 
-    assert !firm.companies.empty?
+    author.destroy
+    comment.reload
 
-    assert_deprecated { firm.destroy }
+    assert_nil comment.author_id
+    assert_nil comment.author_type
+  end
 
-    assert !firm.errors.empty?
+  def test_restrict_with_exception
+    firm = RestrictedWithExceptionFirm.create!(name: "restrict")
+    firm.companies.create(name: "child")
 
-    assert_equal 'message for deprecated key', firm.errors[:base].first
-    assert RestrictedWithErrorFirm.exists?(name: 'restrict')
-    assert firm.companies.exists?(name: 'child')
-  ensure
-    I18n.backend.reload!
+    assert_not_empty firm.companies
+    assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
+    assert RestrictedWithExceptionFirm.exists?(name: "restrict")
+    assert firm.companies.exists?(name: "child")
   end
 
   def test_restrict_with_error
-    firm = RestrictedWithErrorFirm.create!(:name => 'restrict')
-    firm.companies.create(:name => 'child')
+    firm = RestrictedWithErrorFirm.create!(name: "restrict")
+    firm.companies.create(name: "child")
 
-    assert !firm.companies.empty?
+    assert_not_empty firm.companies
 
     firm.destroy
 
-    assert !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')
-    assert firm.companies.exists?(:name => 'child')
+    assert RestrictedWithErrorFirm.exists?(name: "restrict")
+    assert firm.companies.exists?(name: "child")
   end
 
   def test_restrict_with_error_with_locale
     I18n.backend = I18n::Backend::Simple.new
-    I18n.backend.store_translations 'en', activerecord: {attributes: {restricted_with_error_firm: {companies: 'client companies'}}}
-    firm = RestrictedWithErrorFirm.create!(name: 'restrict')
-    firm.companies.create(name: 'child')
+    I18n.backend.store_translations "en", activerecord: { attributes: { restricted_with_error_firm: { companies: "client companies" } } }
+    firm = RestrictedWithErrorFirm.create!(name: "restrict")
+    firm.companies.create(name: "child")
 
-    assert !firm.companies.empty?
+    assert_not_empty firm.companies
 
     firm.destroy
 
-    assert !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')
-    assert firm.companies.exists?(name: 'child')
+    assert RestrictedWithErrorFirm.exists?(name: "restrict")
+    assert firm.companies.exists?(name: "child")
   ensure
     I18n.backend.reload!
   end
@@ -1569,10 +1947,10 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_included_in_collection_for_new_records
-    client = Client.create(:name => 'Persisted')
+    client = Client.create(name: "Persisted")
     assert_nil client.client_of
     assert_equal false, Firm.new.clients_of_firm.include?(client),
-     'includes a client that does not belong to any firm'
+     "includes a client that does not belong to any firm"
   end
 
   def test_adding_array_and_collection
@@ -1580,7 +1958,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_replace_with_less
-    firm = Firm.all.merge!(:order => "id").first
+    firm = Firm.first
     firm.clients = [companies(:first_client)]
     assert firm.save, "Could not save firm"
     firm.reload
@@ -1594,7 +1972,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_replace_with_new
-    firm = Firm.all.merge!(:order => "id").first
+    firm = Firm.first
     firm.clients = [companies(:second_client), Client.new("name" => "New Client")]
     firm.save
     firm.reload
@@ -1607,8 +1985,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     account = Account.new
     orig_accounts = firm.accounts.to_a
 
-    assert !account.valid?
-    assert !orig_accounts.empty?
+    assert_not_predicate account, :valid?
+    assert_not_empty orig_accounts
     error = assert_raise ActiveRecord::RecordNotSaved do
       firm.accounts = [account]
     end
@@ -1623,16 +2001,16 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm.clients = []
     firm.save
 
-    assert_queries(0, ignore_none: true) do
+    assert_no_queries do
       firm.clients = []
     end
 
-    assert_equal [], firm.send('clients=', [])
+    assert_equal [], firm.public_send("clients=", [])
   end
 
   def test_transactions_when_replacing_on_persisted
-    good = Client.new(:name => "Good")
-    bad  = Client.new(:name => "Bad", :raise_on_save => true)
+    good = Client.new(name: "Good")
+    bad  = Client.new(name: "Bad", raise_on_save: true)
 
     companies(:first_firm).clients_of_firm = [good]
 
@@ -1645,8 +2023,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_transactions_when_replacing_on_new_record
-    assert_no_queries(ignore_none: false) do
-      firm = Firm.new
+    firm = Firm.new
+    assert_queries(0) do
       firm.clients_of_firm = [Client.new("name" => "New Client")]
     end
   end
@@ -1658,7 +2036,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_get_ids_for_loaded_associations
     company = companies(:first_firm)
     company.clients.reload
-    assert_queries(0) do
+    assert_no_queries do
       company.client_ids
       company.client_ids
     end
@@ -1666,9 +2044,29 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_get_ids_for_unloaded_associations_does_not_load_them
     company = companies(:first_firm)
-    assert !company.clients.loaded?
+    assert_not_predicate company.clients, :loaded?
     assert_equal [companies(:first_client).id, companies(:second_client).id, companies(:another_first_firm_client).id], company.client_ids
-    assert !company.clients.loaded?
+    assert_not_predicate company.clients, :loaded?
+  end
+
+  def test_counter_cache_on_unloaded_association
+    car = Car.create(name: "My AppliCar")
+    assert_equal 0, car.engines.size
+  end
+
+  def test_ids_reader_cache_not_used_for_size_when_association_is_dirty
+    firm = Firm.create!(name: "Startup")
+    assert_equal 0, firm.client_ids.size
+    firm.clients.build
+    assert_equal 1, firm.clients.size
+  end
+
+  def test_ids_reader_cache_should_be_cleared_when_collection_is_deleted
+    firm = companies(:first_firm)
+    assert_equal [2, 3, 11], firm.client_ids
+    client = firm.clients.first
+    firm.clients.delete(client)
+    assert_equal [3, 11], firm.client_ids
   end
 
   def test_get_ids_ignores_include_option
@@ -1680,9 +2078,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_get_ids_for_association_on_new_record_does_not_try_to_find_records
-    Company.columns  # Load schema information so we don't query below
-    Contract.columns # if running just this test.
-
     company = Company.new
     assert_queries(0) do
       company.contract_ids
@@ -1695,7 +2090,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     contract_a = Contract.create!
     contract_b = Contract.create!
     Contract.create! # another contract
-    company = Company.new(:name => "Some Company")
+    company = Company.new(name: "Some Company")
 
     company.contract_ids = [contract_a.id, contract_b.id]
     assert_equal [contract_a.id, contract_b.id], company.contract_ids
@@ -1707,8 +2102,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_assign_ids_ignoring_blanks
-    firm = Firm.create!(:name => 'Apple')
-    firm.client_ids = [companies(:first_client).id, nil, companies(:second_client).id, '']
+    firm = Firm.create!(name: "Apple")
+    firm.client_ids = [companies(:first_client).id, nil, companies(:second_client).id, ""]
     firm.save!
 
     assert_equal 2, firm.clients.reload.size
@@ -1723,19 +2118,28 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     [
       lambda { authors(:mary).comment_ids = [comments(:greetings).id, comments(:more_greetings).id] },
       lambda { authors(:mary).comments = [comments(:greetings), comments(:more_greetings)] },
-      lambda { authors(:mary).comments << Comment.create!(:body => "Yay", :post_id => 424242) },
+      lambda { authors(:mary).comments << Comment.create!(body: "Yay", post_id: 424242) },
       lambda { authors(:mary).comments.delete(authors(:mary).comments.first) },
-    ].each {|block| assert_raise(ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection, &block) }
+    ].each { |block| assert_raise(ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection, &block) }
+  end
+
+  def test_associations_order_should_be_priority_over_throughs_order
+    original = authors(:david)
+    expected = [13, 12, 10, 9, 8, 7, 6, 5, 3, 2, 1]
+    assert_equal expected, original.comments_desc.map(&:id)
+    preloaded = Author.includes(:comments_desc).find(original.id)
+    assert_equal expected, preloaded.comments_desc.map(&:id)
+    assert_equal original.posts_sorted_by_id.first.comments.map(&:id), preloaded.posts_sorted_by_id.first.comments.map(&:id)
   end
 
   def test_dynamic_find_should_respect_association_order_for_through
     assert_equal Comment.find(10), authors(:david).comments_desc.where("comments.type = 'SpecialComment'").first
-    assert_equal Comment.find(10), authors(:david).comments_desc.find_by_type('SpecialComment')
+    assert_equal Comment.find(10), authors(:david).comments_desc.find_by_type("SpecialComment")
   end
 
   def test_has_many_through_respects_hash_conditions
-    assert_equal authors(:david).hello_posts, authors(:david).hello_posts_with_hash_conditions
-    assert_equal authors(:david).hello_post_comments, authors(:david).hello_post_comments_with_hash_conditions
+    assert_equal authors(:david).hello_posts.sort_by(&:id), authors(:david).hello_posts_with_hash_conditions.sort_by(&:id)
+    assert_equal authors(:david).hello_post_comments.sort_by(&:id), authors(:david).hello_post_comments_with_hash_conditions.sort_by(&:id)
   end
 
   def test_include_uses_array_include_after_loaded
@@ -1745,7 +2149,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     client = firm.clients.first
 
     assert_no_queries do
-      assert firm.clients.loaded?
+      assert_predicate firm.clients, :loaded?
       assert_equal true, firm.clients.include?(client)
     end
   end
@@ -1755,18 +2159,18 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     client = firm.clients.first
 
     firm.reload
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
     assert_queries(1) do
       assert_equal true, firm.clients.include?(client)
     end
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_include_returns_false_for_non_matching_record_to_verify_scoping
     firm = companies(:first_firm)
-    client = Client.create!(:name => 'Not Associated')
+    client = Client.create!(name: "Not Associated")
 
-    assert ! firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
     assert_equal false, firm.clients.include?(client)
   end
 
@@ -1775,15 +2179,15 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     firm.clients.first
     firm.clients.second
     firm.clients.last
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_first_or_last_on_loaded_association_should_not_fetch_with_query
     firm = companies(:first_firm)
     firm.clients.load_target
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
 
-    assert_no_queries(ignore_none: false) do
+    assert_no_queries do
       firm.clients.first
       assert_equal 2, firm.clients.first(2).size
       firm.clients.last
@@ -1791,10 +2195,10 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_calling_first_or_last_on_existing_record_with_build_should_load_association
+  def test_calling_first_nth_or_last_on_existing_record_with_build_should_load_association
     firm = companies(:first_firm)
-    firm.clients.build(:name => 'Foo')
-    assert !firm.clients.loaded?
+    firm.clients.build(name: "Foo")
+    assert_not_predicate firm.clients, :loaded?
 
     assert_queries 1 do
       firm.clients.first
@@ -1802,13 +2206,31 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       firm.clients.last
     end
 
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
+
+    author = Author.create!(name: "Carl")
+    third  = topics(:third)
+    fourth = topics(:fourth).becomes(Topic)
+
+    new_topic = author.topics_without_type.build
+
+    assert_not_predicate author.topics_without_type, :loaded?
+
+    assert_queries(1) do
+      if current_adapter?(:Mysql2Adapter, :SQLite3Adapter)
+        assert_equal fourth, author.topics_without_type.first
+        assert_equal third, author.topics_without_type.second
+      end
+      assert_equal new_topic, author.topics_without_type.last
+    end
+
+    assert_predicate author.topics_without_type, :loaded?
   end
 
   def test_calling_first_nth_or_last_on_existing_record_with_create_should_not_load_association
     firm = companies(:first_firm)
-    firm.clients.create(:name => 'Foo')
-    assert !firm.clients.loaded?
+    firm.clients.create(name: "Foo")
+    assert_not_predicate firm.clients, :loaded?
 
     assert_queries 3 do
       firm.clients.first
@@ -1816,7 +2238,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       firm.clients.last
     end
 
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_first_nth_or_last_on_new_record_should_not_run_queries
@@ -1831,15 +2253,15 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_calling_first_or_last_with_integer_on_association_should_not_load_association
     firm = companies(:first_firm)
-    firm.clients.create(:name => 'Foo')
-    assert !firm.clients.loaded?
+    firm.clients.create(name: "Foo")
+    assert_not_predicate firm.clients, :loaded?
 
     assert_queries 2 do
       firm.clients.first(2)
       firm.clients.last(2)
     end
 
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_many_should_count_instead_of_loading_association
@@ -1847,37 +2269,38 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_queries(1) do
       firm.clients.many?  # use count query
     end
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_many_on_loaded_association_should_not_use_query
     firm = companies(:first_firm)
-    firm.clients.collect  # force load
+    firm.clients.load  # force load
     assert_no_queries { assert firm.clients.many? }
   end
 
   def test_calling_many_should_defer_to_collection_if_using_a_block
     firm = companies(:first_firm)
     assert_queries(1) do
-      firm.clients.expects(:size).never
-      firm.clients.many? { true }
+      assert_not_called(firm.clients, :size) do
+        firm.clients.many? { true }
+      end
     end
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
   end
 
   def test_calling_many_should_return_false_if_none_or_one
     firm = companies(:another_firm)
-    assert !firm.clients_like_ms.many?
+    assert_not_predicate firm.clients_like_ms, :many?
     assert_equal 0, firm.clients_like_ms.size
 
     firm = companies(:first_firm)
-    assert !firm.limited_clients.many?
+    assert_not_predicate firm.limited_clients, :many?
     assert_equal 1, firm.limited_clients.size
   end
 
   def test_calling_many_should_return_true_if_more_than_one
     firm = companies(:first_firm)
-    assert firm.clients.many?
+    assert_predicate firm.clients, :many?
     assert_equal 3, firm.clients.size
   end
 
@@ -1886,33 +2309,34 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_queries(1) do
       firm.clients.none?  # use count query
     end
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_none_on_loaded_association_should_not_use_query
     firm = companies(:first_firm)
-    firm.clients.collect  # force load
-    assert_no_queries { assert ! firm.clients.none? }
+    firm.clients.load  # force load
+    assert_no_queries { assert_not firm.clients.none? }
   end
 
   def test_calling_none_should_defer_to_collection_if_using_a_block
     firm = companies(:first_firm)
     assert_queries(1) do
-      firm.clients.expects(:size).never
-      firm.clients.none? { true }
+      assert_not_called(firm.clients, :size) do
+        firm.clients.none? { true }
+      end
     end
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
   end
 
   def test_calling_none_should_return_true_if_none
     firm = companies(:another_firm)
-    assert firm.clients_like_ms.none?
+    assert_predicate firm.clients_like_ms, :none?
     assert_equal 0, firm.clients_like_ms.size
   end
 
   def test_calling_none_should_return_false_if_any
     firm = companies(:first_firm)
-    assert !firm.limited_clients.none?
+    assert_not_predicate firm.limited_clients, :none?
     assert_equal 1, firm.limited_clients.size
   end
 
@@ -1921,39 +2345,40 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_queries(1) do
       firm.clients.one?  # use count query
     end
-    assert !firm.clients.loaded?
+    assert_not_predicate firm.clients, :loaded?
   end
 
   def test_calling_one_on_loaded_association_should_not_use_query
     firm = companies(:first_firm)
-    firm.clients.collect  # force load
-    assert_no_queries { assert ! firm.clients.one? }
+    firm.clients.load  # force load
+    assert_no_queries { assert_not firm.clients.one? }
   end
 
   def test_calling_one_should_defer_to_collection_if_using_a_block
     firm = companies(:first_firm)
     assert_queries(1) do
-      firm.clients.expects(:size).never
-      firm.clients.one? { true }
+      assert_not_called(firm.clients, :size) do
+        firm.clients.one? { true }
+      end
     end
-    assert firm.clients.loaded?
+    assert_predicate firm.clients, :loaded?
   end
 
   def test_calling_one_should_return_false_if_zero
     firm = companies(:another_firm)
-    assert ! firm.clients_like_ms.one?
+    assert_not_predicate firm.clients_like_ms, :one?
     assert_equal 0, firm.clients_like_ms.size
   end
 
   def test_calling_one_should_return_true_if_one
     firm = companies(:first_firm)
-    assert firm.limited_clients.one?
+    assert_predicate firm.limited_clients, :one?
     assert_equal 1, firm.limited_clients.size
   end
 
   def test_calling_one_should_return_false_if_more_than_one
     firm = companies(:first_firm)
-    assert ! firm.clients.one?
+    assert_not_predicate firm.clients, :one?
     assert_equal 3, firm.clients.size
   end
 
@@ -1961,13 +2386,13 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     old = ActiveRecord::Base.store_full_sti_class
     ActiveRecord::Base.store_full_sti_class = true
 
-    firm = Namespaced::Firm.create({ :name => 'Some Company' })
-    firm.clients.create({ :name => 'Some Client' })
+    firm = Namespaced::Firm.create(name: "Some Company")
+    firm.clients.create(name: "Some Client")
 
     stats = Namespaced::Firm.all.merge!(
-      :select => "#{Namespaced::Firm.table_name}.id, COUNT(#{Namespaced::Client.table_name}.id) AS num_clients",
-      :joins  => :clients,
-      :group  => "#{Namespaced::Firm.table_name}.id"
+      select: "#{Namespaced::Firm.table_name}.id, COUNT(#{Namespaced::Client.table_name}.id) AS num_clients",
+      joins: :clients,
+      group: "#{Namespaced::Firm.table_name}.id"
     ).find firm.id
     assert_equal 1, stats.num_clients.to_i
   ensure
@@ -1975,9 +2400,10 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_association_proxy_transaction_method_starts_transaction_in_association_class
-    Comment.expects(:transaction)
-    Post.first.comments.transaction do
-      # nothing
+    assert_called(Comment, :transaction) do
+      Post.first.comments.transaction do
+        # nothing
+      end
     end
   end
 
@@ -1986,43 +2412,45 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal client_association.new.attributes, client_association.send(:new).attributes
   end
 
-  def test_respond_to_private_class_methods
-    client_association = companies(:first_firm).clients
-    assert !client_association.respond_to?(:private_method)
-    assert client_association.respond_to?(:private_method, true)
-  end
-
   def test_creating_using_primary_key
-    firm = Firm.all.merge!(:order => "id").first
-    client = firm.clients_using_primary_key.create!(:name => 'test')
+    firm = Firm.first
+    client = firm.clients_using_primary_key.create!(name: "test")
     assert_equal firm.name, client.firm_name
   end
 
   def test_defining_has_many_association_with_delete_all_dependency_lazily_evaluates_target_class
-    ActiveRecord::Reflection::AssociationReflection.any_instance.expects(:class_name).never
-    class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-      class DeleteAllModel < ActiveRecord::Base
-        has_many :nonentities, :dependent => :delete_all
-      end
-    EOF
+    assert_not_called_on_instance_of(
+      ActiveRecord::Reflection::AssociationReflection,
+      :class_name,
+    ) do
+      class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        class DeleteAllModel < ActiveRecord::Base
+          has_many :nonentities, :dependent => :delete_all
+        end
+      EOF
+    end
   end
 
   def test_defining_has_many_association_with_nullify_dependency_lazily_evaluates_target_class
-    ActiveRecord::Reflection::AssociationReflection.any_instance.expects(:class_name).never
-    class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-      class NullifyModel < ActiveRecord::Base
-        has_many :nonentities, :dependent => :nullify
-      end
-    EOF
+    assert_not_called_on_instance_of(
+      ActiveRecord::Reflection::AssociationReflection,
+      :class_name,
+    ) do
+      class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        class NullifyModel < ActiveRecord::Base
+          has_many :nonentities, :dependent => :nullify
+        end
+      EOF
+    end
   end
 
   def test_attributes_are_being_set_when_initialized_from_has_many_association_with_where_clause
-    new_comment = posts(:welcome).comments.where(:body => "Some content").build
+    new_comment = posts(:welcome).comments.where(body: "Some content").build
     assert_equal new_comment.body, "Some content"
   end
 
   def test_attributes_are_being_set_when_initialized_from_has_many_association_with_multiple_where_clauses
-    new_comment = posts(:welcome).comments.where(:body => "Some content").where(:type => 'SpecialComment').build
+    new_comment = posts(:welcome).comments.where(body: "Some content").where(type: "SpecialComment").build
     assert_equal new_comment.body, "Some content"
     assert_equal new_comment.type, "SpecialComment"
     assert_equal new_comment.post_id, posts(:welcome).id
@@ -2036,7 +2464,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_load_target_respects_protected_attributes
     topic = Topic.create!
-    reply = topic.replies.create(:title => "reply 1")
+    reply = topic.replies.create(title: "reply 1")
     reply.approved = false
     reply.save!
 
@@ -2059,11 +2487,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     ary    = topics(:first).replies.to_a
     target = topics(:first).replies.target
 
-    assert_not_equal target.object_id, ary.object_id
+    assert_not_same target, ary
   end
 
   def test_merging_with_custom_attribute_writer
-    bulb = Bulb.new(:color => "red")
+    bulb = Bulb.new(color: "red")
     assert_equal "RED!", bulb.color
 
     car = Car.create!
@@ -2073,26 +2501,34 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_abstract_class_with_polymorphic_has_many
-    post = SubStiPost.create! :title => "fooo", :body => "baa"
-    tagging = Tagging.create! :taggable => post
+    post = SubStiPost.create! title: "fooo", body: "baa"
+    tagging = Tagging.create! taggable: post
     assert_equal [tagging], post.taggings
   end
 
   def test_with_polymorphic_has_many_with_custom_columns_name
-    post = Post.create! :title => 'foo', :body => 'bar'
+    post = Post.create! title: "foo", body: "bar"
     image = Image.create!
 
     post.images << image
 
     assert_equal [image], post.images
+    assert_equal post, image.imageable
   end
 
   def test_build_with_polymorphic_has_many_does_not_allow_to_override_type_and_id
     welcome = posts(:welcome)
-    tagging = welcome.taggings.build(:taggable_id => 99, :taggable_type => 'ShouldNotChange')
+    tagging = welcome.taggings.build(taggable_id: 99, taggable_type: "ShouldNotChange")
 
     assert_equal welcome.id, tagging.taggable_id
-    assert_equal 'Post', tagging.taggable_type
+    assert_equal "Post", tagging.taggable_type
+  end
+
+  def test_build_from_polymorphic_association_sets_inverse_instance
+    post = Post.new
+    tagging = post.taggings.build
+
+    assert_equal post, tagging.taggable
   end
 
   def test_dont_call_save_callbacks_twice_on_has_many
@@ -2104,30 +2540,30 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_association_attributes_are_available_to_after_initialize
-    car = Car.create(:name => 'honda')
+    car = Car.create(name: "honda")
     bulb = car.bulbs.build
 
-    assert_equal car.id, bulb.attributes_after_initialize['car_id']
+    assert_equal car.id, bulb.attributes_after_initialize["car_id"]
   end
 
   def test_attributes_are_set_when_initialized_from_has_many_null_relationship
-    car  = Car.new name: 'honda'
-    bulb = car.bulbs.where(name: 'headlight').first_or_initialize
-    assert_equal 'headlight', bulb.name
+    car  = Car.new name: "honda"
+    bulb = car.bulbs.where(name: "headlight").first_or_initialize
+    assert_equal "headlight", bulb.name
   end
 
   def test_attributes_are_set_when_initialized_from_polymorphic_has_many_null_relationship
-    post    = Post.new title: 'title', body: 'bar'
-    tag     = Tag.create!(name: 'foo')
+    post    = Post.new title: "title", body: "bar"
+    tag     = Tag.create!(name: "foo")
 
     tagging = post.taggings.where(tag: tag).first_or_initialize
 
     assert_equal tag.id, tagging.tag_id
-    assert_equal 'Post', tagging.taggable_type
+    assert_equal "Post", tagging.taggable_type
   end
 
   def test_replace
-    car = Car.create(:name => 'honda')
+    car = Car.create(name: "honda")
     bulb1 = car.bulbs.create
     bulb2 = Bulb.create
 
@@ -2138,7 +2574,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_replace_returns_target
-    car = Car.create(:name => 'honda')
+    car = Car.create(name: "honda")
     bulb1 = car.bulbs.create
     bulb2 = car.bulbs.create
     bulb3 = Bulb.create
@@ -2152,18 +2588,48 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_collection_association_with_private_kernel_method
     firm = companies(:first_firm)
     assert_equal [accounts(:signals37)], firm.accounts.open
+    assert_equal [accounts(:signals37)], firm.accounts.available
+  end
+
+  def test_association_with_or_doesnt_set_inverse_instance_key
+    firm = companies(:first_firm)
+    accounts = firm.accounts.or(Account.where(firm_id: nil)).order(:id)
+    assert_equal [firm.id, nil], accounts.map(&:firm_id)
+  end
+
+  def test_association_with_rewhere_doesnt_set_inverse_instance_key
+    firm = companies(:first_firm)
+    accounts = firm.accounts.rewhere(firm_id: [firm.id, nil]).order(:id)
+    assert_equal [firm.id, nil], accounts.map(&:firm_id)
   end
 
   test "first_or_initialize adds the record to the association" do
-    firm = Firm.create! name: 'omg'
-    client = firm.clients_of_firm.first_or_initialize
+    firm = Firm.create! name: "omg"
+    client = firm.clients_of_firm.where(name: "lol").first_or_initialize do
+      assert_equal 5, Client.count
+    end
+    assert_equal "lol", client.name
     assert_equal [client], firm.clients_of_firm
   end
 
   test "first_or_create adds the record to the association" do
-    firm = Firm.create! name: 'omg'
+    firm = Firm.create! name: "omg"
+    firm.clients_of_firm.load_target
+    client = firm.clients_of_firm.where(name: "lol").first_or_create do
+      assert_equal 5, Client.count
+    end
+    assert_equal "lol", client.name
+    assert_equal [client], firm.clients_of_firm
+    assert_equal [client], firm.reload.clients_of_firm
+  end
+
+  test "first_or_create! adds the record to the association" do
+    firm = Firm.create! name: "omg"
     firm.clients_of_firm.load_target
-    client = firm.clients_of_firm.first_or_create name: 'lol'
+    client = firm.clients_of_firm.where(name: "lol").first_or_create! do
+      assert_equal 5, Client.count
+    end
+    assert_equal "lol", client.name
     assert_equal [client], firm.clients_of_firm
     assert_equal [client], firm.reload.clients_of_firm
   end
@@ -2172,7 +2638,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     post = posts(:welcome)
 
     assert post.taggings_with_delete_all.count > 0
-    assert !post.taggings_with_delete_all.loaded?
+    assert_not_predicate post.taggings_with_delete_all, :loaded?
 
     # 2 queries: one DELETE and another to update the counter cache
     assert_queries(2) do
@@ -2183,9 +2649,9 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   test "has many associations on new records use null relations" do
     post = Post.new
 
-    assert_no_queries(ignore_none: false) do
+    assert_no_queries do
       assert_equal [], post.comments
-      assert_equal [], post.comments.where(body: 'omg')
+      assert_equal [], post.comments.where(body: "omg")
       assert_equal [], post.comments.pluck(:body)
       assert_equal 0,  post.comments.sum(:id)
       assert_equal 0,  post.comments.count
@@ -2194,34 +2660,34 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   test "collection proxy respects default scope" do
     author = authors(:mary)
-    assert !author.first_posts.exists?
+    assert_not_predicate author.first_posts, :exists?
   end
 
   test "association with extend option" do
     post = posts(:welcome)
-    assert_equal "lifo",  post.comments_with_extend.author
-    assert_equal "hello", post.comments_with_extend.greeting
+    assert_equal "lifo", post.comments_with_extend.author
+    assert_equal "hello :)", post.comments_with_extend.greeting
   end
 
   test "association with extend option with multiple extensions" do
     post = posts(:welcome)
-    assert_equal "lifo",  post.comments_with_extend_2.author
-    assert_equal "hullo", post.comments_with_extend_2.greeting
+    assert_equal "lifo", post.comments_with_extend_2.author
+    assert_equal "hullo :)", post.comments_with_extend_2.greeting
   end
 
   test "extend option affects per association" do
     post = posts(:welcome)
-    assert_equal "lifo",  post.comments_with_extend.author
-    assert_equal "lifo",  post.comments_with_extend_2.author
-    assert_equal "hello", post.comments_with_extend.greeting
-    assert_equal "hullo", post.comments_with_extend_2.greeting
+    assert_equal "lifo", post.comments_with_extend.author
+    assert_equal "lifo", post.comments_with_extend_2.author
+    assert_equal "hello :)", post.comments_with_extend.greeting
+    assert_equal "hullo :)", post.comments_with_extend_2.greeting
   end
 
   test "delete record with complex joins" do
     david = authors(:david)
 
     post = david.posts.first
-    post.type = 'PostWithSpecialCategorization'
+    post.type = "PostWithSpecialCategorization"
     post.save
 
     categorization = post.categorizations.first
@@ -2234,8 +2700,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   test "does not duplicate associations when used with natural primary keys" do
-    speedometer = Speedometer.create!(id: '4')
-    speedometer.minivans.create!(minivan_id: 'a-van-red' ,name: 'a van', color: 'red')
+    speedometer = Speedometer.create!(id: "4")
+    speedometer.minivans.create!(minivan_id: "a-van-red", name: "a van", color: "red")
 
     assert_equal 1, speedometer.minivans.to_a.size, "Only one association should be present:\n#{speedometer.minivans.to_a}"
     assert_equal 1, speedometer.reload.minivans.to_a.size
@@ -2248,10 +2714,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
     assert_equal [bulb1], car.bulbs
     assert_equal [bulb1, bulb2], car.all_bulbs.sort_by(&:id)
+    assert_equal [bulb1, bulb2], Car.includes(:all_bulbs).find(car.id).all_bulbs.sort_by(&:id)
+    assert_equal [bulb1, bulb2], Car.eager_load(:all_bulbs).find(car.id).all_bulbs.sort_by(&:id)
   end
 
   test "can unscope and where the default scope of the associated model" do
-    Car.has_many :other_bulbs, -> { unscope(where: [:name]).where(name: 'other') }, class_name: "Bulb"
     car = Car.create!
     bulb1 = Bulb.create! name: "defaulty", car: car
     bulb2 = Bulb.create! name: "other",    car: car
@@ -2261,7 +2728,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   test "can rewhere the default scope of the associated model" do
-    Car.has_many :old_bulbs, -> { rewhere(name: 'old') }, class_name: "Bulb"
     car = Car.create!
     bulb1 = Bulb.create! name: "defaulty", car: car
     bulb2 = Bulb.create! name: "old",      car: car
@@ -2270,13 +2736,13 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal [bulb2], car.old_bulbs
   end
 
-  test 'unscopes the default scope of associated model when used with include' do
+  test "unscopes the default scope of associated model when used with include" do
     car = Car.create!
-    bulb = Bulb.create! name: "other", car: car
+    bulb1 = Bulb.create! name: "defaulty", car: car
+    bulb2 = Bulb.create! name: "other",    car: car
 
-    assert_equal [bulb], Car.find(car.id).all_bulbs
-    assert_equal [bulb], Car.includes(:all_bulbs).find(car.id).all_bulbs
-    assert_equal [bulb], Car.eager_load(:all_bulbs).find(car.id).all_bulbs
+    assert_equal [bulb1, bulb2], Car.includes(:all_bulbs2).find(car.id).all_bulbs2.sort_by(&:id)
+    assert_equal [bulb1, bulb2], Car.eager_load(:all_bulbs2).find(car.id).all_bulbs2.sort_by(&:id)
   end
 
   test "raises RecordNotDestroyed when replaced child can't be destroyed" do
@@ -2291,7 +2757,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal "Failed to destroy the record", error.message
   end
 
-  test 'updates counter cache when default scope is given' do
+  test "updates counter cache when default scope is given" do
     topic = DefaultRejectedTopic.create approved: true
 
     assert_difference "topic.reload.replies_count", 1 do
@@ -2299,8 +2765,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'dangerous association name raises ArgumentError' do
-    [:errors, 'errors', :save, 'save'].each do |name|
+  test "dangerous association name raises ArgumentError" do
+    [:errors, "errors", :save, "save"].each do |name|
       assert_raises(ArgumentError, "Association #{name} should not be allowed") do
         Class.new(ActiveRecord::Base) do
           has_many name
@@ -2309,16 +2775,16 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'passes custom context validation to validate children' do
+  test "passes custom context validation to validate children" do
     pirate = FamousPirate.new
     pirate.famous_ships << ship = FamousShip.new
 
-    assert pirate.valid?
+    assert_predicate pirate, :valid?
     assert_not pirate.valid?(:conference)
     assert_equal "can't be blank", ship.errors[:name].first
   end
 
-  test 'association with instance dependent scope' do
+  test "association with instance dependent scope" do
     bob = authors(:bob)
     Post.create!(title: "signed post by bob", body: "stuff", author: authors(:bob))
     Post.create!(title: "anonymous post", body: "more stuff", author: authors(:bob))
@@ -2328,22 +2794,26 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal [], authors(:david).posts_with_signature.map(&:title)
   end
 
-  test 'associations autosaves when object is already persisted' do
+  test "associations autosaves when object is already persisted" do
     bulb = Bulb.create!
     tyre = Tyre.create!
 
-    car = Car.create! do |c|
+    car = Car.create!(name: "honda") do |c|
       c.bulbs << bulb
       c.tyres << tyre
     end
 
+    assert_equal [nil, "honda"], car.saved_change_to_name
+
     assert_equal 1, car.bulbs.count
     assert_equal 1, car.tyres.count
   end
 
-  test 'associations replace in memory when records have the same id' do
+  test "associations replace in memory when records have the same id" do
     bulb = Bulb.create!
-    car = Car.create!(bulbs: [bulb])
+    car = Car.create!(name: "honda", bulbs: [bulb])
+
+    assert_equal [nil, "honda"], car.saved_change_to_name
 
     new_bulb = Bulb.find(bulb.id)
     new_bulb.name = "foo"
@@ -2352,9 +2822,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal "foo", car.bulbs.first.name
   end
 
-  test 'in memory replacement executes no queries' do
+  test "in memory replacement executes no queries" do
     bulb = Bulb.create!
-    car = Car.create!(bulbs: [bulb])
+    car = Car.create!(name: "honda", bulbs: [bulb])
+
+    assert_equal [nil, "honda"], car.saved_change_to_name
 
     new_bulb = Bulb.find(bulb.id)
 
@@ -2363,7 +2835,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'in memory replacements do not execute callbacks' do
+  test "in memory replacements do not execute callbacks" do
     raise_after_add = false
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = :cars
@@ -2384,9 +2856,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'in memory replacements sets inverse instance' do
+  test "in memory replacements sets inverse instance" do
     bulb = Bulb.create!
-    car = Car.create!(bulbs: [bulb])
+    car = Car.create!(name: "honda", bulbs: [bulb])
+
+    assert_equal [nil, "honda"], car.saved_change_to_name
 
     new_bulb = Bulb.find(bulb.id)
     car.bulbs = [new_bulb]
@@ -2394,10 +2868,21 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_same car, new_bulb.car
   end
 
-  test 'in memory replacement maintains order' do
+  test "reattach to new objects replaces inverse association and foreign key" do
+    bulb = Bulb.create!(car: Car.create!)
+    assert bulb.car_id
+    car = Car.new
+    car.bulbs << bulb
+    assert_equal car, bulb.car
+    assert_nil bulb.car_id
+  end
+
+  test "in memory replacement maintains order" do
     first_bulb = Bulb.create!
     second_bulb = Bulb.create!
-    car = Car.create!(bulbs: [first_bulb, second_bulb])
+    car = Car.create!(name: "honda", bulbs: [first_bulb, second_bulb])
+
+    assert_equal [nil, "honda"], car.saved_change_to_name
 
     same_bulb = Bulb.find(first_bulb.id)
     car.bulbs = [second_bulb, same_bulb]
@@ -2405,8 +2890,16 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal [first_bulb, second_bulb], car.bulbs
   end
 
+  test "association size calculation works with default scoped selects when not previously fetched" do
+    firm = Firm.create!(name: "Firm")
+    5.times { firm.developers_with_select << Developer.create!(name: "Developer") }
+
+    same_firm = Firm.find(firm.id)
+    assert_equal 5, same_firm.developers_with_select.size
+  end
+
   test "prevent double insertion of new object when the parent association loaded in the after save callback" do
-    reset_callbacks(:save, Bulb) do
+    reset_callbacks(Bulb, :save) do
       Bulb.after_save { |record| record.car.bulbs.load }
 
       car = Car.create!
@@ -2417,7 +2910,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   test "prevent double firing the before save callback of new object when the parent association saved in the callback" do
-    reset_callbacks(:save, Bulb) do
+    reset_callbacks(Bulb, :save) do
       count = 0
       Bulb.before_save { |record| record.car.save && count += 1 }
 
@@ -2428,10 +2921,68 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_association_force_reload_with_only_true_is_deprecated
-    company = Company.find(1)
+  test "calling size on an association that has not been loaded performs a query" do
+    car = Car.create!
+    Bulb.create(car_id: car.id)
+
+    car_two = Car.create!
+
+    assert_queries(1) do
+      assert_equal 1, car.bulbs.size
+    end
 
-    assert_deprecated { company.clients_of_firm(true) }
+    assert_queries(1) do
+      assert_equal 0, car_two.bulbs.size
+    end
+  end
+
+  test "calling size on an association that has been loaded does not perform query" do
+    car = Car.create!
+    Bulb.create(car_id: car.id)
+    car.bulb_ids
+
+    car_two = Car.create!
+    car_two.bulb_ids
+
+    assert_no_queries do
+      assert_equal 1, car.bulbs.size
+    end
+
+    assert_no_queries do
+      assert_equal 0, car_two.bulbs.size
+    end
+  end
+
+  test "calling empty on an association that has not been loaded performs a query" do
+    car = Car.create!
+    Bulb.create(car_id: car.id)
+
+    car_two = Car.create!
+
+    assert_queries(1) do
+      assert_not_empty car.bulbs
+    end
+
+    assert_queries(1) do
+      assert_empty car_two.bulbs
+    end
+  end
+
+  test "calling empty on an association that has been loaded does not performs query" do
+    car = Car.create!
+    Bulb.create(car_id: car.id)
+    car.bulb_ids
+
+    car_two = Car.create!
+    car_two.bulb_ids
+
+    assert_no_queries do
+      assert_not_empty car.bulbs
+    end
+
+    assert_no_queries do
+      assert_empty car_two.bulbs
+    end
   end
 
   class AuthorWithErrorDestroyingAssociation < ActiveRecord::Base
@@ -2465,15 +3016,20 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_ids_reader_memoization
-    car = Car.create!(name: 'Tofaş')
+    car = Car.create!(name: "Tofaş")
     bulb = Bulb.create!(car: car)
 
     assert_equal [bulb.id], car.bulb_ids
     assert_no_queries { car.bulb_ids }
+
+    bulb2 = car.bulbs.create!
+
+    assert_equal [bulb.id, bulb2.id], car.bulb_ids
+    assert_no_queries { car.bulb_ids }
   end
 
   def test_loading_association_in_validate_callback_doesnt_affect_persistence
-    reset_callbacks(:validation, Bulb) do
+    reset_callbacks(Bulb, :validation) do
       Bulb.after_validation { |record| record.car.bulbs.load }
 
       car = Car.create!(name: "Car")
@@ -2483,19 +3039,36 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  private
-
-    def reset_callbacks(kind, klass)
-      old_callbacks = {}
-      old_callbacks[klass] = klass.send("_#{kind}_callbacks").dup
-      klass.subclasses.each do |subclass|
-        old_callbacks[subclass] = subclass.send("_#{kind}_callbacks").dup
-      end
-      yield
-    ensure
-      klass.send("_#{kind}_callbacks=", old_callbacks[klass])
-      klass.subclasses.each do |subclass|
-        subclass.send("_#{kind}_callbacks=", old_callbacks[subclass])
+  def test_create_children_could_be_rolled_back_by_after_save
+    firm = Firm.create!(name: "A New Firm, Inc")
+    assert_no_difference "Client.count" do
+      client = firm.clients.create(name: "New Client") do |cli|
+        cli.rollback_on_save = true
+        assert_not cli.rollback_on_create_called
       end
+      assert client.rollback_on_create_called
+    end
+  end
+
+  def test_has_many_with_out_of_range_value
+    reference = Reference.create!(id: 2147483648) # out of range in the integer
+    assert_equal [], reference.ideal_jobs
+  end
+
+  def test_has_many_preloading_with_duplicate_records
+    posts = Post.joins(:comments).preload(:comments).order(:id).to_a
+    assert_equal [1, 2], posts.first.comments.map(&:id).sort
+  end
+
+  def test_has_many_association_with_same_foreign_key_name
+    assert_nothing_raised do
+      firm = Firm.find(15)
+      assert_not_nil(firm.comments.first)
+    end
+  end
+
+  private
+    def force_signal37_to_load_all_clients_of_firm
+      companies(:first_firm).clients_of_firm.load_target
     end
 end