3 require 'models/tagging'
6 require 'models/comment'
7 require 'models/author'
8 require 'models/category'
9 require 'models/categorization'
10 require 'models/vertex'
13 require 'models/citation'
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
20 assert
authors(:david).categories
.include?(categories(:general))
23 def test_has_many_inherited
24 assert
authors(:mary).categories
.include?(categories(:sti_test))
27 def test_inherited_has_many
28 assert
categories(:sti_test).authors
.include?(authors(:mary))
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
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
?
45 def test_has_many_uniq_through_find
46 assert_equal
1, authors(:mary).unique_categorized_posts
.find(:all).size
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
53 def test_polymorphic_has_many
54 assert
posts(:welcome).taggings
.include?(taggings(:welcome_general))
57 def test_polymorphic_has_one
58 assert_equal
taggings(:welcome_general), posts(:welcome).tagging
61 def test_polymorphic_belongs_to
62 assert_equal
posts(:welcome), posts(:welcome).taggings
.first
.taggable
65 def test_polymorphic_has_many_going_through_join_model
66 assert_equal
tags(:general), tag
= posts(:welcome).tags
.first
72 def test_count_polymorphic_has_many
73 assert_equal
1, posts(:welcome).taggings
.count
74 assert_equal
1, posts(:welcome).tags
.count
77 def test_polymorphic_has_many_going_through_join_model_with_find
78 assert_equal
tags(:general), tag
= posts(:welcome).tags
.find(:first)
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
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)
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
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
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
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
119 tagging
= tags(:misc).taggings
.create(:taggable => post
)
120 assert_equal
"SubStiPost", tagging
.taggable_type
123 def test_polymorphic_has_many_going_through_join_model_with_inheritance
124 assert_equal
tags(:general), posts(:thinking).tags
.first
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
131 def test_polymorphic_has_many_create_model_with_inheritance
132 post
= posts(:thinking)
133 assert_instance_of SpecialPost
, post
135 tagging
= tags(:misc).taggings
.create(:taggable => post
)
136 assert_equal
"Post", tagging
.taggable_type
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
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
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
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
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
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
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)
182 old_count
= Tagging
.count
184 assert_equal old_count-1
, Tagging
.count
185 assert_equal
0, posts(:welcome).taggings
.count
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)
193 old_count
= Tagging
.count
195 assert_equal old_count-1
, Tagging
.count
196 assert_equal
0, posts(:welcome).taggings
.count
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)
204 old_count
= Tagging
.count
206 assert_equal old_count
, Tagging
.count
207 assert_equal
0, posts(:welcome).taggings
.count
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)
215 old_count
= Tagging
.count
217 assert_equal old_count-1
, Tagging
.count
218 assert_nil
posts(:welcome).tagging(true)
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)
226 old_count
= Tagging
.count
228 assert_equal old_count
, Tagging
.count
229 assert_nil
posts(:welcome).tagging(true)
232 def test_has_many_with_piggyback
233 assert_equal
"2", categories(:sti_test).authors
.first
.post_id
.to_s
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
}
245 def test_include_polymorphic_has_one
246 post
= Post
.find_by_id(posts(:welcome).id
, :include => :tagging)
247 tagging
= taggings(:welcome_general)
249 assert_equal tagging
, post
.tagging
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)
257 assert_equal tagging
, item
.tagging
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
}
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
}
279 def test_has_many_find_all
280 assert_equal
[categories(:general)], authors(:david).categories
.find(:all)
283 def test_has_many_find_first
284 assert_equal
categories(:general), authors(:david).categories
.find(:first)
287 def test_has_many_with_hash_conditions
288 assert_equal
categories(:general), authors(:david).categories_like_general
.find(:first)
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'")
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')
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
}
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
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"
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]
324 assert
posts(:welcome, :reload)[:taggings_count].zero
?
327 def test_unavailable_through_reflection
328 assert_raise(ActiveRecord
::HasManyThroughAssociationNotFoundError) { authors(:david).nothings
}
331 def test_has_many_through_join_model_with_conditions
332 assert_equal
[], posts(:welcome).invalid_taggings
333 assert_equal
[], posts(:welcome).invalid_tags
336 def test_has_many_polymorphic
337 assert_raise ActiveRecord
::HasManyThroughAssociationPolymorphicError do
338 assert_equal
posts(:welcome, :thinking), tags(:general).taggables
340 assert_raise ActiveRecord
::EagerLoadPolymorphicError do
341 assert_equal
posts(:welcome, :thinking), tags(:general).taggings
.find(:all, :include => :taggable, :conditions => 'bogus_table.column = 1')
345 def test_has_many_polymorphic_with_source_type
346 assert_equal
posts(:welcome, :thinking), tags(:general).tagged_posts
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)
353 assert_equal desired
, tag_with_include
.tagged_posts
355 assert_equal
5, tag_with_include
.taggings
.length
358 def test_has_many_through_has_many_find_all
359 assert_equal
comments(:greetings), authors(:david).comments
.find(:all, :order => 'comments.id').first
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
366 def test_has_many_through_has_many_find_first
367 assert_equal
comments(:greetings), authors(:david).comments
.find(:first, :order => 'comments.id')
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
)
375 def test_has_many_through_has_many_find_by_id
376 assert_equal
comments(:more_greetings), authors(:david).comments
.find(2)
379 def test_has_many_through_polymorphic_has_one
380 assert_raise(ActiveRecord
::HasManyThroughSourceAssociationMacroError) { authors(:david).tagging
}
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
}
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)
391 assert_equal expected_taggings
, author
.taggings
.uniq
.sort_by
{ |t
| t
.id
}
395 def test_has_many_through_has_many_through
396 assert_raise(ActiveRecord
::HasManyThroughSourceAssociationMacroError) { authors(:david).tags
}
399 def test_has_many_through_habtm
400 assert_raise(ActiveRecord
::HasManyThroughSourceAssociationMacroError) { authors(:david).post_categories
}
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
407 assert_equal
[1,2,3,5,6,7,8,9,10], author
.comments
.collect(&:id)
411 def test_eager_load_has_many_through_has_many_with_conditions
412 post
= Post
.find(:first, :include => :invalid_tags)
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)
425 def test_self_referential_has_many_through
426 assert_equal
[authors(:mary)], authors(:david).favorite_authors
427 assert_equal
[], authors(:mary).favorite_authors
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
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
?
442 def test_has_many_through_uses_correct_attributes
443 assert_nil
posts(:thinking).tags
.find_by_name("General").attributes
["tag_id"]
446 def test_associating_unsaved_records_with_has_many_through
447 saved_post
= posts(:thinking)
448 new_tag
= Tag
.new(:name => "new")
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
)
455 assert
!new_tag
.new_record
?
456 assert saved_post
.reload
.tags(true).include?(new_tag
)
459 new_post
= Post
.new(:title => "Association replacmenet works!", :body => "You best believe it.")
460 saved_tag
= tags(:general)
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
)
468 assert
!new_post
.new_record
?
469 assert new_post
.reload
.tags(true).include?(saved_tag
)
471 assert
posts(:thinking).tags
.build
.new_record
?
472 assert
posts(:thinking).tags
.new
.new_record
?
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
)
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
)
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
)
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) }
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
?
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
?
522 def test_adding_junk_to_has_many_through_should_raise_type_mismatch
523 assert_raise(ActiveRecord
::AssociationTypeMismatch) { posts(:thinking).tags
<< "Uhh what now?" }
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))
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
)
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
)
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
)
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
)
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
)
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
)
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?") }
581 def test_has_many_through_sum_uses_calculations
582 assert_nothing_raised
{ authors(:david).comments
.sum(:post_id) }
585 def test_calculations_on_has_many_through_should_disambiguate_fields
586 assert_nothing_raised
{ authors(:david).categories
.maximum(:id) }
589 def test_calculations_on_has_many_through_should_not_disambiguate_fields_unless_necessary
590 assert_nothing_raised
{ authors(:david).categories
.maximum("categories.id") }
593 def test_has_many_through_has_many_with_sti
594 assert_equal
[comments(:does_it_hurt)], authors(:david).special_post_comments
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)
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))
610 def test_polymorphic_has_one
611 expected
= posts(:welcome)
613 tagging
= Tagging
.find(taggings(:welcome_general).id
, :include => :taggable)
614 assert_no_queries
{ assert_equal expected
, tagging
.taggable
}
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
}
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
}
631 def test_preload_polymorph_many_types
632 taggings
= Tagging
.find
:all, :include => :taggable, :conditions => ['taggable_type != ?', 'FakeModel']
634 taggings
.first
.taggable
.id
635 taggings
[1].taggable
.id
638 taggables
= taggings
.map(&:taggable)
639 assert taggables
.include?(items(:dvd))
640 assert taggables
.include?(posts(:welcome))
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'])
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
}
658 def test_belongs_to_shared_parent
659 comments
= Comment
.find(:all, :include => :post, :conditions => 'post_id = 1')
661 assert_equal comments
.first
.post
, comments
[1].post
665 def test_has_many_through_include_uses_array_include_after_loaded
666 david
= authors(:david)
667 david
.categories
.class # force load target
669 category
= david
.categories
.first
672 assert david
.categories
.loaded
?
673 assert david
.categories
.include?(category
)
677 def test_has_many_through_include_checks_if_record_exists_if_target_not_loaded
678 david
= authors(:david)
679 category
= david
.categories
.first
682 assert
! david
.categories
.loaded
?
684 assert david
.categories
.include?(category
)
686 assert
! david
.categories
.loaded
?
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')
693 assert
! david
.categories
.loaded
?
694 assert
! david
.categories
.include?(category
)
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')
701 assert_equal
[9, 10, new_comment
.id
], authors(:david).sti_post_comments
.map(&:id).sort
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
)