activerecord 1.14.4 → 1.15.0

data/test/aaa_create_tables_test.rb

@@ -14,7 +14,11 @@ class AAACreateTablesTest < Test::Unit::TestCase
   end
 
   def test_load_schema
-    eval(File.read("#{File.dirname(__FILE__)}/fixtures/db_definitions/schema.rb"))
+    if ActiveRecord::Base.connection.supports_migrations?
+      eval(File.read("#{File.dirname(__FILE__)}/fixtures/db_definitions/schema.rb"))
+    else
+      recreate ActiveRecord::Base, '3'
+    end
     assert true
   end
   

data/test/abstract_unit.rb

@@ -8,6 +8,10 @@ require 'active_support/binding_of_caller'
 require 'active_support/breakpoint'
 require 'connection'
 
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true
+
+
 QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type') unless Object.const_defined?(:QUOTED_TYPE)
 
 class Test::Unit::TestCase #:nodoc:
@@ -18,9 +22,9 @@ class Test::Unit::TestCase #:nodoc:
   def create_fixtures(*table_names, &block)
     Fixtures.create_fixtures(File.dirname(__FILE__) + "/fixtures/", table_names, {}, &block)
   end
-  
+
   def assert_date_from_db(expected, actual, message = nil)
-    # SQL Server doesn't have a separate column type just for dates, 
+    # SQL Server doesn't have a separate column type just for dates,
     # so the time is in the string and incorrectly formatted
     if current_adapter?(:SQLServerAdapter)
       assert_equal expected.strftime("%Y/%m/%d 00:00:00"), actual.strftime("%Y/%m/%d 00:00:00")
@@ -49,17 +53,23 @@ class Test::Unit::TestCase #:nodoc:
   end
 end
 
-def current_adapter?(type)
-  ActiveRecord::ConnectionAdapters.const_defined?(type) &&
-    ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters.const_get(type))
+def current_adapter?(*types)
+  types.any? do |type|
+    ActiveRecord::ConnectionAdapters.const_defined?(type) &&
+      ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters.const_get(type))
+  end
 end
 
 ActiveRecord::Base.connection.class.class_eval do
   cattr_accessor :query_count
+
+  # Array of regexes of queries that are not counted against query_count
+  @@ignore_list = [/^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/]
+
   alias_method :execute_without_query_counting, :execute
-  def execute_with_query_counting(sql, name = nil)
-    self.query_count += 1
-    execute_without_query_counting(sql, name)
+  def execute_with_query_counting(sql, name = nil, &block)
+    self.query_count += 1 unless @@ignore_list.any? { |r| sql =~ r }
+    execute_without_query_counting(sql, name, &block)
   end
 end
 

data/test/{active_schema_mysql.rb → active_schema_test_mysql.rb}

@@ -17,11 +17,11 @@ class ActiveSchemaTest < Test::Unit::TestCase
   end
   
   def test_add_column
-    assert_equal "ALTER TABLE people ADD last_name varchar(255)", add_column(:people, :last_name, :string)
+    assert_equal "ALTER TABLE people ADD `last_name` varchar(255)", add_column(:people, :last_name, :string)
   end
   
   def test_add_column_with_limit
-    assert_equal "ALTER TABLE people ADD key varchar(32)", add_column(:people, :key, :string, :limit => 32)
+    assert_equal "ALTER TABLE people ADD `key` varchar(32)", add_column(:people, :key, :string, :limit => 32)
   end
   
   private

data/test/adapter_test.rb

@@ -66,19 +66,21 @@ class AdapterTest < Test::Unit::TestCase
   if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
     require 'fixtures/movie'
     require 'fixtures/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_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
 

data/test/adapter_test_sqlserver.rb

@@ -0,0 +1,81 @@
+require 'abstract_unit'
+require 'fixtures/default'
+require 'fixtures/post'
+require 'fixtures/task'
+
+class SqlServerAdapterTest < Test::Unit::TestCase
+  fixtures :posts, :tasks
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    @connection.execute("SET LANGUAGE us_english")
+  end
+
+  # SQL Server 2000 has a bug where some unambiguous date formats are not 
+  # correctly identified if the session language is set to german
+  def test_date_insertion_when_language_is_german
+    @connection.execute("SET LANGUAGE deutsch")
+
+    assert_nothing_raised do
+      Task.create(:starting => Time.utc(2000, 1, 31, 5, 42, 0), :ending => Date.new(2006, 12, 31))
+    end
+  end
+
+  def test_execute_without_block_closes_statement
+    assert_all_statements_used_are_closed do
+      @connection.execute("SELECT 1")
+    end
+  end
+  
+  def test_execute_with_block_closes_statement
+    assert_all_statements_used_are_closed do
+      @connection.execute("SELECT 1") do |sth|
+        assert !sth.finished?, "Statement should still be alive within block"
+      end
+    end
+  end
+  
+  def test_insert_with_identity_closes_statement
+    assert_all_statements_used_are_closed do
+      @connection.insert("INSERT INTO accounts ([id], [firm_id],[credit_limit]) values (999, 1, 50)")
+    end
+  end
+  
+  def test_insert_without_identity_closes_statement
+    assert_all_statements_used_are_closed do
+      @connection.insert("INSERT INTO accounts ([firm_id],[credit_limit]) values (1, 50)")
+    end
+  end
+  
+  def test_active_closes_statement
+    assert_all_statements_used_are_closed do
+      @connection.active?
+    end
+  end 
+
+  def assert_all_statements_used_are_closed(&block)
+    existing_handles = []
+    ObjectSpace.each_object(DBI::StatementHandle) {|handle| existing_handles << handle}
+    GC.disable
+    
+    yield
+    
+    used_handles = []
+    ObjectSpace.each_object(DBI::StatementHandle) {|handle| used_handles << handle unless existing_handles.include? handle}
+         
+    assert_block "No statements were used within given block" do
+      used_handles.size > 0
+    end
+    
+    ObjectSpace.each_object(DBI::StatementHandle) do |handle|
+      assert_block "Statement should have been closed within given block" do 
+        handle.finished?
+      end      
+    end
+  ensure
+    GC.enable
+  end
+end

data/test/aggregations_test.rb

@@ -63,4 +63,33 @@ class AggregationsTest < Test::Unit::TestCase
   def test_gps_inequality
     assert GpsLocation.new('39x110') != GpsLocation.new('39x111')
   end
+  
+  def test_allow_nil_gps_is_nil
+    assert_equal nil, customers(:zaphod).gps_location
+  end
+  
+  def test_allow_nil_gps_set_to_nil
+    customers(:david).gps_location = nil
+    customers(:david).save
+    customers(:david).reload
+    assert_equal nil, customers(:david).gps_location
+  end
+  
+  def test_allow_nil_set_address_attributes_to_nil
+    customers(:zaphod).address = nil
+    assert_equal nil, customers(:zaphod).attributes[:address_street]
+    assert_equal nil, customers(:zaphod).attributes[:address_city]
+    assert_equal nil, customers(:zaphod).attributes[:address_country]
+  end
+  
+  def test_allow_nil_address_set_to_nil
+    customers(:zaphod).address = nil
+    customers(:zaphod).save
+    customers(:zaphod).reload
+    assert_equal nil, customers(:zaphod).address
+  end
+  
+  def test_nil_raises_error_when_allow_nil_is_false
+    assert_raises(NoMethodError) { customers(:david).balance = nil }
+  end
 end

data/test/{association_callbacks_test.rb → associations/callbacks_test.rb}

@@ -111,14 +111,16 @@ class AssociationCallbacksTest < Test::Unit::TestCase
   end
   
   def test_push_with_attributes
-    david = developers(:david)
-    activerecord = projects(:active_record)
-    assert activerecord.developers_log.empty?
-    activerecord.developers_with_callbacks.push_with_attributes(david, {})
-    assert_equal ["before_adding#{david.id}", "after_adding#{david.id}"], activerecord.developers_log
-    activerecord.developers_with_callbacks.push_with_attributes(david, {})
-    assert_equal ["before_adding#{david.id}", "after_adding#{david.id}", "before_adding#{david.id}", 
-                  "after_adding#{david.id}"], activerecord.developers_log
+    assert_deprecated 'push_with_attributes' do
+      david = developers(:david)
+      activerecord = projects(:active_record)
+      assert activerecord.developers_log.empty?
+      activerecord.developers_with_callbacks.push_with_attributes(david, {})
+      assert_equal ["before_adding#{david.id}", "after_adding#{david.id}"], activerecord.developers_log
+      activerecord.developers_with_callbacks.push_with_attributes(david, {})
+      assert_equal ["before_adding#{david.id}", "after_adding#{david.id}", "before_adding#{david.id}", 
+                    "after_adding#{david.id}"], activerecord.developers_log
+    end
   end
 end
 

data/test/{associations_cascaded_eager_loading_test.rb → associations/cascaded_eager_loading_test.rb}

@@ -11,7 +11,7 @@ require 'fixtures/topic'
 require 'fixtures/reply'
 
 class CascadedEagerLoadingTest < Test::Unit::TestCase
-  fixtures :authors, :mixins, :companies, :posts, :categorizations, :topics
+  fixtures :authors, :mixins, :companies, :posts, :topics
 
   def test_eager_association_loading_with_cascaded_two_levels
     authors = Author.find(:all, :include=>{:posts=>:comments}, :order=>"authors.id")
@@ -28,7 +28,7 @@ class CascadedEagerLoadingTest < Test::Unit::TestCase
     assert_equal 1, authors[1].posts.size
     assert_equal 9, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
     assert_equal 1, authors[0].categorizations.size
-    assert_equal 1, authors[1].categorizations.size
+    assert_equal 2, authors[1].categorizations.size
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_with_two_has_many_associations
@@ -94,7 +94,7 @@ class CascadedEagerLoadingTest < Test::Unit::TestCase
       author.posts.first.very_special_comment
     end
   end
-  
+
   def test_eager_association_loading_of_stis_with_multiple_references
     authors = Author.find(:all, :include => { :posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } } }, :order => 'comments.body, very_special_comments_posts.body', :conditions => 'posts.id = 4')
     assert_equal [authors(:david)], authors
@@ -103,4 +103,36 @@ class CascadedEagerLoadingTest < Test::Unit::TestCase
       authors.first.posts.first.special_comments.first.post.very_special_comment
     end
   end
+
+  def test_eager_association_loading_with_recursive_cascading_three_levels_has_many
+    root_node = RecursivelyCascadedTreeMixin.find(:first, :include=>{:children=>{:children=>:children}}, :order => 'mixins.id')
+    assert_equal mixins(:recursively_cascaded_tree_4), assert_no_queries { root_node.children.first.children.first.children.first }
+  end
+
+  def test_eager_association_loading_with_recursive_cascading_three_levels_has_one
+    root_node = RecursivelyCascadedTreeMixin.find(:first, :include=>{:first_child=>{:first_child=>:first_child}}, :order => 'mixins.id')
+    assert_equal mixins(:recursively_cascaded_tree_4), assert_no_queries { root_node.first_child.first_child.first_child }
+  end
+
+  def test_eager_association_loading_with_recursive_cascading_three_levels_belongs_to
+    leaf_node = RecursivelyCascadedTreeMixin.find(:first, :include=>{:parent=>{:parent=>:parent}}, :order => 'mixins.id DESC')
+    assert_equal mixins(:recursively_cascaded_tree_1), assert_no_queries { leaf_node.parent.parent.parent }
+  end
+end
+
+
+require 'fixtures/vertex'
+require 'fixtures/edge'
+class CascadedEagerLoadingTest < Test::Unit::TestCase
+  fixtures :edges, :vertices
+
+  def test_eager_association_loading_with_recursive_cascading_four_levels_has_many_through
+    source = Vertex.find(:first, :include=>{:sinks=>{:sinks=>{:sinks=>:sinks}}}, :order => 'vertices.id')
+    assert_equal vertices(:vertex_4), assert_no_queries { source.sinks.first.sinks.first.sinks.first }
+  end
+
+  def test_eager_association_loading_with_recursive_cascading_four_levels_has_and_belongs_to_many
+    sink = Vertex.find(:first, :include=>{:sources=>{:sources=>{:sources=>:sources}}}, :order => 'vertices.id DESC')
+    assert_equal vertices(:vertex_1), assert_no_queries { sink.sources.first.sources.first.sources.first.sources.first }
+  end
 end

data/test/{associations_go_eager_test.rb → associations/eager_test.rb}

@@ -104,7 +104,7 @@ class EagerAssociationTest < Test::Unit::TestCase
   end
   
   def test_eager_with_has_many_through
-    posts_with_comments = people(:michael).posts.find(:all, :include => :comments )
+    posts_with_comments = people(:michael).posts.find(:all, :include => :comments)
     posts_with_author = people(:michael).posts.find(:all, :include => :author )
     posts_with_comments_and_author = people(:michael).posts.find(:all, :include => [ :comments, :author ])
     assert_equal 2, posts_with_comments.inject(0) { |sum, post| sum += post.comments.size }
@@ -112,6 +112,22 @@ class EagerAssociationTest < Test::Unit::TestCase
     assert_equal authors(:david), assert_no_queries { posts_with_comments_and_author.first.author }
   end
 
+  def test_eager_with_has_many_through_an_sti_join_model
+    author = Author.find(:first, :include => :special_post_comments, :order => 'authors.id')
+    assert_equal [comments(:does_it_hurt)], assert_no_queries { author.special_post_comments }
+  end
+  
+  def test_eager_with_has_many_through_an_sti_join_model_with_conditions_on_both
+    author = Author.find(:first, :include => :special_nonexistant_post_comments, :order => 'authors.id')
+    assert_equal [], author.special_nonexistant_post_comments
+  end
+
+  def test_eager_with_has_many_through_join_model_with_conditions
+    assert_equal Author.find(:first, :include => :hello_post_comments,
+                             :order => 'authors.id').hello_post_comments.sort_by(&:id),
+                 Author.find(:first, :order => 'authors.id').hello_post_comments.sort_by(&:id)
+  end
+
   def test_eager_with_has_many_and_limit
     posts = Post.find(:all, :order => 'posts.id asc', :include => [ :author, :comments ], :limit => 2)
     assert_equal 2, posts.size
@@ -274,6 +290,16 @@ class EagerAssociationTest < Test::Unit::TestCase
   def find_all_ordered(className, include=nil)
     className.find(:all, :order=>"#{className.table_name}.#{className.primary_key}", :include=>include)
   end
+  
+  def test_limited_eager_with_order
+    assert_equal [posts(:thinking), posts(:sti_comments)], Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => 'UPPER(posts.title)', :limit => 2, :offset => 1)
+    assert_equal [posts(:sti_post_and_comments), posts(:sti_comments)], Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => 'UPPER(posts.title) DESC', :limit => 2, :offset => 1)
+  end
+  
+  def test_limited_eager_with_multiple_order_columns
+    assert_equal [posts(:thinking), posts(:sti_comments)], Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => 'UPPER(posts.title), posts.id', :limit => 2, :offset => 1)
+    assert_equal [posts(:sti_post_and_comments), posts(:sti_comments)], Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => 'UPPER(posts.title) DESC, posts.id', :limit => 2, :offset => 1)
+  end
 
   def test_eager_with_multiple_associations_with_same_table_has_many_and_habtm
     # Eager includes of has many and habtm associations aren't necessarily sorted in the same way
@@ -283,7 +309,7 @@ class EagerAssociationTest < Test::Unit::TestCase
     end
     # Test regular association, association with conditions, association with
     # STI, and association with conditions assured not to be true
-    post_types = [:posts, :hello_posts, :special_posts, :nonexistent_posts]
+    post_types = [:posts, :other_posts, :special_posts]
     # test both has_many and has_and_belongs_to_many
     [Author, Category].each do |className|
       d1 = find_all_ordered(className)
@@ -356,4 +382,12 @@ class EagerAssociationTest < Test::Unit::TestCase
     assert_equal 2, one.comments.size
     assert_equal 2, one.categories.size
   end
+  
+  def test_count_with_include
+    if current_adapter?(:SQLServerAdapter, :SybaseAdapter)
+      assert_equal 3, authors(:david).posts_with_comments.count(:conditions => "len(comments.body) > 15")
+    else
+      assert_equal 3, authors(:david).posts_with_comments.count(:conditions => "length(comments.body) > 15")
+    end
+  end
 end

data/test/{associations_extensions_test.rb → associations/extension_test.rb}

@@ -18,6 +18,11 @@ class AssociationsExtensionsTest < Test::Unit::TestCase
   def test_named_extension_on_habtm
     assert_equal projects(:action_controller), developers(:david).projects_extended_by_name.find_most_recent
   end
+
+  def test_named_two_extensions_on_habtm
+    assert_equal projects(:action_controller), developers(:david).projects_extended_by_name_twice.find_most_recent
+    assert_equal projects(:active_record), developers(:david).projects_extended_by_name_twice.find_least_recent
+  end
   
   def test_marshalling_extensions
     david = developers(:david)

data/test/{associations_join_model_test.rb → associations/join_model_test.rb}

@@ -12,21 +12,26 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
   fixtures :posts, :authors, :categories, :categorizations, :comments, :tags, :taggings, :author_favorites
 
   def test_has_many
-    assert_equal categories(:general), authors(:david).categories.first
+    assert authors(:david).categories.include?(categories(:general))
   end
-  
+
   def test_has_many_inherited
-    assert_equal categories(:sti_test), authors(:mary).categories.first
+    assert authors(:mary).categories.include?(categories(:sti_test))
   end
 
   def test_inherited_has_many
-    assert_equal authors(:mary), categories(:sti_test).authors.first
+    assert categories(:sti_test).authors.include?(authors(:mary))
   end
-  
+
+  def test_has_many_uniq_through_join_model
+    assert_equal 2, authors(:mary).categorized_posts.size
+    assert_equal 1, authors(:mary).unique_categorized_posts.size
+  end
+
   def test_polymorphic_has_many
-    assert_equal taggings(:welcome_general), posts(:welcome).taggings.first
+    assert posts(:welcome).taggings.include?(taggings(:welcome_general))
   end
-  
+
   def test_polymorphic_has_one
     assert_equal taggings(:welcome_general), posts(:welcome).tagging
   end
@@ -132,6 +137,13 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
     assert_equal "Post", tagging.taggable_type
     assert_equal old_count+1, posts(:welcome).taggings.count
   end
+  
+  def test_create_bang_polymorphic_with_has_many_scope
+    old_count = posts(:welcome).taggings.count
+    tagging = posts(:welcome).taggings.create!(:tag => tags(:misc))
+    assert_equal "Post", tagging.taggable_type
+    assert_equal old_count+1, posts(:welcome).taggings.count
+  end
 
   def test_create_polymorphic_has_one_with_scope
     old_count = Tagging.count
@@ -241,6 +253,10 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
   def test_has_many_find_first
     assert_equal categories(:general), authors(:david).categories.find(:first)
   end
+
+  def test_has_many_with_hash_conditions
+    assert_equal categories(:general), authors(:david).categories_like_general.find(:first)
+  end
   
   def test_has_many_find_conditions
     assert_equal categories(:general), authors(:david).categories.find(:first, :conditions => "categories.name = 'General'")
@@ -296,7 +312,8 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
   end
 
   def test_has_many_through_has_many_find_conditions
-    assert_equal comments(:does_it_hurt), authors(:david).comments.find(:first, :conditions => "comments.type='SpecialComment'", :order => 'comments.id')
+    options = { :conditions => "comments.#{QUOTED_TYPE}='SpecialComment'", :order => 'comments.id' }
+    assert_equal comments(:does_it_hurt), authors(:david).comments.find(:first, options)
   end
 
   def test_has_many_through_has_many_find_by_id
@@ -334,6 +351,13 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
       assert_equal [1,2,3,5,6,7,8,9,10], author.comments.collect(&:id)
     end
   end
+  
+  def test_eager_load_has_many_through_has_many_with_conditions
+    post = Post.find(:first, :include => :invalid_tags)
+    assert_no_queries do
+      post.invalid_tags
+    end
+  end
 
   def test_eager_belongs_to_and_has_one_not_singularized
     assert_nothing_raised do
@@ -357,6 +381,92 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
     assert_nil posts(:thinking).tags.find_by_name("General").attributes["tag_id"]
   end
 
+  def test_raise_error_when_adding_new_record_to_has_many_through
+    assert_raise(ActiveRecord::HasManyThroughCantAssociateNewRecords) { posts(:thinking).tags << tags(:general).clone }
+    assert_raise(ActiveRecord::HasManyThroughCantAssociateNewRecords) { posts(:thinking).clone.tags << tags(:general) }
+    assert_raise(ActiveRecord::HasManyThroughCantAssociateNewRecords) { posts(:thinking).tags.build }
+  end
+
+  def test_create_associate_when_adding_to_has_many_through
+    count = posts(:thinking).tags.count
+    push = Tag.create!(:name => 'pushme')
+    post_thinking = posts(:thinking)
+    assert_nothing_raised { post_thinking.tags << push }
+    assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag },
+                message = "Expected a Tag in tags collection, got #{wrong.class}.")
+    assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
+                message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
+    assert_equal(count + 1, post_thinking.tags.size)
+    assert_equal(count + 1, post_thinking.tags(true).size)
+
+    assert_nothing_raised { post_thinking.tags.create!(:name => 'foo') }
+    assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag },
+                message = "Expected a Tag in tags collection, got #{wrong.class}.")
+    assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
+                message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
+    assert_equal(count + 2, post_thinking.tags.size)
+    assert_equal(count + 2, post_thinking.tags(true).size)
+
+    assert_nothing_raised { post_thinking.tags.concat(Tag.create!(:name => 'abc'), Tag.create!(:name => 'def')) }
+    assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag },
+                message = "Expected a Tag in tags collection, got #{wrong.class}.")
+    assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
+                message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
+    assert_equal(count + 4, post_thinking.tags.size)
+    assert_equal(count + 4, post_thinking.tags(true).size)
+  end
+
+  def test_adding_junk_to_has_many_through_should_raise_type_mismatch
+    assert_raise(ActiveRecord::AssociationTypeMismatch) { posts(:thinking).tags << "Uhh what now?" }
+  end
+
+  def test_adding_to_has_many_through_should_return_self
+    tags = posts(:thinking).tags
+    assert_equal tags, posts(:thinking).tags.push(tags(:general))
+  end
+
+  def test_delete_associate_when_deleting_from_has_many_through
+    count = posts(:thinking).tags.count
+    tags_before = posts(:thinking).tags
+    tag = Tag.create!(:name => 'doomed')
+    post_thinking = posts(:thinking)
+    post_thinking.tags << tag
+    assert_equal(count + 1, post_thinking.tags(true).size)
+
+    assert_nothing_raised { post_thinking.tags.delete(tag) }    
+    assert_equal(count, post_thinking.tags.size)
+    assert_equal(count, post_thinking.tags(true).size)
+    assert_equal(tags_before.sort, post_thinking.tags.sort)
+  end
+
+  def test_delete_associate_when_deleting_from_has_many_through_with_multiple_tags
+    count = posts(:thinking).tags.count
+    tags_before = posts(:thinking).tags
+    doomed = Tag.create!(:name => 'doomed')
+    doomed2 = Tag.create!(:name => 'doomed2')
+    quaked = Tag.create!(:name => 'quaked')
+    post_thinking = posts(:thinking)
+    post_thinking.tags << doomed << doomed2
+    assert_equal(count + 2, post_thinking.tags(true).size)
+
+    assert_nothing_raised { post_thinking.tags.delete(doomed, doomed2, quaked) }    
+    assert_equal(count, post_thinking.tags.size)
+    assert_equal(count, post_thinking.tags(true).size)
+    assert_equal(tags_before.sort, post_thinking.tags.sort)
+  end
+
+  def test_deleting_junk_from_has_many_through_should_raise_type_mismatch
+    assert_raise(ActiveRecord::AssociationTypeMismatch) { posts(:thinking).tags.delete("Uhh what now?") }
+  end
+
+  def test_has_many_through_sum_uses_calculations
+    assert_nothing_raised { authors(:david).comments.sum(:post_id) }
+  end
+
+  def test_has_many_through_has_many_with_sti
+    assert_equal [comments(:does_it_hurt)], authors(:david).special_post_comments
+  end
+
   private
     # create dynamic Post models to allow different dependency options
     def find_post_with_dependency(post_id, association, association_name, dependency)