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

data/test/cases/associations/belongs_to_associations_test.rb

@@ -1,38 +1,77 @@
-require 'cases/helper'
-require 'models/developer'
-require 'models/project'
-require 'models/company'
-require 'models/topic'
-require 'models/reply'
-require 'models/computer'
-require 'models/post'
-require 'models/author'
-require 'models/tag'
-require 'models/tagging'
-require 'models/comment'
-require 'models/sponsor'
-require 'models/member'
-require 'models/essay'
-require 'models/toy'
-require 'models/invoice'
-require 'models/line_item'
-require 'models/column'
-require 'models/record'
-require 'models/admin'
-require 'models/admin/user'
-require 'models/ship'
-require 'models/treasure'
-require 'models/parrot'
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/developer"
+require "models/project"
+require "models/company"
+require "models/topic"
+require "models/reply"
+require "models/computer"
+require "models/post"
+require "models/author"
+require "models/tag"
+require "models/tagging"
+require "models/comment"
+require "models/sponsor"
+require "models/member"
+require "models/essay"
+require "models/toy"
+require "models/invoice"
+require "models/line_item"
+require "models/column"
+require "models/record"
+require "models/admin"
+require "models/admin/user"
+require "models/ship"
+require "models/treasure"
+require "models/parrot"
+require "models/book"
+require "models/citation"
 
 class BelongsToAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :developers, :projects, :topics,
            :developers_projects, :computers, :authors, :author_addresses,
-           :posts, :tags, :taggings, :comments, :sponsors, :members
+           :essays, :posts, :tags, :taggings, :comments, :sponsors, :members
 
   def test_belongs_to
-    firm = Client.find(3).firm
-    assert_not_nil firm
-    assert_equal companies(:first_firm).name, firm.name
+    client = Client.find(3)
+    first_firm = companies(:first_firm)
+    assert_sql(/LIMIT|ROWNUM <=|FETCH FIRST/) do
+      assert_equal first_firm, client.firm
+      assert_equal first_firm.name, client.firm.name
+    end
+  end
+
+  def test_where_with_custom_primary_key
+    assert_equal [authors(:david)], Author.where(owned_essay: essays(:david_modest_proposal))
+  end
+
+  def test_find_by_with_custom_primary_key
+    assert_equal authors(:david), Author.find_by(owned_essay: essays(:david_modest_proposal))
+  end
+
+  def test_where_on_polymorphic_association_with_nil
+    assert_equal comments(:greetings), Comment.where(author: nil).first
+    assert_equal comments(:greetings), Comment.where(author: [nil]).first
+  end
+
+  def test_where_on_polymorphic_association_with_empty_array
+    assert_empty Comment.where(author: [])
+  end
+
+  def test_assigning_belongs_to_on_destroyed_object
+    client = Client.create!(name: "Client")
+    client.destroy!
+    assert_raise(FrozenError) { client.firm = nil }
+    assert_raise(FrozenError) { client.firm = Firm.new(name: "Firm") }
+  end
+
+  def test_eager_loading_wont_mutate_owner_record
+    client = Client.eager_load(:firm_with_basic_id).first
+    assert_not_predicate client, :firm_id_came_from_user?
+
+    client = Client.preload(:firm_with_basic_id).first
+    assert_not_predicate client, :firm_id_came_from_user?
   end
 
   def test_missing_attribute_error_is_raised_when_no_foreign_key_attribute
@@ -40,14 +79,12 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_belongs_to_does_not_use_order_by
-    ActiveRecord::SQLCounter.clear_log
-    Client.find(3).firm
-  ensure
-    assert ActiveRecord::SQLCounter.log_all.all? { |sql| /order by/i !~ sql }, 'ORDER BY was used in the query'
+    sql_log = capture_sql { Client.find(3).firm }
+    assert sql_log.all? { |sql| !/order by/i.match?(sql) }, "ORDER BY was used in the query: #{sql_log}"
   end
 
   def test_belongs_to_with_primary_key
-    client = Client.create(:name => "Primary key client", :firm_name => companies(:first_firm).name)
+    client = Client.create(name: "Primary key client", firm_name: companies(:first_firm).name)
     assert_equal companies(:first_firm).name, client.firm_with_primary_key.name
   end
 
@@ -60,16 +97,39 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
       # on Oracle aliases are truncated to 30 characters and are quoted in uppercase
       assert_no_match(/"firm_with_primary_keys_compani"\."id"/i, sql)
       assert_match(/"firm_with_primary_keys_compani"\."name"/i, sql)
-	elsif current_adapter?(:IBM_DBAdapter)
-      # Quoting of column names is not necessary for IBM_DB
-      assert_no_match(/firm_with_primary_keys_companies\.id/i, sql)
-      assert_match(/firm_with_primary_keys_companies\.name/i, sql)
     else
-      assert_no_match(/"firm_with_primary_keys_companies"\."id"/, sql)
-      assert_match(/"firm_with_primary_keys_companies"\."name"/, sql)
+      assert_no_match(/firm_with_primary_keys_companies\.id/, sql)
+      assert_match(/firm_with_primary_keys_companies\.name/, sql)
     end
   end
 
+  def test_optional_relation_can_be_set_per_model
+    model1 = Class.new(ActiveRecord::Base) do
+      self.table_name = "accounts"
+      self.belongs_to_required_by_default = false
+
+      belongs_to :company
+
+      def self.name
+        "FirstModel"
+      end
+    end.new
+
+    model2 = Class.new(ActiveRecord::Base) do
+      self.table_name = "accounts"
+      self.belongs_to_required_by_default = true
+
+      belongs_to :company
+
+      def self.name
+        "SecondModel"
+      end
+    end.new
+
+    assert_predicate model1, :valid?
+    assert_not_predicate model2, :valid?
+  end
+
   def test_optional_relation
     original_value = ActiveRecord::Base.belongs_to_required_by_default
     ActiveRecord::Base.belongs_to_required_by_default = true
@@ -81,7 +141,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     end
 
     account = model.new
-    assert account.valid?
+    assert_predicate account, :valid?
   ensure
     ActiveRecord::Base.belongs_to_required_by_default = original_value
   end
@@ -97,8 +157,8 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     end
 
     account = model.new
-    assert_not account.valid?
-    assert_equal [{error: :blank}], account.errors.details[:company]
+    assert_not_predicate account, :valid?
+    assert_equal [{ error: :blank }], account.errors.details[:company]
   ensure
     ActiveRecord::Base.belongs_to_required_by_default = original_value
   end
@@ -114,31 +174,69 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     end
 
     account = model.new
-    assert_not account.valid?
-    assert_equal [{error: :blank}], account.errors.details[:company]
+    assert_not_predicate account, :valid?
+    assert_equal [{ error: :blank }], account.errors.details[:company]
   ensure
     ActiveRecord::Base.belongs_to_required_by_default = original_value
   end
 
+  def test_default
+    david = developers(:david)
+    jamis = developers(:jamis)
+
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "ships"
+      def self.name; "Temp"; end
+      belongs_to :developer, default: -> { david }
+    end
+
+    ship = model.create!
+    assert_equal david, ship.developer
+
+    ship = model.create!(developer: jamis)
+    assert_equal jamis, ship.developer
+
+    ship.update!(developer: nil)
+    assert_equal david, ship.developer
+  end
+
+  def test_default_with_lambda
+    model = Class.new(ActiveRecord::Base) do
+      self.table_name = "ships"
+      def self.name; "Temp"; end
+      belongs_to :developer, default: -> { default_developer }
+
+      def default_developer
+        Developer.first
+      end
+    end
+
+    ship = model.create!
+    assert_equal developers(:david), ship.developer
+
+    ship = model.create!(developer: developers(:jamis))
+    assert_equal developers(:jamis), ship.developer
+  end
+
   def test_default_scope_on_relations_is_not_cached
     counter = 0
 
     comments = Class.new(ActiveRecord::Base) {
-      self.table_name = 'comments'
-      self.inheritance_column = 'not_there'
+      self.table_name = "comments"
+      self.inheritance_column = "not_there"
 
       posts = Class.new(ActiveRecord::Base) {
-        self.table_name = 'posts'
-        self.inheritance_column = 'not_there'
+        self.table_name = "posts"
+        self.inheritance_column = "not_there"
 
         default_scope -> {
           counter += 1
-          where("id = :inc", :inc => counter)
+          where("id = :inc", inc: counter)
         }
 
-        has_many :comments, :anonymous_class => comments
+        has_many :comments, anonymous_class: comments
       }
-      belongs_to :post, :anonymous_class => posts, :inverse_of => false
+      belongs_to :post, anonymous_class: posts, inverse_of: false
     }
 
     assert_equal 0, counter
@@ -163,16 +261,16 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_nil defined?(Region), "This test requires that there is no top-level Region class"
 
     ActiveRecord::Base.connection.instance_eval do
-      create_table(:admin_regions) { |t| t.string :name }
+      create_table(:admin_regions, force: true) { |t| t.string :name }
       add_column :admin_users, :region_id, :integer
     end
     Admin.const_set "RegionalUser", Class.new(Admin::User) { belongs_to(:region) }
     Admin.const_set "Region", Class.new(ActiveRecord::Base)
 
     e = assert_raise(ActiveRecord::AssociationTypeMismatch) {
-      Admin::RegionalUser.new(region: 'wrong value')
+      Admin::RegionalUser.new(region: "wrong value")
     }
-    assert_match(/^Region\([^)]+\) expected, got String\([^)]+\)$/, e.message)
+    assert_match(/^Region\([^)]+\) expected, got "wrong value" which is an instance of String\([^)]+\)$/, e.message)
   ensure
     Admin.send :remove_const, "Region" if Admin.const_defined?("Region")
     Admin.send :remove_const, "RegionalUser" if Admin.const_defined?("RegionalUser")
@@ -181,6 +279,8 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
       remove_column :admin_users, :region_id if column_exists?(:admin_users, :region_id)
       drop_table :admin_regions, if_exists: true
     end
+
+    Admin::User.reset_column_information
   end
 
   def test_natural_assignment
@@ -207,15 +307,15 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   def test_eager_loading_with_primary_key
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
-    citibank_result = Client.all.merge!(:where => {:name => "Citibank"}, :includes => :firm_with_primary_key).first
-    assert citibank_result.association(:firm_with_primary_key).loaded?
+    citibank_result = Client.all.merge!(where: { name: "Citibank" }, includes: :firm_with_primary_key).first
+    assert_predicate citibank_result.association(:firm_with_primary_key), :loaded?
   end
 
   def test_eager_loading_with_primary_key_as_symbol
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
-    citibank_result = Client.all.merge!(:where => {:name => "Citibank"}, :includes => :firm_with_primary_key_symbols).first
-    assert citibank_result.association(:firm_with_primary_key_symbols).loaded?
+    citibank_result = Client.all.merge!(where: { name: "Citibank" }, includes: :firm_with_primary_key_symbols).first
+    assert_predicate citibank_result.association(:firm_with_primary_key_symbols), :loaded?
   end
 
   def test_creating_the_belonging_object
@@ -227,8 +327,17 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal apple, citibank.firm
   end
 
+  def test_creating_the_belonging_object_from_new_record
+    citibank = Account.new("credit_limit" => 10)
+    apple    = citibank.create_firm("name" => "Apple")
+    assert_equal apple, citibank.firm
+    citibank.save
+    citibank.reload
+    assert_equal apple, citibank.firm
+  end
+
   def test_creating_the_belonging_object_with_primary_key
-    client = Client.create(:name => "Primary key client")
+    client = Client.create(name: "Primary key client")
     apple  = client.create_firm_with_primary_key("name" => "Apple")
     assert_equal apple, client.firm_with_primary_key
     client.save
@@ -251,48 +360,48 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
   def test_building_the_belonging_object_with_explicit_sti_base_class
     account = Account.new
-    company = account.build_firm(:type => "Company")
+    company = account.build_firm(type: "Company")
     assert_kind_of Company, company, "Expected #{company.class} to be a Company"
   end
 
   def test_building_the_belonging_object_with_sti_subclass
     account = Account.new
-    company = account.build_firm(:type => "Firm")
+    company = account.build_firm(type: "Firm")
     assert_kind_of Firm, company, "Expected #{company.class} to be a Firm"
   end
 
   def test_building_the_belonging_object_with_an_invalid_type
     account = Account.new
-    assert_raise(ActiveRecord::SubclassNotFound) { account.build_firm(:type => "InvalidType") }
+    assert_raise(ActiveRecord::SubclassNotFound) { account.build_firm(type: "InvalidType") }
   end
 
   def test_building_the_belonging_object_with_an_unrelated_type
     account = Account.new
-    assert_raise(ActiveRecord::SubclassNotFound) { account.build_firm(:type => "Account") }
+    assert_raise(ActiveRecord::SubclassNotFound) { account.build_firm(type: "Account") }
   end
 
   def test_building_the_belonging_object_with_primary_key
-    client = Client.create(:name => "Primary key client")
+    client = Client.create(name: "Primary key client")
     apple  = client.build_firm_with_primary_key("name" => "Apple")
     client.save
     assert_equal apple.name, client.firm_name
   end
 
   def test_create!
-    client  = Client.create!(:name => "Jimmy")
-    account = client.create_account!(:credit_limit => 10)
+    client  = Client.create!(name: "Jimmy")
+    account = client.create_account!(credit_limit: 10)
     assert_equal account, client.account
-    assert account.persisted?
+    assert_predicate account, :persisted?
     client.save
     client.reload
     assert_equal account, client.account
   end
 
   def test_failing_create!
-    client  = Client.create!(:name => "Jimmy")
+    client = Client.create!(name: "Jimmy")
     assert_raise(ActiveRecord::RecordInvalid) { client.create_account! }
     assert_not_nil client.account
-    assert client.account.new_record?
+    assert_predicate client.account, :new_record?
   end
 
   def test_reloading_the_belonging_object
@@ -305,6 +414,30 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal "ODEGY", odegy_account.reload_firm.name
   end
 
+  def test_reload_the_belonging_object_with_query_cache
+    odegy_account_id = accounts(:odegy_account).id
+
+    connection = ActiveRecord::Base.connection
+    connection.enable_query_cache!
+    connection.clear_query_cache
+
+    # Populate the cache with a query
+    odegy_account = Account.find(odegy_account_id)
+
+    # Populate the cache with a second query
+    odegy_account.firm
+
+    assert_equal 2, connection.query_cache.size
+
+    # Clear the cache and fetch the firm again, populating the cache with a query
+    assert_queries(1) { odegy_account.reload_firm }
+
+    # This query is not cached anymore, so it should make a real SQL query
+    assert_queries(1) { Account.find(odegy_account_id) }
+  ensure
+    ActiveRecord::Base.connection.disable_query_cache!
+  end
+
   def test_natural_assignment_to_nil
     client = Client.find(3)
     client.firm = nil
@@ -315,7 +448,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_natural_assignment_to_nil_with_primary_key
-    client = Client.create(:name => "Primary key client", :firm_name => companies(:first_firm).name)
+    client = Client.create(name: "Primary key client", firm_name: companies(:first_firm).name)
     client.firm_with_primary_key = nil
     client.save
     client.association(:firm_with_primary_key).reload
@@ -335,41 +468,52 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
   def test_polymorphic_association_class
     sponsor = Sponsor.new
-    assert_nil sponsor.association(:sponsorable).send(:klass)
+    assert_nil sponsor.association(:sponsorable).klass
     sponsor.association(:sponsorable).reload
     assert_nil sponsor.sponsorable
 
-    sponsor.sponsorable_type = '' # the column doesn't have to be declared NOT NULL
-    assert_nil sponsor.association(:sponsorable).send(:klass)
+    sponsor.sponsorable_type = "" # the column doesn't have to be declared NOT NULL
+    assert_nil sponsor.association(:sponsorable).klass
     sponsor.association(:sponsorable).reload
     assert_nil sponsor.sponsorable
 
-    sponsor.sponsorable = Member.new :name => "Bert"
-    assert_equal Member, sponsor.association(:sponsorable).send(:klass)
-    assert_equal "members", sponsor.association(:sponsorable).aliased_table_name
+    sponsor.sponsorable = Member.new name: "Bert"
+    assert_equal Member, sponsor.association(:sponsorable).klass
   end
 
   def test_with_polymorphic_and_condition
     sponsor = Sponsor.create
-    member = Member.create :name => "Bert"
+    member = Member.create name: "Bert"
+
     sponsor.sponsorable = member
+    sponsor.save!
+
+    assert_equal member, sponsor.sponsorable
+    assert_nil sponsor.sponsorable_with_conditions
+
+    sponsor = Sponsor.preload(:sponsorable, :sponsorable_with_conditions).last
 
     assert_equal member, sponsor.sponsorable
     assert_nil sponsor.sponsorable_with_conditions
   end
 
   def test_with_select
-    assert_equal 1, Company.find(2).firm_with_select.attributes.size
-    assert_equal 1, Company.all.merge!(:includes => :firm_with_select ).find(2).firm_with_select.attributes.size
+    assert_equal 1, Post.find(2).author_with_select.attributes.size
+    assert_equal 1, Post.includes(:author_with_select).find(2).author_with_select.attributes.size
+  end
+
+  def test_custom_attribute_with_select
+    assert_equal 2, Company.find(2).firm_with_select.attributes.size
+    assert_equal 2, Company.includes(:firm_with_select).find(2).firm_with_select.attributes.size
   end
 
   def test_belongs_to_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')
+    ship = Ship.create(name: "Countless")
 
     assert_no_difference lambda { ship.reload.treasures_count }, "treasures_count should not be changed unless counter_cache is given on the relation" do
-      treasure = Treasure.new(name: 'Gold', ship: ship)
+      treasure = Treasure.new(name: "Gold", ship: ship)
       treasure.save
     end
 
@@ -391,31 +535,70 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_belongs_to_counter_with_assigning_nil
-    post = Post.find(1)
-    comment = Comment.find(1)
+    topic = Topic.create!(title: "debate")
+    reply = Reply.create!(title: "blah!", content: "world around!", topic: topic)
+
+    assert_equal topic.id, reply.parent_id
+    assert_equal 1, topic.reload.replies.size
 
-    assert_equal post.id, comment.post_id
-    assert_equal 2, Post.find(post.id).comments.size
+    reply.topic = nil
+    reply.reload
 
-    comment.post = nil
+    assert_equal topic.id, reply.parent_id
+    assert_equal 1, topic.reload.replies.size
 
-    assert_equal 1, Post.find(post.id).comments.size
+    reply.topic = nil
+    reply.save!
+
+    assert_equal 0, topic.reload.replies.size
+  end
+
+  def test_belongs_to_counter_with_assigning_new_object
+    topic = Topic.create!(title: "debate")
+    reply = Reply.create!(title: "blah!", content: "world around!", topic: topic)
+
+    assert_equal topic.id, reply.parent_id
+    assert_equal 1, topic.reload.replies_count
+
+    topic2 = reply.build_topic(title: "debate2")
+    reply.save!
+
+    assert_not_equal topic.id, reply.parent_id
+    assert_equal topic2.id, reply.parent_id
+
+    assert_equal 0, topic.reload.replies_count
+    assert_equal 1, topic2.reload.replies_count
   end
 
   def test_belongs_to_with_primary_key_counter
     debate  = Topic.create("title" => "debate")
     debate2 = Topic.create("title" => "debate2")
-    reply   = Reply.create("title" => "blah!", "content" => "world around!", "parent_title" => "debate")
+    reply   = Reply.create("title" => "blah!", "content" => "world around!", "parent_title" => "debate2")
+
+    assert_equal 0, debate.reload.replies_count
+    assert_equal 1, debate2.reload.replies_count
+
+    reply.parent_title = "debate"
+    reply.save!
+
+    assert_equal 1, debate.reload.replies_count
+    assert_equal 0, debate2.reload.replies_count
+
+    assert_no_queries do
+      reply.topic_with_primary_key = debate
+    end
 
     assert_equal 1, debate.reload.replies_count
     assert_equal 0, debate2.reload.replies_count
 
     reply.topic_with_primary_key = debate2
+    reply.save!
 
     assert_equal 0, debate.reload.replies_count
     assert_equal 1, debate2.reload.replies_count
 
     reply.topic_with_primary_key = nil
+    reply.save!
 
     assert_equal 0, debate.reload.replies_count
     assert_equal 0, debate2.reload.replies_count
@@ -442,11 +625,13 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal 1, Topic.find(topic2.id).replies.size
 
     reply1.topic = nil
+    reply1.save!
 
     assert_equal 0, Topic.find(topic1.id).replies.size
     assert_equal 0, Topic.find(topic2.id).replies.size
 
     reply1.topic = topic1
+    reply1.save!
 
     assert_equal 1, Topic.find(topic1.id).replies.size
     assert_equal 0, Topic.find(topic2.id).replies.size
@@ -475,14 +660,65 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_belongs_to_counter_after_save
-    topic = Topic.create!(:title => "monday night")
-    topic.replies.create!(:title => "re: monday night", :content => "football")
+    topic = Topic.create!(title: "monday night")
+
+    assert_queries(2) do
+      topic.replies.create!(title: "re: monday night", content: "football")
+    end
+
     assert_equal 1, Topic.find(topic.id)[:replies_count]
 
     topic.save!
     assert_equal 1, Topic.find(topic.id)[:replies_count]
   end
 
+  def test_belongs_to_counter_after_touch
+    topic = Topic.create!(title: "topic")
+
+    assert_equal 0, topic.replies_count
+    assert_equal 0, topic.after_touch_called
+
+    reply = Reply.create!(title: "blah!", content: "world around!", topic_with_primary_key: topic)
+
+    assert_equal 1, topic.replies_count
+    assert_equal 1, topic.after_touch_called
+
+    reply.destroy!
+
+    assert_equal 0, topic.replies_count
+    assert_equal 2, topic.after_touch_called
+  end
+
+  def test_belongs_to_touch_with_reassigning
+    debate  = Topic.create!(title: "debate")
+    debate2 = Topic.create!(title: "debate2")
+    reply   = Reply.create!(title: "blah!", content: "world around!", parent_title: "debate2")
+
+    time = 1.day.ago
+
+    debate.touch(time: time)
+    debate2.touch(time: time)
+
+    assert_queries(3) do
+      reply.parent_title = "debate"
+      reply.save!
+    end
+
+    assert_operator debate.reload.updated_at, :>, time
+    assert_operator debate2.reload.updated_at, :>, time
+
+    debate.touch(time: time)
+    debate2.touch(time: time)
+
+    assert_queries(3) do
+      reply.topic_with_primary_key = debate2
+      reply.save!
+    end
+
+    assert_operator debate.reload.updated_at, :>, time
+    assert_operator debate2.reload.updated_at, :>, time
+  end
+
   def test_belongs_to_with_touch_option_on_touch
     line_item = LineItem.create!
     Invoice.create!(line_items: [line_item])
@@ -541,7 +777,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     line_item = LineItem.create!
     Invoice.create!(line_items: [line_item])
 
-    assert_queries(0) { line_item.save }
+    assert_no_queries { line_item.save }
   end
 
   def test_belongs_to_with_touch_option_on_destroy
@@ -578,8 +814,8 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_belongs_to_counter_when_update_columns
-    topic = Topic.create!(:title => "37s")
-    topic.replies.create!(:title => "re: 37s", :content => "rails")
+    topic = Topic.create!(title: "37s")
+    topic.replies.create!(title: "re: 37s", content: "rails")
     assert_equal 1, Topic.find(topic.id)[:replies_count]
 
     topic.update_columns(content: "rails is wonderful")
@@ -590,10 +826,10 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     final_cut = Client.new("name" => "Final Cut")
     firm = Firm.find(1)
     final_cut.firm = firm
-    assert !final_cut.persisted?
+    assert_not_predicate final_cut, :persisted?
     assert final_cut.save
-    assert final_cut.persisted?
-    assert firm.persisted?
+    assert_predicate final_cut, :persisted?
+    assert_predicate firm, :persisted?
     assert_equal firm, final_cut.firm
     final_cut.association(:firm).reload
     assert_equal firm, final_cut.firm
@@ -603,10 +839,10 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     final_cut = Client.new("name" => "Final Cut")
     firm = Firm.find(1)
     final_cut.firm_with_primary_key = firm
-    assert !final_cut.persisted?
+    assert_not_predicate final_cut, :persisted?
     assert final_cut.save
-    assert final_cut.persisted?
-    assert firm.persisted?
+    assert_predicate final_cut, :persisted?
+    assert_predicate firm, :persisted?
     assert_equal firm, final_cut.firm_with_primary_key
     final_cut.association(:firm_with_primary_key).reload
     assert_equal firm, final_cut.firm_with_primary_key
@@ -614,8 +850,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
   def test_new_record_with_foreign_key_but_no_object
     client = Client.new("firm_id" => 1)
-    # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
-    assert_equal Firm.all.merge!(:order => "id").first, client.firm_with_basic_id
+    assert_equal Firm.first, client.firm_with_basic_id
   end
 
   def test_setting_foreign_key_after_nil_target_loaded
@@ -637,7 +872,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
   def test_dont_find_target_when_foreign_key_is_null
     tagging = taggings(:thinking_general)
-    assert_queries(0) { tagging.super_tag }
+    assert_no_queries { tagging.super_tag }
   end
 
   def test_dont_find_target_when_saving_foreign_key_after_stale_association_loaded
@@ -652,11 +887,12 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_counter_cache
-    topic = Topic.create :title => "Zoom-zoom-zoom"
+    topic = Topic.create title: "Zoom-zoom-zoom"
     assert_equal 0, topic[:replies_count]
 
-    reply = Reply.create(:title => "re: zoom", :content => "speedy quick!")
+    reply = Reply.create(title: "re: zoom", content: "speedy quick!")
     reply.topic = topic
+    reply.save!
 
     assert_equal 1, topic.reload[:replies_count]
     assert_equal 1, topic.replies.size
@@ -666,10 +902,10 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_counter_cache_double_destroy
-    topic = Topic.create :title => "Zoom-zoom-zoom"
+    topic = Topic.create title: "Zoom-zoom-zoom"
 
     5.times do
-      topic.replies.create(:title => "re: zoom", :content => "speedy quick!")
+      topic.replies.create(title: "re: zoom", content: "speedy quick!")
     end
 
     assert_equal 5, topic.reload[:replies_count]
@@ -686,10 +922,10 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_concurrent_counter_cache_double_destroy
-    topic = Topic.create :title => "Zoom-zoom-zoom"
+    topic = Topic.create title: "Zoom-zoom-zoom"
 
     5.times do
-      topic.replies.create(:title => "re: zoom", :content => "speedy quick!")
+      topic.replies.create(title: "re: zoom", content: "speedy quick!")
     end
 
     assert_equal 5, topic.reload[:replies_count]
@@ -707,11 +943,12 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_custom_counter_cache
-    reply = Reply.create(:title => "re: zoom", :content => "speedy quick!")
+    reply = Reply.create(title: "re: zoom", content: "speedy quick!")
     assert_equal 0, reply[:replies_count]
 
-    silly = SillyReply.create(:title => "gaga", :content => "boo-boo")
+    silly = SillyReply.create(title: "gaga", content: "boo-boo")
     silly.reply = reply
+    silly.save!
 
     assert_equal 1, reply.reload[:replies_count]
     assert_equal 1, reply.replies.size
@@ -734,7 +971,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   def test_association_assignment_sticks
     post = Post.first
 
-    author1, author2 = Author.all.merge!(:limit => 2).to_a
+    author1, author2 = Author.all.merge!(limit: 2).to_a
     assert_not_nil author1
     assert_not_nil author2
 
@@ -754,7 +991,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
   def test_cant_save_readonly_association
     assert_raise(ActiveRecord::ReadOnlyRecord) { companies(:first_client).readonly_firm.save! }
-    assert companies(:first_client).readonly_firm.readonly?
+    assert_predicate companies(:first_client).readonly_firm, :readonly?
   end
 
   def test_polymorphic_assignment_foreign_key_type_string
@@ -787,7 +1024,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   def test_polymorphic_assignment_with_primary_key_foreign_type_field_updating
     # should update when assigning a saved record
     essay = Essay.new
-    writer = Author.create(:name => "David")
+    writer = Author.create(name: "David")
     essay.writer = writer
     assert_equal "Author", essay.writer_type
 
@@ -812,7 +1049,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
   def test_assignment_updates_foreign_id_field_for_new_and_saved_records
     client = Client.new
-    saved_firm = Firm.create :name => "Saved"
+    saved_firm = Firm.create name: "Saved"
     new_firm = Firm.new
 
     client.firm = saved_firm
@@ -824,7 +1061,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
   def test_polymorphic_assignment_with_primary_key_updates_foreign_id_field_for_new_and_saved_records
     essay = Essay.new
-    saved_writer = Author.create(:name => "David")
+    saved_writer = Author.create(name: "David")
     new_writer = Author.new
 
     essay.writer = saved_writer
@@ -840,7 +1077,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_nil essay.writer_type
 
     essay.writer_id = 1
-    essay.writer_type = 'Author'
+    essay.writer_type = "Author"
 
     essay.writer = nil
     assert_nil essay.writer_id
@@ -862,14 +1099,14 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
     assert_nothing_raised do
       Account.find(@account.id).save!
-      Account.all.merge!(:includes => :firm).find(@account.id).save!
+      Account.all.merge!(includes: :firm).find(@account.id).save!
     end
 
     @account.firm.delete
 
     assert_nothing_raised do
       Account.find(@account.id).save!
-      Account.all.merge!(:includes => :firm).find(@account.id).save!
+      Account.all.merge!(includes: :firm).find(@account.id).save!
     end
   end
 
@@ -890,18 +1127,58 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
   def test_belongs_to_invalid_dependent_option_raises_exception
     error = assert_raise ArgumentError do
-      Class.new(Author).belongs_to :special_author_address, :dependent => :nullify
+      Class.new(Author).belongs_to :special_author_address, dependent: :nullify
+    end
+    assert_equal error.message, "The :dependent option must be one of [:destroy, :delete, :destroy_async], but is :nullify"
+  end
+
+  class EssayDestroy < ActiveRecord::Base
+    self.table_name = "essays"
+    belongs_to :book, dependent: :destroy, class_name: "DestroyableBook"
+  end
+
+  class DestroyableBook < ActiveRecord::Base
+    self.table_name = "books"
+    belongs_to :author, class_name: "UndestroyableAuthor", dependent: :destroy
+  end
+
+  class UndestroyableAuthor < ActiveRecord::Base
+    self.table_name = "authors"
+    has_one :book, class_name: "DestroyableBook", foreign_key: "author_id"
+    before_destroy :dont
+
+    def dont
+      throw(:abort)
+    end
+  end
+
+  def test_dependency_should_halt_parent_destruction
+    author = UndestroyableAuthor.create!(name: "Test")
+    book = DestroyableBook.create!(author: author)
+
+    assert_no_difference ["UndestroyableAuthor.count", "DestroyableBook.count"] do
+      assert_not book.destroy
+    end
+  end
+
+  def test_dependency_should_halt_parent_destruction_with_cascaded_three_levels
+    author = UndestroyableAuthor.create!(name: "Test")
+    book = DestroyableBook.create!(author: author)
+    essay = EssayDestroy.create!(book: book)
+
+    assert_no_difference ["UndestroyableAuthor.count", "DestroyableBook.count", "EssayDestroy.count"] do
+      assert_not essay.destroy
+      assert_not essay.destroyed?
     end
-    assert_equal error.message, 'The :dependent option must be one of [:destroy, :delete], but is :nullify'
   end
 
   def test_attributes_are_being_set_when_initialized_from_belongs_to_association_with_where_clause
-    new_firm = accounts(:signals37).build_firm(:name => 'Apple')
+    new_firm = accounts(:signals37).build_firm(name: "Apple")
     assert_equal new_firm.name, "Apple"
   end
 
   def test_attributes_are_set_without_error_when_initialized_from_belongs_to_association_with_array_in_where_clause
-    new_account = Account.where(:credit_limit => [ 50, 60 ]).new
+    new_account = Account.where(credit_limit: [ 50, 60 ]).new
     assert_nil new_account.credit_limit
   end
 
@@ -913,31 +1190,42 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     firm_proxy                = client.send(:association_instance_get, :firm)
     firm_with_condition_proxy = client.send(:association_instance_get, :firm_with_condition)
 
-    assert !firm_proxy.stale_target?
-    assert !firm_with_condition_proxy.stale_target?
+    assert_not_predicate firm_proxy, :stale_target?
+    assert_not_predicate firm_with_condition_proxy, :stale_target?
     assert_equal companies(:first_firm), client.firm
     assert_equal companies(:first_firm), client.firm_with_condition
 
     client.client_of = companies(:another_firm).id
 
-    assert firm_proxy.stale_target?
-    assert firm_with_condition_proxy.stale_target?
+    assert_predicate firm_proxy, :stale_target?
+    assert_predicate firm_with_condition_proxy, :stale_target?
     assert_equal companies(:another_firm), client.firm
     assert_equal companies(:another_firm), client.firm_with_condition
   end
 
+  def test_destroying_child_with_unloaded_parent_and_foreign_key_and_touch_is_possible_with_has_many_inversing
+    with_has_many_inversing do
+      book     = Book.create!
+      citation = book.citations.create!
+
+      assert_difference "Citation.count", -1 do
+        Citation.find(citation.id).destroy
+      end
+    end
+  end
+
   def test_polymorphic_reassignment_of_associated_id_updates_the_object
     sponsor = sponsors(:moustache_club_sponsor_for_groucho)
 
     sponsor.sponsorable
     proxy = sponsor.send(:association_instance_get, :sponsorable)
 
-    assert !proxy.stale_target?
+    assert_not_predicate proxy, :stale_target?
     assert_equal members(:groucho), sponsor.sponsorable
 
     sponsor.sponsorable_id = members(:some_other_guy).id
 
-    assert proxy.stale_target?
+    assert_predicate proxy, :stale_target?
     assert_equal members(:some_other_guy), sponsor.sponsorable
   end
 
@@ -947,12 +1235,12 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     sponsor.sponsorable
     proxy = sponsor.send(:association_instance_get, :sponsorable)
 
-    assert !proxy.stale_target?
+    assert_not_predicate proxy, :stale_target?
     assert_equal members(:groucho), sponsor.sponsorable
 
-    sponsor.sponsorable_type = 'Firm'
+    sponsor.sponsorable_type = "Firm"
 
-    assert proxy.stale_target?
+    assert_predicate proxy, :stale_target?
     assert_equal companies(:first_firm), sponsor.sponsorable
   end
 
@@ -974,9 +1262,20 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     post    = posts(:welcome)
     comment = comments(:greetings)
 
-    assert_difference lambda { post.reload.tags_count }, -1 do
-      assert_difference 'comment.reload.tags_count', +1 do
+    assert_equal post.id, comment.id
+
+    assert_difference "post.reload.tags_count", -1 do
+      assert_difference "comment.reload.tags_count", +1 do
         tagging.taggable = comment
+        tagging.save!
+      end
+    end
+
+    assert_difference "comment.reload.tags_count", -1 do
+      assert_difference "post.reload.tags_count", +1 do
+        tagging.taggable_type = post.class.polymorphic_name
+        tagging.taggable_id = post.id
+        tagging.save!
       end
     end
   end
@@ -1022,46 +1321,46 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_build_with_block
-    client = Client.create(:name => 'Client Company')
+    client = Client.create(name: "Client Company")
 
-    firm = client.build_firm{ |f| f.name = 'Agency Company' }
-    assert_equal 'Agency Company', firm.name
+    firm = client.build_firm { |f| f.name = "Agency Company" }
+    assert_equal "Agency Company", firm.name
   end
 
   def test_create_with_block
-    client = Client.create(:name => 'Client Company')
+    client = Client.create(name: "Client Company")
 
-    firm = client.create_firm{ |f| f.name = 'Agency Company' }
-    assert_equal 'Agency Company', firm.name
+    firm = client.create_firm { |f| f.name = "Agency Company" }
+    assert_equal "Agency Company", firm.name
   end
 
   def test_create_bang_with_block
-    client = Client.create(:name => 'Client Company')
+    client = Client.create(name: "Client Company")
 
-    firm = client.create_firm!{ |f| f.name = 'Agency Company' }
-    assert_equal 'Agency Company', firm.name
+    firm = client.create_firm! { |f| f.name = "Agency Company" }
+    assert_equal "Agency Company", firm.name
   end
 
   def test_should_set_foreign_key_on_create_association
-    client = Client.create! :name => "fuu"
+    client = Client.create! name: "fuu"
 
-    firm = client.create_firm :name => "baa"
+    firm = client.create_firm name: "baa"
     assert_equal firm.id, client.client_of
   end
 
   def test_should_set_foreign_key_on_create_association!
-    client = Client.create! :name => "fuu"
+    client = Client.create! name: "fuu"
 
-    firm = client.create_firm! :name => "baa"
+    firm = client.create_firm! name: "baa"
     assert_equal firm.id, client.client_of
   end
 
   def test_self_referential_belongs_to_with_counter_cache_assigning_nil
-    comment = Comment.create! :post => posts(:thinking), :body => "fuu"
+    comment = Comment.create! post: posts(:thinking), body: "fuu"
     comment.parent = nil
     comment.save!
 
-    assert_equal nil, comment.reload.parent
+    assert_nil comment.reload.parent
     assert_equal 0, comments(:greetings).reload.children_count
   end
 
@@ -1076,13 +1375,51 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal 1, parent.reload.children_count
   end
 
+  def test_belongs_to_with_out_of_range_value_assigning
+    model = Class.new(Author) do
+      def self.name; "Temp"; end
+      validates :author_address, presence: true
+    end
+
+    author = model.new
+    author.author_address_id = 9223372036854775808 # out of range in the bigint
+
+    assert_nil author.author_address
+    assert_not_predicate author, :valid?
+    assert_equal [{ error: :blank }], author.errors.details[:author_address]
+  end
+
   def test_polymorphic_with_custom_primary_key
     toy = Toy.create!
-    sponsor = Sponsor.create!(:sponsorable => toy)
+    sponsor = Sponsor.create!(sponsorable: toy)
 
     assert_equal toy, sponsor.reload.sponsorable
   end
 
+  class SponsorWithTouchInverse < Sponsor
+    belongs_to :sponsorable, polymorphic: true, inverse_of: :sponsors, touch: true
+  end
+
+  def test_destroying_polymorphic_child_with_unloaded_parent_and_touch_is_possible_with_has_many_inversing
+    with_has_many_inversing do
+      toy     = Toy.create!
+      sponsor = toy.sponsors.create!
+
+      assert_difference "Sponsor.count", -1 do
+        SponsorWithTouchInverse.find(sponsor.id).destroy
+      end
+    end
+  end
+
+  def test_polymorphic_with_false
+    assert_nothing_raised do
+      Class.new(ActiveRecord::Base) do
+        def self.name; "Post"; end
+        belongs_to :category, polymorphic: false
+      end
+    end
+  end
+
   test "stale tracking doesn't care about the type" do
     apple = Firm.create("name" => "Apple")
     citibank = Account.create("credit_limit" => 10)
@@ -1092,12 +1429,12 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
     citibank.firm_id = apple.id.to_s
 
-    assert !citibank.association(:firm).stale_target?
+    assert_not_predicate citibank.association(:firm), :stale_target?
   end
 
   def test_reflect_the_most_recent_change
     author1, author2 = Author.limit(2)
-    post = Post.new(:title => "foo", :body=> "bar")
+    post = Post.new(title: "foo", body: "bar")
 
     post.author    = author1
     post.author_id = author2.id
@@ -1106,8 +1443,8 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal post.author_id, author2.id
   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
           belongs_to name
@@ -1116,16 +1453,31 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     end
   end
 
-  test 'belongs_to works with model called Record' do
+  test "belongs_to works with model called Record" do
     record = Record.create!
     Column.create! record: record
     assert_equal 1, Column.count
   end
 
-  def test_association_force_reload_with_only_true_is_deprecated
-    client = Client.find(3)
+  def test_multiple_counter_cache_with_after_create_update
+    post = posts(:welcome)
+    parent = comments(:greetings)
+
+    assert_difference "parent.reload.children_count", +1 do
+      assert_difference "post.reload.comments_count", +1 do
+        CommentWithAfterCreateUpdate.create(body: "foo", post: post, parent: parent)
+      end
+    end
+  end
+
+  test "assigning an association doesn't result in duplicate objects" do
+    post = Post.create!(title: "title", body: "body")
+    post.comments = [post.comments.build(body: "body")]
+    post.save!
 
-    assert_deprecated { client.firm(true) }
+    assert_equal 1, post.comments.size
+    assert_equal 1, Comment.where(post_id: post.id).count
+    assert_equal post.id, Comment.last.post.id
   end
 end