2 require 'models/developer'
3 require 'models/project'
4 require 'models/company'
7 require 'models/computer'
8 require 'models/customer'
10 require 'models/categorization'
11 require 'models/category'
13 require 'models/author'
14 require 'models/comment'
16 require 'models/tagging'
17 require 'models/person'
18 require 'models/reader'
19 require 'models/parrot'
20 require 'models/pirate'
21 require 'models/treasure'
22 require 'models/price_estimate'
24 require 'models/member'
25 require 'models/membership'
26 require 'models/sponsor'
28 class ProjectWithAfterCreateHook
< ActiveRecord
::Base
29 set_table_name
'projects'
30 has_and_belongs_to_many
:developers,
31 :class_name => "DeveloperForProjectWithAfterCreateHook",
32 :join_table => "developers_projects",
33 :foreign_key => "project_id",
34 :association_foreign_key => "developer_id"
36 after_create
:add_david
39 david
= DeveloperForProjectWithAfterCreateHook
.find_by_name('David')
40 david
.projects
<< self
44 class DeveloperForProjectWithAfterCreateHook
< ActiveRecord
::Base
45 set_table_name
'developers'
46 has_and_belongs_to_many
:projects,
47 :class_name => "ProjectWithAfterCreateHook",
48 :join_table => "developers_projects",
49 :association_foreign_key => "project_id",
50 :foreign_key => "developer_id"
53 class ProjectWithSymbolsForKeys
< ActiveRecord
::Base
54 set_table_name
'projects'
55 has_and_belongs_to_many
:developers,
56 :class_name => "DeveloperWithSymbolsForKeys",
57 :join_table => :developers_projects,
58 :foreign_key => :project_id,
59 :association_foreign_key => "developer_id"
62 class DeveloperWithSymbolsForKeys
< ActiveRecord
::Base
63 set_table_name
'developers'
64 has_and_belongs_to_many
:projects,
65 :class_name => "ProjectWithSymbolsForKeys",
66 :join_table => :developers_projects,
67 :association_foreign_key => :project_id,
68 :foreign_key => "developer_id"
71 class DeveloperWithCounterSQL
< ActiveRecord
::Base
72 set_table_name
'developers'
73 has_and_belongs_to_many
:projects,
74 :class_name => "DeveloperWithCounterSQL",
75 :join_table => "developers_projects",
76 :association_foreign_key => "project_id",
77 :foreign_key => "developer_id",
78 :counter_sql => 'SELECT COUNT(*) AS count_all FROM projects INNER JOIN developers_projects ON projects.id = developers_projects.project_id WHERE developers_projects.developer_id =#{id}'
81 class HasAndBelongsToManyAssociationsTest
< ActiveRecord
::TestCase
82 fixtures
:accounts, :companies, :categories, :posts, :categories_posts, :developers, :projects, :developers_projects,
83 :parrots, :pirates, :treasures, :price_estimates, :tags, :taggings
85 def test_has_and_belongs_to_many
86 david
= Developer
.find(1)
88 assert
!david
.projects
.empty
?
89 assert_equal
2, david
.projects
.size
91 active_record
= Project
.find(1)
92 assert
!active_record
.developers
.empty
?
93 assert_equal
3, active_record
.developers
.size
94 assert active_record
.developers
.include?(david
)
97 def test_triple_equality
98 assert
!(Array
=== Developer
.find(1).projects
)
99 assert Developer
.find(1).projects
=== Array
102 def test_adding_single
103 jamis
= Developer
.find(2)
104 jamis
.projects
.reload
# causing the collection to load
105 action_controller
= Project
.find(2)
106 assert_equal
1, jamis
.projects
.size
107 assert_equal
1, action_controller
.developers
.size
109 jamis
.projects
<< action_controller
111 assert_equal
2, jamis
.projects
.size
112 assert_equal
2, jamis
.projects(true).size
113 assert_equal
2, action_controller
.developers(true).size
116 def test_adding_type_mismatch
117 jamis
= Developer
.find(2)
118 assert_raise(ActiveRecord
::AssociationTypeMismatch) { jamis
.projects
<< nil }
119 assert_raise(ActiveRecord
::AssociationTypeMismatch) { jamis
.projects
<< 1 }
122 def test_adding_from_the_project
123 jamis
= Developer
.find(2)
124 action_controller
= Project
.find(2)
125 action_controller
.developers
.reload
126 assert_equal
1, jamis
.projects
.size
127 assert_equal
1, action_controller
.developers
.size
129 action_controller
.developers
<< jamis
131 assert_equal
2, jamis
.projects(true).size
132 assert_equal
2, action_controller
.developers
.size
133 assert_equal
2, action_controller
.developers(true).size
136 def test_adding_from_the_project_fixed_timestamp
137 jamis
= Developer
.find(2)
138 action_controller
= Project
.find(2)
139 action_controller
.developers
.reload
140 assert_equal
1, jamis
.projects
.size
141 assert_equal
1, action_controller
.developers
.size
142 updated_at
= jamis
.updated_at
144 action_controller
.developers
<< jamis
146 assert_equal updated_at
, jamis
.updated_at
147 assert_equal
2, jamis
.projects(true).size
148 assert_equal
2, action_controller
.developers
.size
149 assert_equal
2, action_controller
.developers(true).size
152 def test_adding_multiple
153 aredridel
= Developer
.new("name" => "Aredridel")
155 aredridel
.projects
.reload
156 aredridel
.projects
.push(Project
.find(1), Project
.find(2))
157 assert_equal
2, aredridel
.projects
.size
158 assert_equal
2, aredridel
.projects(true).size
161 def test_adding_a_collection
162 aredridel
= Developer
.new("name" => "Aredridel")
164 aredridel
.projects
.reload
165 aredridel
.projects
.concat([Project
.find(1), Project
.find(2)])
166 assert_equal
2, aredridel
.projects
.size
167 assert_equal
2, aredridel
.projects(true).size
170 def test_adding_uses_default_values_on_join_table
171 ac
= projects(:action_controller)
172 assert
!developers(:jamis).projects
.include?(ac
)
173 developers(:jamis).projects
<< ac
175 assert
developers(:jamis, :reload).projects
.include?(ac
)
176 project
= developers(:jamis).projects
.detect
{ |p
| p
== ac
}
177 assert_equal
1, project
.access_level
.to_i
180 def test_habtm_attribute_access_and_respond_to
181 project
= developers(:jamis).projects
[0]
182 assert project
.has_attribute
?("name")
183 assert project
.has_attribute
?("joined_on")
184 assert project
.has_attribute
?("access_level")
185 assert project
.respond_to
?("name")
186 assert project
.respond_to
?("name=")
187 assert project
.respond_to
?("name?")
188 assert project
.respond_to
?("joined_on")
189 # given that the 'join attribute' won't be persisted, I don't
190 # think we should define the mutators
191 #assert project.respond_to?("joined_on=")
192 assert project
.respond_to
?("joined_on?")
193 assert project
.respond_to
?("access_level")
194 #assert project.respond_to?("access_level=")
195 assert project
.respond_to
?("access_level?")
198 def test_habtm_adding_before_save
199 no_of_devels
= Developer
.count
200 no_of_projects
= Project
.count
201 aredridel
= Developer
.new("name" => "Aredridel")
202 aredridel
.projects
.concat([Project
.find(1), p
= Project
.new("name" => "Projekt")])
203 assert aredridel
.new_record
?
205 assert aredridel
.save
206 assert
!aredridel
.new_record
?
207 assert_equal no_of_devels
+1, Developer
.count
208 assert_equal no_of_projects
+1, Project
.count
209 assert_equal
2, aredridel
.projects
.size
210 assert_equal
2, aredridel
.projects(true).size
213 def test_habtm_saving_multiple_relationships
214 new_project
= Project
.new("name" => "Grimetime")
215 amount_of_developers
= 4
216 developers
= (0...amount_of_developers
).collect
{|i
| Developer
.create(:name => "JME #{i}") }.reverse
218 new_project
.developer_ids
= [developers
[0].id
, developers
[1].id
]
219 new_project
.developers_with_callback_ids
= [developers
[2].id
, developers
[3].id
]
220 assert new_project
.save
223 assert_equal amount_of_developers
, new_project
.developers
.size
224 assert_equal developers
, new_project
.developers
227 def test_habtm_unique_order_preserved
228 assert_equal
developers(:poor_jamis, :jamis, :david), projects(:active_record).non_unique_developers
229 assert_equal
developers(:poor_jamis, :jamis, :david), projects(:active_record).developers
233 devel
= Developer
.find(1)
234 proj
= assert_no_queries
{ devel
.projects
.build("name" => "Projekt") }
235 assert
!devel
.projects
.loaded
?
237 assert_equal devel
.projects
.last
, proj
238 assert devel
.projects
.loaded
?
240 assert proj
.new_record
?
242 assert
!proj
.new_record
?
243 assert_equal devel
.projects
.last
, proj
244 assert_equal Developer
.find(1).projects
.sort_by(&:id).last
, proj
# prove join table is updated
247 def test_build_by_new_record
248 devel
= Developer
.new(:name => "Marcel", :salary => 75000)
249 proj1
= devel
.projects
.build(:name => "Make bed")
250 proj2
= devel
.projects
.build(:name => "Lie in it")
251 assert_equal devel
.projects
.last
, proj2
252 assert proj2
.new_record
?
254 assert
!devel
.new_record
?
255 assert
!proj2
.new_record
?
256 assert_equal devel
.projects
.last
, proj2
257 assert_equal Developer
.find_by_name("Marcel").projects
.last
, proj2
# prove join table is updated
261 devel
= Developer
.find(1)
262 proj
= devel
.projects
.create("name" => "Projekt")
263 assert
!devel
.projects
.loaded
?
265 assert_equal devel
.projects
.last
, proj
266 assert
!devel
.projects
.loaded
?
268 assert
!proj
.new_record
?
269 assert_equal Developer
.find(1).projects
.sort_by(&:id).last
, proj
# prove join table is updated
272 def test_create_by_new_record
273 devel
= Developer
.new(:name => "Marcel", :salary => 75000)
274 proj1
= devel
.projects
.build(:name => "Make bed")
275 proj2
= devel
.projects
.build(:name => "Lie in it")
276 assert_equal devel
.projects
.last
, proj2
277 assert proj2
.new_record
?
279 assert
!devel
.new_record
?
280 assert
!proj2
.new_record
?
281 assert_equal devel
.projects
.last
, proj2
282 assert_equal Developer
.find_by_name("Marcel").projects
.last
, proj2
# prove join table is updated
285 def test_creation_respects_hash_condition
286 post
= categories(:general).post_with_conditions
.build(:body => '')
289 assert_equal
'Yet Another Testing Title', post
.title
291 another_post
= categories(:general).post_with_conditions
.create(:body => '')
293 assert
!another_post
.new_record
?
294 assert_equal
'Yet Another Testing Title', another_post
.title
297 def test_uniq_after_the_fact
298 dev
= developers(:jamis)
299 dev
.projects
<< projects(:active_record)
300 dev
.projects
<< projects(:active_record)
302 assert_equal
3, dev
.projects
.size
303 assert_equal
1, dev
.projects
.uniq
.size
306 def test_uniq_before_the_fact
307 projects(:active_record).developers
<< developers(:jamis)
308 projects(:active_record).developers
<< developers(:david)
309 assert_equal
3, projects(:active_record, :reload).developers
.size
312 def test_uniq_option_prevents_duplicate_push
313 project
= projects(:active_record)
314 project
.developers
<< developers(:jamis)
315 project
.developers
<< developers(:david)
316 assert_equal
3, project
.developers
.size
318 project
.developers
<< developers(:david)
319 project
.developers
<< developers(:jamis)
320 assert_equal
3, project
.developers
.size
324 david
= Developer
.find(1)
325 active_record
= Project
.find(1)
326 david
.projects
.reload
327 assert_equal
2, david
.projects
.size
328 assert_equal
3, active_record
.developers
.size
330 david
.projects
.delete(active_record
)
332 assert_equal
1, david
.projects
.size
333 assert_equal
1, david
.projects(true).size
334 assert_equal
2, active_record
.developers(true).size
337 def test_deleting_array
338 david
= Developer
.find(1)
339 david
.projects
.reload
340 david
.projects
.delete(Project
.find(:all))
341 assert_equal
0, david
.projects
.size
342 assert_equal
0, david
.projects(true).size
345 def test_deleting_with_sql
346 david
= Developer
.find(1)
347 active_record
= Project
.find(1)
348 active_record
.developers
.reload
349 assert_equal
3, active_record
.developers_by_sql
.size
351 active_record
.developers_by_sql
.delete(david
)
352 assert_equal
2, active_record
.developers_by_sql(true).size
355 def test_deleting_array_with_sql
356 active_record
= Project
.find(1)
357 active_record
.developers
.reload
358 assert_equal
3, active_record
.developers_by_sql
.size
360 active_record
.developers_by_sql
.delete(Developer
.find(:all))
361 assert_equal
0, active_record
.developers_by_sql(true).size
364 def test_deleting_all
365 david
= Developer
.find(1)
366 david
.projects
.reload
368 assert_equal
0, david
.projects
.size
369 assert_equal
0, david
.projects(true).size
372 def test_removing_associations_on_destroy
373 david
= DeveloperWithBeforeDestroyRaise
.find(1)
374 assert
!david
.projects
.empty
?
375 assert_nothing_raised
{ david
.destroy
}
376 assert david
.projects
.empty
?
377 assert DeveloperWithBeforeDestroyRaise
.connection
.select_all("SELECT * FROM developers_projects WHERE developer_id = 1").empty
?
380 def test_additional_columns_from_join_table
381 assert_date_from_db Date
.new(2004, 10, 10), Developer
.find(1).projects
.first
.joined_on
.to_date
385 david
= Developer
.find(1)
386 david
.projects
.reload
387 assert
!david
.projects
.empty
?
388 david
.projects
.destroy_all
389 assert david
.projects
.empty
?
390 assert david
.projects(true).empty
?
393 def test_deprecated_push_with_attributes_was_removed
394 jamis
= developers(:jamis)
395 assert_raise(NoMethodError
) do
396 jamis
.projects
.push_with_attributes(projects(:action_controller), :joined_on => Date
.today
)
400 def test_associations_with_conditions
401 assert_equal
3, projects(:active_record).developers
.size
402 assert_equal
1, projects(:active_record).developers_named_david
.size
403 assert_equal
1, projects(:active_record).developers_named_david_with_hash_conditions
.size
405 assert_equal
developers(:david), projects(:active_record).developers_named_david
.find(developers(:david).id
)
406 assert_equal
developers(:david), projects(:active_record).developers_named_david_with_hash_conditions
.find(developers(:david).id
)
407 assert_equal
developers(:david), projects(:active_record).salaried_developers
.find(developers(:david).id
)
409 projects(:active_record).developers_named_david
.clear
410 assert_equal
2, projects(:active_record, :reload).developers
.size
413 def test_find_in_association
415 assert_equal
developers(:david), projects(:active_record).developers
.find(developers(:david).id
), "SQL find"
418 active_record
= projects(:active_record)
419 active_record
.developers
.reload
420 assert_equal
developers(:david), active_record
.developers
.find(developers(:david).id
), "Ruby find"
423 def test_include_uses_array_include_after_loaded
424 project
= projects(:active_record)
425 project
.developers
.class # force load target
427 developer
= project
.developers
.first
430 assert project
.developers
.loaded
?
431 assert project
.developers
.include?(developer
)
435 def test_include_checks_if_record_exists_if_target_not_loaded
436 project
= projects(:active_record)
437 developer
= project
.developers
.first
440 assert
! project
.developers
.loaded
?
442 assert project
.developers
.include?(developer
)
444 assert
! project
.developers
.loaded
?
447 def test_include_returns_false_for_non_matching_record_to_verify_scoping
448 project
= projects(:active_record)
449 developer
= Developer
.create
:name => "Bryan", :salary => 50_000
451 assert
! project
.developers
.loaded
?
452 assert
! project
.developers
.include?(developer
)
455 def test_find_in_association_with_custom_finder_sql
456 assert_equal
developers(:david), projects(:active_record).developers_with_finder_sql
.find(developers(:david).id
), "SQL find"
458 active_record
= projects(:active_record)
459 active_record
.developers_with_finder_sql
.reload
460 assert_equal
developers(:david), active_record
.developers_with_finder_sql
.find(developers(:david).id
), "Ruby find"
463 def test_find_in_association_with_custom_finder_sql_and_multiple_interpolations
465 assert_equal
[developers(:david), developers(:jamis), developers(:poor_jamis)], projects(:active_record).developers_with_finder_sql
, "first interpolation"
466 # interpolate again, for a different project id
467 assert_equal
[developers(:david)], projects(:action_controller).developers_with_finder_sql
, "second interpolation"
470 def test_find_in_association_with_custom_finder_sql_and_string_id
471 assert_equal
developers(:david), projects(:active_record).developers_with_finder_sql
.find(developers(:david).id
.to_s
), "SQL find"
474 def test_find_with_merged_options
475 assert_equal
1, projects(:active_record).limited_developers
.size
476 assert_equal
1, projects(:active_record).limited_developers
.find(:all).size
477 assert_equal
3, projects(:active_record).limited_developers
.find(:all, :limit => nil).size
480 def test_dynamic_find_should_respect_association_order
481 # Developers are ordered 'name DESC, id DESC'
482 low_id_jamis
= developers(:jamis)
483 middle_id_jamis
= developers(:poor_jamis)
484 high_id_jamis
= projects(:active_record).developers
.create(:name => 'Jamis')
486 assert_equal high_id_jamis
, projects(:active_record).developers
.find(:first, :conditions => "name = 'Jamis'")
487 assert_equal high_id_jamis
, projects(:active_record).developers
.find_by_name('Jamis')
490 def test_dynamic_find_order_should_override_association_order
491 # Developers are ordered 'name DESC, id DESC'
492 low_id_jamis
= developers(:jamis)
493 middle_id_jamis
= developers(:poor_jamis)
494 high_id_jamis
= projects(:active_record).developers
.create(:name => 'Jamis')
496 assert_equal low_id_jamis
, projects(:active_record).developers
.find(:first, :conditions => "name = 'Jamis'", :order => 'id')
497 assert_equal low_id_jamis
, projects(:active_record).developers
.find_by_name('Jamis', :order => 'id')
500 def test_dynamic_find_all_should_respect_association_order
501 # Developers are ordered 'name DESC, id DESC'
502 low_id_jamis
= developers(:jamis)
503 middle_id_jamis
= developers(:poor_jamis)
504 high_id_jamis
= projects(:active_record).developers
.create(:name => 'Jamis')
506 assert_equal
[high_id_jamis
, middle_id_jamis
, low_id_jamis
], projects(:active_record).developers
.find(:all, :conditions => "name = 'Jamis'")
507 assert_equal
[high_id_jamis
, middle_id_jamis
, low_id_jamis
], projects(:active_record).developers
.find_all_by_name('Jamis')
510 def test_dynamic_find_all_order_should_override_association_order
511 # Developers are ordered 'name DESC, id DESC'
512 low_id_jamis
= developers(:jamis)
513 middle_id_jamis
= developers(:poor_jamis)
514 high_id_jamis
= projects(:active_record).developers
.create(:name => 'Jamis')
516 assert_equal
[low_id_jamis
, middle_id_jamis
, high_id_jamis
], projects(:active_record).developers
.find(:all, :conditions => "name = 'Jamis'", :order => 'id')
517 assert_equal
[low_id_jamis
, middle_id_jamis
, high_id_jamis
], projects(:active_record).developers
.find_all_by_name('Jamis', :order => 'id')
520 def test_dynamic_find_all_should_respect_association_limit
521 assert_equal
1, projects(:active_record).limited_developers
.find(:all, :conditions => "name = 'Jamis'").length
522 assert_equal
1, projects(:active_record).limited_developers
.find_all_by_name('Jamis').length
525 def test_dynamic_find_all_order_should_override_association_limit
526 assert_equal
2, projects(:active_record).limited_developers
.find(:all, :conditions => "name = 'Jamis'", :limit => 9_000).length
527 assert_equal
2, projects(:active_record).limited_developers
.find_all_by_name('Jamis', :limit => 9_000).length
530 def test_dynamic_find_all_should_respect_readonly_access
531 projects(:active_record).readonly_developers
.each
{ |d
| assert_raise(ActiveRecord
::ReadOnlyRecord) { d
.save
! } if d
.valid
?}
532 projects(:active_record).readonly_developers
.each
{ |d
| d
.readonly
? }
535 def test_new_with_values_in_collection
536 jamis
= DeveloperForProjectWithAfterCreateHook
.find_by_name('Jamis')
537 david
= DeveloperForProjectWithAfterCreateHook
.find_by_name('David')
538 project
= ProjectWithAfterCreateHook
.new(:name => "Cooking with Bertie")
539 project
.developers
<< jamis
543 assert project
.developers
.include?(jamis
)
544 assert project
.developers
.include?(david
)
547 def test_find_in_association_with_options
548 developers
= projects(:active_record).developers
.find(:all)
549 assert_equal
3, developers
.size
551 assert_equal
developers(:poor_jamis), projects(:active_record).developers
.find(:first, :conditions => "salary < 10000")
552 assert_equal
developers(:jamis), projects(:active_record).developers
.find(:first, :order => "salary DESC")
555 def test_replace_with_less
556 david
= developers(:david)
557 david
.projects
= [projects(:action_controller)]
559 assert_equal
1, david
.projects
.length
562 def test_replace_with_new
563 david
= developers(:david)
564 david
.projects
= [projects(:action_controller), Project
.new("name" => "ActionWebSearch")]
566 assert_equal
2, david
.projects
.length
567 assert
!david
.projects
.include?(projects(:active_record))
570 def test_replace_on_new_object
571 new_developer
= Developer
.new("name" => "Matz")
572 new_developer
.projects
= [projects(:action_controller), Project
.new("name" => "ActionWebSearch")]
574 assert_equal
2, new_developer
.projects
.length
577 def test_consider_type
578 developer
= Developer
.find(:first)
579 special_project
= SpecialProject
.create("name" => "Special Project")
581 other_project
= developer
.projects
.first
582 developer
.special_projects
<< special_project
585 assert developer
.projects
.include?(special_project
)
586 assert developer
.special_projects
.include?(special_project
)
587 assert
!developer
.special_projects
.include?(other_project
)
590 def test_update_attributes_after_push_without_duplicate_join_table_rows
591 developer
= Developer
.new("name" => "Kano")
592 project
= SpecialProject
.create("name" => "Special Project")
593 assert developer
.save
594 developer
.projects
<< project
595 developer
.update_attribute("name", "Bruza")
596 assert_equal
1, Developer
.connection
.select_value(<<-end_sql).to_i
597 SELECT count(*) FROM developers_projects
598 WHERE project_id = #{project.id}
599 AND developer_id = #{developer.id}
603 def test_updating_attributes_on_non_rich_associations
604 welcome
= categories(:technology).posts
.first
605 welcome
.title
= "Something else"
609 def test_habtm_respects_select
610 categories(:technology).select_testing_posts(true).each
do |o
|
611 assert_respond_to o
, :correctness_marker
613 assert_respond_to
categories(:technology).select_testing_posts
.find(:first), :correctness_marker
616 def test_updating_attributes_on_rich_associations
617 david
= projects(:action_controller).developers
.first
619 assert_raises(ActiveRecord
::ReadOnlyRecord) { david
.save
! }
622 def test_updating_attributes_on_rich_associations_with_limited_find_from_reflection
623 david
= projects(:action_controller).selected_developers
.first
625 assert_nothing_raised
{ david
.save
! }
629 def test_updating_attributes_on_rich_associations_with_limited_find
630 david
= projects(:action_controller).developers
.find(:all, :select => "developers.*").first
635 def test_join_table_alias
636 assert_equal
3, Developer
.find(:all, :include => {:projects => :developers}, :conditions => 'developers_projects_join.joined_on IS NOT NULL').size
639 def test_join_with_group
640 group
= Developer
.columns
.inject([]) do |g
, c
|
641 g
<< "developers.#{c.name}"
642 g
<< "developers_projects_2.#{c.name}"
644 Project
.columns
.each
{ |c
| group
<< "projects.#{c.name}" }
646 assert_equal
3, Developer
.find(:all, :include => {:projects => :developers}, :conditions => 'developers_projects_join.joined_on IS NOT NULL', :group => group
.join(",")).size
649 def test_find_grouped
650 all_posts_from_category1
= Post
.find(:all, :conditions => "category_id = 1", :joins => :categories)
651 grouped_posts_of_category1
= Post
.find(:all, :conditions => "category_id = 1", :group => "author_id", :select => 'count(posts.id) as posts_count', :joins => :categories)
652 assert_equal
4, all_posts_from_category1
.size
653 assert_equal
1, grouped_posts_of_category1
.size
656 def test_find_scoped_grouped
657 assert_equal
4, categories(:general).posts_gruoped_by_title
.size
658 assert_equal
1, categories(:technology).posts_gruoped_by_title
.size
662 assert_equal
projects(:active_record, :action_controller).map(&:id).sort
, developers(:david).project_ids
.sort
663 assert_equal
[projects(:active_record).id
], developers(:jamis).project_ids
666 def test_get_ids_for_loaded_associations
667 developer
= developers(:david)
668 developer
.projects(true)
670 developer
.project_ids
671 developer
.project_ids
675 def test_get_ids_for_unloaded_associations_does_not_load_them
676 developer
= developers(:david)
677 assert
!developer
.projects
.loaded
?
678 assert_equal
projects(:active_record, :action_controller).map(&:id).sort
, developer
.project_ids
.sort
679 assert
!developer
.projects
.loaded
?
683 developer
= Developer
.new("name" => "Joe")
684 developer
.project_ids
= projects(:active_record, :action_controller).map(&:id)
687 assert_equal
2, developer
.projects
.length
688 assert_equal
[projects(:active_record), projects(:action_controller)].map(&:id).sort
, developer
.project_ids
.sort
691 def test_assign_ids_ignoring_blanks
692 developer
= Developer
.new("name" => "Joe")
693 developer
.project_ids
= [projects(:active_record).id
, nil, projects(:action_controller).id
, '']
696 assert_equal
2, developer
.projects
.length
697 assert_equal
[projects(:active_record), projects(:action_controller)].map(&:id).sort
, developer
.project_ids
.sort
700 def test_select_limited_ids_list
702 Developer
.transaction
do
703 Developer
.find(:all, :order => 'id').each_with_index
do |record
, i
|
704 record
.update_attributes(:created_at => 5.years
.ago
+ (i
* 5.minutes
))
708 join_base
= ActiveRecord
::Associations::ClassMethods::JoinDependency::JoinBase.new(Project
)
709 join_dep
= ActiveRecord
::Associations::ClassMethods::JoinDependency.new(join_base
, :developers, nil)
710 projects
= Project
.send(:select_limited_ids_list, {:order => 'developers.created_at'}, join_dep
)
711 assert
!projects
.include?("'"), projects
712 assert_equal
%w(1 2), projects
.scan(/\d/).sort
715 def test_scoped_find_on_through_association_doesnt_return_read_only_records
716 tag
= Post
.find(1).tags
.find_by_name("General")
718 assert_nothing_raised
do
723 def test_has_many_through_polymorphic_has_manys_works
724 assert_equal
[10, 20].to_set
, pirates(:redbeard).treasure_estimates
.map(&:price).to_set
727 def test_symbols_as_keys
728 developer
= DeveloperWithSymbolsForKeys
.new(:name => 'David')
729 project
= ProjectWithSymbolsForKeys
.new(:name => 'Rails Testing')
730 project
.developers
<< developer
733 assert_equal
1, project
.developers
.size
734 assert_equal
1, developer
.projects
.size
735 assert_equal developer
, project
.developers
.find(:first)
736 assert_equal project
, developer
.projects
.find(:first)
739 def test_dynamic_find_should_respect_association_include
740 # SQL error in sort clause if :include is not included
741 # due to Unknown column 'authors.id'
742 assert Category
.find(1).posts_with_authors_sorted_by_author_id
.find_by_title('Welcome to the weblog')
745 def test_counting_on_habtm_association_and_not_array
746 david
= Developer
.find(1)
747 # Extra parameter just to make sure we aren't falling back to
748 # Array#count in Ruby >=1.8.7, which would raise an ArgumentError
749 assert_nothing_raised
{ david
.projects
.count(:all, :conditions => '1=1') }
753 david
= Developer
.find(1)
754 assert_equal
2, david
.projects
.count
757 def test_count_with_counter_sql
758 developer
= DeveloperWithCounterSQL
.create(:name => 'tekin')
759 developer
.project_ids
= [projects(:active_record).id
]
762 assert_equal
1, developer
.projects
.count
765 uses_mocha
'mocking Post.transaction' do
766 def test_association_proxy_transaction_method_starts_transaction_in_association_class
767 Post
.expects(:transaction)
768 Category
.find(:first).posts
.transaction
do