Merge branch 'master' into nested_has_many_through

Conflicts:
	activerecord/CHANGELOG
	activerecord/lib/active_record/association_preload.rb
	activerecord/lib/active_record/associations.rb
	activerecord/lib/active_record/associations/class_methods/join_dependency.rb
	activerecord/lib/active_record/associations/class_methods/join_dependency/join_association.rb
	activerecord/lib/active_record/associations/has_many_association.rb
	activerecord/lib/active_record/associations/has_many_through_association.rb
	activerecord/lib/active_record/associations/has_one_association.rb
	activerecord/lib/active_record/associations/has_one_through_association.rb
	activerecord/lib/active_record/associations/through_association_scope.rb
	activerecord/lib/active_record/reflection.rb
	activerecord/test/cases/associations/has_many_through_associations_test.rb
	activerecord/test/cases/associations/has_one_through_associations_test.rb
	activerecord/test/cases/reflection_test.rb
	activerecord/test/cases/relations_test.rb
	activerecord/test/fixtures/memberships.yml
	activerecord/test/models/categorization.rb
	activerecord/test/models/category.rb
	activerecord/test/models/member.rb
	activerecord/test/models/reference.rb
	activerecord/test/models/tagging.rb

100 files changed, 3354 insertions, 1068 deletions

diff --git a/activerecord/test/active_record/connection_adapters/fake_adapter.rb b/activerecord/test/active_record/connection_adapters/fake_adapter.rb
new file mode 100644
index 0000000000..1c2942170e
--- /dev/null
+++ b/activerecord/test/active_record/connection_adapters/fake_adapter.rb
@@ -0,0 +1,36 @@
+module ActiveRecord
+  class Base
+    def self.fake_connection(config)
+      ConnectionAdapters::FakeAdapter.new nil, logger
+    end
+  end
+
+  module ConnectionAdapters
+    class FakeAdapter < AbstractAdapter
+      attr_accessor :tables, :primary_keys
+
+      def initialize(connection, logger)
+        super
+        @tables       = []
+        @primary_keys = {}
+        @columns      = Hash.new { |h,k| h[k] = [] }
+      end
+
+      def primary_key(table)
+        @primary_keys[table]
+      end
+
+      def merge_column(table_name, name, sql_type = nil, options = {})
+        @columns[table_name] << ActiveRecord::ConnectionAdapters::Column.new(
+          name.to_s,
+          options[:default],
+          sql_type.to_s,
+          options[:null])
+      end
+
+      def columns(table_name, message)
+        @columns[table_name]
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapter_test.rb b/activerecord/test/cases/adapter_test.rb
index 646aa88d80..49b2e945c3 100644
--- a/activerecord/test/cases/adapter_test.rb
+++ b/activerecord/test/cases/adapter_test.rb
@@ -141,16 +141,4 @@ class AdapterTest < ActiveRecord::TestCase
       end
     end
   end
-
-  def test_add_limit_offset_should_sanitize_sql_injection_for_limit_without_comas
-    sql_inject = "1 select * from schema"
-    assert_no_match(/schema/, @connection.add_limit_offset!("", :limit=>sql_inject))
-    assert_no_match(/schema/, @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7))
-  end
-
-  def test_add_limit_offset_should_sanitize_sql_injection_for_limit_with_comas
-    sql_inject = "1, 7 procedure help()"
-    assert_no_match(/procedure/, @connection.add_limit_offset!("", :limit=>sql_inject))
-    assert_no_match(/procedure/, @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7))
-  end
 end
diff --git a/activerecord/test/cases/adapters/mysql/connection_test.rb b/activerecord/test/cases/adapters/mysql/connection_test.rb
index 62ffde558f..eb3f8143e7 100644
--- a/activerecord/test/cases/adapters/mysql/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql/connection_test.rb
@@ -102,7 +102,7 @@ class MysqlConnectionTest < ActiveRecord::TestCase
   end
 
   # Test that MySQL allows multiple results for stored procedures
-  if Mysql.const_defined?(:CLIENT_MULTI_RESULTS)
+  if defined?(Mysql) && Mysql.const_defined?(:CLIENT_MULTI_RESULTS)
     def test_multi_results
       rows = ActiveRecord::Base.connection.select_rows('CALL ten();')
       assert_equal 10, rows[0][0].to_i, "ten() did not return 10 as expected: #{rows.inspect}"
diff --git a/activerecord/test/cases/adapters/mysql/reserved_word_test.rb b/activerecord/test/cases/adapters/mysql/reserved_word_test.rb
index 90d8b0d923..43015098c9 100644
--- a/activerecord/test/cases/adapters/mysql/reserved_word_test.rb
+++ b/activerecord/test/cases/adapters/mysql/reserved_word_test.rb
@@ -78,24 +78,6 @@ class MysqlReservedWordTest < ActiveRecord::TestCase
   self.use_instantiated_fixtures = true
   self.use_transactional_fixtures = false
 
-  #fixtures :group
-
-  def test_fixtures
-    f = create_test_fixtures :select, :distinct, :group, :values, :distincts_selects
-
-    assert_nothing_raised {
-      f.each do |x|
-        x.delete_existing_fixtures
-      end
-    }
-
-    assert_nothing_raised {
-      f.each do |x|
-        x.insert_fixtures
-      end
-    }
-  end
-
   #activerecord model class with reserved-word table name
   def test_activerecord_model
     create_test_fixtures :select, :distinct, :group, :values, :distincts_selects
@@ -105,9 +87,9 @@ class MysqlReservedWordTest < ActiveRecord::TestCase
     assert_nothing_raised { x.save }
     x.order = 'y'
     assert_nothing_raised { x.save }
-    assert_nothing_raised { y = Group.find_by_order('y') }
-    assert_nothing_raised { y = Group.find(1) }
-    x = Group.find(1)
+    assert_nothing_raised { Group.find_by_order('y') }
+    assert_nothing_raised { Group.find(1) }
+    Group.find(1)
   end
 
   # has_one association with reserved-word table name
diff --git a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
index 90d8b0d923..1efa7deaeb 100644
--- a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
@@ -78,24 +78,6 @@ class MysqlReservedWordTest < ActiveRecord::TestCase
   self.use_instantiated_fixtures = true
   self.use_transactional_fixtures = false
 
-  #fixtures :group
-
-  def test_fixtures
-    f = create_test_fixtures :select, :distinct, :group, :values, :distincts_selects
-
-    assert_nothing_raised {
-      f.each do |x|
-        x.delete_existing_fixtures
-      end
-    }
-
-    assert_nothing_raised {
-      f.each do |x|
-        x.insert_fixtures
-      end
-    }
-  end
-
   #activerecord model class with reserved-word table name
   def test_activerecord_model
     create_test_fixtures :select, :distinct, :group, :values, :distincts_selects
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
index 234696adeb..b8abdface4 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
@@ -9,6 +9,11 @@ module ActiveRecord
                                        :timeout => 100
       end
 
+      def test_primary_key_returns_nil_for_no_pk
+        @conn.exec_query('create table ex(id int, data string)')
+        assert_nil @conn.primary_key('ex')
+      end
+
       def test_connection_no_db
         assert_raises(ArgumentError) do
           Base.sqlite3_connection {}
diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index 1820f95261..9006914508 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -17,7 +17,7 @@ require 'models/essay'
 class BelongsToAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :developers, :projects, :topics,
            :developers_projects, :computers, :authors, :author_addresses,
-           :posts, :tags, :taggings, :comments
+           :posts, :tags, :taggings, :comments, :sponsors, :members
 
   def test_belongs_to
     Client.find(3).firm.name
@@ -50,11 +50,6 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_nothing_raised { account.firm = account.firm }
   end
 
-  def test_triple_equality
-    assert Client.find(3).firm === Firm
-    assert Firm === Client.find(3).firm
-  end
-
   def test_type_mismatch
     assert_raise(ActiveRecord::AssociationTypeMismatch) { Account.find(1).firm = 1 }
     assert_raise(ActiveRecord::AssociationTypeMismatch) { Account.find(1).firm = Project.find(1) }
@@ -78,27 +73,14 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
     citibank_result = Client.find(:first, :conditions => {:name => "Citibank"}, :include => :firm_with_primary_key)
-    assert_not_nil citibank_result.instance_variable_get("@firm_with_primary_key")
+    assert citibank_result.association_cache.key?(:firm_with_primary_key)
   end
 
   def test_eager_loading_with_primary_key_as_symbol
     Firm.create("name" => "Apple")
     Client.create("name" => "Citibank", :firm_name => "Apple")
     citibank_result = Client.find(:first, :conditions => {:name => "Citibank"}, :include => :firm_with_primary_key_symbols)
-    assert_not_nil citibank_result.instance_variable_get("@firm_with_primary_key_symbols")
-  end
-
-  def test_no_unexpected_aliasing
-    first_firm = companies(:first_firm)
-    another_firm = companies(:another_firm)
-
-    citibank = Account.create("credit_limit" => 10)
-    citibank.firm = first_firm
-    original_proxy = citibank.firm
-    citibank.firm = another_firm
-
-    assert_equal first_firm.object_id, original_proxy.target.object_id
-    assert_equal another_firm.object_id, citibank.firm.target.object_id
+    assert citibank_result.association_cache.key?(:firm_with_primary_key_symbols)
   end
 
   def test_creating_the_belonging_object
@@ -133,6 +115,23 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal apple.name, client.firm_name
   end
 
+  def test_create!
+    client  = Client.create!(:name => "Jimmy")
+    account = client.create_account!(:credit_limit => 10)
+    assert_equal account, client.account
+    assert account.persisted?
+    client.save
+    client.reload
+    assert_equal account, client.account
+  end
+
+  def test_failing_create!
+    client  = Client.create!(:name => "Jimmy")
+    assert_raise(ActiveRecord::RecordInvalid) { client.create_account! }
+    assert_not_nil client.account
+    assert client.account.new_record?
+  end
+
   def test_natural_assignment_to_nil
     client = Client.find(3)
     client.firm = nil
@@ -159,6 +158,15 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_not_nil Company.find(3).firm_with_condition, "Microsoft should have a firm"
   end
 
+  def test_with_polymorphic_and_condition
+    sponsor = Sponsor.create
+    member = Member.create :name => "Bert"
+    sponsor.sponsorable = member
+
+    assert_equal member, sponsor.sponsorable
+    assert_nil sponsor.sponsorable_with_conditions
+  end
+
   def test_with_select
     assert_equal Company.find(2).firm_with_select.attributes.size, 1
     assert_equal Company.find(2, :include => :firm_with_select ).firm_with_select.attributes.size, 1
@@ -175,17 +183,6 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal 0, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply deleted"
   end
 
-  def test_belongs_to_with_primary_key_counter
-    debate = Topic.create("title" => "debate")
-    assert_equal 0, debate.send(:read_attribute, "replies_count"), "No replies yet"
-
-    trash = debate.replies_with_primary_key.create("title" => "blah!", "content" => "world around!")
-    assert_equal 1, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply created"
-
-    trash.destroy
-    assert_equal 0, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply deleted"
-  end
-
   def test_belongs_to_counter_with_assigning_nil
     p = Post.find(1)
     c = Comment.find(1)
@@ -198,16 +195,23 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal 1, Post.find(p.id).comments.size
   end
 
-  def test_belongs_to_with_primary_key_counter_with_assigning_nil
-    debate = Topic.create("title" => "debate")
-    reply  = Reply.create("title" => "blah!", "content" => "world around!", "parent_title" => "debate")
+  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")
+
+    assert_equal 1, debate.reload.replies_count
+    assert_equal 0, debate2.reload.replies_count
 
-    assert_equal debate.title, reply.parent_title
-    assert_equal 1, Topic.find(debate.id).send(:read_attribute, "replies_count")
+    reply.topic_with_primary_key = debate2
+
+    assert_equal 0, debate.reload.replies_count
+    assert_equal 1, debate2.reload.replies_count
 
     reply.topic_with_primary_key = nil
 
-    assert_equal 0, Topic.find(debate.id).send(:read_attribute, "replies_count")
+    assert_equal 0, debate.reload.replies_count
+    assert_equal 0, debate2.reload.replies_count
   end
 
   def test_belongs_to_counter_with_reassigning
@@ -311,13 +315,21 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal Firm.find(:first, :order => "id"), c.firm_with_basic_id
   end
 
-  def test_forgetting_the_load_when_foreign_key_enters_late
-    c = Client.new
-    assert_nil c.firm_with_basic_id
+  def test_setting_foreign_key_after_nil_target_loaded
+    client = Client.new
+    client.firm_with_basic_id
+    client.firm_id = 1
 
-    c.firm_id = 1
-    # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
-    assert_equal Firm.find(:first, :order => "id"), c.firm_with_basic_id
+    assert_equal companies(:first_firm), client.firm_with_basic_id
+  end
+
+  def test_polymorphic_setting_foreign_key_after_nil_target_loaded
+    sponsor = Sponsor.new
+    sponsor.sponsorable
+    sponsor.sponsorable_id = 1
+    sponsor.sponsorable_type = "Member"
+
+    assert_equal members(:groucho), sponsor.sponsorable
   end
 
   def test_field_name_same_as_foreign_key
@@ -419,6 +431,18 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_nil sponsor.sponsorable_id
   end
 
+  def test_assignment_updates_foreign_id_field_for_new_and_saved_records
+    client = Client.new
+    saved_firm = Firm.create :name => "Saved"
+    new_firm = Firm.new
+
+    client.firm = saved_firm
+    assert_equal saved_firm.id, client.client_of
+
+    client.firm = new_firm
+    assert_nil client.client_of
+  end
+
   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")
@@ -488,39 +512,118 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_reassigning_the_parent_id_updates_the_object
-    original_parent = Firm.create! :name => "original"
-    updated_parent = Firm.create! :name => "updated"
+    client = companies(:second_client)
+
+    client.firm
+    client.firm_with_condition
+    firm_proxy                = client.send(:association_instance_get, :firm)
+    firm_with_condition_proxy = client.send(:association_instance_get, :firm_with_condition)
 
-    client = Client.new("client_of" => original_parent.id)
-    assert_equal original_parent, client.firm
-    assert_equal original_parent, client.firm_with_condition
-    assert_equal original_parent, client.firm_with_other_name
+    assert !firm_proxy.stale_target?
+    assert !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 = updated_parent.id
-    assert_equal updated_parent, client.firm
-    assert_equal updated_parent, client.firm_with_condition
-    assert_equal updated_parent, client.firm_with_other_name
+    client.client_of = companies(:another_firm).id
+
+    assert firm_proxy.stale_target?
+    assert 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_polymorphic_reassignment_of_associated_id_updates_the_object
-    member1 = Member.create!
-    member2 = Member.create!
+    sponsor = sponsors(:moustache_club_sponsor_for_groucho)
+
+    sponsor.sponsorable
+    proxy = sponsor.send(:association_instance_get, :sponsorable)
 
-    sponsor = Sponsor.new("sponsorable_type" => "Member", "sponsorable_id" => member1.id)
-    assert_equal member1, sponsor.sponsorable
+    assert !proxy.stale_target?
+    assert_equal members(:groucho), sponsor.sponsorable
 
-    sponsor.sponsorable_id = member2.id
-    assert_equal member2, sponsor.sponsorable
+    sponsor.sponsorable_id = members(:some_other_guy).id
+
+    assert proxy.stale_target?
+    assert_equal members(:some_other_guy), sponsor.sponsorable
   end
 
   def test_polymorphic_reassignment_of_associated_type_updates_the_object
-    member1 = Member.create!
+    sponsor = sponsors(:moustache_club_sponsor_for_groucho)
+
+    sponsor.sponsorable
+    proxy = sponsor.send(:association_instance_get, :sponsorable)
+
+    assert !proxy.stale_target?
+    assert_equal members(:groucho), sponsor.sponsorable
 
-    sponsor = Sponsor.new("sponsorable_type" => "Member", "sponsorable_id" => member1.id)
-    assert_equal member1, sponsor.sponsorable
+    sponsor.sponsorable_type = 'Firm'
 
-    sponsor.sponsorable_type = "Firm"
-    assert_not_equal member1, sponsor.sponsorable
+    assert proxy.stale_target?
+    assert_equal companies(:first_firm), sponsor.sponsorable
   end
 
+  def test_reloading_association_with_key_change
+    client = companies(:second_client)
+    firm = client.association(:firm)
+
+    client.firm = companies(:another_firm)
+    firm.reload
+    assert_equal companies(:another_firm), firm.target
+
+    client.client_of = companies(:first_firm).id
+    firm.reload
+    assert_equal companies(:first_firm), firm.target
+  end
+
+  def test_polymorphic_counter_cache
+    tagging = taggings(:welcome_general)
+    post    = posts(:welcome)
+    comment = comments(:greetings)
+
+    assert_difference 'post.reload.taggings_count', -1 do
+      assert_difference 'comment.reload.taggings_count', +1 do
+        tagging.taggable = comment
+      end
+    end
+  end
+
+  def test_polymorphic_with_custom_foreign_type
+    sponsor = sponsors(:moustache_club_sponsor_for_groucho)
+    groucho = members(:groucho)
+    other   = members(:some_other_guy)
+
+    assert_equal groucho, sponsor.sponsorable
+    assert_equal groucho, sponsor.thing
+
+    sponsor.thing = other
+
+    assert_equal other, sponsor.sponsorable
+    assert_equal other, sponsor.thing
+
+    sponsor.sponsorable = groucho
+
+    assert_equal groucho, sponsor.sponsorable
+    assert_equal groucho, sponsor.thing
+  end
+
+  def test_build_with_conditions
+    client = companies(:second_client)
+    firm   = client.build_bob_firm
+
+    assert_equal "Bob", firm.name
+  end
+
+  def test_create_with_conditions
+    client = companies(:second_client)
+    firm   = client.create_bob_firm
+
+    assert_equal "Bob", firm.name
+  end
+
+  def test_create_bang_with_conditions
+    client = companies(:second_client)
+    firm   = client.create_bob_firm!
+
+    assert_equal "Bob", firm.name
+  end
 end
diff --git a/activerecord/test/cases/associations/callbacks_test.rb b/activerecord/test/cases/associations/callbacks_test.rb
index 6a30e2905b..2d0d4541b4 100644
--- a/activerecord/test/cases/associations/callbacks_test.rb
+++ b/activerecord/test/cases/associations/callbacks_test.rb
@@ -3,6 +3,7 @@ require 'models/post'
 require 'models/author'
 require 'models/project'
 require 'models/developer'
+require 'models/company'
 
 class AssociationCallbacksTest < ActiveRecord::TestCase
   fixtures :posts, :authors, :projects, :developers
@@ -81,6 +82,14 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
     assert_equal callback_log, jack.post_log
   end
 
+  def test_has_many_callbacks_for_destroy_on_parent
+    firm = Firm.create! :name => "Firm"
+    client = firm.clients.create! :name => "Client"
+    firm.destroy
+
+    assert_equal ["before_remove#{client.id}", "after_remove#{client.id}"], firm.log
+  end
+
   def test_has_and_belongs_to_many_add_callback
     david = developers(:david)
     ar = projects(:active_record)
diff --git a/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb b/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
index fb59f63f91..d75791cab9 100644
--- a/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
+++ b/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
@@ -27,6 +27,7 @@ class EagerLoadIncludeFullStiClassNamesTest < ActiveRecord::TestCase
     post = Namespaced::Post.find_by_title( 'Great stuff', :include => :tagging )
     assert_nil post.tagging
 
+    ActiveRecord::IdentityMap.clear
     ActiveRecord::Base.store_full_sti_class = true
     post = Namespaced::Post.find_by_title( 'Great stuff', :include => :tagging )
     assert_instance_of Tagging, post.tagging
diff --git a/activerecord/test/cases/associations/eager_load_nested_include_test.rb b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
index c7671a8c22..2cf9f89c3c 100644
--- a/activerecord/test/cases/associations/eager_load_nested_include_test.rb
+++ b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
@@ -1,9 +1,11 @@
 require 'cases/helper'
 require 'models/post'
+require 'models/tag'
 require 'models/author'
 require 'models/comment'
 require 'models/category'
 require 'models/categorization'
+require 'models/tagging'
 require 'active_support/core_ext/array/random_access'
 
 module Remembered
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 949fbb9300..ed6337b596 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -17,18 +17,28 @@ require 'models/subscription'
 require 'models/book'
 require 'models/developer'
 require 'models/project'
+require 'models/member'
+require 'models/membership'
+require 'models/club'
+require 'models/categorization'
+require 'models/sponsor'
 
 class EagerAssociationTest < ActiveRecord::TestCase
   fixtures :posts, :comments, :authors, :author_addresses, :categories, :categories_posts,
-            :companies, :accounts, :tags, :taggings, :people, :readers,
+            :companies, :accounts, :tags, :taggings, :people, :readers, :categorizations,
             :owners, :pets, :author_favorites, :jobs, :references, :subscribers, :subscriptions, :books,
-            :developers, :projects, :developers_projects
+            :developers, :projects, :developers_projects, :members, :memberships, :clubs, :sponsors
 
   def setup
     # preheat table existence caches
     Comment.find_by_id(1)
   end
 
+  def test_eager_with_has_one_through_join_model_with_conditions_on_the_through
+    member = Member.find(members(:some_other_guy).id, :include => :favourite_club)
+    assert_nil member.favourite_club
+  end
+
   def test_loading_with_one_association
     posts = Post.find(:all, :include => :comments)
     post = posts.find { |p| p.id == 1 }
@@ -110,30 +120,29 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_load_associated_records_in_one_query_when_adapter_has_no_limit
     Post.connection.expects(:in_clause_length).at_least_once.returns(nil)
-    Post.expects(:i_was_called).with([1,2,3,4,5,6,7]).returns([1])
-    associated_records = Post.send(:associated_records, [1,2,3,4,5,6,7]) do |some_ids|
-      Post.i_was_called(some_ids)
+
+    post = posts(:welcome)
+    assert_queries(2) do
+      Post.includes(:comments).where(:id => post.id).to_a
     end
-    assert_equal [1], associated_records
   end
 
   def test_load_associated_records_in_several_queries_when_many_ids_passed
-    Post.connection.expects(:in_clause_length).at_least_once.returns(5)
-    Post.expects(:i_was_called).with([1,2,3,4,5]).returns([1])
-    Post.expects(:i_was_called).with([6,7]).returns([6])
-    associated_records = Post.send(:associated_records, [1,2,3,4,5,6,7]) do |some_ids|
-      Post.i_was_called(some_ids)
+    Post.connection.expects(:in_clause_length).at_least_once.returns(1)
+
+    post1, post2 = posts(:welcome), posts(:thinking)
+    assert_queries(3) do
+      Post.includes(:comments).where(:id => [post1.id, post2.id]).to_a
     end
-    assert_equal [1,6], associated_records
   end
 
   def test_load_associated_records_in_one_query_when_a_few_ids_passed
-    Post.connection.expects(:in_clause_length).at_least_once.returns(5)
-    Post.expects(:i_was_called).with([1,2,3]).returns([1])
-    associated_records = Post.send(:associated_records, [1,2,3]) do |some_ids|
-      Post.i_was_called(some_ids)
+    Post.connection.expects(:in_clause_length).at_least_once.returns(3)
+
+    post = posts(:welcome)
+    assert_queries(2) do
+      Post.includes(:comments).where(:id => post.id).to_a
     end
-    assert_equal [1], associated_records
   end
 
   def test_including_duplicate_objects_from_belongs_to
@@ -175,7 +184,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     author = authors(:david)
     post = author.post_about_thinking_with_last_comment
     last_comment = post.last_comment
-    author = assert_queries(3) { Author.find(author.id, :include => {:post_about_thinking_with_last_comment => :last_comment})} # find the author, then find the posts, then find the comments
+    author = assert_queries(ActiveRecord::IdentityMap.enabled? ? 2 : 3) { Author.find(author.id, :include => {:post_about_thinking_with_last_comment => :last_comment})} # find the author, then find the posts, then find the comments
     assert_no_queries do
       assert_equal post, author.post_about_thinking_with_last_comment
       assert_equal last_comment, author.post_about_thinking_with_last_comment.last_comment
@@ -186,7 +195,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     post = posts(:welcome)
     author = post.author
     author_address = author.author_address
-    post = assert_queries(3) { Post.find(post.id, :include => {:author_with_address => :author_address}) } # find the post, then find the author, then find the address
+    post = assert_queries(ActiveRecord::IdentityMap.enabled? ? 2 : 3) { Post.find(post.id, :include => {:author_with_address => :author_address}) } # find the post, then find the author, then find the address
     assert_no_queries do
       assert_equal author, post.author_with_address
       assert_equal author_address, post.author_with_address.author_address
@@ -202,6 +211,15 @@ class EagerAssociationTest < ActiveRecord::TestCase
     end
   end
 
+  def test_finding_with_includes_on_null_belongs_to_polymorphic_association
+    sponsor = sponsors(:moustache_club_sponsor_for_groucho)
+    sponsor.update_attributes!(:sponsorable => nil)
+    sponsor = assert_queries(1) { Sponsor.find(sponsor.id, :include => :sponsorable) }
+    assert_no_queries do
+      assert_equal nil, sponsor.sponsorable
+    end
+  end
+
   def test_loading_from_an_association
     posts = authors(:david).posts.find(:all, :include => :comments, :order => "posts.id")
     assert_equal 2, posts.first.comments.size
@@ -650,7 +668,11 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_preload_with_interpolation
-    assert_equal [comments(:greetings)], Post.find(posts(:welcome).id, :include => :comments_with_interpolated_conditions).comments_with_interpolated_conditions
+    post = Post.includes(:comments_with_interpolated_conditions).find(posts(:welcome).id)
+    assert_equal [comments(:greetings)], post.comments_with_interpolated_conditions
+
+    post = Post.joins(:comments_with_interpolated_conditions).find(posts(:welcome).id)
+    assert_equal [comments(:greetings)], post.comments_with_interpolated_conditions
   end
 
   def test_polymorphic_type_condition
@@ -794,18 +816,18 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
-    posts = assert_queries(2) do
+    posts = assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) do
       Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => [:comments], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
-    posts = assert_queries(2) do
+    posts = assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) do
       Post.find(:all, :include => :author, :joins => {:taggings => :tag}, :conditions => "tags.name = 'General'", :order => 'posts.id')
     end
     assert_equal posts(:welcome, :thinking), posts
 
-    posts = assert_queries(2) do
+    posts = assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) do
       Post.find(:all, :include => :author, :joins => {:taggings => {:tag => :taggings}}, :conditions => "taggings_tags.super_tag_id=2", :order => 'posts.id')
     end
     assert_equal posts(:welcome, :thinking), posts
@@ -819,7 +841,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
-    posts = assert_queries(2) do
+    posts = assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) do
       Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => ["INNER JOIN comments on comments.post_id = posts.id"], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
     end
     assert_equal [posts(:welcome)], posts
@@ -836,6 +858,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_loading_with_conditions_on_join_model_preloads
+    Author.columns
+
     authors = assert_queries(2) do
       Author.find(:all, :include => :author_address, :joins => :comments, :conditions => "posts.title like 'Welcome%'")
     end
@@ -881,25 +905,55 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_preload_has_one_using_primary_key
-    expected = Firm.find(:first).account_using_primary_key
-    firm = Firm.find :first, :include => :account_using_primary_key
+    expected = accounts(:signals37)
+    firm = Firm.find :first, :include => :account_using_primary_key, :order => 'companies.id'
     assert_no_queries do
       assert_equal expected, firm.account_using_primary_key
     end
   end
 
   def test_include_has_one_using_primary_key
-    expected = Firm.find(1).account_using_primary_key
+    expected = accounts(:signals37)
     firm = Firm.find(:all, :include => :account_using_primary_key, :order => 'accounts.id').detect {|f| f.id == 1}
     assert_no_queries do
       assert_equal expected, firm.account_using_primary_key
     end
   end
 
-  def test_preloading_empty_polymorphic_parent
+  def test_preloading_empty_belongs_to
+    c = Client.create!(:name => 'Foo', :client_of => Company.maximum(:id) + 1)
+
+    client = assert_queries(2) { Client.preload(:firm).find(c.id) }
+    assert_no_queries { assert_nil client.firm }
+  end
+
+  def test_preloading_empty_belongs_to_polymorphic
     t = Tagging.create!(:taggable_type => 'Post', :taggable_id => Post.maximum(:id) + 1, :tag => tags(:general))
 
-    assert_queries(2) { @tagging = Tagging.preload(:taggable).find(t.id) }
-    assert_no_queries { assert ! @tagging.taggable }
+    tagging = assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) { Tagging.preload(:taggable).find(t.id) }
+    assert_no_queries { assert_nil tagging.taggable }
+  end
+
+  def test_preloading_through_empty_belongs_to
+    c = Client.create!(:name => 'Foo', :client_of => Company.maximum(:id) + 1)
+
+    client = assert_queries(2) { Client.preload(:accounts).find(c.id) }
+    assert_no_queries { assert client.accounts.empty? }
+  end
+
+  def test_preloading_has_many_through_with_uniq
+    mary = Author.includes(:unique_categorized_posts).where(:id => authors(:mary).id).first
+    assert_equal 1, mary.unique_categorized_posts.length
+    assert_equal 1, mary.unique_categorized_post_ids.length
+  end
+
+  def test_preloading_polymorphic_with_custom_foreign_type
+    sponsor = sponsors(:moustache_club_sponsor_for_groucho)
+    groucho = members(:groucho)
+
+    sponsor = assert_queries(2) {
+      Sponsor.includes(:thing).where(:id => sponsor.id).first
+    }
+    assert_no_queries { assert_equal groucho, sponsor.thing }
   end
 end
diff --git a/activerecord/test/cases/associations/extension_test.rb b/activerecord/test/cases/associations/extension_test.rb
index efaab8569e..24830a661a 100644
--- a/activerecord/test/cases/associations/extension_test.rb
+++ b/activerecord/test/cases/associations/extension_test.rb
@@ -30,6 +30,11 @@ class AssociationsExtensionsTest < ActiveRecord::TestCase
     assert_equal projects(:active_record), developers(:david).projects_extended_by_name_and_block.find_least_recent
   end
 
+  def test_extension_with_scopes
+    assert_equal comments(:greetings), posts(:welcome).comments.offset(1).find_most_recent
+    assert_equal comments(:greetings), posts(:welcome).comments.not_again.find_most_recent
+  end
+
   def test_marshalling_extensions
     david = developers(:david)
     assert_equal projects(:action_controller), david.projects.find_most_recent
@@ -47,12 +52,16 @@ class AssociationsExtensionsTest < ActiveRecord::TestCase
   end
 
   def test_extension_name
-    extension = Proc.new {}
-    name = :association_name
-
-    assert_equal 'DeveloperAssociationNameAssociationExtension', Developer.send(:create_extension_modules, name, extension, []).first.name
-    assert_equal 'MyApplication::Business::DeveloperAssociationNameAssociationExtension', MyApplication::Business::Developer.send(:create_extension_modules, name, extension, []).first.name
-    assert_equal 'MyApplication::Business::DeveloperAssociationNameAssociationExtension', MyApplication::Business::Developer.send(:create_extension_modules, name, extension, []).first.name
-    assert_equal 'MyApplication::Business::DeveloperAssociationNameAssociationExtension', MyApplication::Business::Developer.send(:create_extension_modules, name, extension, []).first.name
+    assert_equal 'DeveloperAssociationNameAssociationExtension', extension_name(Developer)
+    assert_equal 'MyApplication::Business::DeveloperAssociationNameAssociationExtension', extension_name(MyApplication::Business::Developer)
+    assert_equal 'MyApplication::Business::DeveloperAssociationNameAssociationExtension', extension_name(MyApplication::Business::Developer)
   end
+
+  private
+
+    def extension_name(model)
+      builder = ActiveRecord::Associations::Builder::HasMany.new(model, :association_name, {}) { }
+      builder.send(:wrap_block_extension)
+      builder.options[:extend].first.name
+    end
 end
diff --git a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
index 513f76255c..73d02c9676 100644
--- a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
@@ -72,7 +72,7 @@ class DeveloperWithCounterSQL < ActiveRecord::Base
     :join_table => "developers_projects",
     :association_foreign_key => "project_id",
     :foreign_key => "developer_id",
-    :counter_sql => 'SELECT COUNT(*) AS count_all FROM projects INNER JOIN developers_projects ON projects.id = developers_projects.project_id WHERE developers_projects.developer_id =#{id}'
+    :counter_sql => proc { "SELECT COUNT(*) AS count_all FROM projects INNER JOIN developers_projects ON projects.id = developers_projects.project_id WHERE developers_projects.developer_id =#{id}" }
 end
 
 class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
@@ -101,38 +101,6 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 't1', record[1]
   end
 
-  def test_should_record_timestamp_for_join_table
-    setup_data_for_habtm_case
-
-    con = ActiveRecord::Base.connection
-    sql = 'select * from countries_treaties'
-    record = con.select_rows(sql).last
-    assert_not_nil record[2]
-    assert_not_nil record[3]
-    if current_adapter?(:Mysql2Adapter, :OracleAdapter)
-      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[2].to_s(:db)
-      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[3].to_s(:db)
-    else
-      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[2]
-      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[3]
-    end
-  end
-
-  def test_should_record_timestamp_for_join_table_only_if_timestamp_should_be_recorded
-    begin
-      Treaty.record_timestamps = false
-      setup_data_for_habtm_case
-
-      con = ActiveRecord::Base.connection
-      sql = 'select * from countries_treaties'
-      record = con.select_rows(sql).last
-      assert_nil record[2]
-      assert_nil record[3]
-    ensure
-      Treaty.record_timestamps = true
-    end
-  end
-
   def test_has_and_belongs_to_many
     david = Developer.find(1)
 
@@ -218,34 +186,6 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 2, aredridel.projects(true).size
   end
 
-  def test_adding_uses_default_values_on_join_table
-    ac = projects(:action_controller)
-    assert !developers(:jamis).projects.include?(ac)
-    developers(:jamis).projects << ac
-
-    assert developers(:jamis, :reload).projects.include?(ac)
-    project = developers(:jamis).projects.detect { |p| p == ac }
-    assert_equal 1, project.access_level.to_i
-  end
-
-  def test_habtm_attribute_access_and_respond_to
-    project = developers(:jamis).projects[0]
-    assert project.has_attribute?("name")
-    assert project.has_attribute?("joined_on")
-    assert project.has_attribute?("access_level")
-    assert project.respond_to?("name")
-    assert project.respond_to?("name=")
-    assert project.respond_to?("name?")
-    assert project.respond_to?("joined_on")
-    # given that the 'join attribute' won't be persisted, I don't
-    # think we should define the mutators
-    #assert project.respond_to?("joined_on=")
-    assert project.respond_to?("joined_on?")
-    assert project.respond_to?("access_level")
-    #assert project.respond_to?("access_level=")
-    assert project.respond_to?("access_level?")
-  end
-
   def test_habtm_adding_before_save
     no_of_devels = Developer.count
     no_of_projects = Project.count
@@ -425,38 +365,41 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_removing_associations_on_destroy
     david = DeveloperWithBeforeDestroyRaise.find(1)
     assert !david.projects.empty?
-    assert_raise(RuntimeError) { david.destroy }
+    david.destroy
     assert david.projects.empty?
     assert DeveloperWithBeforeDestroyRaise.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = 1").empty?
   end
 
-  def test_additional_columns_from_join_table
-    assert_date_from_db Date.new(2004, 10, 10), Developer.find(1).projects.first.joined_on.to_date
-  end
-
   def test_destroying
     david = Developer.find(1)
-    active_record = Project.find(1)
+    project = Project.find(1)
     david.projects.reload
     assert_equal 2, david.projects.size
-    assert_equal 3, active_record.developers.size
+    assert_equal 3, project.developers.size
 
-    assert_difference "Project.count", -1 do
-      david.projects.destroy(active_record)
+    assert_no_difference "Project.count" do
+      david.projects.destroy(project)
     end
 
+    join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id} AND project_id = #{project.id}")
+    assert join_records.empty?
+
     assert_equal 1, david.reload.projects.size
     assert_equal 1, david.projects(true).size
   end
 
-  def test_destroying_array
+  def test_destroying_many
     david = Developer.find(1)
     david.projects.reload
+    projects = Project.all
 
-    assert_difference "Project.count", -Project.count do
-      david.projects.destroy(Project.find(:all))
+    assert_no_difference "Project.count" do
+      david.projects.destroy(*projects)
     end
 
+    join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id}")
+    assert join_records.empty?
+
     assert_equal 0, david.reload.projects.size
     assert_equal 0, david.projects(true).size
   end
@@ -465,7 +408,14 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     david = Developer.find(1)
     david.projects.reload
     assert !david.projects.empty?
-    david.projects.destroy_all
+
+    assert_no_difference "Project.count" do
+      david.projects.destroy_all
+    end
+
+    join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id}")
+    assert join_records.empty?
+
     assert david.projects.empty?
     assert david.projects(true).empty?
   end
@@ -675,25 +625,6 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_respond_to categories(:technology).select_testing_posts.find(:first), :correctness_marker
   end
 
-  def test_updating_attributes_on_rich_associations
-    david = projects(:action_controller).developers.first
-    david.name = "DHH"
-    assert_raise(ActiveRecord::ReadOnlyRecord) { david.save! }
-  end
-
-  def test_updating_attributes_on_rich_associations_with_limited_find_from_reflection
-    david = projects(:action_controller).selected_developers.first
-    david.name = "DHH"
-    assert_nothing_raised { david.save! }
-  end
-
-
-  def test_updating_attributes_on_rich_associations_with_limited_find
-    david = projects(:action_controller).developers.find(:all, :select => "developers.*").first
-    david.name = "DHH"
-    assert david.save!
-  end
-
   def test_join_table_alias
     assert_equal 3, Developer.find(:all, :include => {:projects => :developers}, :conditions => 'developers_projects_join.joined_on IS NOT NULL').size
   end
@@ -840,10 +771,13 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     david = Developer.find(1)
     # clear cache possibly created by other tests
     david.projects.reset_column_information
-    assert_queries(0) { david.projects.columns; david.projects.columns }
-    # and again to verify that reset_column_information clears the cache correctly
+
+    # One query for columns, one for primary key
+    assert_queries(2) { david.projects.columns; david.projects.columns }
+
+    ## and again to verify that reset_column_information clears the cache correctly
     david.projects.reset_column_information
-    assert_queries(0) { david.projects.columns; david.projects.columns }
+    assert_queries(2) { david.projects.columns; david.projects.columns }
   end
 
   def test_attributes_are_being_set_when_initialized_from_habm_association_with_where_clause
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index fb772bb8e6..ad774eb9ce 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -43,7 +43,7 @@ end
 class HasManyAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :categories, :companies, :developers, :projects,
            :developers_projects, :topics, :authors, :comments,
-           :people, :posts, :readers, :taggings
+           :people, :posts, :readers, :taggings, :cars
 
   def setup
     Client.destroyed_client_ids.clear
@@ -66,14 +66,36 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 'exotic', bulb.name
   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
+    car = cars(:honda)
+    original_scoped_methods = Bulb.scoped_methods
+
+    bulb = car.bulbs.build
+    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+
+    bulb = car.bulbs.create
+    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+
+    bulb = car.bulbs.create!
+    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+  end
+
   def test_no_sql_should_be_fired_if_association_already_loaded
     Car.create(:name => 'honda')
     bulbs = Car.first.bulbs
     bulbs.inspect # to load all instances of bulbs
+
     assert_no_queries do
       bulbs.first()
       bulbs.first({})
     end
+
+    assert_no_queries do
+      bulbs.last()
+      bulbs.last({})
+    end
   end
 
   def test_create_resets_cached_counters
@@ -257,7 +279,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_counting_using_finder_sql
     assert_equal 2, Firm.find(4).clients_using_sql.count
-    assert_equal 2, Firm.find(4).clients_using_multiline_sql.count
   end
 
   def test_belongs_to_sanity
@@ -608,7 +629,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal topic.replies.to_a.size, topic.replies_count
   end
 
-  def test_deleting_updates_counter_cache_without_dependent_destroy
+  def test_deleting_updates_counter_cache_without_dependent_option
     post = posts(:welcome)
 
     assert_difference "post.reload.taggings_count", -1 do
@@ -616,6 +637,24 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_deleting_updates_counter_cache_with_dependent_delete_all
+    post = posts(:welcome)
+    post.update_attribute(:taggings_with_delete_all_count, post.taggings_count)
+
+    assert_difference "post.reload.taggings_with_delete_all_count", -1 do
+      post.taggings_with_delete_all.delete(post.taggings_with_delete_all.first)
+    end
+  end
+
+  def test_deleting_updates_counter_cache_with_dependent_destroy
+    post = posts(:welcome)
+    post.update_attribute(:taggings_with_destroy_count, post.taggings_count)
+
+    assert_difference "post.reload.taggings_with_destroy_count", -1 do
+      post.taggings_with_destroy.delete(post.taggings_with_destroy.first)
+    end
+  end
+
   def test_deleting_a_collection
     force_signal37_to_load_all_clients_of_firm
     companies(:first_firm).clients_of_firm.create("name" => "Another Client")
@@ -628,8 +667,10 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_delete_all
     force_signal37_to_load_all_clients_of_firm
     companies(:first_firm).clients_of_firm.create("name" => "Another Client")
-    assert_equal 2, companies(:first_firm).clients_of_firm.size
-    companies(:first_firm).clients_of_firm.delete_all
+    clients = companies(:first_firm).clients_of_firm.to_a
+    assert_equal 2, clients.count
+    deleted = companies(:first_firm).clients_of_firm.delete_all
+    assert_equal clients.sort_by(&:id), deleted.sort_by(&:id)
     assert_equal 0, companies(:first_firm).clients_of_firm.size
     assert_equal 0, companies(:first_firm).clients_of_firm(true).size
   end
@@ -649,11 +690,12 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     client_id = firm.clients_of_firm.first.id
     assert_equal 1, firm.clients_of_firm.size
 
-    firm.clients_of_firm.clear
+    cleared = firm.clients_of_firm.clear
 
     assert_equal 0, firm.clients_of_firm.size
     assert_equal 0, firm.clients_of_firm(true).size
     assert_equal [], Client.destroyed_client_ids[firm.id]
+    assert_equal firm.clients_of_firm.object_id, cleared.object_id
 
     # Should not be destroyed since the association is not dependent.
     assert_nothing_raised do
@@ -664,9 +706,9 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_clearing_updates_counter_cache
     topic = Topic.first
 
-    topic.replies.clear
-    topic.reload
-    assert_equal 0, topic.replies_count
+    assert_difference 'topic.reload.replies_count', -1 do
+      topic.replies.clear
+    end
   end
 
   def test_clearing_a_dependent_association_collection
@@ -963,6 +1005,19 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert !firm.clients.include?(:first_client)
   end
 
+  def test_replace_failure
+    firm = companies(:first_firm)
+    account = Account.new
+    orig_accounts = firm.accounts.to_a
+
+    assert !account.valid?
+    assert !orig_accounts.empty?
+    assert_raise ActiveRecord::RecordNotSaved do
+      firm.accounts = [account]
+    end
+    assert_equal orig_accounts, firm.accounts
+  end
+
   def test_get_ids
     assert_equal [companies(:first_client).id, companies(:second_client).id], companies(:first_firm).client_ids
   end
@@ -1302,4 +1357,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal reply.id, first.id
     assert_equal true, first.approved?
   end
+
+  def test_to_a_should_dup_target
+    ary    = topics(:first).replies.to_a
+    target = topics(:first).replies.target
+
+    assert_not_equal target.object_id, ary.object_id
+  end
 end
diff --git a/activerecord/test/cases/associations/has_many_through_associations_test.rb b/activerecord/test/cases/associations/has_many_through_associations_test.rb
index 5fac52257c..9adaebe924 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -20,12 +20,15 @@ require 'models/subscription'
 require 'models/essay'
 require 'models/category'
 require 'models/owner'
+require 'models/categorization'
+require 'models/member'
+require 'models/membership'
+require 'models/club'
 
 class HasManyThroughAssociationsTest < ActiveRecord::TestCase
-  fixtures :posts, :readers, :people, :comments, :authors,
-           :owners, :pets, :toys, :jobs, :references, :companies,
-           :subscribers, :books, :subscriptions, :developers,
-           :essays, :categories, :owners
+  fixtures :posts, :readers, :people, :comments, :authors, :categories, :taggings, :tags,
+           :owners, :pets, :toys, :jobs, :references, :companies, :members, :author_addresses,
+           :subscribers, :books, :subscriptions, :developers, :categorizations, :essays
 
   # Dummies to force column loads so query counts are clean.
   def setup
@@ -33,6 +36,13 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     Reader.create :person_id => 0, :post_id => 0
   end
 
+  def test_include?
+    person = Person.new
+    post = Post.new
+    person.posts << post
+    assert person.posts.include?(post)
+  end
+
   def test_associate_existing
     assert_queries(2) { posts(:thinking); people(:david) }
 
@@ -47,6 +57,16 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     assert posts(:thinking).reload.people(true).include?(people(:david))
   end
 
+  def test_associate_existing_record_twice_should_add_to_target_twice
+    post   = posts(:thinking)
+    person = people(:david)
+
+    assert_difference 'post.people.to_a.count', 2 do
+      post.people << person
+      post.people << person
+    end
+  end
+
   def test_associating_new
     assert_queries(1) { posts(:thinking) }
     new_person = nil # so block binding catches it
@@ -94,6 +114,24 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     assert posts(:thinking).reload.people(true).collect(&:first_name).include?("Ted")
   end
 
+  def test_build_then_save_with_has_many_inverse
+    post   = posts(:thinking)
+    person = post.people.build(:first_name => "Bob")
+    person.save
+    post.reload
+
+    assert post.people.include?(person)
+  end
+
+  def test_build_then_save_with_has_one_inverse
+    post   = posts(:thinking)
+    person = post.single_people.build(:first_name => "Bob")
+    person.save
+    post.reload
+
+    assert post.single_people.include?(person)
+  end
+
   def test_delete_association
     assert_queries(2){posts(:welcome);people(:michael); }
 
@@ -109,8 +147,10 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_destroy_association
-    assert_difference ["Person.count", "Reader.count"], -1 do
-      posts(:welcome).people.destroy(people(:michael))
+    assert_no_difference "Person.count" do
+      assert_difference "Reader.count", -1 do
+        posts(:welcome).people.destroy(people(:michael))
+      end
     end
 
     assert posts(:welcome).reload.people.empty?
@@ -118,8 +158,10 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_destroy_all
-    assert_difference ["Person.count", "Reader.count"], -1 do
-      posts(:welcome).people.destroy_all
+    assert_no_difference "Person.count" do
+      assert_difference "Reader.count", -1 do
+        posts(:welcome).people.destroy_all
+      end
     end
 
     assert posts(:welcome).reload.people.empty?
@@ -132,6 +174,137 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_delete_through_belongs_to_with_dependent_nullify
+    Reference.make_comments = true
+
+    person    = people(:michael)
+    job       = jobs(:magician)
+    reference = Reference.where(:job_id => job.id, :person_id => person.id).first
+
+    assert_no_difference ['Job.count', 'Reference.count'] do
+      assert_difference 'person.jobs.count', -1 do
+        person.jobs_with_dependent_nullify.delete(job)
+      end
+    end
+
+    assert_equal nil, reference.reload.job_id
+  ensure
+    Reference.make_comments = false
+  end
+
+  def test_delete_through_belongs_to_with_dependent_delete_all
+    Reference.make_comments = true
+
+    person = people(:michael)
+    job    = jobs(:magician)
+
+    # Make sure we're not deleting everything
+    assert person.jobs.count >= 2
+
+    assert_no_difference 'Job.count' do
+      assert_difference ['person.jobs.count', 'Reference.count'], -1 do
+        person.jobs_with_dependent_delete_all.delete(job)
+      end
+    end
+
+    # Check that the destroy callback on Reference did not run
+    assert_equal nil, person.reload.comments
+  ensure
+    Reference.make_comments = false
+  end
+
+  def test_delete_through_belongs_to_with_dependent_destroy
+    Reference.make_comments = true
+
+    person = people(:michael)
+    job    = jobs(:magician)
+
+    # Make sure we're not deleting everything
+    assert person.jobs.count >= 2
+
+    assert_no_difference 'Job.count' do
+      assert_difference ['person.jobs.count', 'Reference.count'], -1 do
+        person.jobs_with_dependent_destroy.delete(job)
+      end
+    end
+
+    # Check that the destroy callback on Reference ran
+    assert_equal "Reference destroyed", person.reload.comments
+  ensure
+    Reference.make_comments = false
+  end
+
+  def test_belongs_to_with_dependent_destroy
+    person = PersonWithDependentDestroyJobs.find(1)
+
+    # Create a reference which is not linked to a job. This should not be destroyed.
+    person.references.create!
+
+    assert_no_difference 'Job.count' do
+      assert_difference 'Reference.count', -person.jobs.count do
+        person.destroy
+      end
+    end
+  end
+
+  def test_belongs_to_with_dependent_delete_all
+    person = PersonWithDependentDeleteAllJobs.find(1)
+
+    # Create a reference which is not linked to a job. This should not be destroyed.
+    person.references.create!
+
+    assert_no_difference 'Job.count' do
+      assert_difference 'Reference.count', -person.jobs.count do
+        person.destroy
+      end
+    end
+  end
+
+  def test_belongs_to_with_dependent_nullify
+    person = PersonWithDependentNullifyJobs.find(1)
+
+    references = person.references.to_a
+
+    assert_no_difference ['Reference.count', 'Job.count'] do
+      person.destroy
+    end
+
+    references.each do |reference|
+      assert_equal nil, reference.reload.job_id
+    end
+  end
+
+  def test_update_counter_caches_on_delete
+    post = posts(:welcome)
+    tag  = post.tags.create!(:name => 'doomed')
+
+    assert_difference ['post.reload.taggings_count', 'post.reload.tags_count'], -1 do
+      posts(:welcome).tags.delete(tag)
+    end
+  end
+
+  def test_update_counter_caches_on_delete_with_dependent_destroy
+    post = posts(:welcome)
+    tag  = post.tags.create!(:name => 'doomed')
+    post.update_attribute(:tags_with_destroy_count, post.tags.count)
+
+    assert_difference ['post.reload.taggings_count', 'post.reload.tags_with_destroy_count'], -1 do
+      posts(:welcome).tags_with_destroy.delete(tag)
+    end
+  end
+
+  def test_update_counter_caches_on_delete_with_dependent_nullify
+    post = posts(:welcome)
+    tag  = post.tags.create!(:name => 'doomed')
+    post.update_attribute(:tags_with_nullify_count, post.tags.count)
+
+    assert_no_difference 'post.reload.taggings_count' do
+      assert_difference 'post.reload.tags_with_nullify_count', -1 do
+        posts(:welcome).tags_with_nullify.delete(tag)
+      end
+    end
+  end
+
   def test_replace_association
     assert_queries(4){posts(:welcome);people(:david);people(:michael); posts(:welcome).people(true)}
 
@@ -326,12 +499,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     assert_equal 2, people(:michael).jobs.size
   end
 
-  def test_get_ids_for_belongs_to_source
-    assert_sql(/DISTINCT/) { assert_equal [posts(:welcome).id, posts(:authorless).id].sort, people(:michael).post_ids.sort }
-  end
-
-  def test_get_ids_for_has_many_source
-    assert_equal [comments(:eager_other_comment1).id], authors(:mary).comment_ids
+  def test_get_ids
+    assert_equal [posts(:welcome).id, posts(:authorless).id].sort, people(:michael).post_ids.sort
   end
 
   def test_get_ids_for_loaded_associations
@@ -392,6 +561,41 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     ].each {|block| assert_raise(ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection, &block) }
   end
 
+  def test_has_many_association_through_a_has_many_association_to_self
+    sarah = Person.create!(:first_name => 'Sarah', :primary_contact_id => people(:susan).id, :gender => 'F', :number1_fan_id => 1)
+    john = Person.create!(:first_name => 'John', :primary_contact_id => sarah.id, :gender => 'M', :number1_fan_id => 1)
+    assert_equal sarah.agents, [john]
+    assert_equal people(:susan).agents.map(&:agents).flatten, people(:susan).agents_of_agents
+  end
+
+  def test_associate_existing_with_nonstandard_primary_key_on_belongs_to
+    Categorization.create(:author => authors(:mary), :named_category_name => categories(:general).name)
+    assert_equal categories(:general), authors(:mary).named_categories.first
+  end
+
+  def test_collection_build_with_nonstandard_primary_key_on_belongs_to
+    author   = authors(:mary)
+    category = author.named_categories.build(:name => "Primary")
+    author.save
+    assert Categorization.exists?(:author_id => author.id, :named_category_name => category.name)
+    assert author.named_categories(true).include?(category)
+  end
+
+  def test_collection_create_with_nonstandard_primary_key_on_belongs_to
+    author   = authors(:mary)
+    category = author.named_categories.create(:name => "Primary")
+    assert Categorization.exists?(:author_id => author.id, :named_category_name => category.name)
+    assert author.named_categories(true).include?(category)
+  end
+
+  def test_collection_delete_with_nonstandard_primary_key_on_belongs_to
+    author   = authors(:mary)
+    category = author.named_categories.create(:name => "Primary")
+    author.named_categories.delete(category)
+    assert !Categorization.exists?(:author_id => author.id, :named_category_name => category.name)
+    assert author.named_categories(true).empty?
+  end
+
   def test_collection_singular_ids_getter_with_string_primary_keys
     book = books(:awdr)
     assert_equal 2, book.subscriber_ids.size
@@ -478,4 +682,88 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     post.people << people(:michael)
     assert_equal readers + 1, post.readers.size
   end
+
+  def test_has_many_through_with_default_scope_on_join_model
+    assert_equal posts(:welcome).comments.order('id').all, authors(:david).comments_on_first_posts
+  end
+
+  def test_create_has_many_through_with_default_scope_on_join_model
+    category = authors(:david).special_categories.create(:name => "Foo")
+    assert_equal 1, category.categorizations.where(:special => true).count
+  end
+
+  def test_joining_has_many_through_with_uniq
+    mary = Author.joins(:unique_categorized_posts).where(:id => authors(:mary).id).first
+    assert_equal 1, mary.unique_categorized_posts.length
+    assert_equal 1, mary.unique_categorized_post_ids.length
+  end
+
+  def test_joining_has_many_through_belongs_to
+    posts = Post.joins(:author_categorizations).order('posts.id').
+                 where('categorizations.id' => categorizations(:mary_thinking_sti).id)
+
+    assert_equal [posts(:eager_other), posts(:misc_by_mary), posts(:other_by_mary)], posts
+  end
+
+  def test_select_chosen_fields_only
+    author = authors(:david)
+    assert_equal ['body'], author.comments.select('comments.body').first.attributes.keys
+  end
+
+  def test_get_has_many_through_belongs_to_ids_with_conditions
+    assert_equal [categories(:general).id], authors(:mary).categories_like_general_ids
+  end
+
+  def test_count_has_many_through_with_named_scope
+    assert_equal 2, authors(:mary).categories.count
+    assert_equal 1, authors(:mary).categories.general.count
+  end
+
+  def test_has_many_through_belongs_to_should_update_when_the_through_foreign_key_changes
+    post = posts(:eager_other)
+
+    post.author_categorizations
+    proxy = post.send(:association_instance_get, :author_categorizations)
+
+    assert !proxy.stale_target?
+    assert_equal authors(:mary).categorizations.sort_by(&:id), post.author_categorizations.sort_by(&:id)
+
+    post.author_id = authors(:david).id
+
+    assert proxy.stale_target?
+    assert_equal authors(:david).categorizations.sort_by(&:id), post.author_categorizations.sort_by(&:id)
+  end
+
+  def test_create_with_conditions_hash_on_through_association
+    member = members(:groucho)
+    club   = member.clubs.create!
+
+    assert_equal true, club.reload.membership.favourite
+  end
+
+  def test_deleting_from_has_many_through_a_belongs_to_should_not_try_to_update_counter
+    post    = posts(:welcome)
+    address = author_addresses(:david_address)
+
+    assert post.author_addresses.include?(address)
+    post.author_addresses.delete(address)
+    assert post[:author_count].nil?
+  end
+
+  def test_interpolated_conditions
+    post = posts(:welcome)
+    assert !post.tags.empty?
+    assert_equal post.tags, post.interpolated_tags
+    assert_equal post.tags, post.interpolated_tags_2
+  end
+
+  def test_primary_key_option_on_source
+    post     = posts(:welcome)
+    category = categories(:general)
+    categorization = Categorization.create!(:post_id => post.id, :named_category_name => category.name)
+
+    assert_equal [category], post.named_categories
+    assert_equal [category.name], post.named_category_ids # checks when target loaded
+    assert_equal [category.name], post.reload.named_category_ids # checks when target no loaded
+  end
 end
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index 64449df8f5..c1dad5e246 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -2,9 +2,13 @@ require "cases/helper"
 require 'models/developer'
 require 'models/project'
 require 'models/company'
+require 'models/ship'
+require 'models/pirate'
+require 'models/bulb'
 
 class HasOneAssociationsTest < ActiveRecord::TestCase
-  fixtures :accounts, :companies, :developers, :projects, :developers_projects
+  self.use_transactional_fixtures = false unless supports_savepoints?
+  fixtures :accounts, :companies, :developers, :projects, :developers_projects, :ships, :pirates
 
   def setup
     Account.destroyed_account_ids.clear
@@ -62,11 +66,6 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_nothing_raised { company.account = company.account }
   end
 
-  def test_triple_equality
-    assert Account === companies(:first_firm).account
-    assert companies(:first_firm).account === Account
-  end
-
   def test_type_mismatch
     assert_raise(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).account = 1 }
     assert_raise(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).account = Project.find(1) }
@@ -91,18 +90,18 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   def test_nullification_on_association_change
     firm = companies(:rails_core)
     old_account_id = firm.account.id
-    firm.account = Account.new
+    firm.account = Account.new(:credit_limit => 5)
     # account is dependent with nullify, therefore its firm_id should be nil
     assert_nil Account.find(old_account_id).firm_id
   end
 
   def test_association_change_calls_delete
-    companies(:first_firm).deletable_account = Account.new
+    companies(:first_firm).deletable_account = Account.new(:credit_limit => 5)
     assert_equal [], Account.destroyed_account_ids[companies(:first_firm).id]
   end
 
   def test_association_change_calls_destroy
-    companies(:first_firm).account = Account.new
+    companies(:first_firm).account = Account.new(:credit_limit => 5)
     assert_equal [companies(:first_firm).id], Account.destroyed_account_ids[companies(:first_firm).id]
   end
 
@@ -116,35 +115,6 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_equal company.account, account
   end
 
-  def test_assignment_without_replacement
-    apple = Firm.create("name" => "Apple")
-    citibank = Account.create("credit_limit" => 10)
-    apple.account = citibank
-    assert_equal apple.id, citibank.firm_id
-
-    hsbc = apple.build_account({ :credit_limit => 20}, false)
-    assert_equal apple.id, hsbc.firm_id
-    hsbc.save
-    assert_equal apple.id, citibank.firm_id
-
-    nykredit = apple.create_account({ :credit_limit => 30}, false)
-    assert_equal apple.id, nykredit.firm_id
-    assert_equal apple.id, citibank.firm_id
-    assert_equal apple.id, hsbc.firm_id
-  end
-
-  def test_assignment_without_replacement_on_create
-    apple = Firm.create("name" => "Apple")
-    citibank = Account.create("credit_limit" => 10)
-    apple.account = citibank
-    assert_equal apple.id, citibank.firm_id
-
-    hsbc = apple.create_account({:credit_limit => 10}, false)
-    assert_equal apple.id, hsbc.firm_id
-    hsbc.save
-    assert_equal apple.id, citibank.firm_id
-  end
-
   def test_dependence
     num_accounts = Account.count
 
@@ -193,13 +163,18 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_equal account, firm.account
   end
 
-  def test_build_association_twice_without_saving_affects_nothing
-    count_of_account = Account.count
-    firm = Firm.find(:first)
-    firm.build_account("credit_limit" => 1000)
-    firm.build_account("credit_limit" => 2000)
+  def test_build_and_create_should_not_happen_within_scope
+    pirate = pirates(:blackbeard)
+    original_scoped_methods = Bulb.scoped_methods.dup
 
-    assert_equal count_of_account, Account.count
+    bulb = pirate.build_bulb
+    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+
+    bulb = pirate.create_bulb
+    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+
+    bulb = pirate.create_bulb!
+    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
   end
 
   def test_create_association
@@ -208,25 +183,32 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_equal account, firm.reload.account
   end
 
-  def test_build
-    firm = Firm.new("name" => "GlobalMegaCorp")
-    firm.save
+  def test_create_association_with_bang
+    firm = Firm.create(:name => "GlobalMegaCorp")
+    account = firm.create_account!(:credit_limit => 1000)
+    assert_equal account, firm.reload.account
+  end
 
-    firm.account = account = Account.new("credit_limit" => 1000)
-    assert_equal account, firm.account
-    assert account.save
-    assert_equal account, firm.account
+  def test_create_association_with_bang_failing
+    firm = Firm.create(:name => "GlobalMegaCorp")
+    assert_raise ActiveRecord::RecordInvalid do
+      firm.create_account!
+    end
+    account = firm.account
+    assert_not_nil account
+    account.credit_limit = 5
+    account.save
+    assert_equal account, firm.reload.account
   end
 
-  def test_failing_build_association
+  def test_build
     firm = Firm.new("name" => "GlobalMegaCorp")
     firm.save
 
-    firm.account = account = Account.new
+    firm.account = account = Account.new("credit_limit" => 1000)
     assert_equal account, firm.account
-    assert !account.save
+    assert account.save
     assert_equal account, firm.account
-    assert_equal ["can't be empty"], account.errors["credit_limit"]
   end
 
   def test_create
@@ -330,4 +312,51 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     new_account = companies(:first_firm).build_account(:firm_name => 'Account')
     assert_equal new_account.firm_name, "Account"
   end
+
+  def test_creation_failure_without_dependent_option
+    pirate = pirates(:blackbeard)
+    orig_ship = pirate.ship
+
+    assert_equal ships(:black_pearl), orig_ship
+    new_ship = pirate.create_ship
+    assert_not_equal ships(:black_pearl), new_ship
+    assert_equal new_ship, pirate.ship
+    assert new_ship.new_record?
+    assert_nil orig_ship.pirate_id
+    assert !orig_ship.changed? # check it was saved
+  end
+
+  def test_creation_failure_with_dependent_option
+    pirate = pirates(:blackbeard).becomes(DestructivePirate)
+    orig_ship = pirate.dependent_ship
+
+    new_ship = pirate.create_dependent_ship
+    assert new_ship.new_record?
+    assert orig_ship.destroyed?
+  end
+
+  def test_replacement_failure_due_to_existing_record_should_raise_error
+    pirate = pirates(:blackbeard)
+    pirate.ship.name = nil
+
+    assert !pirate.ship.valid?
+    assert_raise(ActiveRecord::RecordNotSaved) do
+      pirate.ship = ships(:interceptor)
+    end
+    assert_equal ships(:black_pearl), pirate.ship
+    assert_equal pirate.id, pirate.ship.pirate_id
+  end
+
+  def test_replacement_failure_due_to_new_record_should_raise_error
+    pirate = pirates(:blackbeard)
+    new_ship = Ship.new
+
+    assert_raise(ActiveRecord::RecordNotSaved) do
+      pirate.ship = new_ship
+    end
+    assert_equal ships(:black_pearl), pirate.ship
+    assert_equal pirate.id, pirate.ship.pirate_id
+    assert_equal pirate.id, ships(:black_pearl).reload.pirate_id
+    assert_nil new_ship.pirate_id
+  end
 end
diff --git a/activerecord/test/cases/associations/has_one_through_associations_test.rb b/activerecord/test/cases/associations/has_one_through_associations_test.rb
index fc56233ba8..9ba5549277 100644
--- a/activerecord/test/cases/associations/has_one_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_through_associations_test.rb
@@ -13,10 +13,12 @@ require 'models/category'
 require 'models/author'
 require 'models/essay'
 require 'models/owner'
+require 'models/post'
+require 'models/comment'
 
 class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   fixtures :member_types, :members, :clubs, :memberships, :sponsors, :organizations, :minivans,
-           :dashboards, :speedometers, :categories, :authors, :essays, :owners
+           :dashboards, :speedometers, :authors, :posts, :comments, :categories, :essays, :owners
 
   def setup
     @member = members(:groucho)
@@ -26,10 +28,6 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     assert_equal clubs(:boring_club), @member.club
   end
 
-  def test_has_one_through_with_has_many
-    assert_equal clubs(:moustache_club), @member.favourite_club
-  end
-
   def test_creating_association_creates_through_record
     new_member = Member.create(:name => "Chris")
     new_member.club = Club.create(:name => "LRUG")
@@ -89,6 +87,18 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     assert_not_nil assert_no_queries {members[0].sponsor_club}
   end
 
+  def test_has_one_through_with_conditions_eager_loading
+    # conditions on the through table
+    assert_equal clubs(:moustache_club), Member.find(@member.id, :include => :favourite_club).favourite_club
+    memberships(:membership_of_favourite_club).update_attribute(:favourite, false)
+    assert_equal nil,                    Member.find(@member.id, :include => :favourite_club).reload.favourite_club
+
+    # conditions on the source table
+    assert_equal clubs(:moustache_club), Member.find(@member.id, :include => :hairy_club).hairy_club
+    clubs(:moustache_club).update_attribute(:name, "Association of Clean-Shaven Persons")
+    assert_equal nil,                    Member.find(@member.id, :include => :hairy_club).reload.hairy_club
+  end
+
   def test_has_one_through_polymorphic_with_source_type
     assert_equal members(:groucho), clubs(:moustache_club).sponsored_member
   end
@@ -132,7 +142,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   def test_assigning_association_correctly_assigns_target
     new_member = Member.create(:name => "Chris")
     new_member.club = new_club = Club.create(:name => "LRUG")
-    assert_equal new_club, new_member.club.target
+    assert_equal new_club, new_member.association(:club).target
   end
 
   def test_has_one_through_proxy_should_not_respond_to_private_methods
@@ -190,7 +200,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
       MemberDetail.find(:all, :include => :member_type)
     end
     @new_detail = @member_details[0]
-    assert @new_detail.loaded_member_type?
+    assert @new_detail.send(:association, :member_type).loaded?
     assert_not_nil assert_no_queries { @new_detail.member_type }
   end
 
@@ -253,4 +263,51 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     authors = Author.joins(:essay_category_2).where('categories.id' => categories(:general).id)
     assert_equal authors(:david), authors.first
   end
+
+  def test_has_one_through_with_default_scope_on_join_model
+    assert_equal posts(:welcome).comments.order('id').first, authors(:david).comment_on_first_post
+  end
+
+  def test_has_one_through_many_raises_exception
+    assert_raise(ActiveRecord::HasOneThroughCantAssociateThroughCollection) do
+      members(:groucho).club_through_many
+    end
+  end
+
+  def test_has_one_through_belongs_to_should_update_when_the_through_foreign_key_changes
+    minivan = minivans(:cool_first)
+
+    minivan.dashboard
+    proxy = minivan.send(:association_instance_get, :dashboard)
+
+    assert !proxy.stale_target?
+    assert_equal dashboards(:cool_first), minivan.dashboard
+
+    minivan.speedometer_id = speedometers(:second).id
+
+    assert proxy.stale_target?
+    assert_equal dashboards(:second), minivan.dashboard
+  end
+
+  def test_has_one_through_belongs_to_setting_belongs_to_foreign_key_after_nil_target_loaded
+    minivan = Minivan.new
+
+    minivan.dashboard
+    proxy = minivan.send(:association_instance_get, :dashboard)
+
+    minivan.speedometer_id = speedometers(:second).id
+
+    assert proxy.stale_target?
+    assert_equal dashboards(:second), minivan.dashboard
+  end
+
+  def test_assigning_has_one_through_belongs_to_with_new_record_owner
+    minivan   = Minivan.new
+    dashboard = dashboards(:cool_first)
+
+    minivan.dashboard = dashboard
+
+    assert_equal dashboard, minivan.dashboard
+    assert_equal dashboard, minivan.speedometer.dashboard
+  end
 end
diff --git a/activerecord/test/cases/associations/identity_map_test.rb b/activerecord/test/cases/associations/identity_map_test.rb
new file mode 100644
index 0000000000..9b8635774c
--- /dev/null
+++ b/activerecord/test/cases/associations/identity_map_test.rb
@@ -0,0 +1,137 @@
+require "cases/helper"
+require 'models/author'
+require 'models/post'
+
+if ActiveRecord::IdentityMap.enabled?
+class InverseHasManyIdentityMapTest < ActiveRecord::TestCase
+  fixtures :authors, :posts
+
+  def test_parent_instance_should_be_shared_with_every_child_on_find
+    m = Author.first
+    is = m.posts
+    is.each do |i|
+      assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+      m.name = 'Bongo'
+      assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+      i.author.name = 'Mungo'
+      assert_equal m.name, i.author.name, "Name of man should be the same after changes to child-owned instance"
+    end
+  end
+
+  def test_parent_instance_should_be_shared_with_eager_loaded_children
+    m = Author.find(:first, :include => :posts)
+    is = m.posts
+    is.each do |i|
+      assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+      m.name = 'Bongo'
+      assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+      i.author.name = 'Mungo'
+      assert_equal m.name, i.author.name, "Name of man should be the same after changes to child-owned instance"
+    end
+
+    m = Author.find(:first, :include => :posts, :order => 'posts.id')
+    is = m.posts
+    is.each do |i|
+      assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+      m.name = 'Bongo'
+      assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+      i.author.name = 'Mungo'
+      assert_equal m.name, i.author.name, "Name of man should be the same after changes to child-owned instance"
+    end
+  end
+
+  def test_parent_instance_should_be_shared_with_newly_built_child
+    m = Author.first
+    i = m.posts.build(:title => 'Industrial Revolution Re-enactment', :body => 'Lorem ipsum')
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to just-built-child-owned instance"
+  end
+
+  def test_parent_instance_should_be_shared_with_newly_block_style_built_child
+    m = Author.first
+    i = m.posts.build {|ii| ii.title = 'Industrial Revolution Re-enactment'; ii.body = 'Lorem ipsum'}
+    assert_not_nil i.title, "Child attributes supplied to build via blocks should be populated"
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to just-built-child-owned instance"
+  end
+
+  def test_parent_instance_should_be_shared_with_newly_created_child
+    m = Author.first
+    i = m.posts.create(:title => 'Industrial Revolution Re-enactment', :body => 'Lorem ipsum')
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+  end
+
+  def test_parent_instance_should_be_shared_with_newly_created_via_bang_method_child
+    m = Author.first
+    i = m.posts.create!(:title => 'Industrial Revolution Re-enactment', :body => 'Lorem ipsum')
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+  end
+
+  def test_parent_instance_should_be_shared_with_newly_block_style_created_child
+    m = Author.first
+    i = m.posts.create {|ii| ii.title = 'Industrial Revolution Re-enactment'; ii.body = 'Lorem ipsum'}
+    assert_not_nil i.title, "Child attributes supplied to create via blocks should be populated"
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+  end
+
+  def test_parent_instance_should_be_shared_with_poked_in_child
+    m = Author.first
+    i = Post.create(:title => 'Industrial Revolution Re-enactment', :body => 'Lorem ipsum')
+    m.posts << i
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+  end
+
+  def test_parent_instance_should_be_shared_with_replaced_via_accessor_children
+    m = Author.first
+    i = Post.new(:title => 'Industrial Revolution Re-enactment', :body => 'Lorem ipsum')
+    m.posts = [i]
+    assert_same m, i.author
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to replaced-child-owned instance"
+  end
+
+  def test_parent_instance_should_be_shared_with_replaced_via_method_children
+    m = Author.first
+    i = Post.new(:title => 'Industrial Revolution Re-enactment', :body => 'Lorem ipsum')
+    m.posts = [i]
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to replaced-child-owned instance"
+  end
+end
+end
diff --git a/activerecord/test/cases/associations/inner_join_association_test.rb b/activerecord/test/cases/associations/inner_join_association_test.rb
index 780eabc443..e2228228a3 100644
--- a/activerecord/test/cases/associations/inner_join_association_test.rb
+++ b/activerecord/test/cases/associations/inner_join_association_test.rb
@@ -4,6 +4,7 @@ require 'models/comment'
 require 'models/author'
 require 'models/category'
 require 'models/categorization'
+require 'models/person'
 require 'models/tagging'
 require 'models/tag'
 
@@ -16,6 +17,13 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
     assert_equal authors(:david), result.first
   end
 
+  def test_construct_finder_sql_does_not_table_name_collide_on_duplicate_associations
+    assert_nothing_raised do
+      sql = Person.joins(:agents => {:agents => :agents}).joins(:agents => {:agents => {:primary_contact => :agents}}).to_sql
+      assert_match(/agents_people_4/i, sql)
+    end
+  end
+
   def test_construct_finder_sql_ignores_empty_joins_hash
     sql = Author.joins({}).to_sql
     assert_no_match(/JOIN/i, sql)
@@ -65,21 +73,21 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
     authors_with_welcoming_post_titles = Author.calculate(:count, 'authors.id', :joins => :posts, :distinct => true, :conditions => "posts.title like 'Welcome%'")
     assert_equal real_count, authors_with_welcoming_post_titles, "inner join and conditions should have only returned authors posting titles starting with 'Welcome'"
   end
-  
+
   def test_find_with_sti_join
     scope = Post.joins(:special_comments).where(:id => posts(:sti_comments).id)
-    
+
     # The join should match SpecialComment and its subclasses only
     assert scope.where("comments.type" => "Comment").empty?
     assert !scope.where("comments.type" => "SpecialComment").empty?
     assert !scope.where("comments.type" => "SubSpecialComment").empty?
   end
-  
+
   def test_find_with_conditions_on_reflection
     assert !posts(:welcome).comments.empty?
     assert Post.joins(:nonexistant_comments).where(:id => posts(:welcome).id).empty? # [sic!]
   end
-  
+
   def test_find_with_conditions_on_through_reflection
     assert !posts(:welcome).tags.empty?
     assert Post.joins(:misc_tags).where(:id => posts(:welcome).id).empty?
diff --git a/activerecord/test/cases/associations/inverse_associations_test.rb b/activerecord/test/cases/associations/inverse_associations_test.rb
index 0491b2d1fa..76282213d8 100644
--- a/activerecord/test/cases/associations/inverse_associations_test.rb
+++ b/activerecord/test/cases/associations/inverse_associations_test.rb
@@ -114,7 +114,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_newly_built_child
-    m = men(:gordon)
+    m = Man.find(:first)
     f = m.build_face(:description => 'haunted')
     assert_not_nil f.man
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
@@ -125,7 +125,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_newly_created_child
-    m = men(:gordon)
+    m = Man.find(:first)
     f = m.create_face(:description => 'haunted')
     assert_not_nil f.man
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
@@ -137,40 +137,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
 
   def test_parent_instance_should_be_shared_with_newly_created_child_via_bang_method
     m = Man.find(:first)
-    f = m.face.create!(:description => 'haunted')
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
-  end
-
-  def test_parent_instance_should_be_shared_with_newly_built_child_when_we_dont_replace_existing
-    m = Man.find(:first)
-    f = m.build_face({:description => 'haunted'}, false)
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to just-built-child-owned instance"
-  end
-
-  def test_parent_instance_should_be_shared_with_newly_created_child_when_we_dont_replace_existing
-    m = Man.find(:first)
-    f = m.create_face({:description => 'haunted'}, false)
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
-  end
-
-  def test_parent_instance_should_be_shared_with_newly_created_child_via_bang_method_when_we_dont_replace_existing
-    m = Man.find(:first)
-    f = m.face.create!({:description => 'haunted'}, false)
+    f = m.create_face!(:description => 'haunted')
     assert_not_nil f.man
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
     m.name = 'Bongo'
@@ -191,30 +158,6 @@ class InverseHasOneTests < ActiveRecord::TestCase
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
   end
 
-  def test_parent_instance_should_be_shared_with_replaced_via_method_child
-    m = Man.find(:first)
-    f = Face.new(:description => 'haunted')
-    m.face.replace(f)
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
-  end
-
-  def test_parent_instance_should_be_shared_with_replaced_via_method_child_when_we_dont_replace_existing
-    m = Man.find(:first)
-    f = Face.new(:description => 'haunted')
-    m.face.replace(f, false)
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
-  end
-
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
     assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Man.find(:first).dirty_face }
   end
@@ -257,17 +200,6 @@ class InverseHasManyTests < ActiveRecord::TestCase
     end
   end
 
-  def test_parent_instance_should_be_shared_with_newly_built_child
-    m = men(:gordon)
-    i = m.interests.build(:topic => 'Industrial Revolution Re-enactment')
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = 'Mungo'
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to just-built-child-owned instance"
-  end
-
   def test_parent_instance_should_be_shared_with_newly_block_style_built_child
     m = Man.find(:first)
     i = m.interests.build {|ii| ii.topic = 'Industrial Revolution Re-enactment'}
@@ -280,17 +212,6 @@ class InverseHasManyTests < ActiveRecord::TestCase
     assert_equal m.name, i.man.name, "Name of man should be the same after changes to just-built-child-owned instance"
   end
 
-  def test_parent_instance_should_be_shared_with_newly_created_child
-    m = men(:gordon)
-    i = m.interests.create(:topic => 'Industrial Revolution Re-enactment')
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = 'Mungo'
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
-  end
-
   def test_parent_instance_should_be_shared_with_newly_created_via_bang_method_child
     m = Man.find(:first)
     i = m.interests.create!(:topic => 'Industrial Revolution Re-enactment')
@@ -338,18 +259,6 @@ class InverseHasManyTests < ActiveRecord::TestCase
     assert_equal m.name, i.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
   end
 
-  def test_parent_instance_should_be_shared_with_replaced_via_method_children
-    m = Man.find(:first)
-    i = Interest.new(:topic => 'Industrial Revolution Re-enactment')
-    m.interests.replace([i])
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = 'Mungo'
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
-  end
-
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
     assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Man.find(:first).secret_interests }
   end
@@ -433,19 +342,6 @@ class InverseBelongsToTests < ActiveRecord::TestCase
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
   end
 
-  def test_child_instance_should_be_shared_with_replaced_via_method_parent
-    f = faces(:trusting)
-    assert_not_nil f.man
-    m = Man.new(:name => 'Charles')
-    f.man.replace(m)
-    assert_not_nil m.face
-    assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
-    f.description = 'gormless'
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
-    m.face.description = 'pleasing'
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
-  end
-
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
     assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.find(:first).horrible_man }
   end
@@ -501,7 +397,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
     new_man = Man.new
 
     assert_not_nil face.polymorphic_man
-    face.polymorphic_man.replace(new_man)
+    face.polymorphic_man = new_man
 
     assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same before changes to parent instance"
     face.description = 'Bongo'
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index 2aac95a25d..543eff7d8b 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -13,7 +13,8 @@ require 'models/book'
 require 'models/citation'
 
 class AssociationsJoinModelTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
+
   fixtures :posts, :authors, :categories, :categorizations, :comments, :tags, :taggings, :author_favorites, :vertices, :items, :books,
     # Reload edges table from fixtures as otherwise repeated test was failing
     :edges
@@ -85,16 +86,9 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     end
   end
 
-  def test_polymorphic_has_many_going_through_join_model_with_disabled_include
-    assert_equal tags(:general), tag = posts(:welcome).tags.add_joins_and_select.first
-    assert_queries 1 do
-      tag.tagging
-    end
-  end
-
   def test_polymorphic_has_many_going_through_join_model_with_custom_select_and_joins
     assert_equal tags(:general), tag = posts(:welcome).tags.add_joins_and_select.first
-    tag.author_id
+    assert_nothing_raised(NoMethodError) { tag.author_id }
   end
 
   def test_polymorphic_has_many_going_through_join_model_with_custom_foreign_key
@@ -159,7 +153,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_create_polymorphic_has_one_with_scope
     old_count = Tagging.count
-    tagging = posts(:welcome).tagging.create(:tag => tags(:misc))
+    tagging = posts(:welcome).create_tagging(:tag => tags(:misc))
     assert_equal "Post", tagging.taggable_type
     assert_equal old_count+1, Tagging.count
   end
@@ -220,7 +214,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_with_piggyback
-    assert_equal "2", categories(:sti_test).authors.first.post_id.to_s
+    assert_equal "2", categories(:sti_test).authors_with_select.first.post_id.to_s
   end
 
   def test_include_has_many_through
@@ -298,6 +292,22 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_equal [authors(:mary)], posts(:authorless).authors
   end
 
+  def test_has_many_going_through_join_model_with_custom_primary_key
+    assert_equal [authors(:david)], posts(:thinking).authors_using_author_id
+  end
+
+  def test_has_many_going_through_polymorphic_join_model_with_custom_primary_key
+    assert_equal [tags(:general)], posts(:eager_other).tags_using_author_id
+  end
+
+  def test_has_many_through_with_custom_primary_key_on_belongs_to_source
+    assert_equal [authors(:david), authors(:david)], posts(:thinking).author_using_custom_pk
+  end
+
+  def test_has_many_through_with_custom_primary_key_on_has_many_source
+    assert_equal [authors(:david), authors(:bob)], posts(:thinking).authors_using_custom_pk.order(:id)
+  end
+
   def test_both_scoped_and_explicit_joins_should_be_respected
     assert_nothing_raised do
       Post.send(:with_scope, :find => {:joins => "left outer join comments on comments.id = posts.id"}) do
@@ -324,11 +334,16 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_polymorphic
-    assert_raise ActiveRecord::HasManyThroughAssociationPolymorphicError do
-      assert_equal posts(:welcome, :thinking), tags(:general).taggables
+    assert_raise ActiveRecord::HasManyThroughAssociationPolymorphicSourceError do
+      tags(:general).taggables
+    end
+
+    assert_raise ActiveRecord::HasManyThroughAssociationPolymorphicThroughError do
+      taggings(:welcome_general).things
     end
+
     assert_raise ActiveRecord::EagerLoadPolymorphicError do
-      assert_equal posts(:welcome, :thinking), tags(:general).taggings.find(:all, :include => :taggable, :conditions => 'bogus_table.column = 1')
+      tags(:general).taggings.find(:all, :include => :taggable, :conditions => 'bogus_table.column = 1')
     end
   end
 
@@ -488,6 +503,10 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_nothing_raised { vertices(:vertex_1).sinks << vertices(:vertex_5) }
   end
 
+  def test_add_to_join_table_with_no_id
+    assert_nothing_raised { vertices(:vertex_1).sinks << vertices(:vertex_5) }
+  end
+
   def test_has_many_through_collection_size_doesnt_load_target_if_not_loaded
     author = authors(:david)
     assert_equal 10, author.comments.size
@@ -496,7 +515,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_has_many_through_collection_size_uses_counter_cache_if_it_exists
     author = authors(:david)
-    author.stubs(:read_attribute).with('comments_count').returns(100)
+    author.stubs(:_read_attribute).with('comments_count').returns(100)
     assert_equal 100, author.comments.size
     assert !author.comments.loaded?
   end
diff --git a/activerecord/test/cases/associations/nested_through_associations_test.rb b/activerecord/test/cases/associations/nested_through_associations_test.rb
index db7c8b6c45..a4ac69782a 100644
--- a/activerecord/test/cases/associations/nested_through_associations_test.rb
+++ b/activerecord/test/cases/associations/nested_through_associations_test.rb
@@ -51,9 +51,19 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   # Through: has_many
   def test_has_many_through_has_many_with_has_many_through_source_reflection
     general = tags(:general)
-
     assert_equal [general, general], authors(:david).tags
+  end
+
+  def test_has_many_through_has_many_with_has_many_through_source_reflection_preload
+    authors = assert_queries(5) { Author.includes(:tags).to_a }
+    general = tags(:general)
+
+    assert_no_queries do
+      assert_equal [general, general], authors.first.tags
+    end
+  end
 
+  def test_has_many_through_has_many_with_has_many_through_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
       Author.where('tags.id' => tags(:general).id),
       [authors(:david)], :tags
@@ -62,11 +72,6 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     # This ensures that the polymorphism of taggings is being observed correctly
     authors = Author.joins(:tags).where('taggings.taggable_type' => 'FakeModel')
     assert authors.empty?
-
-    authors = assert_queries(5) { Author.includes(:tags).to_a }
-    assert_no_queries do
-      assert_equal [general, general], authors.first.tags
-    end
   end
 
   # has_many through
@@ -74,60 +79,69 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   # Through: has_many through
   def test_has_many_through_has_many_through_with_has_many_source_reflection
     luke, david = subscribers(:first), subscribers(:second)
+    assert_equal [luke, david, david], authors(:david).subscribers.order('subscribers.nick')
+  end
 
-    author = authors(:david)
-    assert_equal [luke, david, david], author.subscribers.order('subscribers.nick')
+  def test_has_many_through_has_many_through_with_has_many_source_reflection_preload
+    luke, david = subscribers(:first), subscribers(:second)
+    authors = assert_queries(4) { Author.includes(:subscribers).to_a }
+    assert_no_queries do
+      assert_equal [luke, david, david], authors.first.subscribers.sort_by(&:nick)
+    end
+  end
 
+  def test_has_many_through_has_many_through_with_has_many_source_reflection_preload_via_joins
     # All authors with subscribers where one of the subscribers' nick is 'alterself'
     assert_includes_and_joins_equal(
       Author.where('subscribers.nick' => 'alterself'),
       [authors(:david)], :subscribers
     )
-
-    authors = assert_queries(4) { Author.includes(:subscribers).to_a }
-    assert_no_queries do
-      assert_equal [luke, david, david], authors.first.subscribers.sort_by(&:nick)
-    end
   end
 
   # has_many through
   # Source: has_one through
   # Through: has_one
   def test_has_many_through_has_one_with_has_one_through_source_reflection
-    founding = member_types(:founding)
-
-    assert_equal [founding], members(:groucho).nested_member_types
-
-    assert_includes_and_joins_equal(
-      Member.where('member_types.id' => founding.id),
-      [members(:groucho)], :nested_member_types
-    )
+    assert_equal [member_types(:founding)], members(:groucho).nested_member_types
+  end
 
+  def test_has_many_through_has_one_with_has_one_through_source_reflection_preload
     members = assert_queries(4) { Member.includes(:nested_member_types).to_a }
+    founding = member_types(:founding)
     assert_no_queries do
       assert_equal [founding], members.first.nested_member_types
     end
   end
 
+  def test_has_many_through_has_one_with_has_one_through_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Member.where('member_types.id' => member_types(:founding).id),
+      [members(:groucho)], :nested_member_types
+    )
+  end
+
   # has_many through
   # Source: has_one
   # Through: has_one through
   def test_has_many_through_has_one_through_with_has_one_source_reflection
-    mustache = sponsors(:moustache_club_sponsor_for_groucho)
-
-    assert_equal [mustache], members(:groucho).nested_sponsors
-
-    assert_includes_and_joins_equal(
-      Member.where('sponsors.id' => mustache.id),
-      [members(:groucho)], :nested_sponsors
-    )
+    assert_equal [sponsors(:moustache_club_sponsor_for_groucho)], members(:groucho).nested_sponsors
+  end
 
+  def test_has_many_through_has_one_through_with_has_one_source_reflection_preload
     members = assert_queries(4) { Member.includes(:nested_sponsors).to_a }
+    mustache = sponsors(:moustache_club_sponsor_for_groucho)
     assert_no_queries do
       assert_equal [mustache], members.first.nested_sponsors
     end
   end
 
+  def test_has_many_through_has_one_through_with_has_one_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Member.where('sponsors.id' => sponsors(:moustache_club_sponsor_for_groucho).id),
+      [members(:groucho)], :nested_sponsors
+    )
+  end
+
   # has_many through
   # Source: has_many through
   # Through: has_one
@@ -136,7 +150,18 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
     assert_equal [groucho_details, other_details],
                  members(:groucho).organization_member_details.order('member_details.id')
+  end
+
+  def test_has_many_through_has_one_with_has_many_through_source_reflection_preload
+    members = assert_queries(4) { Member.includes(:organization_member_details).to_a.sort_by(&:id) }
+    groucho_details, other_details = member_details(:groucho), member_details(:some_other_guy)
+
+    assert_no_queries do
+      assert_equal [groucho_details, other_details], members.first.organization_member_details.sort_by(&:id)
+    end
+  end
 
+  def test_has_many_through_has_one_with_has_many_through_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
       Member.where('member_details.id' => member_details(:groucho).id).order('member_details.id'),
       [members(:groucho), members(:some_other_guy)], :organization_member_details
@@ -145,11 +170,6 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     members = Member.joins(:organization_member_details).
                      where('member_details.id' => 9)
     assert members.empty?
-
-    members = assert_queries(4) { Member.includes(:organization_member_details).to_a.sort_by(&:id) }
-    assert_no_queries do
-      assert_equal [groucho_details, other_details], members.first.organization_member_details.sort_by(&:id)
-    end
   end
 
   # has_many through
@@ -160,20 +180,26 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
     assert_equal [groucho_details, other_details],
                  members(:groucho).organization_member_details_2.order('member_details.id')
+  end
+
+  def test_has_many_through_has_one_through_with_has_many_source_reflection_preload
+    members = assert_queries(4) { Member.includes(:organization_member_details_2).to_a.sort_by(&:id) }
+    groucho_details, other_details = member_details(:groucho), member_details(:some_other_guy)
 
+    assert_no_queries do
+      assert_equal [groucho_details, other_details], members.first.organization_member_details_2.sort_by(&:id)
+    end
+  end
+
+  def test_has_many_through_has_one_through_with_has_many_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
-      Member.where('member_details.id' => groucho_details.id).order('member_details.id'),
+      Member.where('member_details.id' => member_details(:groucho).id).order('member_details.id'),
       [members(:groucho), members(:some_other_guy)], :organization_member_details_2
     )
 
     members = Member.joins(:organization_member_details_2).
                      where('member_details.id' => 9)
     assert members.empty?
-
-    members = assert_queries(4) { Member.includes(:organization_member_details_2).to_a.sort_by(&:id) }
-    assert_no_queries do
-      assert_equal [groucho_details, other_details], members.first.organization_member_details_2.sort_by(&:id)
-    end
   end
 
   # has_many through
@@ -183,18 +209,24 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     general, cooking = categories(:general), categories(:cooking)
 
     assert_equal [general, cooking], authors(:bob).post_categories.order('categories.id')
+  end
 
-    assert_includes_and_joins_equal(
-      Author.where('categories.id' => cooking.id),
-      [authors(:bob)], :post_categories
-    )
-
+  def test_has_many_through_has_many_with_has_and_belongs_to_many_source_reflection_preload
     authors = assert_queries(3) { Author.includes(:post_categories).to_a.sort_by(&:id) }
+    general, cooking = categories(:general), categories(:cooking)
+
     assert_no_queries do
       assert_equal [general, cooking], authors[2].post_categories.sort_by(&:id)
     end
   end
 
+  def test_has_many_through_has_many_with_has_and_belongs_to_many_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Author.where('categories.id' => categories(:cooking).id),
+      [authors(:bob)], :post_categories
+    )
+  end
+
   # has_many through
   # Source: has_many
   # Through: has_and_belongs_to_many
@@ -202,18 +234,24 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     greetings, more = comments(:greetings), comments(:more_greetings)
 
     assert_equal [greetings, more], categories(:technology).post_comments.order('comments.id')
+  end
 
-    assert_includes_and_joins_equal(
-      Category.where('comments.id' => more.id).order('comments.id'),
-      [categories(:general), categories(:technology)], :post_comments
-    )
-
+  def test_has_many_through_has_and_belongs_to_many_with_has_many_source_reflection_preload
     categories = assert_queries(3) { Category.includes(:post_comments).to_a.sort_by(&:id) }
+    greetings, more = comments(:greetings), comments(:more_greetings)
+
     assert_no_queries do
       assert_equal [greetings, more], categories[1].post_comments.sort_by(&:id)
     end
   end
 
+  def test_has_many_through_has_and_belongs_to_many_with_has_many_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Category.where('comments.id' => comments(:more_greetings).id).order('comments.id'),
+      [categories(:general), categories(:technology)], :post_comments
+    )
+  end
+
   # has_many through
   # Source: has_many through a habtm
   # Through: has_many through
@@ -221,35 +259,45 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     greetings, more = comments(:greetings), comments(:more_greetings)
 
     assert_equal [greetings, more], authors(:bob).category_post_comments.order('comments.id')
+  end
 
-    assert_includes_and_joins_equal(
-      Author.where('comments.id' => comments(:does_it_hurt).id).order('comments.id'),
-      [authors(:david), authors(:mary)], :category_post_comments
-    )
-
+  def test_has_many_through_has_many_with_has_many_through_habtm_source_reflection_preload
     authors = assert_queries(5) { Author.includes(:category_post_comments).to_a.sort_by(&:id) }
+    greetings, more = comments(:greetings), comments(:more_greetings)
+
     assert_no_queries do
       assert_equal [greetings, more], authors[2].category_post_comments.sort_by(&:id)
     end
   end
 
+  def test_has_many_through_has_many_with_has_many_through_habtm_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Author.where('comments.id' => comments(:does_it_hurt).id).order('comments.id'),
+      [authors(:david), authors(:mary)], :category_post_comments
+    )
+  end
+
   # has_many through
   # Source: belongs_to
   # Through: has_many through
   def test_has_many_through_has_many_through_with_belongs_to_source_reflection
+    assert_equal [tags(:general), tags(:general)], authors(:david).tagging_tags
+  end
+
+  def test_has_many_through_has_many_through_with_belongs_to_source_reflection_preload
+    authors = assert_queries(5) { Author.includes(:tagging_tags).to_a }
     general = tags(:general)
 
-    assert_equal [general, general], authors(:david).tagging_tags
+    assert_no_queries do
+      assert_equal [general, general], authors.first.tagging_tags
+    end
+  end
 
+  def test_has_many_through_has_many_through_with_belongs_to_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
       Author.where('tags.id' => tags(:general).id),
       [authors(:david)], :tagging_tags
     )
-
-    authors = assert_queries(5) { Author.includes(:tagging_tags).to_a }
-    assert_no_queries do
-      assert_equal [general, general], authors.first.tagging_tags
-    end
   end
 
   # has_many through
@@ -260,54 +308,68 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
 
     assert_equal [welcome_general, thinking_general],
                  categorizations(:david_welcome_general).post_taggings.order('taggings.id')
+  end
 
-    assert_includes_and_joins_equal(
-      Categorization.where('taggings.id' => welcome_general.id).order('taggings.id'),
-      [categorizations(:david_welcome_general)], :post_taggings
-    )
-
+  def test_has_many_through_belongs_to_with_has_many_through_source_reflection_preload
     categorizations = assert_queries(4) { Categorization.includes(:post_taggings).to_a.sort_by(&:id) }
+    welcome_general, thinking_general = taggings(:welcome_general), taggings(:thinking_general)
+
     assert_no_queries do
       assert_equal [welcome_general, thinking_general], categorizations.first.post_taggings.sort_by(&:id)
     end
   end
 
+  def test_has_many_through_belongs_to_with_has_many_through_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Categorization.where('taggings.id' => taggings(:welcome_general).id).order('taggings.id'),
+      [categorizations(:david_welcome_general)], :post_taggings
+    )
+  end
+
   # has_one through
   # Source: has_one through
   # Through: has_one
   def test_has_one_through_has_one_with_has_one_through_source_reflection
+    assert_equal member_types(:founding), members(:groucho).nested_member_type
+  end
+
+  def test_has_one_through_has_one_with_has_one_through_source_reflection_preload
+    members = assert_queries(4) { Member.includes(:nested_member_type).to_a.sort_by(&:id) }
     founding = member_types(:founding)
 
-    assert_equal founding, members(:groucho).nested_member_type
+    assert_no_queries do
+      assert_equal founding, members.first.nested_member_type
+    end
+  end
 
+  def test_has_one_through_has_one_with_has_one_through_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
-      Member.where('member_types.id' => founding.id),
+      Member.where('member_types.id' => member_types(:founding).id),
       [members(:groucho)], :nested_member_type
     )
-
-    members = assert_queries(4) { Member.includes(:nested_member_type).to_a.sort_by(&:id) }
-    assert_no_queries do
-      assert_equal founding, members.first.nested_member_type
-    end
   end
 
   # has_one through
   # Source: belongs_to
   # Through: has_one through
   def test_has_one_through_has_one_through_with_belongs_to_source_reflection
+    assert_equal categories(:general), members(:groucho).club_category
+  end
+
+  def test_has_one_through_has_one_through_with_belongs_to_source_reflection_preload
+    members = assert_queries(4) { Member.includes(:club_category).to_a.sort_by(&:id) }
     general = categories(:general)
 
-    assert_equal general, members(:groucho).club_category
+    assert_no_queries do
+      assert_equal general, members.first.club_category
+    end
+  end
 
+  def test_has_one_through_has_one_through_with_belongs_to_source_reflection_preload_via_joins
     assert_includes_and_joins_equal(
       Member.where('categories.id' => categories(:technology).id),
       [members(:blarpy_winkup)], :club_category
     )
-
-    members = assert_queries(4) { Member.includes(:club_category).to_a.sort_by(&:id) }
-    assert_no_queries do
-      assert_equal general, members.first.club_category
-    end
   end
 
   def test_distinct_has_many_through_a_has_many_through_association_on_source_reflection
@@ -406,41 +468,49 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_nested_has_many_through_with_conditions_on_through_associations
-    blue, bob = tags(:blue), authors(:bob)
-
-    assert_equal [blue], bob.misc_post_first_blue_tags
-
-    # Pointless condition to force single-query loading
-    assert_includes_and_joins_equal(
-      Author.where('tags.id = tags.id'),
-      [bob], :misc_post_first_blue_tags
-    )
+    assert_equal [tags(:blue)], authors(:bob).misc_post_first_blue_tags
+  end
 
+  def test_nested_has_many_through_with_conditions_on_through_associations_preload
     assert Author.where('tags.id' => 100).joins(:misc_post_first_blue_tags).empty?
 
     authors = assert_queries(3) { Author.includes(:misc_post_first_blue_tags).to_a.sort_by(&:id) }
+    blue = tags(:blue)
+
     assert_no_queries do
       assert_equal [blue], authors[2].misc_post_first_blue_tags
     end
   end
 
-  def test_nested_has_many_through_with_conditions_on_source_associations
-    blue, bob = tags(:blue), authors(:bob)
-
-    assert_equal [blue], bob.misc_post_first_blue_tags_2
-
+  def test_nested_has_many_through_with_conditions_on_through_associations_preload_via_joins
     # Pointless condition to force single-query loading
     assert_includes_and_joins_equal(
       Author.where('tags.id = tags.id'),
-      [bob], :misc_post_first_blue_tags_2
+      [authors(:bob)], :misc_post_first_blue_tags
     )
+  end
+
+  def test_nested_has_many_through_with_conditions_on_source_associations
+    assert_equal [tags(:blue)], authors(:bob).misc_post_first_blue_tags_2
+  end
 
+  def test_nested_has_many_through_with_conditions_on_source_associations_preload
     authors = assert_queries(4) { Author.includes(:misc_post_first_blue_tags_2).to_a.sort_by(&:id) }
+    blue = tags(:blue)
+
     assert_no_queries do
       assert_equal [blue], authors[2].misc_post_first_blue_tags_2
     end
   end
 
+  def test_nested_has_many_through_with_conditions_on_source_associations_preload_via_joins
+    # Pointless condition to force single-query loading
+    assert_includes_and_joins_equal(
+      Author.where('tags.id = tags.id'),
+      [authors(:bob)], :misc_post_first_blue_tags_2
+    )
+  end
+
   def test_nested_has_many_through_with_foreign_key_option_on_the_source_reflection_through_reflection
     assert_equal [categories(:general)], organizations(:nsa).author_essay_categories
 
diff --git a/activerecord/test/cases/associations_test.rb b/activerecord/test/cases/associations_test.rb
index 83c605d2bb..47b8e48582 100644
--- a/activerecord/test/cases/associations_test.rb
+++ b/activerecord/test/cases/associations_test.rb
@@ -133,25 +133,6 @@ end
 class AssociationProxyTest < ActiveRecord::TestCase
   fixtures :authors, :posts, :categorizations, :categories, :developers, :projects, :developers_projects
 
-  def test_proxy_accessors
-    welcome = posts(:welcome)
-    assert_equal  welcome, welcome.author.proxy_owner
-    assert_equal  welcome.class.reflect_on_association(:author), welcome.author.proxy_reflection
-    welcome.author.class  # force load target
-    assert_equal  welcome.author, welcome.author.proxy_target
-
-    david = authors(:david)
-    assert_equal  david, david.posts.proxy_owner
-    assert_equal  david.class.reflect_on_association(:posts), david.posts.proxy_reflection
-    david.posts.class   # force load target
-    assert_equal  david.posts, david.posts.proxy_target
-
-    assert_equal  david, david.posts_with_extension.testing_proxy_owner
-    assert_equal  david.class.reflect_on_association(:posts_with_extension), david.posts_with_extension.testing_proxy_reflection
-    david.posts_with_extension.class   # force load target
-    assert_equal  david.posts_with_extension, david.posts_with_extension.testing_proxy_target
-  end
-
   def test_push_does_not_load_target
     david = authors(:david)
 
@@ -216,37 +197,12 @@ class AssociationProxyTest < ActiveRecord::TestCase
     assert_equal post.body, "More cool stuff!"
   end
 
-  def test_failed_reload_returns_nil
-    p = setup_dangling_association
-    assert_nil p.author.reload
-  end
-
-  def test_failed_reset_returns_nil
-    p = setup_dangling_association
-    assert_nil p.author.reset
-  end
-
   def test_reload_returns_assocition
     david = developers(:david)
     assert_nothing_raised do
       assert_equal david.projects, david.projects.reload.reload
     end
   end
-
-  if RUBY_VERSION < '1.9'
-    def test_splat_does_not_invoke_to_a_on_singular_targets
-      author = posts(:welcome).author
-      author.reload.target.expects(:to_a).never
-      [*author]
-    end
-  end
-
-  def setup_dangling_association
-    josh = Author.create(:name => "Josh")
-    p = Post.create(:title => "New on Edge", :body => "More cool stuff!", :author => josh)
-    josh.destroy
-    p
-  end
 end
 
 class OverridingAssociationsTest < ActiveRecord::TestCase
diff --git a/activerecord/test/cases/attribute_methods/read_test.rb b/activerecord/test/cases/attribute_methods/read_test.rb
new file mode 100644
index 0000000000..d0a9028264
--- /dev/null
+++ b/activerecord/test/cases/attribute_methods/read_test.rb
@@ -0,0 +1,61 @@
+require "cases/helper"
+
+module ActiveRecord
+  module AttributeMethods
+    class ReadTest < ActiveRecord::TestCase
+      class FakeColumn < Struct.new(:name)
+        def type_cast_code(var)
+          var
+        end
+
+        def type; :integer; end
+      end
+
+      def setup
+        @klass = Class.new do
+          include ActiveRecord::AttributeMethods
+          include ActiveRecord::AttributeMethods::Read
+
+          def self.column_names
+            %w{ one two three }
+          end
+
+          def self.primary_key
+          end
+
+          def self.columns
+            column_names.map { FakeColumn.new(name) }
+          end
+
+          def self.columns_hash
+            Hash[column_names.map { |name|
+              [name, FakeColumn.new(name)]
+            }]
+          end
+
+          def self.serialized_attributes; {}; end
+        end
+      end
+
+      def test_define_attribute_methods
+        instance = @klass.new
+
+        @klass.column_names.each do |name|
+          assert ! instance.methods.map(&:to_s).include?(name)
+        end
+
+        @klass.define_attribute_methods
+
+        @klass.column_names.each do |name|
+          assert(instance.methods.map(&:to_s).include?(name), "#{name} is not defined")
+        end
+      end
+
+      def test_attribute_methods_generated?
+        assert(!@klass.attribute_methods_generated?, 'attribute_methods_generated?')
+        @klass.define_attribute_methods
+        assert(@klass.attribute_methods_generated?, 'attribute_methods_generated?')
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index 8214815bde..dfacf58da8 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -8,6 +8,7 @@ require 'models/topic'
 require 'models/company'
 require 'models/category'
 require 'models/reply'
+require 'models/contact'
 
 class AttributeMethodsTest < ActiveRecord::TestCase
   fixtures :topics, :developers, :companies, :computers
@@ -105,7 +106,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
 
   def test_read_attributes_before_type_cast
     category = Category.new({:name=>"Test categoty", :type => nil})
-    category_attrs = {"name"=>"Test categoty", "type" => nil, "categorizations_count" => nil}
+    category_attrs = {"name"=>"Test categoty", "id" => nil, "type" => nil, "categorizations_count" => nil}
     assert_equal category_attrs , category.attributes_before_type_cast
   end
 
@@ -116,24 +117,23 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  unless current_adapter?(:Mysql2Adapter)
-    def test_read_attributes_before_type_cast_on_datetime
-      developer = Developer.find(:first)
-      # Oracle adapter returns Time before type cast
-      unless current_adapter?(:OracleAdapter)
-        assert_equal developer.created_at.to_s(:db) , developer.attributes_before_type_cast["created_at"].to_s
-      else
-        assert_equal developer.created_at.to_s(:db) , developer.attributes_before_type_cast["created_at"].to_s(:db)
+  def test_read_attributes_before_type_cast_on_datetime
+    developer = Developer.find(:first)
+    if current_adapter?(:Mysql2Adapter, :OracleAdapter)
+      # Mysql2 and Oracle adapters keep the value in Time instance
+      assert_equal developer.created_at.to_s(:db), developer.attributes_before_type_cast["created_at"].to_s(:db)
+    else
+      assert_equal developer.created_at.to_s(:db), developer.attributes_before_type_cast["created_at"].to_s
+    end
 
-        developer.created_at = "345643456"
-        assert_equal developer.created_at_before_type_cast, "345643456"
-        assert_equal developer.created_at, nil
+    developer.created_at = "345643456"
 
-        developer.created_at = "2010-03-21 21:23:32"
-        assert_equal developer.created_at_before_type_cast.to_s, "2010-03-21 21:23:32"
-        assert_equal developer.created_at, Time.parse("2010-03-21 21:23:32")
-      end
-    end
+    assert_equal developer.created_at_before_type_cast, "345643456"
+    assert_equal developer.created_at, nil
+
+    developer.created_at = "2010-03-21 21:23:32"
+    assert_equal developer.created_at_before_type_cast, "2010-03-21 21:23:32"
+    assert_equal developer.created_at, Time.parse("2010-03-21 21:23:32")
   end
 
   def test_hash_content
@@ -247,6 +247,12 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     # puts ""
   end
 
+  def test_read_overridden_attribute
+    topic = Topic.new(:title => 'a')
+    def topic.title() 'b' end
+    assert_equal 'a', topic[:title]
+  end
+
   def test_query_attribute_string
     [nil, "", " "].each do |value|
       assert_equal false, Topic.new(:author_name => value).author_name?
@@ -455,6 +461,14 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_write_nil_to_time_attributes
+    in_time_zone "Pacific Time (US & Canada)" do
+      record = @target.new
+      record.written_on = nil
+      assert_nil record.written_on
+    end
+  end
+
   def test_time_attributes_are_retrieved_in_current_time_zone
     in_time_zone "Pacific Time (US & Canada)" do
       utc_time = Time.utc(2008, 1, 1)
@@ -596,6 +610,10 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     Object.send(:undef_method, :title) # remove test method from object
   end
 
+  def test_list_of_serialized_attributes
+    assert_equal %w(content), Topic.serialized_attributes.keys
+    assert_equal %w(preferences), Contact.serialized_attributes.keys
+  end
 
   private
   def cached_columns
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index fbf7121468..8f55b7ebe6 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -21,19 +21,19 @@ require 'models/eye'
 
 class TestAutosaveAssociationsInGeneral < ActiveRecord::TestCase
   def test_autosave_should_be_a_valid_option_for_has_one
-    assert base.valid_keys_for_has_one_association.include?(:autosave)
+    assert ActiveRecord::Associations::Builder::HasOne.valid_options.include?(:autosave)
   end
 
   def test_autosave_should_be_a_valid_option_for_belongs_to
-    assert base.valid_keys_for_belongs_to_association.include?(:autosave)
+    assert ActiveRecord::Associations::Builder::BelongsTo.valid_options.include?(:autosave)
   end
 
   def test_autosave_should_be_a_valid_option_for_has_many
-    assert base.valid_keys_for_has_many_association.include?(:autosave)
+    assert ActiveRecord::Associations::Builder::HasMany.valid_options.include?(:autosave)
   end
 
   def test_autosave_should_be_a_valid_option_for_has_and_belongs_to_many
-    assert base.valid_keys_for_has_and_belongs_to_many_association.include?(:autosave)
+    assert ActiveRecord::Associations::Builder::HasAndBelongsToMany.valid_options.include?(:autosave)
   end
 
   def test_should_not_add_the_same_callbacks_multiple_times_for_has_one
@@ -90,7 +90,7 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
     firm = Firm.find(:first)
     assert firm.valid?
 
-    firm.account = Account.new
+    firm.build_account
 
     assert !firm.account.valid?
     assert !firm.valid?
@@ -102,7 +102,7 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
     firm = Firm.find(:first)
     assert firm.valid?
 
-    firm.unvalidated_account = Account.new
+    firm.build_unvalidated_account
 
     assert !firm.unvalidated_account.valid?
     assert firm.valid?
@@ -112,7 +112,7 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
   def test_build_before_child_saved
     firm = Firm.find(1)
 
-    account = firm.account.build("credit_limit" => 1000)
+    account = firm.build_account("credit_limit" => 1000)
     assert_equal account, firm.account
     assert !account.persisted?
     assert firm.save
@@ -340,6 +340,13 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
     tags(:misc).create_tagging(:taggable => posts(:thinking))
     assert_equal num_tagging + 1, Tagging.count
   end
+
+  def test_build_and_then_save_parent_should_not_reload_target
+    client = Client.find(:first)
+    apple = client.build_firm(:name => "Apple")
+    client.save!
+    assert_no_queries { assert_equal apple, client.firm }
+  end
 end
 
 class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCase
@@ -565,7 +572,7 @@ class TestDefaultAutosaveAssociationOnNewRecord < ActiveRecord::TestCase
 end
 
 class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
@@ -578,7 +585,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
     @pirate.ship.mark_for_destruction
 
     assert !@pirate.reload.marked_for_destruction?
-    assert !@pirate.ship.marked_for_destruction?
+    assert !@pirate.ship.reload.marked_for_destruction?
   end
 
   # has_one
@@ -667,119 +674,227 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
       end
     end
 
+    @ship.pirate.catchphrase = "Changed Catchphrase"
+
     assert_raise(RuntimeError) { assert !@ship.save }
     assert_not_nil @ship.reload.pirate
   end
 
-  # has_many & has_and_belongs_to
-  %w{ parrots birds }.each do |association_name|
-    define_method("test_should_destroy_#{association_name}_as_part_of_the_save_transaction_if_they_were_marked_for_destroyal") do
-      2.times { |i| @pirate.send(association_name).create!(:name => "#{association_name}_#{i}") }
+  def test_should_save_changed_child_objects_if_parent_is_saved
+    @pirate = @ship.create_pirate(:catchphrase => "Don' botharrr talkin' like one, savvy?")
+    @parrot = @pirate.parrots.create!(:name => 'Posideons Killer')
+    @parrot.name = "NewName"
+    @ship.save
+
+    assert_equal 'NewName', @parrot.reload.name
+  end
+
+  def test_should_destroy_has_many_as_part_of_the_save_transaction_if_they_were_marked_for_destruction
+    2.times { |i| @pirate.birds.create!(:name => "birds_#{i}") }
 
-      assert !@pirate.send(association_name).any? { |child| child.marked_for_destruction? }
+    assert !@pirate.birds.any? { |child| child.marked_for_destruction? }
 
-      @pirate.send(association_name).each { |child| child.mark_for_destruction }
-      klass = @pirate.send(association_name).first.class
-      ids = @pirate.send(association_name).map(&:id)
+    @pirate.birds.each { |child| child.mark_for_destruction }
+    klass = @pirate.birds.first.class
+    ids = @pirate.birds.map(&:id)
 
-      assert @pirate.send(association_name).all? { |child| child.marked_for_destruction? }
-      ids.each { |id| assert klass.find_by_id(id) }
+    assert @pirate.birds.all? { |child| child.marked_for_destruction? }
+    ids.each { |id| assert klass.find_by_id(id) }
 
-      @pirate.save
-      assert @pirate.reload.send(association_name).empty?
-      ids.each { |id| assert_nil klass.find_by_id(id) }
+    @pirate.save
+    assert @pirate.reload.birds.empty?
+    ids.each { |id| assert_nil klass.find_by_id(id) }
+  end
+
+  def test_should_skip_validation_on_has_many_if_marked_for_destruction
+    2.times { |i| @pirate.birds.create!(:name => "birds_#{i}") }
+
+    @pirate.birds.each { |bird| bird.name = '' }
+    assert !@pirate.valid?
+
+    @pirate.birds.each do |bird|
+      bird.mark_for_destruction
+      bird.expects(:valid?).never
     end
+    assert_difference("Bird.count", -2) { @pirate.save! }
+  end
 
-    define_method("test_should_skip_validation_on_the_#{association_name}_association_if_marked_for_destruction") do
-      2.times { |i| @pirate.send(association_name).create!(:name => "#{association_name}_#{i}") }
-      children = @pirate.send(association_name)
+  def test_should_skip_validation_on_has_many_if_destroyed
+    @pirate.birds.create!(:name => "birds_1")
 
-      children.each { |child| child.name = '' }
-      assert !@pirate.valid?
+    @pirate.birds.each { |bird| bird.name = '' }
+    assert !@pirate.valid?
 
-      children.each do |child|
-        child.mark_for_destruction
-        child.expects(:valid?).never
+    @pirate.birds.each { |bird| bird.destroy }
+    assert @pirate.valid?
+  end
+
+  def test_a_child_marked_for_destruction_should_not_be_destroyed_twice_while_saving_has_many
+    @pirate.birds.create!(:name => "birds_1")
+
+    @pirate.birds.each { |bird| bird.mark_for_destruction }
+    assert @pirate.save
+
+    @pirate.birds.each { |bird| bird.expects(:destroy).never }
+    assert @pirate.save
+  end
+
+  def test_should_rollback_destructions_if_an_exception_occurred_while_saving_has_many
+    2.times { |i| @pirate.birds.create!(:name => "birds_#{i}") }
+    before = @pirate.birds.map { |c| c.mark_for_destruction ; c }
+
+    # Stub the destroy method of the second child to raise an exception
+    class << before.last
+      def destroy(*args)
+        super
+        raise 'Oh noes!'
       end
-      assert_difference("#{association_name.classify}.count", -2) { @pirate.save! }
     end
 
-    define_method("test_should_skip_validation_on_the_#{association_name}_association_if_destroyed") do
-      @pirate.send(association_name).create!(:name => "#{association_name}_1")
-      children = @pirate.send(association_name)
+    assert_raise(RuntimeError) { assert !@pirate.save }
+    assert_equal before, @pirate.reload.birds
+  end
+
+  # Add and remove callbacks tests for association collections.
+  %w{ method proc }.each do |callback_type|
+    define_method("test_should_run_add_callback_#{callback_type}s_for_has_many") do
+      association_name_with_callbacks = "birds_with_#{callback_type}_callbacks"
+
+      pirate = Pirate.new(:catchphrase => "Arr")
+      pirate.send(association_name_with_callbacks).build(:name => "Crowe the One-Eyed")
 
-      children.each { |child| child.name = '' }
-      assert !@pirate.valid?
+      expected = [
+        "before_adding_#{callback_type}_bird_<new>",
+        "after_adding_#{callback_type}_bird_<new>"
+      ]
 
-      children.each { |child| child.destroy }
-      assert @pirate.valid?
+      assert_equal expected, pirate.ship_log
     end
 
-    define_method("test_a_child_marked_for_destruction_should_not_be_destroyed_twice_while_saving_#{association_name}") do
-      @pirate.send(association_name).create!(:name => "#{association_name}_1")
-      children = @pirate.send(association_name)
+    define_method("test_should_run_remove_callback_#{callback_type}s_for_has_many") do
+      association_name_with_callbacks = "birds_with_#{callback_type}_callbacks"
 
-      children.each { |child| child.mark_for_destruction }
-      assert @pirate.save
-      children.each { |child| child.expects(:destroy).never }
-      assert @pirate.save
+      @pirate.send(association_name_with_callbacks).create!(:name => "Crowe the One-Eyed")
+      @pirate.send(association_name_with_callbacks).each { |c| c.mark_for_destruction }
+      child_id = @pirate.send(association_name_with_callbacks).first.id
+
+      @pirate.ship_log.clear
+      @pirate.save
+
+      expected = [
+        "before_removing_#{callback_type}_bird_#{child_id}",
+        "after_removing_#{callback_type}_bird_#{child_id}"
+      ]
+
+      assert_equal expected, @pirate.ship_log
     end
+  end
 
-    define_method("test_should_rollback_destructions_if_an_exception_occurred_while_saving_#{association_name}") do
-      2.times { |i| @pirate.send(association_name).create!(:name => "#{association_name}_#{i}") }
-      before = @pirate.send(association_name).map { |c| c.mark_for_destruction ; c }
+  def test_should_destroy_habtm_as_part_of_the_save_transaction_if_they_were_marked_for_destruction
+    2.times { |i| @pirate.parrots.create!(:name => "parrots_#{i}") }
 
-      # Stub the destroy method of the the second child to raise an exception
-      class << before.last
-        def destroy(*args)
-          super
-          raise 'Oh noes!'
-        end
-      end
+    assert !@pirate.parrots.any? { |parrot| parrot.marked_for_destruction? }
+    @pirate.parrots.each { |parrot| parrot.mark_for_destruction }
 
-      assert_raise(RuntimeError) { assert !@pirate.save }
-      assert_equal before, @pirate.reload.send(association_name)
+    assert_no_difference "Parrot.count" do
+      @pirate.save
     end
 
-    # Add and remove callbacks tests for association collections.
-    %w{ method proc }.each do |callback_type|
-      define_method("test_should_run_add_callback_#{callback_type}s_for_#{association_name}") do
-        association_name_with_callbacks = "#{association_name}_with_#{callback_type}_callbacks"
+    assert @pirate.reload.parrots.empty?
 
-        pirate = Pirate.new(:catchphrase => "Arr")
-        pirate.send(association_name_with_callbacks).build(:name => "Crowe the One-Eyed")
+    join_records = Pirate.connection.select_all("SELECT * FROM parrots_pirates WHERE pirate_id = #{@pirate.id}")
+    assert join_records.empty?
+  end
 
-        expected = [
-          "before_adding_#{callback_type}_#{association_name.singularize}_<new>",
-          "after_adding_#{callback_type}_#{association_name.singularize}_<new>"
-        ]
+  def test_should_skip_validation_on_habtm_if_marked_for_destruction
+    2.times { |i| @pirate.parrots.create!(:name => "parrots_#{i}") }
 
-        assert_equal expected, pirate.ship_log
-      end
+    @pirate.parrots.each { |parrot| parrot.name = '' }
+    assert !@pirate.valid?
+
+    @pirate.parrots.each do |parrot|
+      parrot.mark_for_destruction
+      parrot.expects(:valid?).never
+    end
+
+    @pirate.save!
+    assert @pirate.reload.parrots.empty?
+  end
+
+  def test_should_skip_validation_on_habtm_if_destroyed
+    @pirate.parrots.create!(:name => "parrots_1")
 
-      define_method("test_should_run_remove_callback_#{callback_type}s_for_#{association_name}") do
-        association_name_with_callbacks = "#{association_name}_with_#{callback_type}_callbacks"
+    @pirate.parrots.each { |parrot| parrot.name = '' }
+    assert !@pirate.valid?
 
-        @pirate.send(association_name_with_callbacks).create!(:name => "Crowe the One-Eyed")
-        @pirate.send(association_name_with_callbacks).each { |c| c.mark_for_destruction }
-        child_id = @pirate.send(association_name_with_callbacks).first.id
+    @pirate.parrots.each { |parrot| parrot.destroy }
+    assert @pirate.valid?
+  end
 
-        @pirate.ship_log.clear
-        @pirate.save
+  def test_a_child_marked_for_destruction_should_not_be_destroyed_twice_while_saving_habtm
+    @pirate.parrots.create!(:name => "parrots_1")
+
+    @pirate.parrots.each { |parrot| parrot.mark_for_destruction }
+    assert @pirate.save
+
+    assert_no_queries do
+      assert @pirate.save
+    end
+  end
 
-        expected = [
-          "before_removing_#{callback_type}_#{association_name.singularize}_#{child_id}",
-          "after_removing_#{callback_type}_#{association_name.singularize}_#{child_id}"
-        ]
+  def test_should_rollback_destructions_if_an_exception_occurred_while_saving_habtm
+    2.times { |i| @pirate.parrots.create!(:name => "parrots_#{i}") }
+    before = @pirate.parrots.map { |c| c.mark_for_destruction ; c }
 
-        assert_equal expected, @pirate.ship_log
+    class << @pirate.parrots
+      def destroy(*args)
+        super
+        raise 'Oh noes!'
       end
     end
+
+    assert_raise(RuntimeError) { assert !@pirate.save }
+    assert_equal before, @pirate.reload.parrots
+  end
+
+  # Add and remove callbacks tests for association collections.
+  %w{ method proc }.each do |callback_type|
+    define_method("test_should_run_add_callback_#{callback_type}s_for_habtm") do
+      association_name_with_callbacks = "parrots_with_#{callback_type}_callbacks"
+
+      pirate = Pirate.new(:catchphrase => "Arr")
+      pirate.send(association_name_with_callbacks).build(:name => "Crowe the One-Eyed")
+
+      expected = [
+        "before_adding_#{callback_type}_parrot_<new>",
+        "after_adding_#{callback_type}_parrot_<new>"
+      ]
+
+      assert_equal expected, pirate.ship_log
+    end
+
+    define_method("test_should_run_remove_callback_#{callback_type}s_for_habtm") do
+      association_name_with_callbacks = "parrots_with_#{callback_type}_callbacks"
+
+      @pirate.send(association_name_with_callbacks).create!(:name => "Crowe the One-Eyed")
+      @pirate.send(association_name_with_callbacks).each { |c| c.mark_for_destruction }
+      child_id = @pirate.send(association_name_with_callbacks).first.id
+
+      @pirate.ship_log.clear
+      @pirate.save
+
+      expected = [
+        "before_removing_#{callback_type}_parrot_#{child_id}",
+        "after_removing_#{callback_type}_parrot_#{child_id}"
+      ]
+
+      assert_equal expected, @pirate.ship_log
+    end
   end
 end
 
 class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
@@ -850,7 +965,10 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
     values = [@pirate.reload.catchphrase, @pirate.ship.name, *@pirate.ship.parts.map(&:name)]
     # Oracle saves empty string as NULL
     if current_adapter?(:OracleAdapter)
-      assert_equal [nil, nil, nil, nil], values
+      expected = ActiveRecord::IdentityMap.enabled? ?
+        [nil, nil, '', ''] :
+        [nil, nil, nil, nil]
+      assert_equal expected, values
     else
       assert_equal ['', '', '', ''], values
     end
@@ -899,7 +1017,7 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
 end
 
 class TestAutosaveAssociationOnABelongsToAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @ship = Ship.create(:name => 'Nights Dirty Lightning')
@@ -945,7 +1063,8 @@ class TestAutosaveAssociationOnABelongsToAssociation < ActiveRecord::TestCase
     @ship.save(:validate => false)
     # Oracle saves empty string as NULL
     if current_adapter?(:OracleAdapter)
-      assert_equal [nil, nil], [@ship.reload.name, @ship.pirate.catchphrase]
+      expected = ActiveRecord::IdentityMap.enabled? ?  [nil, ''] : [nil, nil]
+      assert_equal expected, [@ship.reload.name, @ship.pirate.catchphrase]
     else
       assert_equal ['', ''], [@ship.reload.name, @ship.pirate.catchphrase]
     end
@@ -1146,7 +1265,7 @@ module AutosaveAssociationOnACollectionAssociationTests
 end
 
 class TestAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @association_name = :birds
@@ -1160,7 +1279,7 @@ class TestAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCase
 end
 
 class TestAutosaveAssociationOnAHasAndBelongsToManyAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @association_name = :parrots
@@ -1175,7 +1294,7 @@ class TestAutosaveAssociationOnAHasAndBelongsToManyAssociation < ActiveRecord::T
 end
 
 class TestAutosaveAssociationValidationsOnAHasManyAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
@@ -1191,11 +1310,12 @@ class TestAutosaveAssociationValidationsOnAHasManyAssociation < ActiveRecord::Te
 end
 
 class TestAutosaveAssociationValidationsOnAHasOneAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
     @pirate.create_ship(:name => 'titanic')
+    super
   end
 
   test "should automatically validate associations with :validate => true" do
@@ -1204,7 +1324,7 @@ class TestAutosaveAssociationValidationsOnAHasOneAssociation < ActiveRecord::Tes
     assert !@pirate.valid?
   end
 
-  test "should not automatically validate associations without :validate => true" do
+  test "should not automatically asd validate associations without :validate => true" do
     assert @pirate.valid?
     @pirate.non_validated_ship.name = ''
     assert @pirate.valid?
@@ -1212,7 +1332,7 @@ class TestAutosaveAssociationValidationsOnAHasOneAssociation < ActiveRecord::Tes
 end
 
 class TestAutosaveAssociationValidationsOnABelongsToAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
@@ -1232,7 +1352,7 @@ class TestAutosaveAssociationValidationsOnABelongsToAssociation < ActiveRecord::
 end
 
 class TestAutosaveAssociationValidationsOnAHABTMAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
@@ -1254,7 +1374,7 @@ class TestAutosaveAssociationValidationsOnAHABTMAssociation < ActiveRecord::Test
 end
 
 class TestAutosaveAssociationValidationMethodsGeneration < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.new
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 86d4a90fc4..b62b5003e4 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -19,6 +19,8 @@ require 'models/minimalistic'
 require 'models/warehouse_thing'
 require 'models/parrot'
 require 'models/loose_person'
+require 'models/edge'
+require 'models/joke'
 require 'rexml/document'
 require 'active_support/core_ext/exception'
 
@@ -48,6 +50,57 @@ class Boolean < ActiveRecord::Base; end
 class BasicsTest < ActiveRecord::TestCase
   fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, 'warehouse-things', :authors, :categorizations, :categories, :posts
 
+  def test_columns_should_obey_set_primary_key
+    pk = Subscriber.columns.find { |x| x.name == 'nick' }
+    assert pk.primary, 'nick should be primary key'
+  end
+
+  def test_primary_key_with_no_id
+    assert_nil Edge.primary_key
+  end
+
+  unless current_adapter?(:PostgreSQLAdapter,:OracleAdapter,:SQLServerAdapter)
+    def test_limit_with_comma
+      assert_nothing_raised do
+        Topic.limit("1,2").all
+      end
+    end
+  end
+
+  def test_limit_without_comma
+    assert_nothing_raised do
+      assert_equal 1, Topic.limit("1").all.length
+    end
+
+    assert_nothing_raised do
+      assert_equal 1, Topic.limit(1).all.length
+    end
+  end
+
+  def test_invalid_limit
+    assert_raises(ArgumentError) do
+      Topic.limit("asdfadf").all
+    end
+  end
+
+  def test_limit_should_sanitize_sql_injection_for_limit_without_comas
+    assert_raises(ArgumentError) do
+      Topic.limit("1 select * from schema").all
+    end
+  end
+
+  def test_limit_should_sanitize_sql_injection_for_limit_with_comas
+    assert_raises(ArgumentError) do
+      Topic.limit("1, 7 procedure help()").all
+    end
+  end
+
+  unless current_adapter?(:MysqlAdapter) || current_adapter?(:Mysql2Adapter)
+    def test_limit_should_allow_sql_literal
+      assert_equal 1, Topic.limit(Arel.sql('2-1')).all.length
+    end
+  end
+
   def test_select_symbol
     topic_ids = Topic.select(:id).map(&:id).sort
     assert_equal Topic.find(:all).map(&:id).sort, topic_ids
@@ -81,6 +134,7 @@ class BasicsTest < ActiveRecord::TestCase
     fakepool = Class.new(Struct.new(:spec)) {
       def with_connection; yield self; end
       def connection_pool; self; end
+      def table_exists?(name); false; end
       def quote_table_name(*args); raise "lol quote_table_name"; end
     }
 
@@ -698,7 +752,7 @@ class BasicsTest < ActiveRecord::TestCase
 
     duped_topic.reload
     # FIXME: I think this is poor behavior, and will fix it with #5686
-    assert_equal({'a' => 'c'}.to_s, duped_topic.title)
+    assert_equal({'a' => 'c'}.to_yaml, duped_topic.title)
   end
 
   def test_dup_with_aggregate_of_same_name_as_attribute
@@ -997,6 +1051,25 @@ class BasicsTest < ActiveRecord::TestCase
     Topic.serialize(:content)
   end
 
+  def test_serialized_default_class
+    Topic.serialize(:content, Hash)
+    topic = Topic.new
+    assert_equal Hash, topic.content.class
+    assert_equal Hash, topic.read_attribute(:content).class
+    topic.content["beer"] = "MadridRb"
+    assert topic.save
+    topic.reload
+    assert_equal Hash, topic.content.class
+    assert_equal "MadridRb", topic.content["beer"]
+  ensure
+    Topic.serialize(:content)
+  end
+
+  def test_serialized_no_default_class_for_object
+    topic = Topic.new
+    assert_nil topic.content
+  end
+
   def test_serialized_boolean_value_true
     Topic.serialize(:content)
     topic = Topic.new(:content => true)
@@ -1013,6 +1086,52 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal topic.content, false
   end
 
+  def test_serialize_with_coder
+    coder = Class.new {
+      # Identity
+      def load(thing)
+        thing
+      end
+
+      # base 64
+      def dump(thing)
+        [thing].pack('m')
+      end
+    }.new
+
+    Topic.serialize(:content, coder)
+    s = 'hello world'
+    topic = Topic.new(:content => s)
+    assert topic.save
+    topic = topic.reload
+    assert_equal [s].pack('m'), topic.content
+  ensure
+    Topic.serialize(:content)
+  end
+
+  def test_serialize_with_bcrypt_coder
+    crypt_coder = Class.new {
+      def load(thing)
+        return unless thing
+        BCrypt::Password.new thing
+      end
+
+      def dump(thing)
+        BCrypt::Password.create(thing).to_s
+      end
+    }.new
+
+    Topic.serialize(:content, crypt_coder)
+    password = 'password'
+    topic = Topic.new(:content => password)
+    assert topic.save
+    topic = topic.reload
+    assert_kind_of BCrypt::Password, topic.content
+    assert_equal(true, topic.content == password, 'password should equal')
+  ensure
+    Topic.serialize(:content)
+  end
+
   def test_quote
     author_name = "\\ \001 ' \n \\n \""
     topic = Topic.create('author_name' => author_name)
@@ -1068,9 +1187,14 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_define_attr_method_with_block
-    k = Class.new( ActiveRecord::Base )
-    k.send(:define_attr_method, :primary_key) { "sys_" + original_primary_key }
-    assert_equal "sys_id", k.primary_key
+    k = Class.new( ActiveRecord::Base ) do
+      class << self
+        attr_accessor :foo_key
+      end
+    end
+    k.foo_key = "id"
+    k.send(:define_attr_method, :foo_key) { "sys_" + original_foo_key }
+    assert_equal "sys_id", k.foo_key
   end
 
   def test_set_table_name_with_value
@@ -1081,6 +1205,16 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal "bar", k.table_name
   end
 
+  def test_switching_between_table_name
+    assert_difference("GoodJoke.count") do
+      Joke.set_table_name "cold_jokes"
+      Joke.create
+
+      Joke.set_table_name "funny_jokes"
+      Joke.create
+    end
+  end
+
   def test_quoted_table_name_after_set_table_name
     klass = Class.new(ActiveRecord::Base)
 
@@ -1109,6 +1243,7 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_set_primary_key_with_block
     k = Class.new( ActiveRecord::Base )
+    k.primary_key = 'id'
     k.set_primary_key { "sys_" + original_primary_key }
     assert_equal "sys_id", k.primary_key
   end
@@ -1161,12 +1296,6 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal res6, res7
   end
 
-  def test_interpolate_sql
-    assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo@bar') }
-    assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo bar) baz') }
-    assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo bar} baz') }
-  end
-
   def test_scoped_find_conditions
     scoped_developers = Developer.send(:with_scope, :find => { :conditions => 'salary > 90000' }) do
       Developer.find(:all, :conditions => 'id < 5')
@@ -1477,6 +1606,14 @@ class BasicsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_clear_cache!
+    # preheat cache
+    c1 = Post.columns
+    ActiveRecord::Base.clear_cache!
+    c2 = Post.columns
+    assert_not_equal c1, c2
+  end
+
   def test_default_scope_is_reset
     Object.const_set :UnloadablePost, Class.new(ActiveRecord::Base)
     UnloadablePost.table_name = 'posts'
@@ -1492,4 +1629,11 @@ class BasicsTest < ActiveRecord::TestCase
   ensure
     Object.class_eval{ remove_const :UnloadablePost } if defined?(UnloadablePost)
   end
+
+  def test_marshal_round_trip
+    expected = posts(:welcome)
+    actual   = Marshal.load(Marshal.dump(expected))
+
+    assert_equal expected.attributes, actual.attributes
+  end
 end
diff --git a/activerecord/test/cases/batches_test.rb b/activerecord/test/cases/batches_test.rb
index 9e72ac4250..dc0e0da4c5 100644
--- a/activerecord/test/cases/batches_test.rb
+++ b/activerecord/test/cases/batches_test.rb
@@ -7,6 +7,7 @@ class EachTest < ActiveRecord::TestCase
   def setup
     @posts = Post.order("id asc")
     @total = Post.count
+    Post.count('id') # preheat arel's table cache
   end
 
   def test_each_should_excecute_one_query_per_batch
diff --git a/activerecord/test/cases/bind_parameter_test.rb b/activerecord/test/cases/bind_parameter_test.rb
new file mode 100644
index 0000000000..19383bb06b
--- /dev/null
+++ b/activerecord/test/cases/bind_parameter_test.rb
@@ -0,0 +1,90 @@
+require 'cases/helper'
+require 'models/topic'
+
+module ActiveRecord
+  class BindParameterTest < ActiveRecord::TestCase
+    fixtures :topics
+
+    class LogListener
+      attr_accessor :calls
+
+      def initialize
+        @calls = []
+      end
+
+      def call(*args)
+        calls << args
+      end
+    end
+
+    def setup
+      super
+      @connection = ActiveRecord::Base.connection
+      @listener   = LogListener.new
+      @pk         = Topic.columns.find { |c| c.primary }
+      ActiveSupport::Notifications.subscribe('sql.active_record', @listener)
+    end
+
+    def teardown
+      ActiveSupport::Notifications.unsubscribe(@listener)
+    end
+
+    def test_binds_are_logged
+      # FIXME: use skip with minitest
+      return unless @connection.supports_statement_cache?
+
+      sub   = @connection.substitute_for(@pk, [])
+      binds = [[@pk, 1]]
+      sql   = "select * from topics where id = #{sub}"
+
+      @connection.exec_query(sql, 'SQL', binds)
+
+      message = @listener.calls.find { |args| args[4][:sql] == sql }
+      assert_equal binds, message[4][:binds]
+    end
+
+    def test_find_one_uses_binds
+      # FIXME: use skip with minitest
+      return unless @connection.supports_statement_cache?
+
+      Topic.find(1)
+      binds = [[@pk, 1]]
+      message = @listener.calls.find { |args| args[4][:binds] == binds }
+      assert message, 'expected a message with binds'
+    end
+
+    def test_logs_bind_vars
+      # FIXME: use skip with minitest
+      return unless @connection.supports_statement_cache?
+
+      pk = Topic.columns.find { |x| x.primary }
+
+      payload = {
+        :name  => 'SQL',
+        :sql   => 'select * from topics where id = ?',
+        :binds => [[pk, 10]]
+      }
+      event  = ActiveSupport::Notifications::Event.new(
+        'foo',
+        Time.now,
+        Time.now,
+        123,
+        payload)
+
+        logger = Class.new(ActiveRecord::LogSubscriber) {
+          attr_reader :debugs
+          def initialize
+            super
+            @debugs = []
+          end
+
+          def debug str
+            @debugs << str
+          end
+        }.new
+
+        logger.sql event
+        assert_match([[pk.name, 10]].inspect, logger.debugs.first)
+    end
+  end
+end
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index 5cb8485b4b..caf07a7357 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -23,6 +23,17 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal 53.0, value
   end
 
+  def test_should_return_decimal_average_of_integer_field
+    value = Account.average(:id)
+    assert_equal 3.5, value
+  end
+
+  def test_should_return_integer_average_if_db_returns_such
+    Account.connection.stubs :select_value => 3
+    value = Account.average(:id)
+    assert_equal 3, value
+  end
+
   def test_should_return_nil_as_average
     assert_nil NumericData.average(:bank_balance)
   end
@@ -98,6 +109,36 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal [2, 6], c.keys.compact
   end
 
+  def test_limit_with_offset_is_kept
+    return if current_adapter?(:OracleAdapter)
+
+    queries = assert_sql { Account.limit(1).offset(1).count }
+    assert_equal 1, queries.length
+    assert_match(/LIMIT/, queries.first)
+    assert_match(/OFFSET/, queries.first)
+  end
+
+  def test_offset_without_limit_removes_offset
+    queries = assert_sql { Account.offset(1).count }
+    assert_equal 1, queries.length
+    assert_no_match(/LIMIT/, queries.first)
+    assert_no_match(/OFFSET/, queries.first)
+  end
+
+  def test_limit_without_offset_removes_limit
+    queries = assert_sql { Account.limit(1).count }
+    assert_equal 1, queries.length
+    assert_no_match(/LIMIT/, queries.first)
+    assert_no_match(/OFFSET/, queries.first)
+  end
+
+  def test_no_limit_no_offset
+    queries = assert_sql { Account.count }
+    assert_equal 1, queries.length
+    assert_no_match(/LIMIT/, queries.first)
+    assert_no_match(/OFFSET/, queries.first)
+  end
+
   def test_should_group_by_summed_field_having_condition
     c = Account.sum(:credit_limit, :group => :firm_id,
                                    :having => 'sum(credit_limit) > 50')
diff --git a/activerecord/test/cases/coders/yaml_column_test.rb b/activerecord/test/cases/coders/yaml_column_test.rb
new file mode 100644
index 0000000000..c7dcc21809
--- /dev/null
+++ b/activerecord/test/cases/coders/yaml_column_test.rb
@@ -0,0 +1,46 @@
+
+require "cases/helper"
+
+module ActiveRecord
+  module Coders
+    class YAMLColumnTest < ActiveRecord::TestCase
+      def test_initialize_takes_class
+        coder = YAMLColumn.new(Object)
+        assert_equal Object, coder.object_class
+      end
+
+      def test_type_mismatch_on_different_classes
+        coder = YAMLColumn.new(Array)
+        assert_raises(SerializationTypeMismatch) do
+          coder.load "--- foo"
+        end
+      end
+
+      def test_nil_is_ok
+        coder = YAMLColumn.new
+        assert_nil coder.load "--- "
+      end
+
+      def test_returns_new_with_different_class
+        coder = YAMLColumn.new SerializationTypeMismatch
+        assert_equal SerializationTypeMismatch, coder.load("--- ").class
+      end
+
+      def test_returns_string_unless_starts_with_dash
+        coder = YAMLColumn.new
+        assert_equal 'foo', coder.load("foo")
+      end
+
+      def test_load_handles_other_classes
+        coder = YAMLColumn.new
+        assert_equal [], coder.load([])
+      end
+
+      def test_load_swallows_yaml_exceptions
+        coder = YAMLColumn.new
+        bad_yaml = '--- {'
+        assert_equal bad_yaml, coder.load(bad_yaml)
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/column_definition_test.rb b/activerecord/test/cases/column_definition_test.rb
index cc6a6b44f2..d1dddd4c2c 100644
--- a/activerecord/test/cases/column_definition_test.rb
+++ b/activerecord/test/cases/column_definition_test.rb
@@ -1,121 +1,145 @@
 require "cases/helper"
 
-class ColumnDefinitionTest < ActiveRecord::TestCase
-  def setup
-    @adapter = ActiveRecord::ConnectionAdapters::AbstractAdapter.new(nil)
-    def @adapter.native_database_types
-      {:string => "varchar"}
-    end
-  end
+module ActiveRecord
+  module ConnectionAdapters
+    class ColumnDefinitionTest < ActiveRecord::TestCase
+      def setup
+        @adapter = AbstractAdapter.new(nil)
+        def @adapter.native_database_types
+          {:string => "varchar"}
+        end
+      end
 
-  # Avoid column definitions in create table statements like:
-  # `title` varchar(255) DEFAULT NULL
-  def test_should_not_include_default_clause_when_default_is_null
-    column = ActiveRecord::ConnectionAdapters::Column.new("title", nil, "varchar(20)")
-    column_def = ActiveRecord::ConnectionAdapters::ColumnDefinition.new(
-      @adapter, column.name, "string",
-      column.limit, column.precision, column.scale, column.default, column.null)
-    assert_equal "title varchar(20)", column_def.to_sql
-  end
+      def test_can_set_coder
+        column = Column.new("title", nil, "varchar(20)")
+        column.coder = YAML
+        assert_equal YAML, column.coder
+      end
 
-  def test_should_include_default_clause_when_default_is_present
-    column = ActiveRecord::ConnectionAdapters::Column.new("title", "Hello", "varchar(20)")
-    column_def = ActiveRecord::ConnectionAdapters::ColumnDefinition.new(
-      @adapter, column.name, "string",
-      column.limit, column.precision, column.scale, column.default, column.null)
-    assert_equal %Q{title varchar(20) DEFAULT 'Hello'}, column_def.to_sql
-  end
+      def test_encoded?
+        column = Column.new("title", nil, "varchar(20)")
+        assert !column.encoded?
 
-  def test_should_specify_not_null_if_null_option_is_false
-    column = ActiveRecord::ConnectionAdapters::Column.new("title", "Hello", "varchar(20)", false)
-    column_def = ActiveRecord::ConnectionAdapters::ColumnDefinition.new(
-      @adapter, column.name, "string",
-      column.limit, column.precision, column.scale, column.default, column.null)
-    assert_equal %Q{title varchar(20) DEFAULT 'Hello' NOT NULL}, column_def.to_sql
-  end
+        column.coder = YAML
+        assert column.encoded?
+      end
 
-  if current_adapter?(:MysqlAdapter)
-    def test_should_set_default_for_mysql_binary_data_types
-      binary_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", "a", "binary(1)")
-      assert_equal "a", binary_column.default
+      def test_type_case_coded_column
+        column = Column.new("title", nil, "varchar(20)")
+        column.coder = YAML
+        assert_equal "hello", column.type_cast("--- hello")
+      end
 
-      varbinary_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", "a", "varbinary(1)")
-      assert_equal "a", varbinary_column.default
-    end
+      # Avoid column definitions in create table statements like:
+      # `title` varchar(255) DEFAULT NULL
+      def test_should_not_include_default_clause_when_default_is_null
+        column = Column.new("title", nil, "varchar(20)")
+        column_def = ColumnDefinition.new(
+          @adapter, column.name, "string",
+          column.limit, column.precision, column.scale, column.default, column.null)
+          assert_equal "title varchar(20)", column_def.to_sql
+      end
 
-    def test_should_not_set_default_for_blob_and_text_data_types
-      assert_raise ArgumentError do
-        ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", "a", "blob")
+      def test_should_include_default_clause_when_default_is_present
+        column = Column.new("title", "Hello", "varchar(20)")
+        column_def = ColumnDefinition.new(
+          @adapter, column.name, "string",
+          column.limit, column.precision, column.scale, column.default, column.null)
+          assert_equal %Q{title varchar(20) DEFAULT 'Hello'}, column_def.to_sql
       end
 
-      assert_raise ArgumentError do
-        ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", "Hello", "text")
+      def test_should_specify_not_null_if_null_option_is_false
+        column = Column.new("title", "Hello", "varchar(20)", false)
+        column_def = ColumnDefinition.new(
+          @adapter, column.name, "string",
+          column.limit, column.precision, column.scale, column.default, column.null)
+          assert_equal %Q{title varchar(20) DEFAULT 'Hello' NOT NULL}, column_def.to_sql
       end
 
-      text_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", nil, "text")
-      assert_equal nil, text_column.default
+      if current_adapter?(:MysqlAdapter)
+        def test_should_set_default_for_mysql_binary_data_types
+          binary_column = MysqlColumn.new("title", "a", "binary(1)")
+          assert_equal "a", binary_column.default
 
-      not_null_text_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", nil, "text", false)
-      assert_equal "", not_null_text_column.default
-    end
+          varbinary_column = MysqlColumn.new("title", "a", "varbinary(1)")
+          assert_equal "a", varbinary_column.default
+        end
 
-    def test_has_default_should_return_false_for_blog_and_test_data_types
-      blob_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", nil, "blob")
-      assert !blob_column.has_default?
+        def test_should_not_set_default_for_blob_and_text_data_types
+          assert_raise ArgumentError do
+            MysqlColumn.new("title", "a", "blob")
+          end
 
-      text_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", nil, "text")
-      assert !text_column.has_default?
-    end
-  end
+          assert_raise ArgumentError do
+            MysqlColumn.new("title", "Hello", "text")
+          end
 
-  if current_adapter?(:Mysql2Adapter)
-    def test_should_set_default_for_mysql_binary_data_types
-      binary_column = ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", "a", "binary(1)")
-      assert_equal "a", binary_column.default
+          text_column = MysqlColumn.new("title", nil, "text")
+          assert_equal nil, text_column.default
 
-      varbinary_column = ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", "a", "varbinary(1)")
-      assert_equal "a", varbinary_column.default
-    end
+          not_null_text_column = MysqlColumn.new("title", nil, "text", false)
+          assert_equal "", not_null_text_column.default
+        end
 
-    def test_should_not_set_default_for_blob_and_text_data_types
-      assert_raise ArgumentError do
-        ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", "a", "blob")
-      end
+        def test_has_default_should_return_false_for_blog_and_test_data_types
+          blob_column = MysqlColumn.new("title", nil, "blob")
+          assert !blob_column.has_default?
 
-      assert_raise ArgumentError do
-        ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", "Hello", "text")
+          text_column = MysqlColumn.new("title", nil, "text")
+          assert !text_column.has_default?
+        end
       end
 
-      text_column = ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", nil, "text")
-      assert_equal nil, text_column.default
+      if current_adapter?(:Mysql2Adapter)
+        def test_should_set_default_for_mysql_binary_data_types
+          binary_column = Mysql2Column.new("title", "a", "binary(1)")
+          assert_equal "a", binary_column.default
 
-      not_null_text_column = ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", nil, "text", false)
-      assert_equal "", not_null_text_column.default
-    end
+          varbinary_column = Mysql2Column.new("title", "a", "varbinary(1)")
+          assert_equal "a", varbinary_column.default
+        end
 
-    def test_has_default_should_return_false_for_blog_and_test_data_types
-      blob_column = ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", nil, "blob")
-      assert !blob_column.has_default?
+        def test_should_not_set_default_for_blob_and_text_data_types
+          assert_raise ArgumentError do
+            Mysql2Column.new("title", "a", "blob")
+          end
 
-      text_column = ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", nil, "text")
-      assert !text_column.has_default?
-    end
-  end
+          assert_raise ArgumentError do
+            Mysql2Column.new("title", "Hello", "text")
+          end
 
-  if current_adapter?(:PostgreSQLAdapter)
-    def test_bigint_column_should_map_to_integer
-      bigint_column = ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new('number', nil, "bigint")
-      assert_equal :integer, bigint_column.type
-    end
+          text_column = Mysql2Column.new("title", nil, "text")
+          assert_equal nil, text_column.default
 
-    def test_smallint_column_should_map_to_integer
-      smallint_column = ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new('number', nil, "smallint")
-      assert_equal :integer, smallint_column.type
-    end
+          not_null_text_column = Mysql2Column.new("title", nil, "text", false)
+          assert_equal "", not_null_text_column.default
+        end
+
+        def test_has_default_should_return_false_for_blog_and_test_data_types
+          blob_column = Mysql2Column.new("title", nil, "blob")
+          assert !blob_column.has_default?
 
-    def test_uuid_column_should_map_to_string
-      uuid_column = ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new('unique_id', nil, "uuid")
-      assert_equal :string, uuid_column.type
+          text_column = Mysql2Column.new("title", nil, "text")
+          assert !text_column.has_default?
+        end
+      end
+
+      if current_adapter?(:PostgreSQLAdapter)
+        def test_bigint_column_should_map_to_integer
+          bigint_column = PostgreSQLColumn.new('number', nil, "bigint")
+          assert_equal :integer, bigint_column.type
+        end
+
+        def test_smallint_column_should_map_to_integer
+          smallint_column = PostgreSQLColumn.new('number', nil, "smallint")
+          assert_equal :integer, smallint_column.type
+        end
+
+        def test_uuid_column_should_map_to_string
+          uuid_column = PostgreSQLColumn.new('unique_id', nil, "uuid")
+          assert_equal :string, uuid_column.type
+        end
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/connection_pool_test.rb b/activerecord/test/cases/connection_pool_test.rb
index 2e18117895..7ac14fa8d6 100644
--- a/activerecord/test/cases/connection_pool_test.rb
+++ b/activerecord/test/cases/connection_pool_test.rb
@@ -3,6 +3,58 @@ require "cases/helper"
 module ActiveRecord
   module ConnectionAdapters
     class ConnectionPoolTest < ActiveRecord::TestCase
+      def setup
+        # Keep a duplicate pool so we do not bother others
+        @pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+
+        if in_memory_db?
+          # Separate connections to an in-memory database create an entirely new database,
+          # with an empty schema etc, so we just stub out this schema on the fly.
+          @pool.with_connection do |connection|
+            connection.create_table :posts do |t|
+              t.integer :cololumn
+            end
+          end
+        end
+      end
+
+      def test_pool_caches_columns
+        columns = @pool.columns['posts']
+        assert_equal columns, @pool.columns['posts']
+      end
+
+      def test_pool_caches_columns_hash
+        columns_hash = @pool.columns_hash['posts']
+        assert_equal columns_hash, @pool.columns_hash['posts']
+      end
+
+      def test_clearing_column_cache
+        @pool.columns['posts']
+        @pool.columns_hash['posts']
+
+        @pool.clear_cache!
+
+        assert_equal 0, @pool.columns.size
+        assert_equal 0, @pool.columns_hash.size
+      end
+
+      def test_primary_key
+        assert_equal 'id', @pool.primary_keys['posts']
+      end
+
+      def test_primary_key_for_non_existent_table
+        assert_equal 'id', @pool.primary_keys['omgponies']
+      end
+
+      def test_primary_key_is_set_on_columns
+        posts_columns = @pool.columns_hash['posts']
+        assert posts_columns['id'].primary
+
+        (posts_columns.keys - ['id']).each do |key|
+          assert !posts_columns[key].primary
+        end
+      end
+
       def test_clear_stale_cached_connections!
         pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
 
@@ -55,6 +107,26 @@ module ActiveRecord
         end.join()
 
       end
+
+      def test_automatic_reconnect=
+        pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+        assert pool.automatic_reconnect
+        assert pool.connection
+
+        pool.disconnect!
+        assert pool.connection
+
+        pool.disconnect!
+        pool.automatic_reconnect = false
+
+        assert_raises(ConnectionNotEstablished) do
+          pool.connection
+        end
+
+        assert_raises(ConnectionNotEstablished) do
+          pool.with_connection
+        end
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/custom_locking_test.rb b/activerecord/test/cases/custom_locking_test.rb
new file mode 100644
index 0000000000..d63ecdbcc5
--- /dev/null
+++ b/activerecord/test/cases/custom_locking_test.rb
@@ -0,0 +1,17 @@
+require "cases/helper"
+require 'models/person'
+
+module ActiveRecord
+  class CustomLockingTest < ActiveRecord::TestCase
+    fixtures :people
+
+    def test_custom_lock
+      if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
+        assert_match 'SHARE MODE', Person.lock('LOCK IN SHARE MODE').to_sql
+        assert_sql(/LOCK IN SHARE MODE/) do
+          Person.find(1, :lock => 'LOCK IN SHARE MODE')
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index f4af6506c5..2e620d8b03 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -984,7 +984,7 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_select_rows
     assert_equal(
-      [["1", nil, nil, "37signals"],
+      [["1", "1", nil, "37signals"],
        ["2", "1", "2", "Summit"],
        ["3", "1", "1", "Microsoft"]],
       Company.connection.select_rows("SELECT id, firm_id, client_of, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! {|i| i.map! {|j| j.to_s unless j.nil?}})
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
index 9ce163a00f..fa40fad56d 100644
--- a/activerecord/test/cases/fixtures_test.rb
+++ b/activerecord/test/cases/fixtures_test.rb
@@ -13,6 +13,7 @@ require 'models/category'
 require 'models/parrot'
 require 'models/pirate'
 require 'models/treasure'
+require 'models/traffic_light'
 require 'models/matey'
 require 'models/ship'
 require 'models/book'
@@ -24,7 +25,7 @@ class FixturesTest < ActiveRecord::TestCase
   self.use_instantiated_fixtures = true
   self.use_transactional_fixtures = false
 
-  fixtures :topics, :developers, :accounts, :tasks, :categories, :funny_jokes, :binaries
+  fixtures :topics, :developers, :accounts, :tasks, :categories, :funny_jokes, :binaries, :traffic_lights
 
   FIXTURES = %w( accounts binaries companies customers
                  developers developers_projects entrants
@@ -34,7 +35,7 @@ class FixturesTest < ActiveRecord::TestCase
   def test_clean_fixtures
     FIXTURES.each do |name|
       fixtures = nil
-      assert_nothing_raised { fixtures = create_fixtures(name) }
+      assert_nothing_raised { fixtures = create_fixtures(name).first }
       assert_kind_of(Fixtures, fixtures)
       fixtures.each { |_name, fixture|
         fixture.each { |key, value|
@@ -52,7 +53,7 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_attributes
-    topics = create_fixtures("topics")
+    topics = create_fixtures("topics").first
     assert_equal("The First Topic", topics["first"]["title"])
     assert_nil(topics["second"]["author_email_address"])
   end
@@ -126,12 +127,11 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_instantiation
-    topics = create_fixtures("topics")
+    topics = create_fixtures("topics").first
     assert_kind_of Topic, topics["first"].find
   end
 
   def test_complete_instantiation
-    assert_equal 4, @topics.size
     assert_equal "The First Topic", @first.title
   end
 
@@ -141,7 +141,6 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_erb_in_fixtures
-    assert_equal 11, @developers.size
     assert_equal "fixture_5", @dev_5.name
   end
 
@@ -198,12 +197,15 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_binary_in_fixtures
-    assert_equal 1, @binaries.size
     data = File.open(ASSETS_ROOT + "/flowers.jpg", 'rb') { |f| f.read }
     data.force_encoding('ASCII-8BIT') if data.respond_to?(:force_encoding)
     data.freeze
     assert_equal data, @flowers.data
   end
+
+  def test_serialized_fixtures
+    assert_equal ["Green", "Red", "Orange"], traffic_lights(:uk).state
+  end
 end
 
 if Account.connection.respond_to?(:reset_pk_sequence!)
@@ -240,7 +242,7 @@ if Account.connection.respond_to?(:reset_pk_sequence!)
 
     def test_create_fixtures_resets_sequences_when_not_cached
       @instances.each do |instance|
-        max_id = create_fixtures(instance.class.table_name).inject(0) do |_max_id, (_, fixture)|
+        max_id = create_fixtures(instance.class.table_name).first.fixtures.inject(0) do |_max_id, (_, fixture)|
           fixture_id = fixture['id'].to_i
           fixture_id > _max_id ? fixture_id : _max_id
         end
@@ -299,9 +301,6 @@ class FixturesWithoutInstanceInstantiationTest < ActiveRecord::TestCase
 
   def test_without_instance_instantiation
     assert !defined?(@first), "@first is not defined"
-    assert_not_nil @topics
-    assert_not_nil @developers
-    assert_not_nil @accounts
   end
 end
 
@@ -379,6 +378,21 @@ class ForeignKeyFixturesTest < ActiveRecord::TestCase
   end
 end
 
+class OverRideFixtureMethodTest < ActiveRecord::TestCase
+  fixtures :topics
+
+  def topics(name)
+    topic = super
+    topic.title = 'omg'
+    topic
+  end
+
+  def test_fixture_methods_can_be_overridden
+    x = topics :first
+    assert_equal 'omg', x.title
+  end
+end
+
 class CheckSetTableNameFixturesTest < ActiveRecord::TestCase
   set_fixture_class :funny_jokes => 'Joke'
   fixtures :funny_jokes
@@ -504,7 +518,7 @@ class FasterFixturesTest < ActiveRecord::TestCase
   fixtures :categories, :authors
 
   def load_extra_fixture(name)
-    fixture = create_fixtures(name)
+    fixture = create_fixtures(name).first
     assert fixture.is_a?(Fixtures)
     @loaded_fixtures[fixture.table_name] = fixture
   end
diff --git a/activerecord/test/cases/habtm_destroy_order_test.rb b/activerecord/test/cases/habtm_destroy_order_test.rb
new file mode 100644
index 0000000000..15598392e2
--- /dev/null
+++ b/activerecord/test/cases/habtm_destroy_order_test.rb
@@ -0,0 +1,17 @@
+require "cases/helper"
+require "models/lesson"
+require "models/student"
+
+class HabtmDestroyOrderTest < ActiveRecord::TestCase
+  test "may not delete a lesson with students" do
+    sicp = Lesson.new(:name => "SICP")
+    ben = Student.new(:name => "Ben Bitdiddle")
+    sicp.students << ben
+    sicp.save!
+    assert_raises LessonError do
+      assert_no_difference('Lesson.count') do
+        sicp.destroy
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/helper.rb b/activerecord/test/cases/helper.rb
index f9bbc5299b..fd20f1b120 100644
--- a/activerecord/test/cases/helper.rb
+++ b/activerecord/test/cases/helper.rb
@@ -11,7 +11,14 @@ require 'mocha'
 
 require 'active_record'
 require 'active_support/dependencies'
-require 'connection'
+begin
+  require 'connection'
+rescue LoadError
+  # If we cannot load connection we assume that driver was not loaded for this test case, so we load sqlite3 as default one.
+  # This allows for running separate test cases by simply running test file.
+  connection_type = defined?(JRUBY_VERSION) ? 'jdbc' : 'native'
+  require "test/connections/#{connection_type}_sqlite3/connection"
+end
 
 # Show backtraces for deprecated behavior for quicker cleanup.
 ActiveSupport::Deprecation.debug = true
@@ -19,6 +26,9 @@ ActiveSupport::Deprecation.debug = true
 # Quote "type" if it's a reserved word for the current connection.
 QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type')
 
+# Enable Identity Map for testing
+ActiveRecord::IdentityMap.enabled = (ENV['IM'] == "false" ? false : true)
+
 def current_adapter?(*types)
   types.any? do |type|
     ActiveRecord::ConnectionAdapters.const_defined?(type) &&
@@ -26,6 +36,15 @@ def current_adapter?(*types)
   end
 end
 
+def in_memory_db?
+  current_adapter?(:SQLiteAdapter) &&
+  ActiveRecord::Base.connection_pool.spec.config[:database] == ":memory:"
+end
+
+def supports_savepoints?
+  ActiveRecord::Base.connection.supports_savepoints?
+end
+
 def with_env_tz(new_tz = 'US/Eastern')
   old_tz, ENV['TZ'] = ENV['TZ'], new_tz
   yield
@@ -40,42 +59,31 @@ ensure
   ActiveRecord::Base.default_timezone = old_zone
 end
 
-ActiveRecord::Base.connection.class.class_eval do
-  IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /SHOW FIELDS/]
+module ActiveRecord
+  class SQLCounter
+    IGNORED_SQL = [/^PRAGMA (?!(table_info))/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/]
 
-  # FIXME: this needs to be refactored so specific database can add their own
-  # ignored SQL.  This ignored SQL is for Oracle.
-  IGNORED_SQL.concat [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from ((all|user)_tab_columns|(all|user)_triggers|(all|user)_constraints)/im]
+    # FIXME: this needs to be refactored so specific database can add their own
+    # ignored SQL.  This ignored SQL is for Oracle.
+    IGNORED_SQL.concat [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im]
 
-  def execute_with_query_record(sql, name = nil, &block)
-    $queries_executed ||= []
-    $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
-    execute_without_query_record(sql, name, &block)
-  end
+    def initialize
+      $queries_executed = []
+    end
 
-  alias_method_chain :execute, :query_record
+    def call(name, start, finish, message_id, values)
+      sql = values[:sql]
 
-  def exec_query_with_query_record(sql, name = nil, binds = [], &block)
-    $queries_executed ||= []
-    $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
-    exec_query_without_query_record(sql, name, binds, &block)
+      # FIXME: this seems bad. we should probably have a better way to indicate
+      # the query was cached
+      unless 'CACHE' == values[:name]
+        $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
+      end
+    end
   end
-
-  alias_method_chain :exec_query, :query_record
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
 end
 
-ActiveRecord::Base.connection.class.class_eval {
-  attr_accessor :column_calls
-
-  def columns_with_calls(*args)
-    @column_calls ||= 0
-    @column_calls += 1
-    columns_without_calls(*args)
-  end
-
-  alias_method_chain :columns, :calls
-}
-
 unless ENV['FIXTURE_DEBUG']
   module ActiveRecord::TestFixtures::ClassMethods
     def try_to_load_dependency_with_silence(*args)
@@ -96,15 +104,15 @@ class ActiveSupport::TestCase
   self.use_transactional_fixtures = true
 
   def create_fixtures(*table_names, &block)
-    Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, {}, &block)
+    Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, fixture_class_names, &block)
   end
 end
 
-# silence verbose schema loading
-original_stdout = $stdout
-$stdout = StringIO.new
+def load_schema
+  # silence verbose schema loading
+  original_stdout = $stdout
+  $stdout = StringIO.new
 
-begin
   adapter_name = ActiveRecord::Base.connection.adapter_name.downcase
   adapter_specific_schema_file = SCHEMA_ROOT + "/#{adapter_name}_specific_schema.rb"
 
@@ -117,6 +125,8 @@ ensure
   $stdout = original_stdout
 end
 
+load_schema
+
 class << Time
   unless method_defined? :now_before_time_travel
     alias_method :now_before_time_travel, :now
@@ -133,4 +143,3 @@ class << Time
     @now = nil
   end
 end
-
diff --git a/activerecord/test/cases/identity_map_test.rb b/activerecord/test/cases/identity_map_test.rb
new file mode 100644
index 0000000000..d98638ab73
--- /dev/null
+++ b/activerecord/test/cases/identity_map_test.rb
@@ -0,0 +1,402 @@
+require "cases/helper"
+require 'models/developer'
+require 'models/project'
+require 'models/company'
+require 'models/topic'
+require 'models/reply'
+require 'models/computer'
+require 'models/customer'
+require 'models/order'
+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/subscriber'
+require "models/pirate"
+require "models/bird"
+require "models/parrot"
+
+if ActiveRecord::IdentityMap.enabled?
+class IdentityMapTest < ActiveRecord::TestCase
+  fixtures :accounts, :companies, :developers, :projects, :topics,
+    :developers_projects, :computers, :authors, :author_addresses,
+    :posts, :tags, :taggings, :comments, :subscribers
+
+  ##############################################################################
+  # Basic tests checking if IM is functioning properly on basic find operations#
+  ##############################################################################
+
+  def test_find_id
+    assert_same(Client.find(3), Client.find(3))
+  end
+
+  def test_find_id_without_identity_map
+    ActiveRecord::IdentityMap.without do
+      assert_not_same(Client.find(3), Client.find(3))
+    end
+  end
+
+  def test_find_id_use_identity_map
+    ActiveRecord::IdentityMap.enabled = false
+    ActiveRecord::IdentityMap.use do
+      assert_same(Client.find(3), Client.find(3))
+    end
+    ActiveRecord::IdentityMap.enabled = true
+  end
+
+  def test_find_pkey
+    assert_same(
+      Subscriber.find('swistak'),
+      Subscriber.find('swistak')
+    )
+  end
+
+  def test_find_by_id
+    assert_same(
+      Client.find_by_id(3),
+      Client.find_by_id(3)
+    )
+  end
+
+  def test_find_by_string_and_numeric_id
+    assert_same(
+      Client.find_by_id("3"),
+      Client.find_by_id(3)
+    )
+  end
+
+  def test_find_by_pkey
+    assert_same(
+      Subscriber.find_by_nick('swistak'),
+      Subscriber.find_by_nick('swistak')
+    )
+  end
+
+  def test_find_first_id
+    assert_same(
+      Client.find(:first, :conditions => {:id => 1}),
+      Client.find(:first, :conditions => {:id => 1})
+    )
+  end
+
+  def test_find_first_pkey
+    assert_same(
+      Subscriber.find(:first, :conditions => {:nick => 'swistak'}),
+      Subscriber.find(:first, :conditions => {:nick => 'swistak'})
+    )
+  end
+
+  ##############################################################################
+  # Tests checking if IM is functioning properly on more advanced finds        #
+  # and associations                                                           #
+  ##############################################################################
+
+  def test_owner_object_is_associated_from_identity_map
+    post = Post.find(1)
+    comment = post.comments.first
+
+    assert_no_queries do
+      comment.post
+    end
+    assert_same post, comment.post
+  end
+
+  def test_associated_object_are_assigned_from_identity_map
+    post = Post.find(1)
+
+    post.comments.each do |comment|
+      assert_same post, comment.post
+      assert_equal post.object_id, comment.post.object_id
+    end
+  end
+
+  def test_creation
+    t1 = Topic.create("title" => "t1")
+    t2 = Topic.find(t1.id)
+    assert_same(t1, t2)
+  end
+
+  ##############################################################################
+  # Tests checking dirty attribute behaviour with IM                           #
+  ##############################################################################
+
+  def test_loading_new_instance_should_not_update_dirty_attributes
+    swistak = Subscriber.find(:first, :conditions => {:nick => 'swistak'})
+    swistak.name = "Swistak Sreberkowiec"
+    assert_equal(["name"], swistak.changed)
+    assert_equal({"name" => ["Marcin Raczkowski", "Swistak Sreberkowiec"]}, swistak.changes)
+
+    s = Subscriber.find('swistak')
+
+    assert swistak.name_changed?
+    assert_equal("Swistak Sreberkowiec", swistak.name)
+  end
+
+  def test_loading_new_instance_should_change_dirty_attribute_original_value
+    swistak = Subscriber.find(:first, :conditions => {:nick => 'swistak'})
+    swistak.name = "Swistak Sreberkowiec"
+
+    Subscriber.update_all({:name => "Raczkowski Marcin"}, {:name => "Marcin Raczkowski"})
+
+    s = Subscriber.find('swistak')
+
+    assert_equal({'name' => ["Raczkowski Marcin", "Swistak Sreberkowiec"]}, swistak.changes)
+    assert_equal("Swistak Sreberkowiec", swistak.name)
+  end
+
+  def test_loading_new_instance_should_remove_dirt
+    swistak = Subscriber.find(:first, :conditions => {:nick => 'swistak'})
+    swistak.name = "Swistak Sreberkowiec"
+
+    assert_equal({"name" => ["Marcin Raczkowski", "Swistak Sreberkowiec"]}, swistak.changes)
+
+    Subscriber.update_all({:name => "Swistak Sreberkowiec"}, {:name => "Marcin Raczkowski"})
+
+    s = Subscriber.find('swistak')
+
+    assert_equal("Swistak Sreberkowiec", swistak.name)
+    assert_equal({}, swistak.changes)
+    assert !swistak.name_changed?
+  end
+
+  def test_has_many_associations
+    pirate = Pirate.create!(:catchphrase => "Don' botharrr talkin' like one, savvy?")
+    pirate.birds.create!(:name => 'Posideons Killer')
+    pirate.birds.create!(:name => 'Killer bandita Dionne')
+
+    posideons, killer = pirate.birds
+
+    pirate.reload
+
+    pirate.birds_attributes = [{ :id => posideons.id, :name => 'Grace OMalley' }]
+    assert_equal 'Grace OMalley', pirate.birds.to_a.find { |r| r.id == posideons.id }.name
+  end
+
+  def test_changing_associations
+    post1 = Post.create("title" => "One post", "body" => "Posting...")
+    post2 = Post.create("title" => "Another post", "body" => "Posting... Again...")
+    comment = Comment.new("body" => "comment")
+
+    comment.post = post1
+    assert comment.save
+
+    assert_same(post1.comments.first, comment)
+
+    comment.post = post2
+    assert comment.save
+
+    assert_same(post2.comments.first, comment)
+    assert_equal(0, post1.comments.size)
+  end
+
+  def test_im_with_polymorphic_has_many_going_through_join_model_with_custom_select_and_joins
+    tag = posts(:welcome).tags.first
+    tag_with_joins_and_select = posts(:welcome).tags.add_joins_and_select.first
+    assert_same(tag, tag_with_joins_and_select)
+    assert_nothing_raised(NoMethodError, "Joins/select was not loaded") { tag.author_id }
+  end
+
+  ##############################################################################
+  # Tests checking Identity Map behaviour with preloaded associations, joins,  #
+  # includes etc.                                                              #
+  ##############################################################################
+
+  def test_find_with_preloaded_associations
+    assert_queries(2) do
+      posts = Post.preload(:comments)
+      assert posts.first.comments.first
+    end
+
+    # With IM we'll retrieve post object from previous query, it'll have comments
+    # already preloaded from first call
+    assert_queries(1) do
+      posts = Post.preload(:comments).to_a
+      assert posts.first.comments.first
+    end
+
+    assert_queries(2) do
+      posts = Post.preload(:author)
+      assert posts.first.author
+    end
+
+    # With IM we'll retrieve post object from previous query, it'll have comments
+    # already preloaded from first call
+    assert_queries(1) do
+      posts = Post.preload(:author).to_a
+      assert posts.first.author
+    end
+
+    assert_queries(1) do
+      posts = Post.preload(:author, :comments).to_a
+      assert posts.first.author
+      assert posts.first.comments.first
+    end
+  end
+
+  def test_find_with_included_associations
+    assert_queries(2) do
+      posts = Post.includes(:comments)
+      assert posts.first.comments.first
+    end
+
+    assert_queries(1) do
+      posts = Post.scoped.includes(:comments)
+      assert posts.first.comments.first
+    end
+
+    assert_queries(2) do
+      posts = Post.includes(:author)
+      assert posts.first.author
+    end
+
+    assert_queries(1) do
+      posts = Post.includes(:author, :comments).to_a
+      assert posts.first.author
+      assert posts.first.comments.first
+    end
+  end
+
+  def test_eager_loading_with_conditions_on_joined_table_preloads
+    posts = Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => [:comments], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+    assert_equal [posts(:welcome)], posts
+    assert_equal authors(:david), assert_no_queries { posts[0].author}
+    assert_same posts.first.author, Author.first
+
+    posts = Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => [:comments], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+    assert_equal [posts(:welcome)], posts
+    assert_equal authors(:david), assert_no_queries { posts[0].author}
+    assert_same posts.first.author, Author.first
+
+    posts = Post.find(:all, :include => :author, :joins => {:taggings => :tag}, :conditions => "tags.name = 'General'", :order => 'posts.id')
+    assert_equal posts(:welcome, :thinking), posts
+    assert_same posts.first.author, Author.first
+
+    posts = Post.find(:all, :include => :author, :joins => {:taggings => {:tag => :taggings}}, :conditions => "taggings_tags.super_tag_id=2", :order => 'posts.id')
+    assert_equal posts(:welcome, :thinking), posts
+    assert_same posts.first.author, Author.first
+  end
+
+  def test_eager_loading_with_conditions_on_string_joined_table_preloads
+    posts = assert_queries(2) do
+      Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => "INNER JOIN comments on comments.post_id = posts.id", :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+    end
+    assert_equal [posts(:welcome)], posts
+    assert_equal authors(:david), assert_no_queries { posts[0].author}
+
+    posts = assert_queries(1) do
+      Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => ["INNER JOIN comments on comments.post_id = posts.id"], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+    end
+    assert_equal [posts(:welcome)], posts
+    assert_equal authors(:david), assert_no_queries { posts[0].author}
+  end
+
+  ##############################################################################
+  # Behaviour releated to saving failures
+  ##############################################################################
+
+  def test_reload_object_if_save_failed
+    developer = Developer.first
+    developer.salary = 0
+
+    assert !developer.save
+
+    same_developer = Developer.first
+
+    assert_not_same  developer, same_developer
+    assert_not_equal 0, same_developer.salary
+    assert_not_equal developer.salary, same_developer.salary
+  end
+
+  def test_reload_object_if_forced_save_failed
+    developer = Developer.first
+    developer.salary = 0
+
+    assert_raise(ActiveRecord::RecordInvalid) { developer.save! }
+
+    same_developer = Developer.first
+
+    assert_not_same  developer, same_developer
+    assert_not_equal 0, same_developer.salary
+    assert_not_equal developer.salary, same_developer.salary
+  end
+
+  def test_reload_object_if_update_attributes_fails
+    developer = Developer.first
+    developer.salary = 0
+
+    assert !developer.update_attributes(:salary => 0)
+
+    same_developer = Developer.first
+
+    assert_not_same  developer, same_developer
+    assert_not_equal 0, same_developer.salary
+    assert_not_equal developer.salary, same_developer.salary
+  end
+
+  ##############################################################################
+  # Behaviour of readonly, forzen, destroyed
+  ##############################################################################
+
+  def test_find_using_identity_map_respects_readonly_when_loading_associated_object_first
+    author  = Author.first
+    readonly_comment = author.readonly_comments.first
+
+    comment = Comment.first
+    assert !comment.readonly?
+
+    assert readonly_comment.readonly?
+
+    assert_raise(ActiveRecord::ReadOnlyRecord) {readonly_comment.save}
+    assert comment.save
+  end
+
+  def test_find_using_identity_map_respects_readonly
+    comment = Comment.first
+    assert !comment.readonly?
+
+    author  = Author.first
+    readonly_comment = author.readonly_comments.first
+
+    assert readonly_comment.readonly?
+
+    assert_raise(ActiveRecord::ReadOnlyRecord) {readonly_comment.save}
+    assert comment.save
+  end
+
+  def test_find_using_select_and_identity_map
+    author_id, author = Author.select('id').first, Author.first
+
+    assert_equal author_id, author
+    assert_same author_id, author
+    assert_not_nil author.name
+
+    post, post_id = Post.first, Post.select('id').first
+
+    assert_equal post_id, post
+    assert_same post_id, post
+    assert_not_nil post.title
+  end
+
+# Currently AR is not allowing changing primary key (see Persistence#update)
+# So we ignore it. If this changes, this test needs to be uncommented.
+#  def test_updating_of_pkey
+#    assert client = Client.find(3),
+#    client.update_attribute(:id, 666)
+#
+#    assert Client.find(666)
+#    assert_same(client, Client.find(666))
+#
+#    s = Subscriber.find_by_nick('swistak')
+#    assert s.update_attribute(:nick, 'swistakTheJester')
+#    assert_equal('swistakTheJester', s.nick)
+#
+#    assert stj = Subscriber.find_by_nick('swistakTheJester')
+#    assert_same(s, stj)
+#  end
+
+end
+end
diff --git a/activerecord/test/cases/inheritance_test.rb b/activerecord/test/cases/inheritance_test.rb
index c3da9cdf53..b5d8314541 100644
--- a/activerecord/test/cases/inheritance_test.rb
+++ b/activerecord/test/cases/inheritance_test.rb
@@ -203,12 +203,12 @@ class InheritanceTest < ActiveRecord::TestCase
 
   def test_eager_load_belongs_to_something_inherited
     account = Account.find(1, :include => :firm)
-    assert_not_nil account.instance_variable_get("@firm"), "nil proves eager load failed"
+    assert account.association_cache.key?(:firm), "nil proves eager load failed"
   end
 
   def test_eager_load_belongs_to_primary_key_quoting
     con = Account.connection
-    assert_sql(/\(#{con.quote_table_name('companies')}.#{con.quote_column_name('id')} = 1\)/) do
+    assert_sql(/#{con.quote_table_name('companies')}.#{con.quote_column_name('id')} IN \(1\)/) do
       Account.find(1, :include => :firm)
     end
   end
@@ -219,6 +219,10 @@ class InheritanceTest < ActiveRecord::TestCase
     switch_to_default_inheritance_column
   end
 
+  def test_inherits_custom_primary_key
+    assert_equal Subscriber.primary_key, SpecialSubscriber.primary_key
+  end
+
   def test_inheritance_without_mapping
     assert_kind_of SpecialSubscriber, SpecialSubscriber.find("webster132")
     assert_nothing_raised { s = SpecialSubscriber.new("name" => "And breaaaaathe!"); s.id = 'roger'; s.save }
diff --git a/activerecord/test/cases/lifecycle_test.rb b/activerecord/test/cases/lifecycle_test.rb
index b8c3ffb9cb..6cd8494c9e 100644
--- a/activerecord/test/cases/lifecycle_test.rb
+++ b/activerecord/test/cases/lifecycle_test.rb
@@ -7,6 +7,16 @@ require 'models/comment'
 
 class SpecialDeveloper < Developer; end
 
+class DeveloperObserver < ActiveRecord::Observer
+  def calls
+    @calls ||= []
+  end
+
+  def before_save(developer)
+    calls << developer
+  end
+end
+
 class SalaryChecker < ActiveRecord::Observer
   observe :special_developer
   attr_accessor :last_saved
@@ -101,9 +111,10 @@ class LifecycleTest < ActiveRecord::TestCase
   fixtures :topics, :developers, :minimalistics
 
   def test_before_destroy
-    original_count = Topic.count
-    (topic_to_be_destroyed = Topic.find(1)).destroy
-    assert_equal original_count - (1 + topic_to_be_destroyed.replies.size), Topic.count
+    topic = Topic.find(1)
+    assert_difference 'Topic.count', -(1 + topic.replies.size) do
+      topic.destroy
+    end
   end
 
   def test_auto_observer
@@ -195,4 +206,14 @@ class LifecycleTest < ActiveRecord::TestCase
     assert_equal developer, SalaryChecker.instance.last_saved
   end
 
+  def test_observer_is_called_once
+    observer = DeveloperObserver.instance # activate
+    observer.calls.clear
+
+    developer = Developer.create! :name => 'Ancestor', :salary => 100000
+    special_developer = SpecialDeveloper.create! :name => 'Descendent', :salary => 100000
+
+    assert_equal [developer, special_developer], observer.calls
+  end
+
 end
diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index f9678cb0c5..636a709924 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -1,6 +1,7 @@
 require 'thread'
 require "cases/helper"
 require 'models/person'
+require 'models/job'
 require 'models/reader'
 require 'models/legacy_thing'
 require 'models/reference'
@@ -19,11 +20,6 @@ end
 class OptimisticLockingTest < ActiveRecord::TestCase
   fixtures :people, :legacy_things, :references
 
-  # need to disable transactional fixtures, because otherwise the sqlite3
-  # adapter (at least) chokes when we try and change the schema in the middle
-  # of a test (see test_increment_counter_*).
-  self.use_transactional_fixtures = false
-
   def test_lock_existing
     p1 = Person.find(1)
     p2 = Person.find(1)
@@ -103,6 +99,14 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal 1, p1.lock_version
   end
 
+  def test_touch_existing_lock
+    p1 = Person.find(1)
+    assert_equal 0, p1.lock_version
+
+    p1.touch
+    assert_equal 1, p1.lock_version
+  end
+
 
   def test_lock_column_name_existing
     t1 = LegacyThing.find(1)
@@ -152,6 +156,33 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal "unchangeable name", p.first_name
   end
 
+  def test_quote_table_name
+    ref = references(:michael_magician)
+    ref.favourite = !ref.favourite
+    assert ref.save
+  end
+
+  # Useful for partial updates, don't only update the lock_version if there
+  # is nothing else being updated.
+  def test_update_without_attributes_does_not_only_update_lock_version
+    assert_nothing_raised do
+      p1 = Person.create!(:first_name => 'anika')
+      lock_version = p1.lock_version
+      p1.save
+      p1.reload
+      assert_equal lock_version, p1.lock_version
+    end
+  end
+end
+
+class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
+  fixtures :people, :legacy_things, :references
+
+  # need to disable transactional fixtures, because otherwise the sqlite3
+  # adapter (at least) chokes when we try and change the schema in the middle
+  # of a test (see test_increment_counter_*).
+  self.use_transactional_fixtures = false
+
   { :lock_version => Person, :custom_lock_version => LegacyThing }.each do |name, model|
     define_method("test_increment_counter_updates_#{name}") do
       counter_test model, 1 do |id|
@@ -198,24 +229,6 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_raises(ActiveRecord::RecordNotFound) { LegacyThing.find(t.id) }
   end
 
-  def test_quote_table_name
-    ref = references(:michael_magician)
-    ref.favourite = !ref.favourite
-    assert ref.save
-  end
-
-  # Useful for partial updates, don't only update the lock_version if there
-  # is nothing else being updated.
-  def test_update_without_attributes_does_not_only_update_lock_version
-    assert_nothing_raised do
-      p1 = Person.create!(:first_name => 'anika')
-      lock_version = p1.lock_version
-      p1.save
-      p1.reload
-      assert_equal lock_version, p1.lock_version
-    end
-  end
-
   private
 
     def add_counter_column_to(model, col='test_count')
@@ -252,7 +265,7 @@ end
 
 # TODO: The Sybase, and OpenBase adapters currently have no support for pessimistic locking
 
-unless current_adapter?(:SybaseAdapter, :OpenBaseAdapter)
+unless current_adapter?(:SybaseAdapter, :OpenBaseAdapter) || in_memory_db?
   class PessimisticLockingTest < ActiveRecord::TestCase
     self.use_transactional_fixtures = false
     fixtures :people, :readers
diff --git a/activerecord/test/cases/method_scoping_test.rb b/activerecord/test/cases/method_scoping_test.rb
index 0ffd0e2ab3..7e8383da9e 100644
--- a/activerecord/test/cases/method_scoping_test.rb
+++ b/activerecord/test/cases/method_scoping_test.rb
@@ -14,7 +14,7 @@ class MethodScopingTest < ActiveRecord::TestCase
 
   def test_set_conditions
     Developer.send(:with_scope, :find => { :conditions => 'just a test...' }) do
-      assert_equal '(just a test...)', Developer.scoped.arel.send(:where_clauses).join(' AND ')
+      assert_match '(just a test...)', Developer.scoped.arel.to_sql
     end
   end
 
@@ -227,7 +227,7 @@ class MethodScopingTest < ActiveRecord::TestCase
   end
 
   def test_scoped_create_with_join_and_merge
-    (Comment.where(:body => "but Who's Buying?").joins(:post) & Post.where(:body => 'Peace Sells...')).with_scope do
+    Comment.where(:body => "but Who's Buying?").joins(:post).merge(Post.where(:body => 'Peace Sells...')).with_scope do
       assert_equal({:body => "but Who's Buying?"}, Comment.scoped.scope_for_create)
     end
   end
@@ -275,7 +275,7 @@ class NestedScopingTest < ActiveRecord::TestCase
     Developer.send(:with_scope, :find => { :conditions => 'salary = 80000' }) do
       Developer.send(:with_scope, :find => { :limit => 10 }) do
         devs = Developer.scoped
-        assert_equal '(salary = 80000)', devs.arel.send(:where_clauses).join(' AND ')
+        assert_match '(salary = 80000)', devs.arel.to_sql
         assert_equal 10, devs.taken
       end
     end
@@ -309,7 +309,7 @@ class NestedScopingTest < ActiveRecord::TestCase
     Developer.send(:with_scope, :find => { :conditions => "name = 'David'" }) do
       Developer.send(:with_scope, :find => { :conditions => 'salary = 80000' }) do
         devs = Developer.scoped
-        assert_equal "(name = 'David') AND (salary = 80000)", devs.arel.send(:where_clauses).join(' AND ')
+        assert_match "(name = 'David') AND (salary = 80000)", devs.arel.to_sql
         assert_equal(1, Developer.count)
       end
       Developer.send(:with_scope, :find => { :conditions => "name = 'Maiha'" }) do
@@ -322,7 +322,7 @@ class NestedScopingTest < ActiveRecord::TestCase
     Developer.send(:with_scope, :find => { :conditions => 'salary = 80000', :limit => 10 }) do
       Developer.send(:with_scope, :find => { :conditions => "name = 'David'" }) do
         devs = Developer.scoped
-        assert_equal "(salary = 80000) AND (name = 'David')", devs.arel.send(:where_clauses).join(' AND ')
+        assert_match "(salary = 80000) AND (name = 'David')", devs.arel.to_sql
         assert_equal 10, devs.taken
       end
     end
diff --git a/activerecord/test/cases/migration/command_recorder_test.rb b/activerecord/test/cases/migration/command_recorder_test.rb
index ea2292dda5..ae531ebb4c 100644
--- a/activerecord/test/cases/migration/command_recorder_test.rb
+++ b/activerecord/test/cases/migration/command_recorder_test.rb
@@ -16,7 +16,7 @@ module ActiveRecord
 
       def test_send_calls_super
         assert_raises(NoMethodError) do
-          @recorder.send(:create_table, :horses)
+          @recorder.send(:non_existing_method, :horses)
         end
       end
 
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index 1a65045ded..9d7c49768b 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -14,7 +14,7 @@ if ActiveRecord::Base.connection.supports_migrations?
   class Reminder < ActiveRecord::Base; end
 
   class ActiveRecord::Migration
-    class <<self
+    class << self
       attr_accessor :message_count
     end
 
@@ -1923,6 +1923,149 @@ if ActiveRecord::Base.connection.supports_migrations?
     end
   end
 
+  if ActiveRecord::Base.connection.supports_bulk_alter?
+    class BulkAlterTableMigrationsTest < ActiveRecord::TestCase
+      def setup
+        @connection = Person.connection
+        @connection.create_table(:delete_me, :force => true) {|t| }
+      end
+
+      def teardown
+        Person.connection.drop_table(:delete_me) rescue nil
+      end
+
+      def test_adding_multiple_columns
+        assert_queries(1) do
+          with_bulk_change_table do |t|
+            t.column :name, :string
+            t.string :qualification, :experience
+            t.integer :age, :default => 0
+            t.date :birthdate
+            t.timestamps
+          end
+        end
+
+        assert_equal 8, columns.size
+        [:name, :qualification, :experience].each {|s| assert_equal :string, column(s).type }
+        assert_equal 0, column(:age).default
+      end
+
+      def test_removing_columns
+        with_bulk_change_table do |t|
+          t.string :qualification, :experience
+        end
+
+        [:qualification, :experience].each {|c| assert column(c) }
+
+        assert_queries(1) do
+          with_bulk_change_table do |t|
+            t.remove :qualification, :experience
+            t.string :qualification_experience
+          end
+        end
+
+        [:qualification, :experience].each {|c| assert ! column(c) }
+        assert column(:qualification_experience)
+      end
+
+      def test_adding_indexes
+        with_bulk_change_table do |t|
+          t.string :username
+          t.string :name
+          t.integer :age
+        end
+
+        # Adding an index fires a query everytime to check if an index already exists or not
+        assert_queries(3) do
+          with_bulk_change_table do |t|
+            t.index :username, :unique => true, :name => :awesome_username_index
+            t.index [:name, :age]
+          end
+        end
+
+        assert_equal 2, indexes.size
+
+        name_age_index = index(:index_delete_me_on_name_and_age)
+        assert_equal ['name', 'age'].sort, name_age_index.columns.sort
+        assert ! name_age_index.unique
+
+        assert index(:awesome_username_index).unique
+      end
+
+      def test_removing_index
+        with_bulk_change_table do |t|
+          t.string :name
+          t.index :name
+        end
+
+        assert index(:index_delete_me_on_name)
+
+        assert_queries(3) do
+          with_bulk_change_table do |t|
+            t.remove_index :name
+            t.index :name, :name => :new_name_index, :unique => true
+          end
+        end
+
+        assert ! index(:index_delete_me_on_name)
+
+        new_name_index = index(:new_name_index)
+        assert new_name_index.unique
+      end
+
+      def test_changing_columns
+        with_bulk_change_table do |t|
+          t.string :name
+          t.date :birthdate
+        end
+
+        assert ! column(:name).default
+        assert_equal :date, column(:birthdate).type
+
+        # One query for columns (delete_me table)
+        # One query for primary key (delete_me table)
+        # One query to do the bulk change
+        assert_queries(3) do
+          with_bulk_change_table do |t|
+            t.change :name, :string, :default => 'NONAME'
+            t.change :birthdate, :datetime
+          end
+        end
+
+        assert_equal 'NONAME', column(:name).default
+        assert_equal :datetime, column(:birthdate).type
+      end
+
+      protected
+
+      def with_bulk_change_table
+        # Reset columns/indexes cache as we're changing the table
+        @columns = @indexes = nil
+
+        Person.connection.change_table(:delete_me, :bulk => true) do |t|
+          yield t
+        end
+      end
+
+      def column(name)
+        columns.detect {|c| c.name == name.to_s }
+      end
+
+      def columns
+        @columns ||= Person.connection.columns('delete_me')
+      end
+
+      def index(name)
+        indexes.detect {|i| i.name == name.to_s }
+      end
+
+      def indexes
+        @indexes ||= Person.connection.indexes('delete_me')
+      end
+    end # AlterTableMigrationsTest
+
+  end
+
   class CopyMigrationsTest < ActiveRecord::TestCase
     def setup
     end
@@ -2083,4 +2226,3 @@ if ActiveRecord::Base.connection.supports_migrations?
     end
   end
 end
-
diff --git a/activerecord/test/cases/modules_test.rb b/activerecord/test/cases/modules_test.rb
index 14870cb0e2..a2041af16a 100644
--- a/activerecord/test/cases/modules_test.rb
+++ b/activerecord/test/cases/modules_test.rb
@@ -49,7 +49,6 @@ class ModulesTest < ActiveRecord::TestCase
 
   def test_find_account_and_include_company
     account = MyApplication::Billing::Account.find(1, :include => :firm)
-    assert_kind_of MyApplication::Business::Firm, account.instance_variable_get('@firm')
     assert_kind_of MyApplication::Business::Firm, account.firm
   end
 
diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index 6ac3e3fc56..fb050c3e52 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -64,6 +64,10 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert Reply.scopes.include?(:base)
     assert_equal Reply.find(:all), Reply.base
   end
+  
+  def test_classes_dont_inherit_subclasses_scopes
+    assert !ActiveRecord::Base.scopes.include?(:base)
+  end
 
   def test_scopes_with_options_limit_finds_to_those_matching_the_criteria_specified
     assert !Topic.find(:all, :conditions => {:approved => true}).empty?
@@ -141,26 +145,26 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_equal 1, Topic.multiple_extensions.extension_one
   end
 
-  def test_has_many_associations_have_access_to_named_scopes
+  def test_has_many_associations_have_access_to_scopes
     assert_not_equal Post.containing_the_letter_a, authors(:david).posts
     assert !Post.containing_the_letter_a.empty?
 
     assert_equal authors(:david).posts & Post.containing_the_letter_a, authors(:david).posts.containing_the_letter_a
   end
 
-  def test_named_scope_with_STI
+  def test_scope_with_STI
     assert_equal 3,Post.containing_the_letter_a.count
     assert_equal 1,SpecialPost.containing_the_letter_a.count
   end
 
-  def test_has_many_through_associations_have_access_to_named_scopes
+  def test_has_many_through_associations_have_access_to_scopes
     assert_not_equal Comment.containing_the_letter_e, authors(:david).comments
     assert !Comment.containing_the_letter_e.empty?
 
     assert_equal authors(:david).comments & Comment.containing_the_letter_e, authors(:david).comments.containing_the_letter_e
   end
 
-  def test_named_scopes_honor_current_scopes_from_when_defined
+  def test_scopes_honor_current_scopes_from_when_defined
     assert !Post.ranked_by_comments.limit_by(5).empty?
     assert !authors(:david).posts.ranked_by_comments.limit_by(5).empty?
     assert_not_equal Post.ranked_by_comments.limit_by(5), authors(:david).posts.ranked_by_comments.limit_by(5)
@@ -236,7 +240,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     end
   end
 
-  def test_any_should_not_fire_query_if_named_scope_loaded
+  def test_any_should_not_fire_query_if_scope_loaded
     topics = Topic.base
     topics.collect # force load
     assert_no_queries { assert topics.any? }
@@ -259,7 +263,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     end
   end
 
-  def test_many_should_not_fire_query_if_named_scope_loaded
+  def test_many_should_not_fire_query_if_scope_loaded
     topics = Topic.base
     topics.collect # force load
     assert_no_queries { assert topics.many? }
@@ -276,27 +280,27 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert Topic.base.many?
   end
 
-  def test_should_build_on_top_of_named_scope
+  def test_should_build_on_top_of_scope
     topic = Topic.approved.build({})
     assert topic.approved
   end
 
-  def test_should_build_new_on_top_of_named_scope
+  def test_should_build_new_on_top_of_scope
     topic = Topic.approved.new
     assert topic.approved
   end
 
-  def test_should_create_on_top_of_named_scope
+  def test_should_create_on_top_of_scope
     topic = Topic.approved.create({})
     assert topic.approved
   end
 
-  def test_should_create_with_bang_on_top_of_named_scope
+  def test_should_create_with_bang_on_top_of_scope
     topic = Topic.approved.create!({})
     assert topic.approved
   end
 
-  def test_should_build_on_top_of_chained_named_scopes
+  def test_should_build_on_top_of_chained_scopes
     topic = Topic.approved.by_lifo.build({})
     assert topic.approved
     assert_equal 'lifo', topic.author_name
@@ -310,7 +314,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_kind_of Topic, Topic.approved.sample
   end
 
-  def test_should_use_where_in_query_for_named_scope
+  def test_should_use_where_in_query_for_scope
     assert_equal Developer.find_all_by_name('Jamis').to_set, Developer.find_all_by_id(Developer.jamises).to_set
   end
 
@@ -361,7 +365,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_equal [posts(:sti_comments)], Post.with_special_comments.with_post(4).all.uniq
   end
 
-  def test_named_scopes_batch_finders
+  def test_scopes_batch_finders
     assert_equal 3, Topic.approved.count
 
     assert_queries(4) do
@@ -381,7 +385,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     end
   end
 
-  def test_named_scopes_with_reserved_names
+  def test_scopes_with_reserved_names
     class << Topic
       def public_method; end
       public :public_method
@@ -400,7 +404,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     end
   end
 
-  def test_named_scopes_on_relations
+  def test_scopes_on_relations
     # Topic.replied
     approved_topics = Topic.scoped.approved.order('id DESC')
     assert_equal topics(:fourth), approved_topics.first
@@ -409,19 +413,19 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_equal topics(:third), replied_approved_topics.first
   end
 
-  def test_index_on_named_scope
+  def test_index_on_scope
     approved = Topic.approved.order('id ASC')
     assert_equal topics(:second), approved[0]
     assert approved.loaded?
   end
 
-  def test_nested_named_scopes_queries_size
+  def test_nested_scopes_queries_size
     assert_queries(1) do
       Topic.approved.by_lifo.replied.written_before(Time.now).all
     end
   end
 
-  def test_named_scopes_are_cached_on_associations
+  def test_scopes_are_cached_on_associations
     post = posts(:welcome)
 
     assert_equal post.comments.containing_the_letter_e.object_id, post.comments.containing_the_letter_e.object_id
@@ -430,7 +434,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_no_queries { post.comments.containing_the_letter_e.all }
   end
 
-  def test_named_scopes_with_arguments_are_cached_on_associations
+  def test_scopes_with_arguments_are_cached_on_associations
     post = posts(:welcome)
 
     one = post.comments.limit_by(1).all
@@ -443,17 +447,17 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_no_queries { post.comments.limit_by(2).all }
   end
 
-  def test_named_scopes_are_reset_on_association_reload
+  def test_scopes_are_reset_on_association_reload
     post = posts(:welcome)
 
     [:destroy_all, :reset, :delete_all].each do |method|
       before = post.comments.containing_the_letter_e
-      post.comments.send(method)
+      post.association(:comments).send(method)
       assert before.object_id != post.comments.containing_the_letter_e.object_id, "AssociationCollection##{method} should reset the named scopes cache"
     end
   end
 
-  def test_named_scoped_are_lazy_loaded_if_table_still_does_not_exist
+  def test_scoped_are_lazy_loaded_if_table_still_does_not_exist
     assert_nothing_raised do
       require "models/without_table"
     end
diff --git a/activerecord/test/cases/nested_attributes_test.rb b/activerecord/test/cases/nested_attributes_test.rb
index ffcc7a081a..c57ab7ed28 100644
--- a/activerecord/test/cases/nested_attributes_test.rb
+++ b/activerecord/test/cases/nested_attributes_test.rb
@@ -147,6 +147,15 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     pirate.ship_attributes = { :id => "" }
     assert_nothing_raised(ActiveRecord::RecordNotFound) { pirate.save! }
   end
+
+  def test_first_and_array_index_zero_methods_return_the_same_value_when_nested_attributes_are_set_to_update_existing_record
+    Man.accepts_nested_attributes_for(:interests)
+    man = Man.create(:name => "John")
+    interest = man.interests.create :topic => 'gardning'
+    man = Man.find man.id
+    man.interests_attributes = [{:id => interest.id, :topic => 'gardening'}]
+    assert_equal man.interests.first.topic, man.interests[0].topic
+  end
 end
 
 class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
@@ -298,7 +307,7 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
 
   def test_should_create_new_model_when_nothing_is_there_and_update_only_is_true
     @ship.delete
-    
+
     @pirate.reload.update_attributes(:update_only_ship_attributes => { :name => 'Mayflower' })
 
     assert_not_nil @pirate.ship
@@ -451,7 +460,7 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
 
   def test_should_not_destroy_the_associated_model_until_the_parent_is_saved
     pirate = @ship.pirate
-    
+
     @ship.attributes = { :pirate_attributes => { :id => pirate.id, '_destroy' => true } }
     assert_nothing_raised(ActiveRecord::RecordNotFound) { Pirate.find(pirate.id) }
     @ship.save
@@ -859,7 +868,7 @@ class TestNestedAttributesWithNonStandardPrimaryKeys < ActiveRecord::TestCase
 end
 
 class TestHasOneAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.create!(:catchphrase => "My baby takes tha mornin' train!")
@@ -899,7 +908,7 @@ class TestHasOneAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveRe
 end
 
 class TestHasManyAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @ship = Ship.create!(:name => "The good ship Dollypop")
@@ -909,16 +918,16 @@ class TestHasManyAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveR
 
   test "if association is not loaded and association record is saved and then in memory record attributes should be saved" do
     @ship.parts_attributes=[{:id => @part.id,:name =>'Deck'}]
-    assert_equal 1, @ship.parts.proxy_target.size
+    assert_equal 1, @ship.association(:parts).target.size
     assert_equal 'Deck', @ship.parts[0].name
   end
 
   test "if association is not loaded and child doesn't change and I am saving a grandchild then in memory record should be used" do
     @ship.parts_attributes=[{:id => @part.id,:trinkets_attributes =>[{:id => @trinket.id, :name => 'Ruby'}]}]
-    assert_equal 1, @ship.parts.proxy_target.size
+    assert_equal 1, @ship.association(:parts).target.size
     assert_equal 'Mast', @ship.parts[0].name
-    assert_no_difference("@ship.parts[0].trinkets.proxy_target.size") do
-      @ship.parts[0].trinkets.proxy_target.size
+    assert_no_difference("@ship.parts[0].association(:trinkets).target.size") do
+      @ship.parts[0].association(:trinkets).target.size
     end
     assert_equal 'Ruby', @ship.parts[0].trinkets[0].name
     @ship.save
diff --git a/activerecord/test/cases/pooled_connections_test.rb b/activerecord/test/cases/pooled_connections_test.rb
index de5fa140ba..6269437b14 100644
--- a/activerecord/test/cases/pooled_connections_test.rb
+++ b/activerecord/test/cases/pooled_connections_test.rb
@@ -137,4 +137,4 @@ class PooledConnectionsTest < ActiveRecord::TestCase
   def add_record(name)
     ActiveRecord::Base.connection_pool.with_connection { Project.create! :name => name }
   end
-end unless %w(FrontBase).include? ActiveRecord::Base.connection.adapter_name
+end unless current_adapter?(:FrontBase) || in_memory_db?
diff --git a/activerecord/test/cases/query_cache_test.rb b/activerecord/test/cases/query_cache_test.rb
index 33916c4e46..53aefc7b58 100644
--- a/activerecord/test/cases/query_cache_test.rb
+++ b/activerecord/test/cases/query_cache_test.rb
@@ -63,7 +63,7 @@ class QueryCacheTest < ActiveRecord::TestCase
       # Oracle adapter returns count() as Fixnum or Float
       if current_adapter?(:OracleAdapter)
         assert_kind_of Numeric, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-      elsif current_adapter?(:SQLite3Adapter) && SQLite3::Version::VERSION > '1.2.5' || current_adapter?(:Mysql2Adapter) || current_adapter?(:MysqlAdapter)
+      elsif current_adapter?(:SQLite3Adapter) && SQLite3::VERSION > '1.2.5' || current_adapter?(:Mysql2Adapter) || current_adapter?(:MysqlAdapter)
         # Future versions of the sqlite3 adapter will return numeric
         assert_instance_of Fixnum,
          Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
diff --git a/activerecord/test/cases/quoting_test.rb b/activerecord/test/cases/quoting_test.rb
index 2ef5b5a800..b87fb51d97 100644
--- a/activerecord/test/cases/quoting_test.rb
+++ b/activerecord/test/cases/quoting_test.rb
@@ -154,13 +154,13 @@ module ActiveRecord
       end
 
       def test_crazy_object
-        crazy = Class.new { def to_s; 'lol' end }.new
+        crazy = Class.new { def to_yaml; 'lol' end }.new
         assert_equal "'lol'", @quoter.quote(crazy, nil)
         assert_equal "'lol'", @quoter.quote(crazy, Object.new)
       end
 
       def test_crazy_object_calls_quote_string
-        crazy = Class.new { def to_s; 'lo\l' end }.new
+        crazy = Class.new { def to_yaml; 'lo\l' end }.new
         assert_equal "'lo\\\\l'", @quoter.quote(crazy, nil)
         assert_equal "'lo\\\\l'", @quoter.quote(crazy, Object.new)
       end
diff --git a/activerecord/test/cases/readonly_test.rb b/activerecord/test/cases/readonly_test.rb
index 98011f40a4..e21109baae 100644
--- a/activerecord/test/cases/readonly_test.rb
+++ b/activerecord/test/cases/readonly_test.rb
@@ -6,13 +6,8 @@ require 'models/project'
 require 'models/reader'
 require 'models/person'
 
-# Dummy class methods to test implicit association scoping.
-def Comment.foo() find :first end
-def Project.foo() find :first end
-
-
 class ReadOnlyTest < ActiveRecord::TestCase
-  fixtures :posts, :comments, :developers, :projects, :developers_projects
+  fixtures :posts, :comments, :developers, :projects, :developers_projects, :people, :readers
 
   def test_cant_save_readonly_record
     dev = Developer.find(1)
@@ -49,15 +44,6 @@ class ReadOnlyTest < ActiveRecord::TestCase
     Developer.joins(', projects').readonly(false).each { |d| assert !d.readonly? }
   end
 
-
-  def test_habtm_find_readonly
-    dev = Developer.find(1)
-    assert !dev.projects.empty?
-    assert dev.projects.all?(&:readonly?)
-    assert dev.projects.find(:all).all?(&:readonly?)
-    assert dev.projects.readonly(true).all?(&:readonly?)
-  end
-
   def test_has_many_find_readonly
     post = Post.find(1)
     assert !post.comments.empty?
@@ -71,6 +57,18 @@ class ReadOnlyTest < ActiveRecord::TestCase
     assert !people.any?(&:readonly?)
   end
 
+  def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_by_id
+    assert !posts(:welcome).people.find(1).readonly?
+  end
+
+  def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_first
+    assert !posts(:welcome).people.first.readonly?
+  end
+
+  def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_last
+    assert !posts(:welcome).people.last.readonly?
+  end
+
   def test_readonly_scoping
     Post.send(:with_scope, :find => { :conditions => '1=1' }) do
       assert !Post.find(1).readonly?
@@ -102,7 +100,13 @@ class ReadOnlyTest < ActiveRecord::TestCase
   end
 
   def test_association_collection_method_missing_scoping_not_readonly
-    assert !Developer.find(1).projects.foo.readonly?
-    assert !Post.find(1).comments.foo.readonly?
+    developer = Developer.find(1)
+    project   = Post.find(1)
+
+    assert !developer.projects.all_as_method.first.readonly?
+    assert !developer.projects.all_as_scope.first.readonly?
+
+    assert !project.comments.all_as_method.first.readonly?
+    assert !project.comments.all_as_scope.first.readonly?
   end
 end
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index c461bb401f..9529ae56b8 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -17,6 +17,7 @@ require 'models/book'
 require 'models/subscriber'
 require 'models/subscription'
 require 'models/tag'
+require 'models/sponsor'
 
 class ReflectionTest < ActiveRecord::TestCase
   include ActiveRecord::Reflection
@@ -136,11 +137,11 @@ class ReflectionTest < ActiveRecord::TestCase
 
   def test_belongs_to_inferred_foreign_key_from_assoc_name
     Company.belongs_to :foo
-    assert_equal "foo_id", Company.reflect_on_association(:foo).primary_key_name
+    assert_equal "foo_id", Company.reflect_on_association(:foo).foreign_key
     Company.belongs_to :bar, :class_name => "Xyzzy"
-    assert_equal "bar_id", Company.reflect_on_association(:bar).primary_key_name
+    assert_equal "bar_id", Company.reflect_on_association(:bar).foreign_key
     Company.belongs_to :baz, :class_name => "Xyzzy", :foreign_key => "xyzzy_id"
-    assert_equal "xyzzy_id", Company.reflect_on_association(:baz).primary_key_name
+    assert_equal "xyzzy_id", Company.reflect_on_association(:baz).foreign_key
   end
 
   def test_association_reflection_in_modules
@@ -187,8 +188,8 @@ class ReflectionTest < ActiveRecord::TestCase
 
   def test_reflection_of_all_associations
     # FIXME these assertions bust a lot
-    assert_equal 37, Firm.reflect_on_all_associations.size
-    assert_equal 27, Firm.reflect_on_all_associations(:has_many).size
+    assert_equal 36, Firm.reflect_on_all_associations.size
+    assert_equal 26, Firm.reflect_on_all_associations(:has_many).size
     assert_equal 10, Firm.reflect_on_all_associations(:has_one).size
     assert_equal 0, Firm.reflect_on_all_associations(:belongs_to).size
   end
@@ -243,6 +244,7 @@ class ReflectionTest < ActiveRecord::TestCase
     # Normal association
     assert_equal "id",   Author.reflect_on_association(:posts).association_primary_key.to_s
     assert_equal "name", Author.reflect_on_association(:essay).association_primary_key.to_s
+    assert_equal "id",   Tagging.reflect_on_association(:taggable).association_primary_key.to_s
 
     # Through association (uses the :primary_key option from the source reflection)
     assert_equal "nick", Author.reflect_on_association(:subscribers).association_primary_key.to_s
@@ -255,6 +257,11 @@ class ReflectionTest < ActiveRecord::TestCase
     assert_equal "name", Author.reflect_on_association(:essay).active_record_primary_key.to_s
   end
 
+  def test_foreign_type
+    assert_equal "sponsorable_type", Sponsor.reflect_on_association(:sponsorable).foreign_type.to_s
+    assert_equal "sponsorable_type", Sponsor.reflect_on_association(:thing).foreign_type.to_s
+  end
+
   def test_collection_association
     assert Pirate.reflect_on_association(:birds).collection?
     assert Pirate.reflect_on_association(:parrots).collection?
@@ -292,6 +299,18 @@ class ReflectionTest < ActiveRecord::TestCase
     assert !AssociationReflection.new(:has_and_belongs_to_many, :clients, { :autosave => true, :validate => false }, Firm).validate?
   end
 
+  def test_foreign_key
+    assert_equal "author_id", Author.reflect_on_association(:posts).foreign_key.to_s
+    assert_equal "category_id", Post.reflect_on_association(:categorizations).foreign_key.to_s
+  end
+
+  def test_primary_key_name
+    assert_deprecated do
+      assert_equal "author_id", Author.reflect_on_association(:posts).primary_key_name.to_s
+      assert_equal "category_id", Post.reflect_on_association(:categorizations).primary_key_name.to_s
+    end
+  end
+
   private
     def assert_reflection(klass, association, options)
       assert reflection = klass.reflect_on_association(association)
diff --git a/activerecord/test/cases/relation_scoping_test.rb b/activerecord/test/cases/relation_scoping_test.rb
index 1f43515558..7369aaea1d 100644
--- a/activerecord/test/cases/relation_scoping_test.rb
+++ b/activerecord/test/cases/relation_scoping_test.rb
@@ -152,7 +152,7 @@ class NestedRelationScopingTest < ActiveRecord::TestCase
     Developer.where('salary = 80000').scoping do
       Developer.limit(10).scoping do
         devs = Developer.scoped
-        assert_equal '(salary = 80000)', devs.arel.send(:where_clauses).join(' AND ')
+        assert_match '(salary = 80000)', devs.arel.to_sql
         assert_equal 10, devs.taken
       end
     end
@@ -259,7 +259,8 @@ class HasManyScopingTest< ActiveRecord::TestCase
   end
 
   def test_should_default_scope_on_associations_is_overriden_by_association_conditions
-    assert_equal [], people(:michael).fixed_bad_references
+    reference = references(:michael_unicyclist).becomes(BadReference)
+    assert_equal [reference], people(:michael).fixed_bad_references
   end
 
   def test_should_maintain_default_scope_on_eager_loaded_associations
@@ -422,7 +423,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal expected, received
   end
 
-  def test_named_scope_overwrites_default
+  def test_scope_overwrites_default
     expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.name }
     received = DeveloperOrderedBySalary.by_name.find(:all).collect { |dev| dev.name }
     assert_equal expected, received
@@ -485,4 +486,21 @@ class DefaultScopingTest < ActiveRecord::TestCase
     posts_offset_limit = Post.offset(2).limit(3)
     assert_equal posts_limit_offset, posts_offset_limit
   end
+
+  def test_create_with_merge
+    aaron = PoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).merge(
+              PoorDeveloperCalledJamis.create_with(:name => 'Aaron')).new
+    assert_equal 20, aaron.salary
+    assert_equal 'Aaron', aaron.name
+
+    aaron = PoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).
+                                     create_with(:name => 'Aaron').new
+    assert_equal 20, aaron.salary
+    assert_equal 'Aaron', aaron.name
+  end
+
+  def test_create_with_reset
+    jamis = PoorDeveloperCalledJamis.create_with(:name => 'Aaron').create_with(nil).new
+    assert_equal 'Jamis', jamis.name
+  end
 end
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 688fc70484..54537f11a8 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -27,6 +27,12 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal van.id, Minivan.where(:minivan_id => van).to_a.first.minivan_id
   end
 
+  def test_do_not_double_quote_string_id_with_array
+    van = Minivan.last
+    assert van
+    assert_equal van, Minivan.where(:minivan_id => [van]).to_a.first
+  end
+
   def test_bind_values
     relation = Post.scoped
     assert_equal [], relation.bind_values
@@ -36,7 +42,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal [], relation.bind_values
   end
 
-  def test_two_named_scopes_with_includes_should_not_drop_any_include
+  def test_two_scopes_with_includes_should_not_drop_any_include
     car = Car.incl_engines.incl_tyres.first
     assert_no_queries { car.tyres.length }
     assert_no_queries { car.engines.length }
@@ -184,6 +190,10 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal [2, 4, 6, 8, 10], even_ids.sort
   end
 
+  def test_joins_with_nil_argument
+    assert_nothing_raised { DependentFirm.joins(nil).first }
+  end
+
   def test_finding_with_hash_conditions_on_joined_table
     firms = DependentFirm.joins(:account).where({:name => 'RailsCore', :accounts => { :credit_limit => 55..60 }}).to_a
     assert_equal 1, firms.size
@@ -248,7 +258,7 @@ class RelationTest < ActiveRecord::TestCase
     end
   end
 
-  def test_respond_to_class_methods_and_named_scopes
+  def test_respond_to_class_methods_and_scopes
     assert DeveloperOrderedBySalary.scoped.respond_to?(:all_ordered_by_name)
     assert Topic.scoped.respond_to?(:by_lifo)
   end
@@ -275,8 +285,8 @@ class RelationTest < ActiveRecord::TestCase
       assert posts.first.comments.first
     end
 
-    assert_queries(2) do
-      posts = Post.preload(:comments).order('posts.id').to_a
+    assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) do
+      posts = Post.preload(:comments).to_a
       assert posts.first.comments.first
     end
 
@@ -285,13 +295,13 @@ class RelationTest < ActiveRecord::TestCase
       assert posts.first.author
     end
 
-    assert_queries(2) do
-      posts = Post.preload(:author).order('posts.id').to_a
+    assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) do
+      posts = Post.preload(:author).to_a
       assert posts.first.author
     end
 
-    assert_queries(3) do
-      posts = Post.preload(:author, :comments).order('posts.id').to_a
+    assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 3) do
+      posts = Post.preload(:author, :comments).to_a
       assert posts.first.author
       assert posts.first.comments.first
     end
@@ -303,8 +313,8 @@ class RelationTest < ActiveRecord::TestCase
       assert posts.first.comments.first
     end
 
-    assert_queries(2) do
-      posts = Post.scoped.includes(:comments).order('posts.id')
+    assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) do
+      posts = Post.scoped.includes(:comments)
       assert posts.first.comments.first
     end
 
@@ -313,8 +323,8 @@ class RelationTest < ActiveRecord::TestCase
       assert posts.first.author
     end
 
-    assert_queries(3) do
-      posts = Post.includes(:author, :comments).order('posts.id').to_a
+    assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 3) do
+      posts = Post.includes(:author, :comments).to_a
       assert posts.first.author
       assert posts.first.comments.first
     end
@@ -464,10 +474,17 @@ class RelationTest < ActiveRecord::TestCase
     relation = relation.where(:name => david.name)
     relation = relation.where(:name => 'Santiago')
     relation = relation.where(:id => david.id)
-    assert_equal [david], relation.all
+    assert_equal [], relation.all
+  end
+
+  def test_multi_where_ands_queries
+    relation = Author.unscoped
+    david = authors(:david)
+    sql = relation.where(:name => david.name).where(:name => 'Santiago').to_sql
+    assert_match('AND', sql)
   end
 
-  def test_find_all_with_multiple_ors
+  def test_find_all_with_multiple_should_use_and
     david = authors(:david)
     relation = [
       { :name => david.name },
@@ -476,7 +493,34 @@ class RelationTest < ActiveRecord::TestCase
     ].inject(Author.unscoped) do |memo, param|
       memo.where(param)
     end
-    assert_equal [david], relation.all
+    assert_equal [], relation.all
+  end
+
+  def test_find_all_using_where_with_relation
+    david = authors(:david)
+    # switching the lines below would succeed in current rails
+    # assert_queries(2) {
+    assert_queries(1) {
+      relation = Author.where(:id => Author.where(:id => david.id))
+      assert_equal [david], relation.all
+    }
+  end
+
+  def test_find_all_using_where_with_relation_with_joins
+    david = authors(:david)
+    assert_queries(1) {
+      relation = Author.where(:id => Author.joins(:posts).where(:id => david.id))
+      assert_equal [david], relation.all
+    }
+  end
+
+
+  def test_find_all_using_where_with_relation_with_select_to_build_subquery
+    david = authors(:david)
+    assert_queries(1) {
+      relation = Author.where(:name => Author.where(:id => david.id).select(:name))
+      assert_equal [david], relation.all
+    }
   end
 
   def test_exists
@@ -535,17 +579,17 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_relation_merging
-    devs = Developer.where("salary >= 80000") & Developer.limit(2) & Developer.order('id ASC').where("id < 3")
+    devs = Developer.where("salary >= 80000").merge(Developer.limit(2)).merge(Developer.order('id ASC').where("id < 3"))
     assert_equal [developers(:david), developers(:jamis)], devs.to_a
 
-    dev_with_count = Developer.limit(1) & Developer.order('id DESC') & Developer.select('developers.*')
+    dev_with_count = Developer.limit(1).merge(Developer.order('id DESC')).merge(Developer.select('developers.*'))
     assert_equal [developers(:poor_jamis)], dev_with_count.to_a
   end
 
   def test_relation_merging_with_eager_load
     relations = []
-    relations << (Post.order('comments.id DESC') & Post.eager_load(:last_comment) & Post.scoped)
-    relations << (Post.eager_load(:last_comment) & Post.order('comments.id DESC') & Post.scoped)
+    relations << Post.order('comments.id DESC').merge(Post.eager_load(:last_comment)).merge(Post.scoped)
+    relations << Post.eager_load(:last_comment).merge(Post.order('comments.id DESC')).merge(Post.scoped)
 
     relations.each do |posts|
       post = posts.find { |p| p.id == 1 }
@@ -554,18 +598,20 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_relation_merging_with_locks
-    devs = Developer.lock.where("salary >= 80000").order("id DESC") & Developer.limit(2)
+    devs = Developer.lock.where("salary >= 80000").order("id DESC").merge(Developer.limit(2))
     assert_present devs.locked
   end
 
   def test_relation_merging_with_preload
-    [Post.scoped & Post.preload(:author), Post.preload(:author) & Post.scoped].each do |posts|
-      assert_queries(2) { assert posts.first.author }
+    ActiveRecord::IdentityMap.without do
+      [Post.scoped.merge(Post.preload(:author)), Post.preload(:author).merge(Post.scoped)].each do |posts|
+        assert_queries(2) { assert posts.first.author }
+      end
     end
   end
 
   def test_relation_merging_with_joins
-    comments = Comment.joins(:post).where(:body => 'Thank you for the welcome') & Post.where(:body => 'Such a lovely day')
+    comments = Comment.joins(:post).where(:body => 'Thank you for the welcome').merge(Post.where(:body => 'Such a lovely day'))
     assert_equal 1, comments.count
   end
 
@@ -630,6 +676,14 @@ class RelationTest < ActiveRecord::TestCase
   def test_any
     posts = Post.scoped
 
+    # This test was failing when run on its own (as opposed to running the entire suite).
+    # The second line in the assert_queries block was causing visit_Arel_Attributes_Attribute
+    # in Arel::Visitors::ToSql to trigger a SHOW TABLES query. Running that line here causes
+    # the SHOW TABLES result to be cached so we don't have to do it again in the block.
+    #
+    # This is obviously a rubbish fix but it's the best I can come up with for now...
+    posts.where(:id => nil).any?
+
     assert_queries(3) do
       assert posts.any? # Uses COUNT()
       assert ! posts.where(:id => nil).any?
@@ -754,7 +808,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal 'zyke', FastCar.order('name desc').find(:first, :order => 'id').name
   end
 
-  def test_default_scope_order_with_named_scope_order
+  def test_default_scope_order_with_scope_order
     assert_equal 'zyke', CoolCar.order_using_new_style.limit(1).first.name
     assert_equal 'zyke', CoolCar.order_using_old_style.limit(1).first.name
     assert_equal 'zyke', FastCar.order_using_new_style.limit(1).first.name
@@ -788,4 +842,12 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal [rails_author], [rails_author] & relation
     assert_equal [rails_author], relation & [rails_author]
   end
+
+  def test_removing_limit_with_options
+    assert_not_equal 1, Post.limit(1).all(:limit => nil).count
+  end
+
+  def test_primary_key
+    assert_equal "id", Post.scoped.primary_key
+  end
 end
diff --git a/activerecord/test/cases/serialization_test.rb b/activerecord/test/cases/serialization_test.rb
index 25dbcc9fc2..677d659f39 100644
--- a/activerecord/test/cases/serialization_test.rb
+++ b/activerecord/test/cases/serialization_test.rb
@@ -23,6 +23,12 @@ class SerializationTest < ActiveRecord::TestCase
     @contact = Contact.new(@contact_attributes)
   end
 
+  def test_serialized_init_with
+    topic = Topic.allocate
+    topic.init_with('attributes' => { 'content' => '--- foo' })
+    assert_equal 'foo', topic.content
+  end
+
   def test_to_xml
     xml = REXML::Document.new(topics(:first).to_xml(:indent => 0))
     bonus_time_in_current_timezone = topics(:first).bonus_time.xmlschema
diff --git a/activerecord/test/cases/session_store/session_test.rb b/activerecord/test/cases/session_store/session_test.rb
index 6f1c170a0c..cee5ddd003 100644
--- a/activerecord/test/cases/session_store/session_test.rb
+++ b/activerecord/test/cases/session_store/session_test.rb
@@ -5,7 +5,7 @@ require 'active_record/session_store'
 module ActiveRecord
   class SessionStore
     class SessionTest < ActiveRecord::TestCase
-      self.use_transactional_fixtures = false
+      self.use_transactional_fixtures = false unless supports_savepoints? && ActiveRecord::Base.connection.supports_ddl_transactions?
 
       def setup
         super
@@ -60,6 +60,7 @@ module ActiveRecord
       end
 
       def test_loaded?
+        Session.create_table!
         s = Session.new
         assert !s.loaded?, 'session is not loaded'
       end
diff --git a/activerecord/test/cases/timestamp_test.rb b/activerecord/test/cases/timestamp_test.rb
index 70c098bc6d..1c21f0f3b6 100644
--- a/activerecord/test/cases/timestamp_test.rb
+++ b/activerecord/test/cases/timestamp_test.rb
@@ -140,4 +140,34 @@ class TimestampTest < ActiveRecord::TestCase
   ensure
     Toy.belongs_to :pet
   end
+
+  def test_timestamp_attributes_for_create
+    toy = Toy.first
+    assert_equal toy.send(:timestamp_attributes_for_create), [:created_at, :created_on]
+  end
+
+  def test_timestamp_attributes_for_update
+    toy = Toy.first
+    assert_equal toy.send(:timestamp_attributes_for_update), [:updated_at, :updated_on]
+  end
+
+  def test_all_timestamp_attributes
+    toy = Toy.first
+    assert_equal toy.send(:all_timestamp_attributes), [:created_at, :created_on, :updated_at, :updated_on]
+  end
+
+  def test_timestamp_attributes_for_create_in_model
+    toy = Toy.first
+    assert_equal toy.send(:timestamp_attributes_for_create_in_model), [:created_at]
+  end
+
+  def test_timestamp_attributes_for_update_in_model
+    toy = Toy.first
+    assert_equal toy.send(:timestamp_attributes_for_update_in_model), [:updated_at]
+  end
+
+  def test_all_timestamp_attributes_in_model
+    toy = Toy.first
+    assert_equal toy.send(:all_timestamp_attributes_in_model), [:created_at, :updated_at]
+  end
 end
diff --git a/activerecord/test/cases/transactions_test.rb b/activerecord/test/cases/transactions_test.rb
index b0ccd71836..110a18772f 100644
--- a/activerecord/test/cases/transactions_test.rb
+++ b/activerecord/test/cases/transactions_test.rb
@@ -370,23 +370,23 @@ class TransactionTest < ActiveRecord::TestCase
       assert topic_2.save
       @first.save
       @second.destroy
-      assert_equal true, topic_1.persisted?
+      assert topic_1.persisted?, 'persisted'
       assert_not_nil topic_1.id
-      assert_equal true, topic_2.persisted?
+      assert topic_2.persisted?, 'persisted'
       assert_not_nil topic_2.id
-      assert_equal true, @first.persisted?
+      assert @first.persisted?, 'persisted'
       assert_not_nil @first.id
-      assert_equal true, @second.destroyed?
+      assert @second.destroyed?, 'destroyed'
       raise ActiveRecord::Rollback
     end
 
-    assert_equal false, topic_1.persisted?
+    assert !topic_1.persisted?, 'not persisted'
     assert_nil topic_1.id
-    assert_equal false, topic_2.persisted?
+    assert !topic_2.persisted?, 'not persisted'
     assert_nil topic_2.id
-    assert_equal true, @first.persisted?
+    assert @first.persisted?, 'persisted'
     assert_not_nil @first.id
-    assert_equal false, @second.destroyed?
+    assert !@second.destroyed?, 'not destroyed'
   end
 
   if current_adapter?(:PostgreSQLAdapter) && defined?(PGconn::PQTRANS_IDLE)
diff --git a/activerecord/test/cases/unconnected_test.rb b/activerecord/test/cases/unconnected_test.rb
index 23ad10f3f9..f85fb4e5da 100644
--- a/activerecord/test/cases/unconnected_test.rb
+++ b/activerecord/test/cases/unconnected_test.rb
@@ -4,7 +4,7 @@ class TestRecord < ActiveRecord::Base
 end
 
 class TestUnconnectedAdapter < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @underlying = ActiveRecord::Base.connection
@@ -14,6 +14,7 @@ class TestUnconnectedAdapter < ActiveRecord::TestCase
   def teardown
     @underlying = nil
     ActiveRecord::Base.establish_connection(@specification)
+    load_schema if in_memory_db?
   end
 
   def test_connection_no_longer_established
diff --git a/activerecord/test/cases/validations/uniqueness_validation_test.rb b/activerecord/test/cases/validations/uniqueness_validation_test.rb
index 679d67553b..b4f3dd034c 100644
--- a/activerecord/test/cases/validations/uniqueness_validation_test.rb
+++ b/activerecord/test/cases/validations/uniqueness_validation_test.rb
@@ -6,19 +6,6 @@ require 'models/warehouse_thing'
 require 'models/guid'
 require 'models/event'
 
-# The following methods in Topic are used in test_conditional_validation_*
-class Topic
-  has_many :unique_replies, :dependent => :destroy, :foreign_key => "parent_id"
-  has_many :silly_unique_replies, :dependent => :destroy, :foreign_key => "parent_id"
-end
-
-class UniqueReply < Reply
-  validates_uniqueness_of :content, :scope => 'parent_id'
-end
-
-class SillyUniqueReply < UniqueReply
-end
-
 class Wizard < ActiveRecord::Base
   self.abstract_class = true
 
diff --git a/activerecord/test/cases/xml_serialization_test.rb b/activerecord/test/cases/xml_serialization_test.rb
index 2003e25e35..a6074b23e7 100644
--- a/activerecord/test/cases/xml_serialization_test.rb
+++ b/activerecord/test/cases/xml_serialization_test.rb
@@ -262,4 +262,10 @@ class DatabaseConnectedXmlSerializationTest < ActiveRecord::TestCase
     assert array.include? 'github'
   end
 
+  def test_should_support_aliased_attributes
+    xml = Author.select("name as firstname").to_xml
+    array = Hash.from_xml(xml)['authors']
+    assert_equal array.size, array.select { |author| author.has_key? 'firstname' }.size
+  end
+
 end
diff --git a/activerecord/test/cases/yaml_serialization_test.rb b/activerecord/test/cases/yaml_serialization_test.rb
index 0fc9918744..0b54c309d1 100644
--- a/activerecord/test/cases/yaml_serialization_test.rb
+++ b/activerecord/test/cases/yaml_serialization_test.rb
@@ -17,4 +17,30 @@ class YamlSerializationTest < ActiveRecord::TestCase
     t = YAML.load YAML.dump topic
     assert_equal topic, t
   end
+
+  def test_encode_with_coder
+    topic = Topic.first
+    coder = {}
+    topic.encode_with coder
+    assert_equal({'attributes' => topic.attributes}, coder)
+  end
+
+  begin
+    require 'psych'
+
+    def test_psych_roundtrip
+      topic = Topic.first
+      assert topic
+      t = Psych.load Psych.dump topic
+      assert_equal topic, t
+    end
+
+    def test_psych_roundtrip_new_object
+      topic = Topic.new
+      assert topic
+      t = Psych.load Psych.dump topic
+      assert_equal topic.attributes, t.attributes
+    end
+  rescue LoadError
+  end
 end
diff --git a/activerecord/test/connections/native_sqlite3/connection.rb b/activerecord/test/connections/native_sqlite3/connection.rb
index c517c2375e..c2aff5551f 100644
--- a/activerecord/test/connections/native_sqlite3/connection.rb
+++ b/activerecord/test/connections/native_sqlite3/connection.rb
@@ -3,21 +3,12 @@ require_dependency 'models/course'
 require 'logger'
 ActiveRecord::Base.logger = Logger.new("debug.log")
 
-class SqliteError < StandardError
-end
-
 BASE_DIR = FIXTURES_ROOT
 sqlite_test_db  = "#{BASE_DIR}/fixture_database.sqlite3"
 sqlite_test_db2 = "#{BASE_DIR}/fixture_database_2.sqlite3"
 
 def make_connection(clazz, db_file)
   ActiveRecord::Base.configurations = { clazz.name => { :adapter => 'sqlite3', :database => db_file, :timeout => 5000 } }
-  unless File.exist?(db_file)
-    puts "SQLite3 database not found at #{db_file}. Rebuilding it."
-    sqlite_command = %Q{sqlite3 "#{db_file}" "create table a (a integer); drop table a;"}
-    puts "Executing '#{sqlite_command}'"
-    raise SqliteError.new("Seems that there is no sqlite3 executable available") unless system(sqlite_command)
-  end
   clazz.establish_connection(clazz.name)
 end
 
diff --git a/activerecord/test/connections/native_sqlite3/in_memory_connection.rb b/activerecord/test/connections/native_sqlite3/in_memory_connection.rb
deleted file mode 100644
index 6aba9719bb..0000000000
--- a/activerecord/test/connections/native_sqlite3/in_memory_connection.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-print "Using native SQLite3\n"
-require_dependency 'models/course'
-require 'logger'
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-class SqliteError < StandardError
-end
-
-def make_connection(clazz, db_definitions_file)
-  clazz.establish_connection(:adapter => 'sqlite3', :database  => ':memory:')
-  File.read(SCHEMA_ROOT + "/#{db_definitions_file}").split(';').each do |command|
-    clazz.connection.execute(command) unless command.strip.empty?
-  end
-end
-
-make_connection(ActiveRecord::Base, 'sqlite.sql')
-make_connection(Course, 'sqlite2.sql')
-load(SCHEMA_ROOT + "/schema.rb")
diff --git a/activerecord/test/connections/native_sqlite3_mem/connection.rb b/activerecord/test/connections/native_sqlite3_mem/connection.rb
new file mode 100644
index 0000000000..14e10900d1
--- /dev/null
+++ b/activerecord/test/connections/native_sqlite3_mem/connection.rb
@@ -0,0 +1,19 @@
+# This file connects to an in-memory SQLite3 database, which is a very fast way to run the tests.
+# The downside is that disconnect from the database results in the database effectively being
+# wiped. For this reason, pooled_connections_test.rb is disabled when using an in-memory database.
+
+print "Using native SQLite3 (in memory)\n"
+require_dependency 'models/course'
+require 'logger'
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+class SqliteError < StandardError
+end
+
+def make_connection(clazz)
+  ActiveRecord::Base.configurations = { clazz.name => { :adapter => 'sqlite3', :database  => ':memory:' } }
+  clazz.establish_connection(clazz.name)
+end
+
+make_connection(ActiveRecord::Base)
+make_connection(Course)
diff --git a/activerecord/test/fixtures/companies.yml b/activerecord/test/fixtures/companies.yml
index ffaa097686..a982d3921d 100644
--- a/activerecord/test/fixtures/companies.yml
+++ b/activerecord/test/fixtures/companies.yml
@@ -12,6 +12,7 @@ first_firm:
   type: Firm
   name: 37signals
   ruby_type: Firm
+  firm_id: 1
 
 second_client:
   id: 3
diff --git a/activerecord/test/fixtures/dashboards.yml b/activerecord/test/fixtures/dashboards.yml
index e75bf46e6c..a4c7e0d309 100644
--- a/activerecord/test/fixtures/dashboards.yml
+++ b/activerecord/test/fixtures/dashboards.yml
@@ -1,3 +1,6 @@
 cool_first:
   dashboard_id: d1
-  name: my_dashboard
\ No newline at end of file
+  name: my_dashboard
+second:
+  dashboard_id: d2
+  name: second
diff --git a/activerecord/test/fixtures/posts.yml b/activerecord/test/fixtures/posts.yml
index 264ca164f0..7298096025 100644
--- a/activerecord/test/fixtures/posts.yml
+++ b/activerecord/test/fixtures/posts.yml
@@ -5,6 +5,7 @@ welcome:
   body: Such a lovely day
   comments_count: 2
   taggings_count: 1
+  tags_count: 1
   type: Post
 
 thinking:
@@ -14,6 +15,7 @@ thinking:
   body: Like I hopefully always am
   comments_count: 1
   taggings_count: 1
+  tags_count: 1
   type: SpecialPost
 
 authorless:
diff --git a/activerecord/test/fixtures/ships.yml b/activerecord/test/fixtures/ships.yml
index 137055aad1..df914262b3 100644
--- a/activerecord/test/fixtures/ships.yml
+++ b/activerecord/test/fixtures/ships.yml
@@ -1,5 +1,6 @@
 black_pearl:
   name: "Black Pearl"
+  pirate: blackbeard
 interceptor:
   id: 2
   name: "Interceptor"
diff --git a/activerecord/test/fixtures/speedometers.yml b/activerecord/test/fixtures/speedometers.yml
index 6a471aba0a..e12398f0c4 100644
--- a/activerecord/test/fixtures/speedometers.yml
+++ b/activerecord/test/fixtures/speedometers.yml
@@ -1,4 +1,8 @@
 cool_first:
   speedometer_id: s1
   name: my_speedometer
-  dashboard_id: d1
\ No newline at end of file
+  dashboard_id: d1
+second:
+  speedometer_id: s2
+  name: second
+  dashboard_id: d2
diff --git a/activerecord/test/fixtures/subscribers.yml b/activerecord/test/fixtures/subscribers.yml
index 9ffb4a156f..c6a8c2fa24 100644
--- a/activerecord/test/fixtures/subscribers.yml
+++ b/activerecord/test/fixtures/subscribers.yml
@@ -5,3 +5,7 @@ first:
 second:
   nick: webster132
   name: David Heinemeier Hansson
+
+thrid:
+  nick: swistak
+  name: Marcin Raczkowski
\ No newline at end of file
diff --git a/activerecord/test/fixtures/traffic_lights.yml b/activerecord/test/fixtures/traffic_lights.yml
new file mode 100644
index 0000000000..6dabd53474
--- /dev/null
+++ b/activerecord/test/fixtures/traffic_lights.yml
@@ -0,0 +1,6 @@
+uk:
+  location: UK
+  state:
+    - Green
+    - Red
+    - Orange
diff --git a/activerecord/test/models/author.rb b/activerecord/test/models/author.rb
index 43bfd93e60..f362f70dec 100644
--- a/activerecord/test/models/author.rb
+++ b/activerecord/test/models/author.rb
@@ -26,6 +26,12 @@ class Author < ActiveRecord::Base
   has_many :comments_with_order_and_conditions, :through => :posts, :source => :comments, :order => 'comments.body', :conditions => "comments.body like 'Thank%'"
   has_many :comments_with_include, :through => :posts, :source => :comments, :include => :post
 
+  has_many :first_posts
+  has_many :comments_on_first_posts, :through => :first_posts, :source => :comments, :order => 'posts.id desc, comments.id asc'
+
+  has_one :first_post
+  has_one :comment_on_first_post,  :through => :first_post, :source => :comments, :order => 'posts.id desc, comments.id asc'
+
   has_many :thinking_posts, :class_name => 'Post', :conditions => { :title => 'So I was thinking' }, :dependent => :delete_all
   has_many :welcome_posts,  :class_name => 'Post', :conditions => { :title => 'Welcome to the weblog' }
 
@@ -72,6 +78,11 @@ class Author < ActiveRecord::Base
 
   has_many :categorizations
   has_many :categories, :through => :categorizations
+  has_many :named_categories, :through => :categorizations
+
+  has_many :special_categorizations
+  has_many :special_categories, :through => :special_categorizations, :source => :category
+  has_one  :special_category,   :through => :special_categorizations, :source => :category
 
   has_many :categories_like_general, :through => :categorizations, :source => :category, :class_name => 'Category', :conditions => { :name => 'General' }
 
diff --git a/activerecord/test/models/bulb.rb b/activerecord/test/models/bulb.rb
index 9eefc5803a..7178bb0d00 100644
--- a/activerecord/test/models/bulb.rb
+++ b/activerecord/test/models/bulb.rb
@@ -1,7 +1,14 @@
 class Bulb < ActiveRecord::Base
-  
+
   default_scope :conditions => {:name => 'defaulty' }
-  
+
   belongs_to :car
 
+  attr_reader :scoped_methods_after_initialize
+
+  after_initialize :record_scoped_methods_after_initialize
+  def record_scoped_methods_after_initialize
+    @scoped_methods_after_initialize = self.class.scoped_methods.dup
+  end
+
 end
diff --git a/activerecord/test/models/categorization.rb b/activerecord/test/models/categorization.rb
index 8e2fa96498..09489b8ea4 100644
--- a/activerecord/test/models/categorization.rb
+++ b/activerecord/test/models/categorization.rb
@@ -1,7 +1,20 @@
 class Categorization < ActiveRecord::Base
   belongs_to :post
   belongs_to :category
+  belongs_to :named_category, :class_name => 'Category', :foreign_key => :named_category_name, :primary_key => :name
   belongs_to :author
 
   has_many :post_taggings, :through => :author, :source => :taggings
+
+  belongs_to :author_using_custom_pk,  :class_name => 'Author', :foreign_key => :author_id, :primary_key => :author_address_extra_id
+  has_many   :authors_using_custom_pk, :class_name => 'Author', :foreign_key => :id,        :primary_key => :category_id
+end
+
+class SpecialCategorization < ActiveRecord::Base
+  self.table_name = 'categorizations'
+
+  default_scope where(:special => true)
+
+  belongs_to :author
+  belongs_to :category
 end
diff --git a/activerecord/test/models/category.rb b/activerecord/test/models/category.rb
index 95825c72ef..02b85fd38a 100644
--- a/activerecord/test/models/category.rb
+++ b/activerecord/test/models/category.rb
@@ -22,9 +22,12 @@ class Category < ActiveRecord::Base
   end
 
   has_many :categorizations
-  has_many :authors, :through => :categorizations, :select => 'authors.*, categorizations.post_id'
-
   has_many :post_comments, :through => :posts, :source => :comments
+
+  has_many :authors, :through => :categorizations
+  has_many :authors_with_select, :through => :categorizations, :source => :author, :select => 'authors.*, categorizations.post_id'
+
+  scope :general, :conditions => { :name => 'General' }
 end
 
 class SpecialCategory < Category
diff --git a/activerecord/test/models/club.rb b/activerecord/test/models/club.rb
index 83d6b1b15a..24a65b0f2f 100644
--- a/activerecord/test/models/club.rb
+++ b/activerecord/test/models/club.rb
@@ -1,4 +1,5 @@
 class Club < ActiveRecord::Base
+  has_one :membership
   has_many :memberships
   has_many :members, :through => :memberships
   has_many :current_memberships
diff --git a/activerecord/test/models/comment.rb b/activerecord/test/models/comment.rb
index 1a3fb42b66..2a4c37089a 100644
--- a/activerecord/test/models/comment.rb
+++ b/activerecord/test/models/comment.rb
@@ -1,6 +1,7 @@
 class Comment < ActiveRecord::Base
   scope :limit_by, lambda {|l| limit(l) }
   scope :containing_the_letter_e, :conditions => "comments.body LIKE '%e%'"
+  scope :not_again, where("comments.body NOT LIKE '%again%'")
   scope :for_first_post, :conditions => { :post_id => 1 }
   scope :for_first_author,
               :joins => :post,
@@ -16,6 +17,11 @@ class Comment < ActiveRecord::Base
   def self.search_by_type(q)
     self.find(:all, :conditions => ["#{QUOTED_TYPE} = ?", q])
   end
+
+  def self.all_as_method
+    all
+  end
+  scope :all_as_scope, {}
 end
 
 class SpecialComment < Comment
diff --git a/activerecord/test/models/company.rb b/activerecord/test/models/company.rb
index ee5f77b613..e0b30efd51 100644
--- a/activerecord/test/models/company.rb
+++ b/activerecord/test/models/company.rb
@@ -38,7 +38,9 @@ end
 class Firm < Company
   has_many :clients, :order => "id", :dependent => :destroy, :counter_sql =>
       "SELECT COUNT(*) FROM companies WHERE firm_id = 1 " +
-      "AND (#{QUOTED_TYPE} = 'Client' OR #{QUOTED_TYPE} = 'SpecialClient' OR #{QUOTED_TYPE} = 'VerySpecialClient' )"
+      "AND (#{QUOTED_TYPE} = 'Client' OR #{QUOTED_TYPE} = 'SpecialClient' OR #{QUOTED_TYPE} = 'VerySpecialClient' )",
+      :before_remove => :log_before_remove,
+      :after_remove  => :log_after_remove
   has_many :unsorted_clients, :class_name => "Client"
   has_many :clients_sorted_desc, :class_name => "Client", :order => "id DESC"
   has_many :clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id"
@@ -46,20 +48,16 @@ class Firm < Company
   has_many :dependent_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id", :dependent => :destroy
   has_many :exclusively_dependent_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id", :dependent => :delete_all
   has_many :limited_clients, :class_name => "Client", :limit => 1
+  has_many :clients_with_interpolated_conditions, :class_name => "Client", :conditions => proc { "rating > #{rating}" }
   has_many :clients_like_ms, :conditions => "name = 'Microsoft'", :class_name => "Client", :order => "id"
-  has_many :clients_with_interpolated_conditions, :class_name => "Client", :conditions => 'rating > #{rating}'
   has_many :clients_like_ms_with_hash_conditions, :conditions => { :name => 'Microsoft' }, :class_name => "Client", :order => "id"
-  has_many :clients_using_sql, :class_name => "Client", :finder_sql => 'SELECT * FROM companies WHERE client_of = #{id}'
-  has_many :clients_using_multiline_sql, :class_name => "Client", :finder_sql => '
-  SELECT
-  companies.*
-  FROM companies WHERE companies.client_of = #{id}'
+  has_many :clients_using_sql, :class_name => "Client", :finder_sql => proc { "SELECT * FROM companies WHERE client_of = #{id}" }
   has_many :clients_using_counter_sql, :class_name => "Client",
-           :finder_sql  => 'SELECT * FROM companies WHERE client_of = #{id}',
-           :counter_sql => 'SELECT COUNT(*) FROM companies WHERE client_of = #{id}'
+           :finder_sql  => proc { "SELECT * FROM companies WHERE client_of = #{id} " },
+           :counter_sql => proc { "SELECT COUNT(*) FROM companies WHERE client_of = #{id}" }
   has_many :clients_using_zero_counter_sql, :class_name => "Client",
-           :finder_sql  => 'SELECT * FROM companies WHERE client_of = #{id}',
-           :counter_sql => 'SELECT 0 FROM companies WHERE client_of = #{id}'
+           :finder_sql  => proc { "SELECT * FROM companies WHERE client_of = #{id}" },
+           :counter_sql => proc { "SELECT 0 FROM companies WHERE client_of = #{id}" }
   has_many :no_clients_using_counter_sql, :class_name => "Client",
            :finder_sql  => 'SELECT * FROM companies WHERE client_of = 1000',
            :counter_sql => 'SELECT COUNT(*) FROM companies WHERE client_of = 1000'
@@ -88,6 +86,19 @@ class Firm < Company
   has_one :unautosaved_account, :foreign_key => "firm_id", :class_name => 'Account', :autosave => false
   has_many :accounts
   has_many :unautosaved_accounts, :foreign_key => "firm_id", :class_name => 'Account', :autosave => false
+
+  def log
+    @log ||= []
+  end
+
+  private
+    def log_before_remove(record)
+      log << "before_remove#{record.id}"
+    end
+
+    def log_after_remove(record)
+      log << "after_remove#{record.id}"
+    end
 end
 
 class DependentFirm < Company
@@ -109,6 +120,9 @@ class Client < Company
   belongs_to :firm_with_primary_key, :class_name => "Firm", :primary_key => "name", :foreign_key => "firm_name"
   belongs_to :firm_with_primary_key_symbols, :class_name => "Firm", :primary_key => :name, :foreign_key => :firm_name
   belongs_to :readonly_firm, :class_name => "Firm", :foreign_key => "firm_id", :readonly => true
+  belongs_to :bob_firm, :class_name => "Firm", :foreign_key => "client_of", :conditions => { :name => "Bob" }
+  has_many :accounts, :through => :firm
+  belongs_to :account
 
   # Record destruction so we can test whether firm.clients.clear has
   # is calling client.destroy, deleting from the database, or setting
diff --git a/activerecord/test/models/contact.rb b/activerecord/test/models/contact.rb
index 975a885331..e081eee661 100644
--- a/activerecord/test/models/contact.rb
+++ b/activerecord/test/models/contact.rb
@@ -1,8 +1,14 @@
 class Contact < ActiveRecord::Base
+  establish_connection(:adapter => 'fake')
+
+  connection.tables = ['contacts']
+  connection.primary_keys = {
+    'contacts' => 'id'
+  }
+
   # mock out self.columns so no pesky db is needed for these tests
   def self.column(name, sql_type = nil, options = {})
-    @columns ||= []
-    @columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, options[:default], sql_type.to_s, options[:null])
+    connection.merge_column('contacts', name, sql_type, options)
   end
 
   column :name,        :string
diff --git a/activerecord/test/models/contract.rb b/activerecord/test/models/contract.rb
index 606c99cd4e..94fd48e12a 100644
--- a/activerecord/test/models/contract.rb
+++ b/activerecord/test/models/contract.rb
@@ -1,4 +1,4 @@
 class Contract < ActiveRecord::Base
   belongs_to :company
   belongs_to :developer
-end
\ No newline at end of file
+end
diff --git a/activerecord/test/models/customer.rb b/activerecord/test/models/customer.rb
index e258ccdb6c..777f6b5ba0 100644
--- a/activerecord/test/models/customer.rb
+++ b/activerecord/test/models/customer.rb
@@ -70,4 +70,4 @@ class Fullname
   def to_s
     "#{first} #{last.upcase}"
   end
-end
\ No newline at end of file
+end
diff --git a/activerecord/test/models/joke.rb b/activerecord/test/models/joke.rb
index 3978abc2ba..d7f01e59e6 100644
--- a/activerecord/test/models/joke.rb
+++ b/activerecord/test/models/joke.rb
@@ -1,3 +1,7 @@
 class Joke < ActiveRecord::Base
   set_table_name 'funny_jokes'
 end
+
+class GoodJoke < ActiveRecord::Base
+  set_table_name 'funny_jokes'
+end
diff --git a/activerecord/test/models/lesson.rb b/activerecord/test/models/lesson.rb
new file mode 100644
index 0000000000..4c88153068
--- /dev/null
+++ b/activerecord/test/models/lesson.rb
@@ -0,0 +1,11 @@
+class LessonError < Exception
+end
+
+class Lesson < ActiveRecord::Base
+  has_and_belongs_to_many :students
+  before_destroy :ensure_no_students
+
+  def ensure_no_students
+    raise LessonError unless students.empty?
+  end
+end
diff --git a/activerecord/test/models/member.rb b/activerecord/test/models/member.rb
index fbf0b80164..991e0e051f 100644
--- a/activerecord/test/models/member.rb
+++ b/activerecord/test/models/member.rb
@@ -1,9 +1,10 @@
 class Member < ActiveRecord::Base
   has_one :current_membership
-  has_many :memberships
+  has_one :membership
   has_many :fellow_members, :through => :club, :source => :members
   has_one :club, :through => :current_membership
-  has_one :favourite_club, :through => :memberships, :conditions => ["memberships.favourite = ?", true], :source => :club
+  has_one :favourite_club, :through => :membership, :conditions => ["memberships.favourite = ?", true], :source => :club
+  has_one :hairy_club, :through => :membership, :conditions => {:clubs => {:name => "Moustache and Eyebrow Fancier Club"}}, :source => :club
   has_one :sponsor, :as => :sponsorable
   has_one :sponsor_club, :through => :sponsor
   has_one :member_detail
@@ -20,4 +21,10 @@ class Member < ActiveRecord::Base
   has_many :organization_member_details_2, :through => :organization, :source => :member_details
 
   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, :conditions => { :favourite => true }
+  has_many :clubs, :through => :current_memberships
 end
diff --git a/activerecord/test/models/person.rb b/activerecord/test/models/person.rb
index 5a5b6f9626..ad59d12672 100644
--- a/activerecord/test/models/person.rb
+++ b/activerecord/test/models/person.rb
@@ -1,17 +1,24 @@
 class Person < ActiveRecord::Base
   has_many :readers
+  has_one :reader
+
   has_many :posts, :through => :readers
   has_many :posts_with_no_comments, :through => :readers, :source => :post, :include => :comments, :conditions => 'comments.id is null'
 
   has_many :references
   has_many :bad_references
   has_many :fixed_bad_references, :conditions => { :favourite => true }, :class_name => 'BadReference'
-  has_many :jobs, :through => :references
   has_one :favourite_reference, :class_name => 'Reference', :conditions => ['favourite=?', true]
   has_many :posts_with_comments_sorted_by_comment_id, :through => :readers, :source => :post, :include => :comments, :order => 'comments.id'
 
+  has_many :jobs, :through => :references
+  has_many :jobs_with_dependent_destroy, :source => :job, :through => :references, :dependent => :destroy
+  has_many :jobs_with_dependent_delete_all, :source => :job, :through => :references, :dependent => :delete_all
+  has_many :jobs_with_dependent_nullify, :source => :job, :through => :references, :dependent => :nullify
+
   belongs_to :primary_contact, :class_name => 'Person'
   has_many :agents, :class_name => 'Person', :foreign_key => 'primary_contact_id'
+  has_many :agents_of_agents, :through => :agents, :source => :agents
   belongs_to :number1_fan, :class_name => 'Person'
 
   has_many :agents_posts, :through => :agents, :source => :posts
@@ -20,3 +27,24 @@ class Person < ActiveRecord::Base
   scope :males, :conditions => { :gender => 'M' }
   scope :females, :conditions => { :gender => 'F' }
 end
+
+class PersonWithDependentDestroyJobs < ActiveRecord::Base
+  self.table_name = 'people'
+
+  has_many :references, :foreign_key => :person_id
+  has_many :jobs, :source => :job, :through => :references, :dependent => :destroy
+end
+
+class PersonWithDependentDeleteAllJobs < ActiveRecord::Base
+  self.table_name = 'people'
+
+  has_many :references, :foreign_key => :person_id
+  has_many :jobs, :source => :job, :through => :references, :dependent => :delete_all
+end
+
+class PersonWithDependentNullifyJobs < ActiveRecord::Base
+  self.table_name = 'people'
+
+  has_many :references, :foreign_key => :person_id
+  has_many :jobs, :source => :job, :through => :references, :dependent => :nullify
+end
diff --git a/activerecord/test/models/pirate.rb b/activerecord/test/models/pirate.rb
index f2c45053e7..0d3f62bb33 100644
--- a/activerecord/test/models/pirate.rb
+++ b/activerecord/test/models/pirate.rb
@@ -34,6 +34,8 @@ class Pirate < ActiveRecord::Base
     :after_remove   => proc {|p,b| p.ship_log << "after_removing_proc_bird_#{b.id}"}
   has_many :birds_with_reject_all_blank, :class_name => "Bird"
 
+  has_one :bulb, :foreign_key => :car_id
+
   accepts_nested_attributes_for :parrots, :birds, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }
   accepts_nested_attributes_for :ship, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }
   accepts_nested_attributes_for :update_only_ship, :update_only => true
@@ -78,3 +80,7 @@ class Pirate < ActiveRecord::Base
       ship_log << "#{callback}_#{record.class.name.downcase}_#{record.id || '<new>'}"
     end
 end
+
+class DestructivePirate < Pirate
+  has_one :dependent_ship, :class_name => 'Ship', :foreign_key => :pirate_id, :dependent => :destroy
+end
diff --git a/activerecord/test/models/post.rb b/activerecord/test/models/post.rb
index e9c8c02e45..b39325f949 100644
--- a/activerecord/test/models/post.rb
+++ b/activerecord/test/models/post.rb
@@ -38,9 +38,11 @@ class Post < ActiveRecord::Base
   end
 
   has_many :author_favorites, :through => :author
+  has_many :author_categorizations, :through => :author, :source => :categorizations
+  has_many :author_addresses, :through => :author
 
   has_many :comments_with_interpolated_conditions, :class_name => 'Comment',
-      :conditions => ['#{"#{aliased_table_name}." rescue ""}body = ?', 'Thank you for the welcome']
+    :conditions => proc { ["#{"#{aliased_table_name}." rescue ""}body = ?", 'Thank you for the welcome'] }
 
   has_one  :very_special_comment
   has_one  :very_special_comment_with_post, :class_name => "VerySpecialComment", :include => :post
@@ -55,11 +57,21 @@ class Post < ActiveRecord::Base
   has_many :taggings, :as => :taggable
   has_many :tags, :through => :taggings do
     def add_joins_and_select
-      find :all, :select => 'tags.*, authors.id as author_id', :include => false,
+      find :all, :select => 'tags.*, authors.id as author_id',
         :joins => 'left outer join posts on taggings.taggable_id = posts.id left outer join authors on posts.author_id = authors.id'
     end
   end
 
+  has_many :interpolated_taggings, :class_name => 'Tagging', :as => :taggable, :conditions => proc { "1 = #{1}" }
+  has_many :interpolated_tags, :through => :taggings
+  has_many :interpolated_tags_2, :through => :interpolated_taggings, :source => :tag
+
+  has_many :taggings_with_delete_all, :class_name => 'Tagging', :as => :taggable, :dependent => :delete_all
+  has_many :taggings_with_destroy, :class_name => 'Tagging', :as => :taggable, :dependent => :destroy
+
+  has_many :tags_with_destroy, :through => :taggings, :source => :tag, :dependent => :destroy
+  has_many :tags_with_nullify, :through => :taggings, :source => :tag, :dependent => :nullify
+
   has_many :misc_tags, :through => :taggings, :source => :tag, :conditions => "tags.name = 'Misc'"
   has_many :funky_tags, :through => :taggings, :source => :tag
   has_many :super_tags, :through => :taggings
@@ -77,9 +89,21 @@ class Post < ActiveRecord::Base
   has_many :categorizations, :foreign_key => :category_id
   has_many :authors, :through => :categorizations
 
+  has_many :categorizations_using_author_id, :primary_key => :author_id, :foreign_key => :post_id, :class_name => 'Categorization'
+  has_many :authors_using_author_id, :through => :categorizations_using_author_id, :source => :author
+
+  has_many :taggings_using_author_id, :primary_key => :author_id, :as => :taggable, :class_name => 'Tagging'
+  has_many :tags_using_author_id, :through => :taggings_using_author_id, :source => :tag
+
+  has_many :standard_categorizations, :class_name => 'Categorization', :foreign_key => :post_id
+  has_many :author_using_custom_pk,  :through => :standard_categorizations
+  has_many :authors_using_custom_pk, :through => :standard_categorizations
+  has_many :named_categories, :through => :standard_categorizations
+
   has_many :readers
   has_many :readers_with_person, :include => :person, :class_name => "Reader"
   has_many :people, :through => :readers
+  has_many :single_people, :through => :readers
   has_many :people_with_callbacks, :source=>:person, :through => :readers,
               :before_add    => lambda {|owner, reader| log(:added,   :before, reader.first_name) },
               :after_add     => lambda {|owner, reader| log(:added,   :after,  reader.first_name) },
@@ -127,3 +151,10 @@ class PostForAuthor < ActiveRecord::Base
   cattr_accessor :selected_author
   default_scope lambda { where(:author_id => PostForAuthor.selected_author) }
 end
+
+class FirstPost < ActiveRecord::Base
+  self.table_name = 'posts'
+  default_scope where(:id => 1)
+  has_many :comments, :foreign_key => :post_id
+  has_one  :comment,  :foreign_key => :post_id
+end
diff --git a/activerecord/test/models/project.rb b/activerecord/test/models/project.rb
index 416032cb75..efe1ce67da 100644
--- a/activerecord/test/models/project.rb
+++ b/activerecord/test/models/project.rb
@@ -7,14 +7,15 @@ class Project < ActiveRecord::Base
   has_and_belongs_to_many :developers_named_david, :class_name => "Developer", :conditions => "name = 'David'", :uniq => true
   has_and_belongs_to_many :developers_named_david_with_hash_conditions, :class_name => "Developer", :conditions => { :name => 'David' }, :uniq => true
   has_and_belongs_to_many :salaried_developers, :class_name => "Developer", :conditions => "salary > 0"
-  has_and_belongs_to_many :developers_with_finder_sql, :class_name => "Developer", :finder_sql => 'SELECT t.*, j.* FROM developers_projects j, developers t WHERE t.id = j.developer_id AND j.project_id = #{id} ORDER BY t.id'
-  has_and_belongs_to_many :developers_with_multiline_finder_sql, :class_name => "Developer", :finder_sql => '
-    SELECT
-      t.*, j.*
-    FROM
-      developers_projects j,
-      developers t WHERE t.id = j.developer_id AND j.project_id = #{id} ORDER BY t.id'
-  has_and_belongs_to_many :developers_by_sql, :class_name => "Developer", :delete_sql => "DELETE FROM developers_projects WHERE project_id = \#{id} AND developer_id = \#{record.id}"
+  has_and_belongs_to_many :developers_with_finder_sql, :class_name => "Developer", :finder_sql => proc { "SELECT t.*, j.* FROM developers_projects j, developers t WHERE t.id = j.developer_id AND j.project_id = #{id} ORDER BY t.id" }
+  has_and_belongs_to_many :developers_with_multiline_finder_sql, :class_name => "Developer", :finder_sql => proc {
+    "SELECT
+       t.*, j.*
+     FROM
+       developers_projects j,
+       developers t WHERE t.id = j.developer_id AND j.project_id = #{id} ORDER BY t.id"
+  }
+  has_and_belongs_to_many :developers_by_sql, :class_name => "Developer", :delete_sql => proc { |record| "DELETE FROM developers_projects WHERE project_id = #{id} AND developer_id = #{record.id}" }
   has_and_belongs_to_many :developers_with_callbacks, :class_name => "Developer", :before_add => Proc.new {|o, r| o.developers_log << "before_adding#{r.id || '<new>'}"},
                             :after_add => Proc.new {|o, r| o.developers_log << "after_adding#{r.id || '<new>'}"},
                             :before_remove => Proc.new {|o, r| o.developers_log << "before_removing#{r.id}"},
@@ -28,6 +29,10 @@ class Project < ActiveRecord::Base
     @developers_log = []
   end
 
+  def self.all_as_method
+    all
+  end
+  scope :all_as_scope, {}
 end
 
 class SpecialProject < Project
diff --git a/activerecord/test/models/reader.rb b/activerecord/test/models/reader.rb
index 27527bf566..0207a2bd92 100644
--- a/activerecord/test/models/reader.rb
+++ b/activerecord/test/models/reader.rb
@@ -1,4 +1,5 @@
 class Reader < ActiveRecord::Base
   belongs_to :post
-  belongs_to :person
+  belongs_to :person, :inverse_of => :readers
+  belongs_to :single_person, :class_name => 'Person', :foreign_key => :person_id, :inverse_of => :reader
 end
diff --git a/activerecord/test/models/reference.rb b/activerecord/test/models/reference.rb
index 87d4a71963..e33a0f2acc 100644
--- a/activerecord/test/models/reference.rb
+++ b/activerecord/test/models/reference.rb
@@ -3,6 +3,18 @@ class Reference < ActiveRecord::Base
   belongs_to :job
 
   has_many :agents_posts_authors, :through => :person
+
+  class << self
+    attr_accessor :make_comments
+  end
+
+  before_destroy :make_comments
+
+  def make_comments
+    if self.class.make_comments
+      person.update_attributes :comments => "Reference destroyed"
+    end
+  end
 end
 
 class BadReference < ActiveRecord::Base
diff --git a/activerecord/test/models/reply.rb b/activerecord/test/models/reply.rb
index 110d540120..6adfe0ae3c 100644
--- a/activerecord/test/models/reply.rb
+++ b/activerecord/test/models/reply.rb
@@ -10,6 +10,13 @@ class Reply < Topic
   attr_accessible :title, :author_name, :author_email_address, :written_on, :content, :last_read, :parent_title
 end
 
+class UniqueReply < Reply
+  validates_uniqueness_of :content, :scope => 'parent_id'
+end
+
+class SillyUniqueReply < UniqueReply
+end
+
 class WrongReply < Reply
   validate :errors_on_empty_content
   validate :title_is_wrong_create, :on => :create
diff --git a/activerecord/test/models/sponsor.rb b/activerecord/test/models/sponsor.rb
index 50c2c2d76c..aa4a3638fd 100644
--- a/activerecord/test/models/sponsor.rb
+++ b/activerecord/test/models/sponsor.rb
@@ -1,4 +1,7 @@
 class Sponsor < ActiveRecord::Base
   belongs_to :sponsor_club, :class_name => "Club", :foreign_key => "club_id"
   belongs_to :sponsorable, :polymorphic => true
-end
\ No newline at end of file
+  belongs_to :thing, :polymorphic => true, :foreign_type => :sponsorable_type, :foreign_key => :sponsorable_id
+  belongs_to :sponsorable_with_conditions, :polymorphic => true,
+             :foreign_type => 'sponsorable_type', :foreign_key => 'sponsorable_id', :conditions => {:name => 'Ernie'}
+end
diff --git a/activerecord/test/models/student.rb b/activerecord/test/models/student.rb
new file mode 100644
index 0000000000..f459f2a9a3
--- /dev/null
+++ b/activerecord/test/models/student.rb
@@ -0,0 +1,3 @@
+class Student < ActiveRecord::Base
+  has_and_belongs_to_many :lessons
+end
diff --git a/activerecord/test/models/tagging.rb b/activerecord/test/models/tagging.rb
index c6ff8d390b..17e627a60e 100644
--- a/activerecord/test/models/tagging.rb
+++ b/activerecord/test/models/tagging.rb
@@ -8,5 +8,7 @@ class Tagging < ActiveRecord::Base
   belongs_to :invalid_tag, :class_name => 'Tag', :foreign_key => 'tag_id'
   belongs_to :blue_tag,    :class_name => 'Tag', :foreign_key => :tag_id, :conditions => "tags.name = 'Blue'"
   belongs_to :tag_with_primary_key, :class_name => 'Tag', :foreign_key => :tag_id, :primary_key => :custom_primary_key
+  belongs_to :interpolated_tag, :class_name => 'Tag', :foreign_key => :tag_id, :conditions => proc { "1 = #{1}" }
   belongs_to :taggable, :polymorphic => true, :counter_cache => true
+  has_many :things, :through => :taggable
 end
diff --git a/activerecord/test/models/task.rb b/activerecord/test/models/task.rb
index ee0282c79b..e36989dd56 100644
--- a/activerecord/test/models/task.rb
+++ b/activerecord/test/models/task.rb
@@ -1,3 +1,5 @@
 class Task < ActiveRecord::Base
-
+  def updated_at
+    ending
+  end
 end
diff --git a/activerecord/test/models/topic.rb b/activerecord/test/models/topic.rb
index 6496f36f7e..6440dbe8ab 100644
--- a/activerecord/test/models/topic.rb
+++ b/activerecord/test/models/topic.rb
@@ -45,6 +45,10 @@ class Topic < ActiveRecord::Base
 
   has_many :replies, :dependent => :destroy, :foreign_key => "parent_id"
   has_many :replies_with_primary_key, :class_name => "Reply", :dependent => :destroy, :primary_key => "title", :foreign_key => "parent_title"
+
+  has_many :unique_replies, :dependent => :destroy, :foreign_key => "parent_id"
+  has_many :silly_unique_replies, :dependent => :destroy, :foreign_key => "parent_id"
+
   serialize :content
 
   before_create  :default_written_on
diff --git a/activerecord/test/models/traffic_light.rb b/activerecord/test/models/traffic_light.rb
new file mode 100644
index 0000000000..228f3f7bd4
--- /dev/null
+++ b/activerecord/test/models/traffic_light.rb
@@ -0,0 +1,3 @@
+class TrafficLight < ActiveRecord::Base
+  serialize :state, Array
+end
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index 5deb233f2d..bdadd0698b 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -113,8 +113,10 @@ ActiveRecord::Schema.define do
 
   create_table :categorizations, :force => true do |t|
     t.column :category_id, :integer
+    t.string :named_category_name
     t.column :post_id, :integer
     t.column :author_id, :integer
+    t.column :special, :boolean
   end
 
   create_table :citations, :force => true do |t|
@@ -145,6 +147,7 @@ ActiveRecord::Schema.define do
       t.text    :body, :null => false
     end
     t.string  :type
+    t.integer :taggings_count, :default => 0
   end
 
   create_table :companies, :force => true do |t|
@@ -155,6 +158,7 @@ ActiveRecord::Schema.define do
     t.string  :name
     t.integer :client_of
     t.integer :rating, :default => 1
+    t.integer :account_id
   end
 
   add_index :companies, [:firm_id, :type, :rating, :ruby_type], :name => "company_index"
@@ -231,6 +235,10 @@ ActiveRecord::Schema.define do
     t.string :name
   end
 
+  create_table :cold_jokes, :force => true do |t|
+    t.string :name
+  end
+
   create_table :goofy_string_id, :force => true, :id => false do |t|
     t.string :id, :null => false
     t.string :info
@@ -281,6 +289,15 @@ ActiveRecord::Schema.define do
     t.integer :version, :null => false, :default => 0
   end
 
+  create_table :lessons, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :lessons_students, :id => false, :force => true do |t|
+    t.references :lesson
+    t.references :student
+  end
+
   create_table :line_items, :force => true do |t|
     t.integer :invoice_id
     t.integer :amount
@@ -419,6 +436,8 @@ ActiveRecord::Schema.define do
     t.string     :gender, :limit => 1
     t.references :number1_fan
     t.integer    :lock_version, :null => false, :default => 0
+    t.string     :comments
+    t.timestamps
   end
 
   create_table :pets, :primary_key => :pet_id ,:force => true do |t|
@@ -447,6 +466,11 @@ ActiveRecord::Schema.define do
     t.string  :type
     t.integer :comments_count, :default => 0
     t.integer :taggings_count, :default => 0
+    t.integer :taggings_with_delete_all_count, :default => 0
+    t.integer :taggings_with_destroy_count, :default => 0
+    t.integer :tags_count, :default => 0
+    t.integer :tags_with_destroy_count, :default => 0
+    t.integer :tags_with_nullify_count, :default => 0
   end
 
   create_table :price_estimates, :force => true do |t|
@@ -516,6 +540,10 @@ ActiveRecord::Schema.define do
     t.string :sponsorable_type
   end
 
+  create_table :students, :force => true do |t|
+    t.string :name
+  end
+
   create_table :subscribers, :force => true, :id => false do |t|
     t.string :nick, :null => false
     t.string :name