vendor/rails/activerecord/test/cases/associations/join_model_test.rb

   1 require "cases/helper"
   2 require 'models/tag'
   3 require 'models/tagging'
   4 require 'models/post'
   5 require 'models/item'
   6 require 'models/comment'
   7 require 'models/author'
   8 require 'models/category'
   9 require 'models/categorization'
  10 require 'models/vertex'
  11 require 'models/edge'
  12 require 'models/book'
  13 require 'models/citation'
  14
  15 class AssociationsJoinModelTest < ActiveRecord::TestCase
  16   self.use_transactional_fixtures = false
  17   fixtures :posts, :authors, :categories, :categorizations, :comments, :tags, :taggings, :author_favorites, :vertices, :items, :books
  18
  19   def test_has_many
  20     assert authors(:david).categories.include?(categories(:general))
  21   end
  22
  23   def test_has_many_inherited
  24     assert authors(:mary).categories.include?(categories(:sti_test))
  25   end
  26
  27   def test_inherited_has_many
  28     assert categories(:sti_test).authors.include?(authors(:mary))
  29   end
  30
  31   def test_has_many_uniq_through_join_model
  32     assert_equal 2, authors(:mary).categorized_posts.size
  33     assert_equal 1, authors(:mary).unique_categorized_posts.size
  34   end
  35
  36   def test_has_many_uniq_through_count
  37     author = authors(:mary)
  38     assert !authors(:mary).unique_categorized_posts.loaded?
  39     assert_queries(1) { assert_equal 1, author.unique_categorized_posts.count }
  40     assert_queries(1) { assert_equal 1, author.unique_categorized_posts.count(:title) }
  41     assert_queries(1) { assert_equal 0, author.unique_categorized_posts.count(:title, :conditions => "title is NULL") }
  42     assert !authors(:mary).unique_categorized_posts.loaded?
  43   end
  44
  45   def test_has_many_uniq_through_find
  46     assert_equal 1, authors(:mary).unique_categorized_posts.find(:all).size
  47   end
  48
  49   def test_has_many_uniq_through_dynamic_find
  50     assert_equal 1, authors(:mary).unique_categorized_posts.find_all_by_title("So I was thinking").size
  51   end
  52
  53   def test_polymorphic_has_many
  54     assert posts(:welcome).taggings.include?(taggings(:welcome_general))
  55   end
  56
  57   def test_polymorphic_has_one
  58     assert_equal taggings(:welcome_general), posts(:welcome).tagging
  59   end
  60
  61   def test_polymorphic_belongs_to
  62     assert_equal posts(:welcome), posts(:welcome).taggings.first.taggable
  63   end
  64
  65   def test_polymorphic_has_many_going_through_join_model
  66     assert_equal tags(:general), tag = posts(:welcome).tags.first
  67     assert_no_queries do
  68       tag.tagging
  69     end
  70   end
  71
  72   def test_count_polymorphic_has_many
  73     assert_equal 1, posts(:welcome).taggings.count
  74     assert_equal 1, posts(:welcome).tags.count
  75   end
  76
  77   def test_polymorphic_has_many_going_through_join_model_with_find
  78     assert_equal tags(:general), tag = posts(:welcome).tags.find(:first)
  79     assert_no_queries do
  80       tag.tagging
  81     end
  82   end
  83
  84   def test_polymorphic_has_many_going_through_join_model_with_include_on_source_reflection
  85     assert_equal tags(:general), tag = posts(:welcome).funky_tags.first
  86     assert_no_queries do
  87       tag.tagging
  88     end
  89   end
  90
  91   def test_polymorphic_has_many_going_through_join_model_with_include_on_source_reflection_with_find
  92     assert_equal tags(:general), tag = posts(:welcome).funky_tags.find(:first)
  93     assert_no_queries do
  94       tag.tagging
  95     end
  96   end
  97
  98   def test_polymorphic_has_many_going_through_join_model_with_disabled_include
  99     assert_equal tags(:general), tag = posts(:welcome).tags.add_joins_and_select.first
 100     assert_queries 1 do
 101       tag.tagging
 102     end
 103   end
 104
 105   def test_polymorphic_has_many_going_through_join_model_with_custom_select_and_joins
 106     assert_equal tags(:general), tag = posts(:welcome).tags.add_joins_and_select.first
 107     tag.author_id
 108   end
 109
 110   def test_polymorphic_has_many_going_through_join_model_with_custom_foreign_key
 111     assert_equal tags(:misc), taggings(:welcome_general).super_tag
 112     assert_equal tags(:misc), posts(:welcome).super_tags.first
 113   end
 114
 115   def test_polymorphic_has_many_create_model_with_inheritance_and_custom_base_class
 116     post = SubStiPost.create :title => 'SubStiPost', :body => 'SubStiPost body'
 117     assert_instance_of SubStiPost, post
 118
 119     tagging = tags(:misc).taggings.create(:taggable => post)
 120     assert_equal "SubStiPost", tagging.taggable_type
 121   end
 122
 123   def test_polymorphic_has_many_going_through_join_model_with_inheritance
 124     assert_equal tags(:general), posts(:thinking).tags.first
 125   end
 126
 127   def test_polymorphic_has_many_going_through_join_model_with_inheritance_with_custom_class_name
 128     assert_equal tags(:general), posts(:thinking).funky_tags.first
 129   end
 130
 131   def test_polymorphic_has_many_create_model_with_inheritance
 132     post = posts(:thinking)
 133     assert_instance_of SpecialPost, post
 134
 135     tagging = tags(:misc).taggings.create(:taggable => post)
 136     assert_equal "Post", tagging.taggable_type
 137   end
 138
 139   def test_polymorphic_has_one_create_model_with_inheritance
 140     tagging = tags(:misc).create_tagging(:taggable => posts(:thinking))
 141     assert_equal "Post", tagging.taggable_type
 142   end
 143
 144   def test_set_polymorphic_has_many
 145     tagging = tags(:misc).taggings.create
 146     posts(:thinking).taggings << tagging
 147     assert_equal "Post", tagging.taggable_type
 148   end
 149
 150   def test_set_polymorphic_has_one
 151     tagging = tags(:misc).taggings.create
 152     posts(:thinking).tagging = tagging
 153     assert_equal "Post", tagging.taggable_type
 154   end
 155
 156   def test_create_polymorphic_has_many_with_scope
 157     old_count = posts(:welcome).taggings.count
 158     tagging = posts(:welcome).taggings.create(:tag => tags(:misc))
 159     assert_equal "Post", tagging.taggable_type
 160     assert_equal old_count+1, posts(:welcome).taggings.count
 161   end
 162
 163   def test_create_bang_polymorphic_with_has_many_scope
 164     old_count = posts(:welcome).taggings.count
 165     tagging = posts(:welcome).taggings.create!(:tag => tags(:misc))
 166     assert_equal "Post", tagging.taggable_type
 167     assert_equal old_count+1, posts(:welcome).taggings.count
 168   end
 169
 170   def test_create_polymorphic_has_one_with_scope
 171     old_count = Tagging.count
 172     tagging = posts(:welcome).tagging.create(:tag => tags(:misc))
 173     assert_equal "Post", tagging.taggable_type
 174     assert_equal old_count+1, Tagging.count
 175   end
 176
 177   def test_delete_polymorphic_has_many_with_delete_all
 178     assert_equal 1, posts(:welcome).taggings.count
 179     posts(:welcome).taggings.first.update_attribute :taggable_type, 'PostWithHasManyDeleteAll'
 180     post = find_post_with_dependency(1, :has_many, :taggings, :delete_all)
 181
 182     old_count = Tagging.count
 183     post.destroy
 184     assert_equal old_count-1, Tagging.count
 185     assert_equal 0, posts(:welcome).taggings.count
 186   end
 187
 188   def test_delete_polymorphic_has_many_with_destroy
 189     assert_equal 1, posts(:welcome).taggings.count
 190     posts(:welcome).taggings.first.update_attribute :taggable_type, 'PostWithHasManyDestroy'
 191     post = find_post_with_dependency(1, :has_many, :taggings, :destroy)
 192
 193     old_count = Tagging.count
 194     post.destroy
 195     assert_equal old_count-1, Tagging.count
 196     assert_equal 0, posts(:welcome).taggings.count
 197   end
 198
 199   def test_delete_polymorphic_has_many_with_nullify
 200     assert_equal 1, posts(:welcome).taggings.count
 201     posts(:welcome).taggings.first.update_attribute :taggable_type, 'PostWithHasManyNullify'
 202     post = find_post_with_dependency(1, :has_many, :taggings, :nullify)
 203
 204     old_count = Tagging.count
 205     post.destroy
 206     assert_equal old_count, Tagging.count
 207     assert_equal 0, posts(:welcome).taggings.count
 208   end
 209
 210   def test_delete_polymorphic_has_one_with_destroy
 211     assert posts(:welcome).tagging
 212     posts(:welcome).tagging.update_attribute :taggable_type, 'PostWithHasOneDestroy'
 213     post = find_post_with_dependency(1, :has_one, :tagging, :destroy)
 214
 215     old_count = Tagging.count
 216     post.destroy
 217     assert_equal old_count-1, Tagging.count
 218     assert_nil posts(:welcome).tagging(true)
 219   end
 220
 221   def test_delete_polymorphic_has_one_with_nullify
 222     assert posts(:welcome).tagging
 223     posts(:welcome).tagging.update_attribute :taggable_type, 'PostWithHasOneNullify'
 224     post = find_post_with_dependency(1, :has_one, :tagging, :nullify)
 225
 226     old_count = Tagging.count
 227     post.destroy
 228     assert_equal old_count, Tagging.count
 229     assert_nil posts(:welcome).tagging(true)
 230   end
 231
 232   def test_has_many_with_piggyback
 233     assert_equal "2", categories(:sti_test).authors.first.post_id.to_s
 234   end
 235
 236   def test_include_has_many_through
 237     posts              = Post.find(:all, :order => 'posts.id')
 238     posts_with_authors = Post.find(:all, :include => :authors, :order => 'posts.id')
 239     assert_equal posts.length, posts_with_authors.length
 240     posts.length.times do |i|
 241       assert_equal posts[i].authors.length, assert_no_queries { posts_with_authors[i].authors.length }
 242     end
 243   end
 244
 245   def test_include_polymorphic_has_one
 246     post    = Post.find_by_id(posts(:welcome).id, :include => :tagging)
 247     tagging = taggings(:welcome_general)
 248     assert_no_queries do
 249       assert_equal tagging, post.tagging
 250     end
 251   end
 252
 253   def test_include_polymorphic_has_one_defined_in_abstract_parent
 254     item    = Item.find_by_id(items(:dvd).id, :include => :tagging)
 255     tagging = taggings(:godfather)
 256     assert_no_queries do
 257       assert_equal tagging, item.tagging
 258     end
 259   end
 260
 261   def test_include_polymorphic_has_many_through
 262     posts           = Post.find(:all, :order => 'posts.id')
 263     posts_with_tags = Post.find(:all, :include => :tags, :order => 'posts.id')
 264     assert_equal posts.length, posts_with_tags.length
 265     posts.length.times do |i|
 266       assert_equal posts[i].tags.length, assert_no_queries { posts_with_tags[i].tags.length }
 267     end
 268   end
 269
 270   def test_include_polymorphic_has_many
 271     posts               = Post.find(:all, :order => 'posts.id')
 272     posts_with_taggings = Post.find(:all, :include => :taggings, :order => 'posts.id')
 273     assert_equal posts.length, posts_with_taggings.length
 274     posts.length.times do |i|
 275       assert_equal posts[i].taggings.length, assert_no_queries { posts_with_taggings[i].taggings.length }
 276     end
 277   end
 278
 279   def test_has_many_find_all
 280     assert_equal [categories(:general)], authors(:david).categories.find(:all)
 281   end
 282
 283   def test_has_many_find_first
 284     assert_equal categories(:general), authors(:david).categories.find(:first)
 285   end
 286
 287   def test_has_many_with_hash_conditions
 288     assert_equal categories(:general), authors(:david).categories_like_general.find(:first)
 289   end
 290
 291   def test_has_many_find_conditions
 292     assert_equal categories(:general), authors(:david).categories.find(:first, :conditions => "categories.name = 'General'")
 293     assert_equal nil, authors(:david).categories.find(:first, :conditions => "categories.name = 'Technology'")
 294   end
 295
 296   def test_has_many_class_methods_called_by_method_missing
 297     assert_equal categories(:general), authors(:david).categories.find_all_by_name('General').first
 298     assert_equal nil, authors(:david).categories.find_by_name('Technology')
 299   end
 300
 301   def test_has_many_array_methods_called_by_method_missing
 302     assert true, authors(:david).categories.any? { |category| category.name == 'General' }
 303     assert_nothing_raised { authors(:david).categories.sort }
 304   end
 305
 306   def test_has_many_going_through_join_model_with_custom_foreign_key
 307     assert_equal [], posts(:thinking).authors
 308     assert_equal [authors(:mary)], posts(:authorless).authors
 309   end
 310
 311   def test_both_scoped_and_explicit_joins_should_be_respected
 312     assert_nothing_raised do
 313       Post.send(:with_scope, :find => {:joins => "left outer join comments on comments.id = posts.id"}) do
 314         Post.find :all, :select => "comments.id, authors.id", :joins => "left outer join authors on authors.id = posts.author_id"
 315       end
 316     end
 317   end
 318
 319   def test_belongs_to_polymorphic_with_counter_cache
 320     assert_equal 0, posts(:welcome)[:taggings_count]
 321     tagging = posts(:welcome).taggings.create(:tag => tags(:general))
 322     assert_equal 1, posts(:welcome, :reload)[:taggings_count]
 323     tagging.destroy
 324     assert posts(:welcome, :reload)[:taggings_count].zero?
 325   end
 326
 327   def test_unavailable_through_reflection
 328     assert_raise(ActiveRecord::HasManyThroughAssociationNotFoundError) { authors(:david).nothings }
 329   end
 330
 331   def test_has_many_through_join_model_with_conditions
 332     assert_equal [], posts(:welcome).invalid_taggings
 333     assert_equal [], posts(:welcome).invalid_tags
 334   end
 335
 336   def test_has_many_polymorphic
 337     assert_raise ActiveRecord::HasManyThroughAssociationPolymorphicError do
 338       assert_equal posts(:welcome, :thinking), tags(:general).taggables
 339     end
 340     assert_raise ActiveRecord::EagerLoadPolymorphicError do
 341       assert_equal posts(:welcome, :thinking), tags(:general).taggings.find(:all, :include => :taggable, :conditions => 'bogus_table.column = 1')
 342     end
 343   end
 344
 345   def test_has_many_polymorphic_with_source_type
 346     assert_equal posts(:welcome, :thinking), tags(:general).tagged_posts
 347   end
 348
 349   def test_eager_has_many_polymorphic_with_source_type
 350     tag_with_include = Tag.find(tags(:general).id, :include => :tagged_posts)
 351     desired = posts(:welcome, :thinking)
 352     assert_no_queries do
 353       assert_equal desired, tag_with_include.tagged_posts
 354     end
 355     assert_equal 5, tag_with_include.taggings.length
 356   end
 357
 358   def test_has_many_through_has_many_find_all
 359     assert_equal comments(:greetings), authors(:david).comments.find(:all, :order => 'comments.id').first
 360   end
 361
 362   def test_has_many_through_has_many_find_all_with_custom_class
 363     assert_equal comments(:greetings), authors(:david).funky_comments.find(:all, :order => 'comments.id').first
 364   end
 365
 366   def test_has_many_through_has_many_find_first
 367     assert_equal comments(:greetings), authors(:david).comments.find(:first, :order => 'comments.id')
 368   end
 369
 370   def test_has_many_through_has_many_find_conditions
 371     options = { :conditions => "comments.#{QUOTED_TYPE}='SpecialComment'", :order => 'comments.id' }
 372     assert_equal comments(:does_it_hurt), authors(:david).comments.find(:first, options)
 373   end
 374
 375   def test_has_many_through_has_many_find_by_id
 376     assert_equal comments(:more_greetings), authors(:david).comments.find(2)
 377   end
 378
 379   def test_has_many_through_polymorphic_has_one
 380     assert_raise(ActiveRecord::HasManyThroughSourceAssociationMacroError) { authors(:david).tagging }
 381   end
 382
 383   def test_has_many_through_polymorphic_has_many
 384     assert_equal taggings(:welcome_general, :thinking_general), authors(:david).taggings.uniq.sort_by { |t| t.id }
 385   end
 386
 387   def test_include_has_many_through_polymorphic_has_many
 388     author            = Author.find_by_id(authors(:david).id, :include => :taggings)
 389     expected_taggings = taggings(:welcome_general, :thinking_general)
 390     assert_no_queries do
 391       assert_equal expected_taggings, author.taggings.uniq.sort_by { |t| t.id }
 392     end
 393   end
 394
 395   def test_has_many_through_has_many_through
 396     assert_raise(ActiveRecord::HasManyThroughSourceAssociationMacroError) { authors(:david).tags }
 397   end
 398
 399   def test_has_many_through_habtm
 400     assert_raise(ActiveRecord::HasManyThroughSourceAssociationMacroError) { authors(:david).post_categories }
 401   end
 402
 403   def test_eager_load_has_many_through_has_many
 404     author = Author.find :first, :conditions => ['name = ?', 'David'], :include => :comments, :order => 'comments.id'
 405     SpecialComment.new; VerySpecialComment.new
 406     assert_no_queries do
 407       assert_equal [1,2,3,5,6,7,8,9,10], author.comments.collect(&:id)
 408     end
 409   end
 410
 411   def test_eager_load_has_many_through_has_many_with_conditions
 412     post = Post.find(:first, :include => :invalid_tags)
 413     assert_no_queries do
 414       post.invalid_tags
 415     end
 416   end
 417
 418   def test_eager_belongs_to_and_has_one_not_singularized
 419     assert_nothing_raised do
 420       Author.find(:first, :include => :author_address)
 421       AuthorAddress.find(:first, :include => :author)
 422     end
 423   end
 424
 425   def test_self_referential_has_many_through
 426     assert_equal [authors(:mary)], authors(:david).favorite_authors
 427     assert_equal [],               authors(:mary).favorite_authors
 428   end
 429
 430   def test_add_to_self_referential_has_many_through
 431     new_author = Author.create(:name => "Bob")
 432     authors(:david).author_favorites.create :favorite_author => new_author
 433     assert_equal new_author, authors(:david).reload.favorite_authors.first
 434   end
 435
 436   def test_has_many_through_uses_conditions_specified_on_the_has_many_association
 437     author = Author.find(:first)
 438     assert !author.comments.blank?
 439     assert author.nonexistant_comments.blank?
 440   end
 441
 442   def test_has_many_through_uses_correct_attributes
 443     assert_nil posts(:thinking).tags.find_by_name("General").attributes["tag_id"]
 444   end
 445
 446   def test_associating_unsaved_records_with_has_many_through
 447     saved_post = posts(:thinking)
 448     new_tag = Tag.new(:name => "new")
 449
 450     saved_post.tags << new_tag
 451     assert !new_tag.new_record? #consistent with habtm!
 452     assert !saved_post.new_record?
 453     assert saved_post.tags.include?(new_tag)
 454
 455     assert !new_tag.new_record?
 456     assert saved_post.reload.tags(true).include?(new_tag)
 457
 458
 459     new_post = Post.new(:title => "Association replacmenet works!", :body => "You best believe it.")
 460     saved_tag = tags(:general)
 461
 462     new_post.tags << saved_tag
 463     assert new_post.new_record?
 464     assert !saved_tag.new_record?
 465     assert new_post.tags.include?(saved_tag)
 466
 467     new_post.save!
 468     assert !new_post.new_record?
 469     assert new_post.reload.tags(true).include?(saved_tag)
 470
 471     assert posts(:thinking).tags.build.new_record?
 472     assert posts(:thinking).tags.new.new_record?
 473   end
 474
 475   def test_create_associate_when_adding_to_has_many_through
 476     count = posts(:thinking).tags.count
 477     push = Tag.create!(:name => 'pushme')
 478     post_thinking = posts(:thinking)
 479     assert_nothing_raised { post_thinking.tags << push }
 480     assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag },
 481                 message = "Expected a Tag in tags collection, got #{wrong.class}.")
 482     assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
 483                 message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
 484     assert_equal(count + 1, post_thinking.tags.size)
 485     assert_equal(count + 1, post_thinking.tags(true).size)
 486
 487     assert_kind_of Tag, post_thinking.tags.create!(:name => 'foo')
 488     assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag },
 489                 message = "Expected a Tag in tags collection, got #{wrong.class}.")
 490     assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
 491                 message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
 492     assert_equal(count + 2, post_thinking.tags.size)
 493     assert_equal(count + 2, post_thinking.tags(true).size)
 494
 495     assert_nothing_raised { post_thinking.tags.concat(Tag.create!(:name => 'abc'), Tag.create!(:name => 'def')) }
 496     assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag },
 497                 message = "Expected a Tag in tags collection, got #{wrong.class}.")
 498     assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
 499                 message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
 500     assert_equal(count + 4, post_thinking.tags.size)
 501     assert_equal(count + 4, post_thinking.tags(true).size)
 502
 503     # Raises if the wrong reflection name is used to set the Edge belongs_to
 504     assert_nothing_raised { vertices(:vertex_1).sinks << vertices(:vertex_5) }
 505   end
 506
 507   def test_has_many_through_collection_size_doesnt_load_target_if_not_loaded
 508     author = authors(:david)
 509     assert_equal 9, author.comments.size
 510     assert !author.comments.loaded?
 511   end
 512
 513   uses_mocha('has_many_through_collection_size_uses_counter_cache_if_it_exists') do
 514     def test_has_many_through_collection_size_uses_counter_cache_if_it_exists
 515       author = authors(:david)
 516       author.stubs(:read_attribute).with('comments_count').returns(100)
 517       assert_equal 100, author.comments.size
 518       assert !author.comments.loaded?
 519     end
 520   end
 521
 522   def test_adding_junk_to_has_many_through_should_raise_type_mismatch
 523     assert_raise(ActiveRecord::AssociationTypeMismatch) { posts(:thinking).tags << "Uhh what now?" }
 524   end
 525
 526   def test_adding_to_has_many_through_should_return_self
 527     tags = posts(:thinking).tags
 528     assert_equal tags, posts(:thinking).tags.push(tags(:general))
 529   end
 530
 531   def test_delete_associate_when_deleting_from_has_many_through_with_nonstandard_id
 532     count = books(:awdr).references.count
 533     references_before = books(:awdr).references
 534     book = Book.create!(:name => 'Getting Real')
 535     book_awdr = books(:awdr)
 536     book_awdr.references << book
 537     assert_equal(count + 1, book_awdr.references(true).size)
 538
 539     assert_nothing_raised { book_awdr.references.delete(book) }
 540     assert_equal(count, book_awdr.references.size)
 541     assert_equal(count, book_awdr.references(true).size)
 542     assert_equal(references_before.sort, book_awdr.references.sort)
 543   end
 544
 545   def test_delete_associate_when_deleting_from_has_many_through
 546     count = posts(:thinking).tags.count
 547     tags_before = posts(:thinking).tags
 548     tag = Tag.create!(:name => 'doomed')
 549     post_thinking = posts(:thinking)
 550     post_thinking.tags << tag
 551     assert_equal(count + 1, post_thinking.taggings(true).size)
 552     assert_equal(count + 1, post_thinking.tags(true).size)
 553
 554     assert_nothing_raised { post_thinking.tags.delete(tag) }
 555     assert_equal(count, post_thinking.tags.size)
 556     assert_equal(count, post_thinking.tags(true).size)
 557     assert_equal(count, post_thinking.taggings(true).size)
 558     assert_equal(tags_before.sort, post_thinking.tags.sort)
 559   end
 560
 561   def test_delete_associate_when_deleting_from_has_many_through_with_multiple_tags
 562     count = posts(:thinking).tags.count
 563     tags_before = posts(:thinking).tags
 564     doomed = Tag.create!(:name => 'doomed')
 565     doomed2 = Tag.create!(:name => 'doomed2')
 566     quaked = Tag.create!(:name => 'quaked')
 567     post_thinking = posts(:thinking)
 568     post_thinking.tags << doomed << doomed2
 569     assert_equal(count + 2, post_thinking.tags(true).size)
 570
 571     assert_nothing_raised { post_thinking.tags.delete(doomed, doomed2, quaked) }
 572     assert_equal(count, post_thinking.tags.size)
 573     assert_equal(count, post_thinking.tags(true).size)
 574     assert_equal(tags_before.sort, post_thinking.tags.sort)
 575   end
 576
 577   def test_deleting_junk_from_has_many_through_should_raise_type_mismatch
 578     assert_raise(ActiveRecord::AssociationTypeMismatch) { posts(:thinking).tags.delete("Uhh what now?") }
 579   end
 580
 581   def test_has_many_through_sum_uses_calculations
 582     assert_nothing_raised { authors(:david).comments.sum(:post_id) }
 583   end
 584
 585   def test_calculations_on_has_many_through_should_disambiguate_fields
 586     assert_nothing_raised { authors(:david).categories.maximum(:id) }
 587   end
 588
 589   def test_calculations_on_has_many_through_should_not_disambiguate_fields_unless_necessary
 590     assert_nothing_raised { authors(:david).categories.maximum("categories.id") }
 591   end
 592
 593   def test_has_many_through_has_many_with_sti
 594     assert_equal [comments(:does_it_hurt)], authors(:david).special_post_comments
 595   end
 596
 597   def test_uniq_has_many_through_should_retain_order
 598     comment_ids = authors(:david).comments.map(&:id)
 599     assert_equal comment_ids.sort, authors(:david).ordered_uniq_comments.map(&:id)
 600     assert_equal comment_ids.sort.reverse, authors(:david).ordered_uniq_comments_desc.map(&:id)
 601   end
 602
 603   def test_polymorphic_has_many
 604     expected = taggings(:welcome_general)
 605     p = Post.find(posts(:welcome).id, :include => :taggings)
 606     assert_no_queries {assert p.taggings.include?(expected)}
 607     assert posts(:welcome).taggings.include?(taggings(:welcome_general))
 608   end
 609
 610   def test_polymorphic_has_one
 611     expected = posts(:welcome)
 612
 613     tagging  = Tagging.find(taggings(:welcome_general).id, :include => :taggable)
 614     assert_no_queries { assert_equal expected, tagging.taggable}
 615   end
 616
 617   def test_polymorphic_belongs_to
 618     p = Post.find(posts(:welcome).id, :include => {:taggings => :taggable})
 619     assert_no_queries {assert_equal posts(:welcome), p.taggings.first.taggable}
 620   end
 621
 622   def test_preload_polymorphic_has_many_through
 623     posts           = Post.find(:all, :order => 'posts.id')
 624     posts_with_tags = Post.find(:all, :include => :tags, :order => 'posts.id')
 625     assert_equal posts.length, posts_with_tags.length
 626     posts.length.times do |i|
 627       assert_equal posts[i].tags.length, assert_no_queries { posts_with_tags[i].tags.length }
 628     end
 629   end
 630
 631   def test_preload_polymorph_many_types
 632     taggings = Tagging.find :all, :include => :taggable, :conditions => ['taggable_type != ?', 'FakeModel']
 633     assert_no_queries do
 634       taggings.first.taggable.id
 635       taggings[1].taggable.id
 636     end
 637
 638     taggables = taggings.map(&:taggable)
 639     assert taggables.include?(items(:dvd))
 640     assert taggables.include?(posts(:welcome))
 641   end
 642
 643   def test_preload_nil_polymorphic_belongs_to
 644     assert_nothing_raised do
 645       taggings = Tagging.find(:all, :include => :taggable, :conditions => ['taggable_type IS NULL'])
 646     end
 647   end
 648
 649   def test_preload_polymorphic_has_many
 650     posts               = Post.find(:all, :order => 'posts.id')
 651     posts_with_taggings = Post.find(:all, :include => :taggings, :order => 'posts.id')
 652     assert_equal posts.length, posts_with_taggings.length
 653     posts.length.times do |i|
 654       assert_equal posts[i].taggings.length, assert_no_queries { posts_with_taggings[i].taggings.length }
 655     end
 656   end
 657
 658   def test_belongs_to_shared_parent
 659     comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 1')
 660     assert_no_queries do
 661       assert_equal comments.first.post, comments[1].post
 662     end
 663   end
 664
 665   def test_has_many_through_include_uses_array_include_after_loaded
 666     david = authors(:david)
 667     david.categories.class # force load target
 668
 669     category = david.categories.first
 670
 671     assert_no_queries do
 672       assert david.categories.loaded?
 673       assert david.categories.include?(category)
 674     end
 675   end
 676
 677   def test_has_many_through_include_checks_if_record_exists_if_target_not_loaded
 678     david = authors(:david)
 679     category = david.categories.first
 680
 681     david.reload
 682     assert ! david.categories.loaded?
 683     assert_queries(1) do
 684       assert david.categories.include?(category)
 685     end
 686     assert ! david.categories.loaded?
 687   end
 688
 689   def test_has_many_through_include_returns_false_for_non_matching_record_to_verify_scoping
 690     david = authors(:david)
 691     category = Category.create!(:name => 'Not Associated')
 692
 693     assert ! david.categories.loaded?
 694     assert ! david.categories.include?(category)
 695   end
 696
 697   def test_has_many_through_goes_through_all_sti_classes
 698     sub_sti_post = SubStiPost.create!(:title => 'test', :body => 'test', :author_id => 1)
 699     new_comment = sub_sti_post.comments.create(:body => 'test')
 700
 701     assert_equal [9, 10, new_comment.id], authors(:david).sti_post_comments.map(&:id).sort
 702   end
 703
 704   private
 705     # create dynamic Post models to allow different dependency options
 706     def find_post_with_dependency(post_id, association, association_name, dependency)
 707       class_name = "PostWith#{association.to_s.classify}#{dependency.to_s.classify}"
 708       Post.find(post_id).update_attribute :type, class_name
 709       klass = Object.const_set(class_name, Class.new(ActiveRecord::Base))
 710       klass.set_table_name 'posts'
 711       klass.send(association, association_name, :as => :taggable, :dependent => dependency)
 712       klass.find(post_id)
 713     end
 714 end