db2 2.6.2 → 2.7.0

data/lib/active_record/connection_adapters/ibm_db_pstmt.rb

@@ -177,7 +177,7 @@ module ActiveRecord
       end
 
       pstmt = connection.prepare(statement, "#{self.class.name} Create")
-      self.id = connection.prepared_insert(pstmt, quoted_attributes.values)
+      self.id = connection.prepared_insert(pstmt, quoted_attributes.values, self.id)
 
       @new_record = false
       id

data/test/cases/adapter_test.rb

@@ -1,202 +1,207 @@
 require "cases/helper"
 
-class AdapterTest < ActiveRecord::TestCase
-  def setup
-    @connection = ActiveRecord::Base.connection
-  end
+module ActiveRecord
+  class AdapterTest < ActiveRecord::TestCase
+    def setup
+      @connection = ActiveRecord::Base.connection
+    end
 
-  if current_adapter?(:IBM_DBAdapter)
-    def test_a_connection_attributes
-      if @connection.servertype.class.name.include?('::IBM_IDS')
-        return
-      end
-      if @connection.respond_to?(:schema)
-        previous_schema = ActiveRecord::Base.connection.schema
-        ActiveRecord::Base.connection.schema = 'SYSCAT'
-        assert_equal 'SYSCAT', ActiveRecord::Base.connection.schema
-        ActiveRecord::Base.connection.schema = previous_schema
-      else
-        warn "#{@connection.class} does not support client connection attribute schema_name"
-      end
-  
-      if @connection.respond_to?(:app_user)
-        ActiveRecord::Base.connection.app_user = 'new_user'
-        assert_equal 'new_user', ActiveRecord::Base.connection.app_user
-      else
-        warn "#{@connection.class} does not support client connection attribute SQL_ATTR_INFO_USER"
-      end
-  
-      if @connection.respond_to?(:account)
-        ActiveRecord::Base.connection.account = 'new_acct'
-        assert_equal 'new_acct', ActiveRecord::Base.connection.account
-      else
-        warn "#{@connection.class} does not support client connection attribute SQL_ATTR_INFO_ACCTSTR"
-      end
-  
-      if @connection.respond_to?(:application)
-        ActiveRecord::Base.connection.application = 'new_app'
-        assert_equal 'new_app', ActiveRecord::Base.connection.application
-      else
-        warn "#{@connection.class} does not support client connection attribute SQL_ATTR_INFO_APPLNAME"
+    if current_adapter?(:IBM_DBAdapter)
+      def test_a_connection_attributes
+        if @connection.servertype.class.name.include?('::IBM_IDS')
+          return
+        end
+        if @connection.respond_to?(:schema)
+          previous_schema = ActiveRecord::Base.connection.schema
+          ActiveRecord::Base.connection.schema = 'SYSCAT'
+          assert_equal 'SYSCAT', ActiveRecord::Base.connection.schema
+          ActiveRecord::Base.connection.schema = previous_schema
+        else
+          warn "#{@connection.class} does not support client connection attribute schema_name"
+        end
+
+        if @connection.respond_to?(:app_user)
+          ActiveRecord::Base.connection.app_user = 'new_user'
+          assert_equal 'new_user', ActiveRecord::Base.connection.app_user
+        else
+          warn "#{@connection.class} does not support client connection attribute SQL_ATTR_INFO_USER"
+        end
+
+        if @connection.respond_to?(:account)
+          ActiveRecord::Base.connection.account = 'new_acct'
+          assert_equal 'new_acct', ActiveRecord::Base.connection.account
+        else
+          warn "#{@connection.class} does not support client connection attribute SQL_ATTR_INFO_ACCTSTR"
+        end
+
+        if @connection.respond_to?(:application)
+          ActiveRecord::Base.connection.application = 'new_app'
+          assert_equal 'new_app', ActiveRecord::Base.connection.application
+        else
+          warn "#{@connection.class} does not support client connection attribute SQL_ATTR_INFO_APPLNAME"
+        end
+
+        if @connection.respond_to?(:workstation)
+          ActiveRecord::Base.connection.workstation = 'new_wrkst'
+          assert_equal 'new_wrkst', ActiveRecord::Base.connection.workstation
+        else
+          warn "#{@connection.class} does not support client connection attribute SQL_ATTR_INFO_WRKSTNNAME"
+        end
       end
+    end
   
-      if @connection.respond_to?(:workstation)
-        ActiveRecord::Base.connection.workstation = 'new_wrkst'
-        assert_equal 'new_wrkst', ActiveRecord::Base.connection.workstation
+    def test_tables
+      tables = @connection.tables
+      assert tables.include?("accounts")
+      assert tables.include?("authors")
+      assert tables.include?("tasks")
+      assert tables.include?("topics")
+    end
+
+    def test_table_exists?
+      assert @connection.table_exists?("accounts")
+      assert !@connection.table_exists?("nonexistingtable")
+      assert !@connection.table_exists?(nil)
+    end
+
+    def test_indexes
+      idx_name = "accounts_idx"
+
+      if @connection.respond_to?(:indexes)
+        indexes = @connection.indexes("accounts")
+        assert indexes.empty?
+
+        @connection.add_index :accounts, :firm_id, :name => idx_name
+        indexes = @connection.indexes("accounts")
+        assert_equal "accounts", indexes.first.table
+        # OpenBase does not have the concept of a named index
+        # Indexes are merely properties of columns.
+        assert_equal idx_name, indexes.first.name unless current_adapter?(:OpenBaseAdapter)
+        assert !indexes.first.unique
+        assert_equal ["firm_id"], indexes.first.columns
       else
-        warn "#{@connection.class} does not support client connection attribute SQL_ATTR_INFO_WRKSTNNAME"
+        warn "#{@connection.class} does not respond to #indexes"
       end
-    end
-  end
-  
-  def test_tables
-    tables = @connection.tables
-    assert tables.include?("accounts")
-    assert tables.include?("authors")
-    assert tables.include?("tasks")
-    assert tables.include?("topics")
-  end
 
-  def test_table_exists?
-    assert @connection.table_exists?("accounts")
-    assert !@connection.table_exists?("nonexistingtable")
-  end
-
-  def test_indexes
-    idx_name = "accounts_idx"
-
-    if @connection.respond_to?(:indexes)
-      indexes = @connection.indexes("accounts")
-      assert indexes.empty?
-
-      @connection.add_index :accounts, :firm_id, :name => idx_name
-      indexes = @connection.indexes("accounts")
-      assert_equal "accounts", indexes.first.table
-      # OpenBase does not have the concept of a named index
-      # Indexes are merely properties of columns.
-      assert_equal idx_name, indexes.first.name unless current_adapter?(:OpenBaseAdapter)
-      assert !indexes.first.unique
-      assert_equal ["firm_id"], indexes.first.columns
-    else
-      warn "#{@connection.class} does not respond to #indexes"
+    ensure
+      @connection.remove_index(:accounts, :name => idx_name) rescue nil
     end
 
-  ensure
-    @connection.remove_index(:accounts, :name => idx_name) rescue nil
-  end
-
-  def test_current_database
-    if @connection.respond_to?(:current_database)
-      assert_equal ENV['ARUNIT_DB_NAME'] || "activerecord_unittest", @connection.current_database
+    def test_current_database
+      if @connection.respond_to?(:current_database)
+        assert_equal ARTest.connection_config['arunit']['database'], @connection.current_database
+      end
     end
-  end
 
-  if current_adapter?(:MysqlAdapter)
-    def test_charset
-      assert_not_nil @connection.charset
-      assert_not_equal 'character_set_database', @connection.charset
-      assert_equal @connection.show_variable('character_set_database'), @connection.charset
-    end
+    if current_adapter?(:MysqlAdapter)
+      def test_charset
+        assert_not_nil @connection.charset
+        assert_not_equal 'character_set_database', @connection.charset
+        assert_equal @connection.show_variable('character_set_database'), @connection.charset
+      end
 
-    def test_collation
-      assert_not_nil @connection.collation
-      assert_not_equal 'collation_database', @connection.collation
-      assert_equal @connection.show_variable('collation_database'), @connection.collation
-    end
+      def test_collation
+        assert_not_nil @connection.collation
+        assert_not_equal 'collation_database', @connection.collation
+        assert_equal @connection.show_variable('collation_database'), @connection.collation
+      end
 
-    def test_show_nonexistent_variable_returns_nil
-      assert_nil @connection.show_variable('foo_bar_baz')
-    end
+      def test_show_nonexistent_variable_returns_nil
+        assert_nil @connection.show_variable('foo_bar_baz')
+      end
 
-    def test_not_specifying_database_name_for_cross_database_selects
-      begin
-        assert_nothing_raised do
-          ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['arunit'].except(:database))
-          ActiveRecord::Base.connection.execute "SELECT activerecord_unittest.pirates.*, activerecord_unittest2.courses.* FROM activerecord_unittest.pirates, activerecord_unittest2.courses"
+      def test_not_specifying_database_name_for_cross_database_selects
+        begin
+          assert_nothing_raised do
+            ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['arunit'].except(:database))
+
+            config = ARTest.connection_config
+            ActiveRecord::Base.connection.execute(
+              "SELECT #{config['arunit']['database']}.pirates.*, #{config['arunit2']['database']}.courses.* " \
+              "FROM #{config['arunit']['database']}.pirates, #{config['arunit2']['database']}.courses"
+            )
+          end
+        ensure
+          ActiveRecord::Base.establish_connection 'arunit'
         end
-      ensure
-        ActiveRecord::Base.establish_connection 'arunit'
       end
     end
-  end
-
-  if current_adapter?(:PostgreSQLAdapter)
-    def test_encoding
-      assert_not_nil @connection.encoding
-    end
-  end
 
-  def test_table_alias
-    def @connection.test_table_alias_length() 10; end
-    class << @connection
-      alias_method :old_table_alias_length, :table_alias_length
-      alias_method :table_alias_length,     :test_table_alias_length
-    end
+    def test_table_alias
+      def @connection.test_table_alias_length() 10; end
+      class << @connection
+        alias_method :old_table_alias_length, :table_alias_length
+        alias_method :table_alias_length,     :test_table_alias_length
+      end
 
-    assert_equal 'posts',      @connection.table_alias_for('posts')
-    assert_equal 'posts_comm', @connection.table_alias_for('posts_comments')
-    assert_equal 'dbo_posts',  @connection.table_alias_for('dbo.posts')
+      assert_equal 'posts',      @connection.table_alias_for('posts')
+      assert_equal 'posts_comm', @connection.table_alias_for('posts_comments')
+      assert_equal 'dbo_posts',  @connection.table_alias_for('dbo.posts')
 
-    class << @connection
-      remove_method :table_alias_length
-      alias_method :table_alias_length, :old_table_alias_length
+      class << @connection
+        remove_method :table_alias_length
+        alias_method :table_alias_length, :old_table_alias_length
+      end
     end
-  end
 
-  # test resetting sequences in odd tables in postgreSQL
-  if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
-    require 'models/movie'
-    require 'models/subscriber'
+    # test resetting sequences in odd tables in postgreSQL
+    if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
+      require 'models/movie'
+      require 'models/subscriber'
 
-    def test_reset_empty_table_with_custom_pk
-      Movie.delete_all
-      Movie.connection.reset_pk_sequence! 'movies'
-      assert_equal 1, Movie.create(:name => 'fight club').id
-    end
+      def test_reset_empty_table_with_custom_pk
+        Movie.delete_all
+        Movie.connection.reset_pk_sequence! 'movies'
+        assert_equal 1, Movie.create(:name => 'fight club').id
+      end
 
-    if ActiveRecord::Base.connection.adapter_name != "FrontBase"
-      def test_reset_table_with_non_integer_pk
-        Subscriber.delete_all
-        Subscriber.connection.reset_pk_sequence! 'subscribers'
-        sub = Subscriber.new(:name => 'robert drake')
-        sub.id = 'bob drake'
-        assert_nothing_raised { sub.save! }
+      if ActiveRecord::Base.connection.adapter_name != "FrontBase"
+        def test_reset_table_with_non_integer_pk
+          Subscriber.delete_all
+          Subscriber.connection.reset_pk_sequence! 'subscribers'
+          sub = Subscriber.new(:name => 'robert drake')
+          sub.id = 'bob drake'
+          assert_nothing_raised { sub.save! }
+        end
       end
     end
-  end
 
-  def test_uniqueness_violations_are_translated_to_specific_exception
-    @connection.execute "INSERT INTO subscribers(nick) VALUES('me')"
-    assert_raises(ActiveRecord::RecordNotUnique) do
+    def test_uniqueness_violations_are_translated_to_specific_exception
       @connection.execute "INSERT INTO subscribers(nick) VALUES('me')"
+      assert_raises(ActiveRecord::RecordNotUnique) do
+        @connection.execute "INSERT INTO subscribers(nick) VALUES('me')"
+      end
     end
-  end
 
-  def test_foreign_key_violations_are_translated_to_specific_exception
-    unless @connection.adapter_name == 'SQLite'
-      assert_raises(ActiveRecord::InvalidForeignKey) do
-        # Oracle adapter uses prefetched primary key values from sequence and passes them to connection adapter insert method
-        if @connection.prefetch_primary_key?
-          id_value = @connection.next_sequence_value(@connection.default_sequence_name("fk_test_has_fk", "id"))
-          @connection.execute "INSERT INTO fk_test_has_fk (id, fk_id) VALUES (#{id_value},0)"
-        else
-          @connection.execute "INSERT INTO fk_test_has_fk (fk_id) VALUES (0)"
+    def test_foreign_key_violations_are_translated_to_specific_exception
+      unless @connection.adapter_name == 'SQLite'
+        assert_raises(ActiveRecord::InvalidForeignKey) do
+          # Oracle adapter uses prefetched primary key values from sequence and passes them to connection adapter insert method
+          if @connection.prefetch_primary_key?
+            id_value = @connection.next_sequence_value(@connection.default_sequence_name("fk_test_has_fk", "id"))
+            @connection.execute "INSERT INTO fk_test_has_fk (id, fk_id) VALUES (#{id_value},0)"
+          else
+            @connection.execute "INSERT INTO fk_test_has_fk (fk_id) VALUES (0)"
+          end
         end
       end
     end
-  end
-
-  unless current_adapter?(:IBM_DBAdapter)
-    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))
+    def test_disable_referential_integrity
+      assert_nothing_raised do
+        @connection.disable_referential_integrity do
+          # Oracle adapter uses prefetched primary key values from sequence and passes them to connection adapter insert method
+          if @connection.prefetch_primary_key?
+            id_value = @connection.next_sequence_value(@connection.default_sequence_name("fk_test_has_fk", "id"))
+            @connection.execute "INSERT INTO fk_test_has_fk (id, fk_id) VALUES (#{id_value},0)"
+          else
+            @connection.execute "INSERT INTO fk_test_has_fk (fk_id) VALUES (0)"
+          end
+          # should deleted created record as otherwise disable_referential_integrity will try to enable contraints after executed block
+          # and will fail (at least on Oracle)
+          @connection.execute "DELETE FROM fk_test_has_fk"
+        end
+      end
     end
   end
 end

data/test/cases/associations/belongs_to_associations_test.rb

@@ -13,11 +13,12 @@ require 'models/comment'
 require 'models/sponsor'
 require 'models/member'
 require 'models/essay'
+require 'models/toy'
 
 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
@@ -54,11 +55,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) }
@@ -79,23 +75,17 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_eager_loading_with_primary_key
-    apple = Firm.create("name" => "Apple")
-    citibank = Client.create("name" => "Citibank", :firm_name => "Apple")
+    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_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
+  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 citibank_result.association_cache.key?(:firm_with_primary_key_symbols)
   end
 
   def test_creating_the_belonging_object
@@ -130,6 +120,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
@@ -156,6 +163,26 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_not_nil Company.find(3).firm_with_condition, "Microsoft should have a firm"
   end
 
+  def test_polymorphic_association_class
+    sponsor = Sponsor.new
+    assert_nil sponsor.association(:sponsorable).send(:klass)
+
+    sponsor.sponsorable_type = '' # the column doesn't have to be declared NOT NULL
+    assert_nil sponsor.association(:sponsorable).send(:klass)
+
+    sponsor.sponsorable = Member.new :name => "Bert"
+    assert_equal Member, sponsor.association(:sponsorable).send(:klass)
+  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
@@ -172,17 +199,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)
@@ -195,16 +211,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
@@ -278,6 +301,15 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal 1, Topic.find(topic.id)[:replies_count]
   end
 
+  def test_belongs_to_counter_when_update_column
+    topic = Topic.create!(:title => "37s")
+    topic.replies.create!(:title => "re: 37s", :content => "rails")
+    assert_equal 1, Topic.find(topic.id)[:replies_count]
+
+    topic.update_column(:content, "rails is wonderfull")
+    assert_equal 1, Topic.find(topic.id)[:replies_count]
+  end
+
   def test_assignment_before_child_saved
     final_cut = Client.new("name" => "Final Cut")
     firm = Firm.find(1)
@@ -308,13 +340,27 @@ 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_dont_find_target_when_foreign_key_is_null
+    tagging = taggings(:thinking_general)
+    queries = assert_sql { tagging.super_tag }
+    assert_equal 0, queries.length
   end
 
   def test_field_name_same_as_foreign_key
@@ -416,6 +462,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")
@@ -483,4 +541,171 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     new_firm = accounts(:signals37).build_firm(:name => 'Apple')
     assert_equal new_firm.name, "Apple"
   end
+
+  def test_reassigning_the_parent_id_updates_the_object
+    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)
+
+    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 = 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
+    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.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
+    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.sponsorable_type = 'Firm'
+
+    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 lambda { 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
+
+  def test_build_with_block
+    client = Client.create(:name => 'Client Company')
+
+    firm = client.build_firm{ |f| f.name = 'Agency Company' }
+    assert_equal 'Agency Company', firm.name
+  end
+
+  def test_create_with_block
+    client = Client.create(:name => 'Client Company')
+
+    firm = client.create_firm{ |f| f.name = 'Agency Company' }
+    assert_equal 'Agency Company', firm.name
+  end
+
+  def test_create_bang_with_block
+    client = Client.create(:name => 'Client Company')
+
+    firm = client.create_firm!{ |f| f.name = 'Agency Company' }
+    assert_equal 'Agency Company', firm.name
+  end
+
+  def test_should_set_foreign_key_on_create_association
+    client = Client.create! :name => "fuu"
+
+    firm = client.create_firm :name => "baa"
+    assert_equal firm.id, client.client_of
+  end
+
+  def test_should_set_foreign_key_on_create_association!
+    client = Client.create! :name => "fuu"
+
+    firm = client.create_firm! :name => "baa"
+    assert_equal firm.id, client.client_of
+  end
+
+  def test_self_referential_belongs_to_with_counter_cache_assigning_nil
+    comment = Comment.create! :post => posts(:thinking), :body => "fuu"
+    comment.parent = nil
+    comment.save!
+
+    assert_equal nil, comment.reload.parent
+    assert_equal 0, comments(:greetings).reload.children_count
+  end
+
+  def test_polymorphic_with_custom_primary_key
+    toy = Toy.create!
+    sponsor = Sponsor.create!(:sponsorable => toy)
+
+    assert_equal toy, sponsor.reload.sponsorable
+  end
 end