11 files changed, 77 insertions, 93 deletions
diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index ec7e4f5fb7..5f7825783b 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -524,13 +524,13 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
 
   def test_invalid_belongs_to_dependent_option_nullify_raises_exception
     assert_raise ArgumentError do
-      Author.belongs_to :special_author_address, :dependent => :nullify
+      Class.new(Author).belongs_to :special_author_address, :dependent => :nullify
     end
   end
 
   def test_invalid_belongs_to_dependent_option_restrict_raises_exception
     assert_raise ArgumentError do
-      Author.belongs_to :special_author_address, :dependent => :restrict
+      Class.new(Author).belongs_to :special_author_address, :dependent => :restrict
     end
   end
 
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index 43440c1146..04714f42e9 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -1091,9 +1091,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_restrict
-    option_before = ActiveRecord::Base.dependent_restrict_raises
-    ActiveRecord::Base.dependent_restrict_raises = true
-
     firm = RestrictedFirm.create!(:name => 'restrict')
     firm.companies.create(:name => 'child')
 
@@ -1101,15 +1098,25 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
     assert RestrictedFirm.exists?(:name => 'restrict')
     assert firm.companies.exists?(:name => 'child')
-  ensure
-    ActiveRecord::Base.dependent_restrict_raises = option_before
   end
 
-  def test_restrict_when_dependent_restrict_raises_config_set_to_false
-    option_before = ActiveRecord::Base.dependent_restrict_raises
-    ActiveRecord::Base.dependent_restrict_raises = false
+  def test_restrict_is_deprecated
+    klass = Class.new(ActiveRecord::Base)
+    assert_deprecated { klass.has_many :posts, dependent: :restrict }
+  end
 
-    firm = RestrictedFirm.create!(:name => 'restrict')
+  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
+    firm = RestrictedWithErrorFirm.create!(:name => 'restrict')
     firm.companies.create(:name => 'child')
 
     assert !firm.companies.empty?
@@ -1119,10 +1126,8 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert !firm.errors.empty?
 
     assert_equal "Cannot delete record because dependent companies exist", firm.errors[:base].first
-    assert RestrictedFirm.exists?(:name => 'restrict')
+    assert RestrictedWithErrorFirm.exists?(:name => 'restrict')
     assert firm.companies.exists?(:name => 'child')
-  ensure
-    ActiveRecord::Base.dependent_restrict_raises = option_before
   end
 
   def test_included_in_collection
@@ -1602,18 +1607,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal [bulb1, bulb3], result
   end
 
-  def test_building_has_many_association_with_restrict_dependency
-    option_before = ActiveRecord::Base.dependent_restrict_raises
-    ActiveRecord::Base.dependent_restrict_raises = true
-
-    klass = Class.new(ActiveRecord::Base)
-
-    assert_deprecated     { klass.has_many :companies, :dependent => :restrict }
-    assert_not_deprecated { klass.has_many :companies }
-  ensure
-    ActiveRecord::Base.dependent_restrict_raises = option_before
-  end
-
   def test_collection_association_with_private_kernel_method
     firm = companies(:first_firm)
     assert_equal [accounts(:signals37)], firm.accounts.open
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index 112735839f..8bc633f2b5 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -156,10 +156,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_nothing_raised { firm.destroy }
   end
 
-  def test_dependence_with_restrict
-    option_before = ActiveRecord::Base.dependent_restrict_raises
-    ActiveRecord::Base.dependent_restrict_raises = true
-
+  def test_restrict
     firm = RestrictedFirm.create!(:name => 'restrict')
     firm.create_account(:credit_limit => 10)
 
@@ -168,38 +165,26 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
     assert RestrictedFirm.exists?(:name => 'restrict')
     assert firm.account.present?
-  ensure
-    ActiveRecord::Base.dependent_restrict_raises = option_before
   end
 
-  def test_dependence_with_restrict_with_dependent_restrict_raises_config_set_to_false
-    option_before = ActiveRecord::Base.dependent_restrict_raises
-    ActiveRecord::Base.dependent_restrict_raises = false
+  def test_restrict_is_deprecated
+    klass = Class.new(ActiveRecord::Base)
+    assert_deprecated { klass.has_one :post, dependent: :restrict }
+  end
 
-    firm = RestrictedFirm.create!(:name => 'restrict')
+  def test_restrict_with_exception
+    firm = RestrictedWithExceptionFirm.create!(:name => 'restrict')
     firm.create_account(:credit_limit => 10)
 
     assert_not_nil firm.account
 
-    firm.destroy
-
-    assert !firm.errors.empty?
-    assert_equal "Cannot delete record because a dependent account exists", firm.errors[:base].first
-    assert RestrictedFirm.exists?(:name => 'restrict')
+    assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
+    assert RestrictedWithExceptionFirm.exists?(:name => 'restrict')
     assert firm.account.present?
-  ensure
-    ActiveRecord::Base.dependent_restrict_raises = option_before
   end
 
-  def test_dependence_with_restrict_with_dependent_restrict_raises_config_set_to_false_and_attribute_name
-    old_backend = I18n.backend
-    I18n.backend = I18n::Backend::Simple.new
-    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:restricted_firm => {:account => "account model"}}}
-
-    option_before = ActiveRecord::Base.dependent_restrict_raises
-    ActiveRecord::Base.dependent_restrict_raises = false
-
-    firm = RestrictedFirm.create!(:name => 'restrict')
+  def test_restrict_with_error
+    firm = RestrictedWithErrorFirm.create!(:name => 'restrict')
     firm.create_account(:credit_limit => 10)
 
     assert_not_nil firm.account
@@ -207,12 +192,9 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     firm.destroy
 
     assert !firm.errors.empty?
-    assert_equal "Cannot delete record because a dependent account model exists", firm.errors[:base].first
-    assert RestrictedFirm.exists?(:name => 'restrict')
+    assert_equal "Cannot delete record because a dependent account exists", firm.errors[:base].first
+    assert RestrictedWithErrorFirm.exists?(:name => 'restrict')
     assert firm.account.present?
-  ensure
-    ActiveRecord::Base.dependent_restrict_raises = option_before
-    I18n.backend = old_backend
   end
 
   def test_successful_build_association
@@ -524,15 +506,16 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_equal car.id, bulb.attributes_after_initialize['car_id']
   end
 
-  def test_building_has_one_association_with_dependent_restrict
-    option_before = ActiveRecord::Base.dependent_restrict_raises
-    ActiveRecord::Base.dependent_restrict_raises = true
+  def test_has_one_transaction
+    company = companies(:first_firm)
+    account = Account.find(1)
 
-    klass = Class.new(ActiveRecord::Base)
+    company.account # force loading
+    assert_no_queries { company.account = account }
 
-    assert_deprecated     { klass.has_one :account, :dependent => :restrict }
-    assert_not_deprecated { klass.has_one :account }
-  ensure
-    ActiveRecord::Base.dependent_restrict_raises = option_before
+    company.account = nil
+    assert_no_queries { company.account = nil }
+    account = Account.find(2)
+    assert_queries { company.account = account }
   end
 end
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index 3cea20527e..86893ec4b3 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -385,7 +385,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_through_polymorphic_has_one
-    assert_equal Tagging.find(1,2).sort_by { |t| t.id }, authors(:david).tagging
+    assert_equal Tagging.find(1,2).sort_by { |t| t.id }, authors(:david).taggings_2
   end
 
   def test_has_many_through_polymorphic_has_many
diff --git a/activerecord/test/cases/helper.rb b/activerecord/test/cases/helper.rb
index 018064233a..4c6d4666ed 100644
--- a/activerecord/test/cases/helper.rb
+++ b/activerecord/test/cases/helper.rb
@@ -19,9 +19,6 @@ require 'support/connection'
 # Show backtraces for deprecated behavior for quicker cleanup.
 ActiveSupport::Deprecation.debug = true
 
-# Avoid deprecation warning setting dependent_restrict_raises to false. The default is true
-ActiveRecord::Base.dependent_restrict_raises = false
-
 # Connect to the database
 ARTest.connect
 
diff --git a/activerecord/test/cases/multiple_db_test.rb b/activerecord/test/cases/multiple_db_test.rb
index 06d6596725..42461e8ecb 100644
--- a/activerecord/test/cases/multiple_db_test.rb
+++ b/activerecord/test/cases/multiple_db_test.rb
@@ -1,9 +1,7 @@
 require "cases/helper"
 require 'models/entrant'
 require 'models/bird'
-
-# So we can test whether Course.connection survives a reload.
-require_dependency 'models/course'
+require 'models/course'
 
 class MultipleDbTest < ActiveRecord::TestCase
   self.use_transactional_fixtures = false
diff --git a/activerecord/test/cases/timestamp_test.rb b/activerecord/test/cases/timestamp_test.rb
index 7444dc5de1..bb034848e1 100644
--- a/activerecord/test/cases/timestamp_test.rb
+++ b/activerecord/test/cases/timestamp_test.rb
@@ -114,9 +114,12 @@ class TimestampTest < ActiveRecord::TestCase
   end
 
   def test_saving_a_record_with_a_belongs_to_that_specifies_touching_a_specific_attribute_the_parent_should_update_that_attribute
-    Pet.belongs_to :owner, :touch => :happy_at
+    klass = Class.new(ActiveRecord::Base) do
+      def self.name; 'Pet'; end
+      belongs_to :owner, :touch => :happy_at
+    end
 
-    pet   = Pet.first
+    pet   = klass.first
     owner = pet.owner
     previously_owner_happy_at = owner.happy_at
 
@@ -124,14 +127,15 @@ class TimestampTest < ActiveRecord::TestCase
     pet.save
 
     assert_not_equal previously_owner_happy_at, pet.owner.happy_at
-  ensure
-    Pet.belongs_to :owner, :touch => true
   end
 
   def test_touching_a_record_with_a_belongs_to_that_uses_a_counter_cache_should_update_the_parent
-    Pet.belongs_to :owner, :counter_cache => :use_count, :touch => true
+    klass = Class.new(ActiveRecord::Base) do
+      def self.name; 'Pet'; end
+      belongs_to :owner, :counter_cache => :use_count, :touch => true
+    end
 
-    pet = Pet.first
+    pet = klass.first
     owner = pet.owner
     owner.update_columns(happy_at: 3.days.ago)
     previously_owner_updated_at = owner.updated_at
@@ -140,15 +144,15 @@ class TimestampTest < ActiveRecord::TestCase
     pet.save
 
     assert_not_equal previously_owner_updated_at, pet.owner.updated_at
-  ensure
-    Pet.belongs_to :owner, :touch => true
   end
 
   def test_touching_a_record_touches_parent_record_and_grandparent_record
-    Toy.belongs_to :pet, :touch => true
-    Pet.belongs_to :owner, :touch => true
+    klass = Class.new(ActiveRecord::Base) do
+      def self.name; 'Toy'; end
+      belongs_to :pet, :touch => true
+    end
 
-    toy = Toy.first
+    toy = klass.first
     pet = toy.pet
     owner = pet.owner
     time = 3.days.ago
@@ -158,8 +162,6 @@ class TimestampTest < ActiveRecord::TestCase
     owner.reload
 
     assert_not_equal time, owner.updated_at
-  ensure
-    Toy.belongs_to :pet
   end
 
   def test_timestamp_attributes_for_create
diff --git a/activerecord/test/models/author.rb b/activerecord/test/models/author.rb
index 3157d8fe7f..77f4a2ec87 100644
--- a/activerecord/test/models/author.rb
+++ b/activerecord/test/models/author.rb
@@ -93,8 +93,8 @@ class Author < ActiveRecord::Base
   has_many :author_favorites
   has_many :favorite_authors, -> { order('name') }, :through => :author_favorites
 
-  has_many :tagging,         :through => :posts
   has_many :taggings,        :through => :posts
+  has_many :taggings_2,      :through => :posts, :source => :tagging
   has_many :tags,            :through => :posts
   has_many :post_categories, :through => :posts, :source => :categories
   has_many :tagging_tags,    :through => :taggings, :source => :tag
diff --git a/activerecord/test/models/company.rb b/activerecord/test/models/company.rb
index 5bfbb5e855..75f38d275c 100644
--- a/activerecord/test/models/company.rb
+++ b/activerecord/test/models/company.rb
@@ -115,8 +115,20 @@ class DependentFirm < Company
 end
 
 class RestrictedFirm < Company
-  has_one :account, -> { order("id") }, :foreign_key => "firm_id", :dependent => :restrict
-  has_many :companies, -> { order("id") }, :foreign_key => 'client_of', :dependent => :restrict
+  ActiveSupport::Deprecation.silence do
+    has_one :account, -> { order("id") }, :foreign_key => "firm_id", :dependent => :restrict
+    has_many :companies, -> { order("id") }, :foreign_key => 'client_of', :dependent => :restrict
+  end
+end
+
+class RestrictedWithExceptionFirm < Company
+  has_one :account, -> { order("id") }, :foreign_key => "firm_id", :dependent => :restrict_with_exception
+  has_many :companies, -> { order("id") }, :foreign_key => 'client_of', :dependent => :restrict_with_exception
+end
+
+class RestrictedWithErrorFirm < Company
+  has_one :account, -> { order("id") }, :foreign_key => "firm_id", :dependent => :restrict_with_error
+  has_many :companies, -> { order("id") }, :foreign_key => 'client_of', :dependent => :restrict_with_error
 end
 
 class Client < Company
diff --git a/activerecord/test/models/member.rb b/activerecord/test/models/member.rb
index 359b29fac3..1134b09d8b 100644
--- a/activerecord/test/models/member.rb
+++ b/activerecord/test/models/member.rb
@@ -24,11 +24,10 @@ class Member < ActiveRecord::Base
 
   has_one :club_category, :through => :club, :source => :category
 
-  has_many :current_memberships
-  has_one :club_through_many, :through => :current_memberships, :source => :club
-
   has_many :current_memberships, -> { where :favourite => true }
   has_many :clubs, :through => :current_memberships
+
+  has_one :club_through_many, :through => :current_memberships, :source => :club
 end
 
 class SelfMember < ActiveRecord::Base
diff --git a/activerecord/test/support/connection.rb b/activerecord/test/support/connection.rb
index c176316a05..92736e0ca9 100644
--- a/activerecord/test/support/connection.rb
+++ b/activerecord/test/support/connection.rb
@@ -1,6 +1,6 @@
 require 'active_support/logger'
-require_dependency 'models/college'
-require_dependency 'models/course'
+require 'models/college'
+require 'models/course'
 
 module ARTest
   def self.connection_name