← Back to branch summary

~michaelforrest/use-case-mapper/trunk

« back to all changes in this revision

Viewing changes to vendor/rails/activerecord/test/cases/associations/join_model_test.rb

  • Committer: Michael Forrest
  • Date: 2010-10-15 16:28:50 UTC
  • Revision ID: michael.forrest@canonical.com-20101015162850-tj2vchanv0kr0dun
refroze gems

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 1, posts(:welcome)[:taggings_count]
 
321
    tagging = posts(:welcome).taggings.create(:tag => tags(:general))
 
322
    assert_equal 2, posts(:welcome, :reload)[:taggings_count]
 
323
    tagging.destroy
 
324
    assert_equal 1, posts(:welcome, :reload)[:taggings_count]
 
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_equal Tagging.find(1,2).sort_by { |t| t.id }, 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