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   def test_has_many_through_collection_size_uses_counter_cache_if_it_exists
 514     author = authors(:david)
 515     author.stubs(:read_attribute).with('comments_count').returns(100)
 516     assert_equal 100, author.comments.size
 517     assert !author.comments.loaded?
 518   end
 519
 520   def test_adding_junk_to_has_many_through_should_raise_type_mismatch
 521     assert_raise(ActiveRecord::AssociationTypeMismatch) { posts(:thinking).tags << "Uhh what now?" }
 522   end
 523
 524   def test_adding_to_has_many_through_should_return_self
 525     tags = posts(:thinking).tags
 526     assert_equal tags, posts(:thinking).tags.push(tags(:general))
 527   end
 528
 529   def test_delete_associate_when_deleting_from_has_many_through_with_nonstandard_id
 530     count = books(:awdr).references.count
 531     references_before = books(:awdr).references
 532     book = Book.create!(:name => 'Getting Real')
 533     book_awdr = books(:awdr)
 534     book_awdr.references << book
 535     assert_equal(count + 1, book_awdr.references(true).size)
 536
 537     assert_nothing_raised { book_awdr.references.delete(book) }
 538     assert_equal(count, book_awdr.references.size)
 539     assert_equal(count, book_awdr.references(true).size)
 540     assert_equal(references_before.sort, book_awdr.references.sort)
 541   end
 542
 543   def test_delete_associate_when_deleting_from_has_many_through
 544     count = posts(:thinking).tags.count
 545     tags_before = posts(:thinking).tags
 546     tag = Tag.create!(:name => 'doomed')
 547     post_thinking = posts(:thinking)
 548     post_thinking.tags << tag
 549     assert_equal(count + 1, post_thinking.taggings(true).size)
 550     assert_equal(count + 1, post_thinking.tags(true).size)
 551
 552     assert_nothing_raised { post_thinking.tags.delete(tag) }
 553     assert_equal(count, post_thinking.tags.size)
 554     assert_equal(count, post_thinking.tags(true).size)
 555     assert_equal(count, post_thinking.taggings(true).size)
 556     assert_equal(tags_before.sort, post_thinking.tags.sort)
 557   end
 558
 559   def test_delete_associate_when_deleting_from_has_many_through_with_multiple_tags
 560     count = posts(:thinking).tags.count
 561     tags_before = posts(:thinking).tags
 562     doomed = Tag.create!(:name => 'doomed')
 563     doomed2 = Tag.create!(:name => 'doomed2')
 564     quaked = Tag.create!(:name => 'quaked')
 565     post_thinking = posts(:thinking)
 566     post_thinking.tags << doomed << doomed2
 567     assert_equal(count + 2, post_thinking.tags(true).size)
 568
 569     assert_nothing_raised { post_thinking.tags.delete(doomed, doomed2, quaked) }
 570     assert_equal(count, post_thinking.tags.size)
 571     assert_equal(count, post_thinking.tags(true).size)
 572     assert_equal(tags_before.sort, post_thinking.tags.sort)
 573   end
 574
 575   def test_deleting_junk_from_has_many_through_should_raise_type_mismatch
 576     assert_raise(ActiveRecord::AssociationTypeMismatch) { posts(:thinking).tags.delete("Uhh what now?") }
 577   end
 578
 579   def test_has_many_through_sum_uses_calculations
 580     assert_nothing_raised { authors(:david).comments.sum(:post_id) }
 581   end
 582
 583   def test_calculations_on_has_many_through_should_disambiguate_fields
 584     assert_nothing_raised { authors(:david).categories.maximum(:id) }
 585   end
 586
 587   def test_calculations_on_has_many_through_should_not_disambiguate_fields_unless_necessary
 588     assert_nothing_raised { authors(:david).categories.maximum("categories.id") }
 589   end
 590
 591   def test_has_many_through_has_many_with_sti
 592     assert_equal [comments(:does_it_hurt)], authors(:david).special_post_comments
 593   end
 594
 595   def test_uniq_has_many_through_should_retain_order
 596     comment_ids = authors(:david).comments.map(&:id)
 597     assert_equal comment_ids.sort, authors(:david).ordered_uniq_comments.map(&:id)
 598     assert_equal comment_ids.sort.reverse, authors(:david).ordered_uniq_comments_desc.map(&:id)
 599   end
 600
 601   def test_polymorphic_has_many
 602     expected = taggings(:welcome_general)
 603     p = Post.find(posts(:welcome).id, :include => :taggings)
 604     assert_no_queries {assert p.taggings.include?(expected)}
 605     assert posts(:welcome).taggings.include?(taggings(:welcome_general))
 606   end
 607
 608   def test_polymorphic_has_one
 609     expected = posts(:welcome)
 610
 611     tagging  = Tagging.find(taggings(:welcome_general).id, :include => :taggable)
 612     assert_no_queries { assert_equal expected, tagging.taggable}
 613   end
 614
 615   def test_polymorphic_belongs_to
 616     p = Post.find(posts(:welcome).id, :include => {:taggings => :taggable})
 617     assert_no_queries {assert_equal posts(:welcome), p.taggings.first.taggable}
 618   end
 619
 620   def test_preload_polymorphic_has_many_through
 621     posts           = Post.find(:all, :order => 'posts.id')
 622     posts_with_tags = Post.find(:all, :include => :tags, :order => 'posts.id')
 623     assert_equal posts.length, posts_with_tags.length
 624     posts.length.times do |i|
 625       assert_equal posts[i].tags.length, assert_no_queries { posts_with_tags[i].tags.length }
 626     end
 627   end
 628
 629   def test_preload_polymorph_many_types
 630     taggings = Tagging.find :all, :include => :taggable, :conditions => ['taggable_type != ?', 'FakeModel']
 631     assert_no_queries do
 632       taggings.first.taggable.id
 633       taggings[1].taggable.id
 634     end
 635
 636     taggables = taggings.map(&:taggable)
 637     assert taggables.include?(items(:dvd))
 638     assert taggables.include?(posts(:welcome))
 639   end
 640
 641   def test_preload_nil_polymorphic_belongs_to
 642     assert_nothing_raised do
 643       taggings = Tagging.find(:all, :include => :taggable, :conditions => ['taggable_type IS NULL'])
 644     end
 645   end
 646
 647   def test_preload_polymorphic_has_many
 648     posts               = Post.find(:all, :order => 'posts.id')
 649     posts_with_taggings = Post.find(:all, :include => :taggings, :order => 'posts.id')
 650     assert_equal posts.length, posts_with_taggings.length
 651     posts.length.times do |i|
 652       assert_equal posts[i].taggings.length, assert_no_queries { posts_with_taggings[i].taggings.length }
 653     end
 654   end
 655
 656   def test_belongs_to_shared_parent
 657     comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 1')
 658     assert_no_queries do
 659       assert_equal comments.first.post, comments[1].post
 660     end
 661   end
 662
 663   def test_has_many_through_include_uses_array_include_after_loaded
 664     david = authors(:david)
 665     david.categories.class # force load target
 666
 667     category = david.categories.first
 668
 669     assert_no_queries do
 670       assert david.categories.loaded?
 671       assert david.categories.include?(category)
 672     end
 673   end
 674
 675   def test_has_many_through_include_checks_if_record_exists_if_target_not_loaded
 676     david = authors(:david)
 677     category = david.categories.first
 678
 679     david.reload
 680     assert ! david.categories.loaded?
 681     assert_queries(1) do
 682       assert david.categories.include?(category)
 683     end
 684     assert ! david.categories.loaded?
 685   end
 686
 687   def test_has_many_through_include_returns_false_for_non_matching_record_to_verify_scoping
 688     david = authors(:david)
 689     category = Category.create!(:name => 'Not Associated')
 690
 691     assert ! david.categories.loaded?
 692     assert ! david.categories.include?(category)
 693   end
 694
 695   def test_has_many_through_goes_through_all_sti_classes
 696     sub_sti_post = SubStiPost.create!(:title => 'test', :body => 'test', :author_id => 1)
 697     new_comment = sub_sti_post.comments.create(:body => 'test')
 698
 699     assert_equal [9, 10, new_comment.id], authors(:david).sti_post_comments.map(&:id).sort
 700   end
 701
 702   private
 703     # create dynamic Post models to allow different dependency options
 704     def find_post_with_dependency(post_id, association, association_name, dependency)
 705       class_name = "PostWith#{association.to_s.classify}#{dependency.to_s.classify}"
 706       Post.find(post_id).update_attribute :type, class_name
 707       klass = Object.const_set(class_name, Class.new(ActiveRecord::Base))
 708       klass.set_table_name 'posts'
 709       klass.send(association, association_name, :as => :taggable, :dependent => dependency)
 710       klass.find(post_id)
 711     end
 712 end