ibm_db 0.4.6 → 0.6.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,1839 @@
1
+ require 'abstract_unit'
2
+ require 'fixtures/developer'
3
+ require 'fixtures/project'
4
+ require 'fixtures/company'
5
+ require 'fixtures/topic'
6
+ require 'fixtures/reply'
7
+ require 'fixtures/computer'
8
+ require 'fixtures/customer'
9
+ require 'fixtures/order'
10
+ require 'fixtures/category'
11
+ require 'fixtures/post'
12
+ require 'fixtures/author'
13
+
14
+
15
+ class AssociationsTest < Test::Unit::TestCase
16
+ fixtures :accounts, :companies, :developers, :projects, :developers_projects,
17
+ :computers
18
+
19
+ def test_bad_collection_keys
20
+ assert_raise(ArgumentError, 'ActiveRecord should have barked on bad collection keys') do
21
+ Class.new(ActiveRecord::Base).has_many(:wheels, :name => 'wheels')
22
+ end
23
+ end
24
+
25
+ def test_force_reload
26
+ firm = Firm.new("name" => "A New Firm, Inc")
27
+ firm.save
28
+ firm.clients.each {|c|} # forcing to load all clients
29
+ assert firm.clients.empty?, "New firm shouldn't have client objects"
30
+ assert_deprecated do
31
+ assert !firm.has_clients?, "New firm shouldn't have clients"
32
+ end
33
+ assert_equal 0, firm.clients.size, "New firm should have 0 clients"
34
+
35
+ client = Client.new("name" => "TheClient.com", "firm_id" => firm.id)
36
+ client.save
37
+
38
+ assert firm.clients.empty?, "New firm should have cached no client objects"
39
+ assert_deprecated do
40
+ assert !firm.has_clients?, "New firm should have cached a no-clients response"
41
+ end
42
+ assert_equal 0, firm.clients.size, "New firm should have cached 0 clients count"
43
+
44
+ assert !firm.clients(true).empty?, "New firm should have reloaded client objects"
45
+ assert_equal 1, firm.clients(true).size, "New firm should have reloaded clients count"
46
+ end
47
+
48
+ def test_storing_in_pstore
49
+ require "tmpdir"
50
+ store_filename = File.join(Dir.tmpdir, "ar-pstore-association-test")
51
+ File.delete(store_filename) if File.exists?(store_filename)
52
+ require "pstore"
53
+ apple = Firm.create("name" => "Apple")
54
+ natural = Client.new("name" => "Natural Company")
55
+ apple.clients << natural
56
+
57
+ db = PStore.new(store_filename)
58
+ db.transaction do
59
+ db["apple"] = apple
60
+ end
61
+
62
+ db = PStore.new(store_filename)
63
+ db.transaction do
64
+ assert_equal "Natural Company", db["apple"].clients.first.name
65
+ end
66
+ end
67
+ end
68
+
69
+ class AssociationProxyTest < Test::Unit::TestCase
70
+ fixtures :authors, :posts
71
+
72
+ def test_proxy_accessors
73
+ welcome = posts(:welcome)
74
+ assert_equal welcome, welcome.author.proxy_owner
75
+ assert_equal welcome.class.reflect_on_association(:author), welcome.author.proxy_reflection
76
+ welcome.author.class # force load target
77
+ assert_equal welcome.author, welcome.author.proxy_target
78
+
79
+ david = authors(:david)
80
+ assert_equal david, david.posts.proxy_owner
81
+ assert_equal david.class.reflect_on_association(:posts), david.posts.proxy_reflection
82
+ david.posts.first # force load target
83
+ assert_equal david.posts, david.posts.proxy_target
84
+
85
+ assert_equal david, david.posts_with_extension.testing_proxy_owner
86
+ assert_equal david.class.reflect_on_association(:posts_with_extension), david.posts_with_extension.testing_proxy_reflection
87
+ david.posts_with_extension.first # force load target
88
+ assert_equal david.posts_with_extension, david.posts_with_extension.testing_proxy_target
89
+ end
90
+ end
91
+
92
+ class HasOneAssociationsTest < Test::Unit::TestCase
93
+ fixtures :accounts, :companies, :developers, :projects, :developers_projects
94
+
95
+ def setup
96
+ Account.destroyed_account_ids.clear
97
+ end
98
+
99
+ def test_has_one
100
+ assert_equal companies(:first_firm).account, Account.find(1)
101
+ assert_equal Account.find(1).credit_limit, companies(:first_firm).account.credit_limit
102
+ end
103
+
104
+ def test_has_one_cache_nils
105
+ firm = companies(:another_firm)
106
+ assert_queries(1) { assert_nil firm.account }
107
+ assert_queries(0) { assert_nil firm.account }
108
+
109
+ firms = Firm.find(:all, :include => :account)
110
+ assert_queries(0) { firms.each(&:account) }
111
+ end
112
+
113
+ def test_can_marshal_has_one_association_with_nil_target
114
+ firm = Firm.new
115
+ assert_nothing_raised do
116
+ assert_equal firm.attributes, Marshal.load(Marshal.dump(firm)).attributes
117
+ end
118
+
119
+ firm.account
120
+ assert_nothing_raised do
121
+ assert_equal firm.attributes, Marshal.load(Marshal.dump(firm)).attributes
122
+ end
123
+ end
124
+
125
+ def test_proxy_assignment
126
+ company = companies(:first_firm)
127
+ assert_nothing_raised { company.account = company.account }
128
+ end
129
+
130
+ def test_triple_equality
131
+ assert Account === companies(:first_firm).account
132
+ assert companies(:first_firm).account === Account
133
+ end
134
+
135
+ def test_type_mismatch
136
+ assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).account = 1 }
137
+ assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).account = Project.find(1) }
138
+ end
139
+
140
+ def test_natural_assignment
141
+ apple = Firm.create("name" => "Apple")
142
+ citibank = Account.create("credit_limit" => 10)
143
+ apple.account = citibank
144
+ assert_equal apple.id, citibank.firm_id
145
+ end
146
+
147
+ def test_natural_assignment_to_nil
148
+ old_account_id = companies(:first_firm).account.id
149
+ companies(:first_firm).account = nil
150
+ companies(:first_firm).save
151
+ assert_nil companies(:first_firm).account
152
+ # account is dependent, therefore is destroyed when reference to owner is lost
153
+ assert_raises(ActiveRecord::RecordNotFound) { Account.find(old_account_id) }
154
+ end
155
+
156
+ def test_assignment_without_replacement
157
+ apple = Firm.create("name" => "Apple")
158
+ citibank = Account.create("credit_limit" => 10)
159
+ apple.account = citibank
160
+ assert_equal apple.id, citibank.firm_id
161
+
162
+ hsbc = apple.build_account({ :credit_limit => 20}, false)
163
+ assert_equal apple.id, hsbc.firm_id
164
+ hsbc.save
165
+ assert_equal apple.id, citibank.firm_id
166
+
167
+ nykredit = apple.create_account({ :credit_limit => 30}, false)
168
+ assert_equal apple.id, nykredit.firm_id
169
+ assert_equal apple.id, citibank.firm_id
170
+ assert_equal apple.id, hsbc.firm_id
171
+ end
172
+
173
+ def test_assignment_without_replacement_on_create
174
+ apple = Firm.create("name" => "Apple")
175
+ citibank = Account.create("credit_limit" => 10)
176
+ apple.account = citibank
177
+ assert_equal apple.id, citibank.firm_id
178
+
179
+ hsbc = apple.create_account({:credit_limit => 10}, false)
180
+ assert_equal apple.id, hsbc.firm_id
181
+ hsbc.save
182
+ assert_equal apple.id, citibank.firm_id
183
+ end
184
+
185
+ def test_dependence
186
+ num_accounts = Account.count
187
+
188
+ firm = Firm.find(1)
189
+ assert !firm.account.nil?
190
+ account_id = firm.account.id
191
+ assert_equal [], Account.destroyed_account_ids[firm.id]
192
+
193
+ firm.destroy
194
+ assert_equal num_accounts - 1, Account.count
195
+ assert_equal [account_id], Account.destroyed_account_ids[firm.id]
196
+ end
197
+
198
+ def test_deprecated_exclusive_dependence
199
+ assert_deprecated(/:exclusively_dependent.*:dependent => :delete_all/) do
200
+ Firm.has_many :deprecated_exclusively_dependent_clients, :class_name => 'Client', :exclusively_dependent => true
201
+ end
202
+ end
203
+
204
+ def test_exclusive_dependence
205
+ num_accounts = Account.count
206
+
207
+ firm = ExclusivelyDependentFirm.find(9)
208
+ assert !firm.account.nil?
209
+ account_id = firm.account.id
210
+ assert_equal [], Account.destroyed_account_ids[firm.id]
211
+
212
+ firm.destroy
213
+ assert_equal num_accounts - 1, Account.count
214
+ assert_equal [], Account.destroyed_account_ids[firm.id]
215
+ end
216
+
217
+ def test_dependence_with_nil_associate
218
+ firm = DependentFirm.new(:name => 'nullify')
219
+ firm.save!
220
+ assert_nothing_raised { firm.destroy }
221
+ end
222
+
223
+ def test_succesful_build_association
224
+ firm = Firm.new("name" => "GlobalMegaCorp")
225
+ firm.save
226
+
227
+ account = firm.build_account("credit_limit" => 1000)
228
+ assert account.save
229
+ assert_equal account, firm.account
230
+ end
231
+
232
+ def test_failing_build_association
233
+ firm = Firm.new("name" => "GlobalMegaCorp")
234
+ firm.save
235
+
236
+ account = firm.build_account
237
+ assert !account.save
238
+ assert_equal "can't be empty", account.errors.on("credit_limit")
239
+ end
240
+
241
+ def test_build_association_twice_without_saving_affects_nothing
242
+ count_of_account = Account.count
243
+ firm = Firm.find(:first)
244
+ account1 = firm.build_account("credit_limit" => 1000)
245
+ account2 = firm.build_account("credit_limit" => 2000)
246
+
247
+ assert_equal count_of_account, Account.count
248
+ end
249
+
250
+ def test_create_association
251
+ firm = Firm.new("name" => "GlobalMegaCorp")
252
+ firm.save
253
+ assert_equal firm.create_account("credit_limit" => 1000), firm.account
254
+ end
255
+
256
+ def test_build
257
+ firm = Firm.new("name" => "GlobalMegaCorp")
258
+ firm.save
259
+
260
+ firm.account = account = Account.new("credit_limit" => 1000)
261
+ assert_equal account, firm.account
262
+ assert account.save
263
+ assert_equal account, firm.account
264
+ end
265
+
266
+ def test_build_before_child_saved
267
+ firm = Firm.find(1)
268
+
269
+ account = firm.account.build("credit_limit" => 1000)
270
+ assert_equal account, firm.account
271
+ assert account.new_record?
272
+ assert firm.save
273
+ assert_equal account, firm.account
274
+ assert !account.new_record?
275
+ end
276
+
277
+ def test_build_before_either_saved
278
+ firm = Firm.new("name" => "GlobalMegaCorp")
279
+
280
+ firm.account = account = Account.new("credit_limit" => 1000)
281
+ assert_equal account, firm.account
282
+ assert account.new_record?
283
+ assert firm.save
284
+ assert_equal account, firm.account
285
+ assert !account.new_record?
286
+ end
287
+
288
+ def test_failing_build_association
289
+ firm = Firm.new("name" => "GlobalMegaCorp")
290
+ firm.save
291
+
292
+ firm.account = account = Account.new
293
+ assert_equal account, firm.account
294
+ assert !account.save
295
+ assert_equal account, firm.account
296
+ assert_equal "can't be empty", account.errors.on("credit_limit")
297
+ end
298
+
299
+ def test_create
300
+ firm = Firm.new("name" => "GlobalMegaCorp")
301
+ firm.save
302
+ firm.account = account = Account.create("credit_limit" => 1000)
303
+ assert_equal account, firm.account
304
+ end
305
+
306
+ def test_create_before_save
307
+ firm = Firm.new("name" => "GlobalMegaCorp")
308
+ firm.account = account = Account.create("credit_limit" => 1000)
309
+ assert_equal account, firm.account
310
+ end
311
+
312
+ def test_dependence_with_missing_association
313
+ Account.destroy_all
314
+ firm = Firm.find(1)
315
+ assert firm.account.nil?
316
+ firm.destroy
317
+ end
318
+
319
+ def test_assignment_before_parent_saved
320
+ firm = Firm.new("name" => "GlobalMegaCorp")
321
+ firm.account = a = Account.find(1)
322
+ assert firm.new_record?
323
+ assert_equal a, firm.account
324
+ assert firm.save
325
+ assert_equal a, firm.account
326
+ assert_equal a, firm.account(true)
327
+ end
328
+
329
+ def test_finding_with_interpolated_condition
330
+ firm = Firm.find(:first)
331
+ superior = firm.clients.create(:name => 'SuperiorCo')
332
+ superior.rating = 10
333
+ superior.save
334
+ assert_equal 10, firm.clients_with_interpolated_conditions.first.rating
335
+ end
336
+
337
+ def test_assignment_before_child_saved
338
+ firm = Firm.find(1)
339
+ firm.account = a = Account.new("credit_limit" => 1000)
340
+ assert !a.new_record?
341
+ assert_equal a, firm.account
342
+ assert_equal a, firm.account
343
+ assert_equal a, firm.account(true)
344
+ end
345
+
346
+ def test_assignment_before_either_saved
347
+ firm = Firm.new("name" => "GlobalMegaCorp")
348
+ firm.account = a = Account.new("credit_limit" => 1000)
349
+ assert firm.new_record?
350
+ assert a.new_record?
351
+ assert_equal a, firm.account
352
+ assert firm.save
353
+ assert !firm.new_record?
354
+ assert !a.new_record?
355
+ assert_equal a, firm.account
356
+ assert_equal a, firm.account(true)
357
+ end
358
+
359
+ def test_not_resaved_when_unchanged
360
+ firm = Firm.find(:first, :include => :account)
361
+ assert_queries(1) { firm.save! }
362
+
363
+ firm = Firm.find(:first)
364
+ firm.account = Account.find(:first)
365
+ assert_queries(1) { firm.save! }
366
+
367
+ firm = Firm.find(:first).clone
368
+ firm.account = Account.find(:first)
369
+ assert_queries(2) { firm.save! }
370
+
371
+ firm = Firm.find(:first).clone
372
+ firm.account = Account.find(:first).clone
373
+ assert_queries(2) { firm.save! }
374
+ end
375
+
376
+ def test_save_still_works_after_accessing_nil_has_one
377
+ jp = Company.new :name => 'Jaded Pixel'
378
+ jp.dummy_account.nil?
379
+
380
+ assert_nothing_raised do
381
+ jp.save!
382
+ end
383
+ end
384
+
385
+ def test_deprecated_inferred_foreign_key
386
+ assert_not_deprecated { Company.belongs_to :firm }
387
+ assert_not_deprecated { Company.belongs_to :client, :foreign_key => "firm_id" }
388
+ assert_not_deprecated { Company.belongs_to :firm, :class_name => "Firm", :foreign_key => "client_of" }
389
+ assert_deprecated("inferred foreign_key name") { Company.belongs_to :client, :class_name => "Firm" }
390
+ end
391
+
392
+ end
393
+
394
+
395
+ class HasManyAssociationsTest < Test::Unit::TestCase
396
+ fixtures :accounts, :companies, :developers, :projects,
397
+ :developers_projects, :topics
398
+
399
+ def setup
400
+ Client.destroyed_client_ids.clear
401
+ end
402
+
403
+ def force_signal37_to_load_all_clients_of_firm
404
+ companies(:first_firm).clients_of_firm.each {|f| }
405
+ end
406
+
407
+ def test_counting_with_counter_sql
408
+ assert_equal 2, Firm.find(:first).clients.count
409
+ end
410
+
411
+ def test_counting
412
+ assert_equal 2, Firm.find(:first).plain_clients.count
413
+ end
414
+
415
+ def test_counting_with_single_conditions
416
+ assert_deprecated 'count' do
417
+ assert_equal 2, Firm.find(:first).plain_clients.count('1=1')
418
+ end
419
+ end
420
+
421
+ def test_counting_with_single_hash
422
+ assert_equal 2, Firm.find(:first).plain_clients.count(:conditions => '1=1')
423
+ end
424
+
425
+ def test_counting_with_column_name_and_hash
426
+ assert_equal 2, Firm.find(:first).plain_clients.count(:all, :conditions => '1=1')
427
+ end
428
+
429
+ def test_finding
430
+ assert_equal 2, Firm.find(:first).clients.length
431
+ end
432
+
433
+ def test_find_many_with_merged_options
434
+ assert_equal 1, companies(:first_firm).limited_clients.size
435
+ assert_equal 1, companies(:first_firm).limited_clients.find(:all).size
436
+ assert_equal 2, companies(:first_firm).limited_clients.find(:all, :limit => nil).size
437
+ end
438
+
439
+ def test_triple_equality
440
+ assert !(Array === Firm.find(:first).clients)
441
+ assert Firm.find(:first).clients === Array
442
+ end
443
+
444
+ def test_finding_default_orders
445
+ assert_equal "Summit", Firm.find(:first).clients.first.name
446
+ end
447
+
448
+ def test_finding_with_different_class_name_and_order
449
+ assert_equal "Microsoft", Firm.find(:first).clients_sorted_desc.first.name
450
+ end
451
+
452
+ def test_finding_with_foreign_key
453
+ assert_equal "Microsoft", Firm.find(:first).clients_of_firm.first.name
454
+ end
455
+
456
+ def test_finding_with_condition
457
+ assert_equal "Microsoft", Firm.find(:first).clients_like_ms.first.name
458
+ end
459
+
460
+ def test_finding_with_condition_hash
461
+ assert_equal "Microsoft", Firm.find(:first).clients_like_ms_with_hash_conditions.first.name
462
+ end
463
+
464
+ def test_finding_using_sql
465
+ firm = Firm.find(:first)
466
+ first_client = firm.clients_using_sql.first
467
+ assert_not_nil first_client
468
+ assert_equal "Microsoft", first_client.name
469
+ assert_equal 1, firm.clients_using_sql.size
470
+ assert_equal 1, Firm.find(:first).clients_using_sql.size
471
+ end
472
+
473
+ def test_counting_using_sql
474
+ assert_equal 1, Firm.find(:first).clients_using_counter_sql.size
475
+ assert_equal 0, Firm.find(:first).clients_using_zero_counter_sql.size
476
+ end
477
+
478
+ def test_counting_non_existant_items_using_sql
479
+ assert_equal 0, Firm.find(:first).no_clients_using_counter_sql.size
480
+ end
481
+
482
+ def test_belongs_to_sanity
483
+ c = Client.new
484
+ assert_nil c.firm
485
+
486
+ if c.firm
487
+ assert false, "belongs_to failed if check"
488
+ end
489
+
490
+ unless c.firm
491
+ else
492
+ assert false, "belongs_to failed unless check"
493
+ end
494
+ end
495
+
496
+ def test_find_ids
497
+ firm = Firm.find(:first)
498
+
499
+ assert_raises(ActiveRecord::RecordNotFound) { firm.clients.find }
500
+
501
+ client = firm.clients.find(2)
502
+ assert_kind_of Client, client
503
+
504
+ client_ary = firm.clients.find([2])
505
+ assert_kind_of Array, client_ary
506
+ assert_equal client, client_ary.first
507
+
508
+ client_ary = firm.clients.find(2, 3)
509
+ assert_kind_of Array, client_ary
510
+ assert_equal 2, client_ary.size
511
+ assert_equal client, client_ary.first
512
+
513
+ assert_raises(ActiveRecord::RecordNotFound) { firm.clients.find(2, 99) }
514
+ end
515
+
516
+ def test_find_all
517
+ assert_deprecated 'find_all' do
518
+ firm = Firm.find_first
519
+ assert_equal firm.clients, firm.clients.find_all
520
+ assert_equal 2, firm.clients.find(:all, :conditions => "#{QUOTED_TYPE} = 'Client'").length
521
+ assert_equal 1, firm.clients.find(:all, :conditions => "name = 'Summit'").length
522
+ end
523
+ end
524
+
525
+ def test_find_all_sanitized
526
+ assert_deprecated 'find_all' do
527
+ firm = Firm.find_first
528
+ assert_equal firm.clients.find_all("name = 'Summit'"), firm.clients.find_all(["name = '%s'", "Summit"])
529
+ summit = firm.clients.find(:all, :conditions => "name = 'Summit'")
530
+ assert_equal summit, firm.clients.find(:all, :conditions => ["name = ?", "Summit"])
531
+ assert_equal summit, firm.clients.find(:all, :conditions => ["name = :name", { :name => "Summit" }])
532
+ end
533
+ end
534
+
535
+ def test_find_first
536
+ assert_deprecated 'find_first' do
537
+ firm = Firm.find_first
538
+ client2 = Client.find(2)
539
+ assert_equal firm.clients.first, firm.clients.find_first
540
+ assert_equal client2, firm.clients.find_first("#{QUOTED_TYPE} = 'Client'")
541
+ assert_equal client2, firm.clients.find(:first, :conditions => "#{QUOTED_TYPE} = 'Client'")
542
+ end
543
+ end
544
+
545
+ def test_find_first_sanitized
546
+ assert_deprecated 'find_first' do
547
+ firm = Firm.find_first
548
+ client2 = Client.find(2)
549
+ assert_deprecated(/find_first/) do
550
+ assert_equal client2, firm.clients.find_first(["#{QUOTED_TYPE} = ?", "Client"])
551
+ end
552
+ assert_equal client2, firm.clients.find(:first, :conditions => ["#{QUOTED_TYPE} = ?", 'Client'])
553
+ assert_equal client2, firm.clients.find(:first, :conditions => ["#{QUOTED_TYPE} = :type", { :type => 'Client' }])
554
+ end
555
+ end
556
+
557
+ def test_find_in_collection
558
+ assert_equal Client.find(2).name, companies(:first_firm).clients.find(2).name
559
+ assert_raises(ActiveRecord::RecordNotFound) { companies(:first_firm).clients.find(6) }
560
+ end
561
+
562
+ def test_find_grouped
563
+ all_clients_of_firm1 = Client.find(:all, :conditions => "firm_id = 1")
564
+ grouped_clients_of_firm1 = Client.find(:all, :conditions => "firm_id = 1", :group => "firm_id", :select => 'firm_id, count(id) as clients_count')
565
+ assert_equal 2, all_clients_of_firm1.size
566
+ assert_equal 1, grouped_clients_of_firm1.size
567
+ end
568
+
569
+ def test_adding
570
+ force_signal37_to_load_all_clients_of_firm
571
+ natural = Client.new("name" => "Natural Company")
572
+ companies(:first_firm).clients_of_firm << natural
573
+ assert_equal 2, companies(:first_firm).clients_of_firm.size # checking via the collection
574
+ assert_equal 2, companies(:first_firm).clients_of_firm(true).size # checking using the db
575
+ assert_equal natural, companies(:first_firm).clients_of_firm.last
576
+ end
577
+
578
+ def test_adding_using_create
579
+ first_firm = companies(:first_firm)
580
+ assert_equal 2, first_firm.plain_clients.size
581
+ natural = first_firm.plain_clients.create(:name => "Natural Company")
582
+ assert_equal 3, first_firm.plain_clients.length
583
+ assert_equal 3, first_firm.plain_clients.size
584
+ end
585
+
586
+ def test_adding_a_mismatch_class
587
+ assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).clients_of_firm << nil }
588
+ assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).clients_of_firm << 1 }
589
+ assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).clients_of_firm << Topic.find(1) }
590
+ end
591
+
592
+ def test_adding_a_collection
593
+ force_signal37_to_load_all_clients_of_firm
594
+ companies(:first_firm).clients_of_firm.concat([Client.new("name" => "Natural Company"), Client.new("name" => "Apple")])
595
+ assert_equal 3, companies(:first_firm).clients_of_firm.size
596
+ assert_equal 3, companies(:first_firm).clients_of_firm(true).size
597
+ end
598
+
599
+ def test_adding_before_save
600
+ no_of_firms = Firm.count
601
+ no_of_clients = Client.count
602
+ new_firm = Firm.new("name" => "A New Firm, Inc")
603
+ new_firm.clients_of_firm.push Client.new("name" => "Natural Company")
604
+ new_firm.clients_of_firm << (c = Client.new("name" => "Apple"))
605
+ assert new_firm.new_record?
606
+ assert c.new_record?
607
+ assert_equal 2, new_firm.clients_of_firm.size
608
+ assert_equal no_of_firms, Firm.count # Firm was not saved to database.
609
+ assert_equal no_of_clients, Client.count # Clients were not saved to database.
610
+ assert new_firm.save
611
+ assert !new_firm.new_record?
612
+ assert !c.new_record?
613
+ assert_equal new_firm, c.firm
614
+ assert_equal no_of_firms+1, Firm.count # Firm was saved to database.
615
+ assert_equal no_of_clients+2, Client.count # Clients were saved to database.
616
+ assert_equal 2, new_firm.clients_of_firm.size
617
+ assert_equal 2, new_firm.clients_of_firm(true).size
618
+ end
619
+
620
+ def test_invalid_adding
621
+ firm = Firm.find(1)
622
+ assert !(firm.clients_of_firm << c = Client.new)
623
+ assert c.new_record?
624
+ assert !firm.valid?
625
+ assert !firm.save
626
+ assert c.new_record?
627
+ end
628
+
629
+ def test_invalid_adding_before_save
630
+ no_of_firms = Firm.count
631
+ no_of_clients = Client.count
632
+ new_firm = Firm.new("name" => "A New Firm, Inc")
633
+ new_firm.clients_of_firm.concat([c = Client.new, Client.new("name" => "Apple")])
634
+ assert c.new_record?
635
+ assert !c.valid?
636
+ assert !new_firm.valid?
637
+ assert !new_firm.save
638
+ assert c.new_record?
639
+ assert new_firm.new_record?
640
+ end
641
+
642
+ def test_build
643
+ new_client = companies(:first_firm).clients_of_firm.build("name" => "Another Client")
644
+ assert_equal "Another Client", new_client.name
645
+ assert new_client.new_record?
646
+ assert_equal new_client, companies(:first_firm).clients_of_firm.last
647
+ assert companies(:first_firm).save
648
+ assert !new_client.new_record?
649
+ assert_equal 2, companies(:first_firm).clients_of_firm(true).size
650
+ end
651
+
652
+ def test_build_many
653
+ new_clients = companies(:first_firm).clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}])
654
+ assert_equal 2, new_clients.size
655
+
656
+ assert companies(:first_firm).save
657
+ assert_equal 3, companies(:first_firm).clients_of_firm(true).size
658
+ end
659
+
660
+ def test_build_without_loading_association
661
+ first_topic = topics(:first)
662
+ Reply.column_names
663
+
664
+ assert_equal 1, first_topic.replies.length
665
+
666
+ assert_no_queries do
667
+ first_topic.replies.build(:title => "Not saved", :content => "Superstars")
668
+ assert_equal 2, first_topic.replies.size
669
+ end
670
+
671
+ assert_equal 2, first_topic.replies.to_ary.size
672
+ end
673
+
674
+ def test_create_without_loading_association
675
+ first_firm = companies(:first_firm)
676
+ Firm.column_names
677
+ Client.column_names
678
+
679
+ assert_equal 1, first_firm.clients_of_firm.size
680
+ first_firm.clients_of_firm.reset
681
+
682
+ assert_queries(1) do
683
+ first_firm.clients_of_firm.create(:name => "Superstars")
684
+ end
685
+
686
+ assert_equal 2, first_firm.clients_of_firm.size
687
+ end
688
+
689
+ def test_invalid_build
690
+ new_client = companies(:first_firm).clients_of_firm.build
691
+ assert new_client.new_record?
692
+ assert !new_client.valid?
693
+ assert_equal new_client, companies(:first_firm).clients_of_firm.last
694
+ assert !companies(:first_firm).save
695
+ assert new_client.new_record?
696
+ assert_equal 1, companies(:first_firm).clients_of_firm(true).size
697
+ end
698
+
699
+ def test_create
700
+ force_signal37_to_load_all_clients_of_firm
701
+ new_client = companies(:first_firm).clients_of_firm.create("name" => "Another Client")
702
+ assert !new_client.new_record?
703
+ assert_equal new_client, companies(:first_firm).clients_of_firm.last
704
+ assert_equal new_client, companies(:first_firm).clients_of_firm(true).last
705
+ end
706
+
707
+ def test_create_many
708
+ companies(:first_firm).clients_of_firm.create([{"name" => "Another Client"}, {"name" => "Another Client II"}])
709
+ assert_equal 3, companies(:first_firm).clients_of_firm(true).size
710
+ end
711
+
712
+ def test_find_or_create
713
+ number_of_clients = companies(:first_firm).clients.size
714
+ the_client = companies(:first_firm).clients.find_or_create_by_name("Yet another client")
715
+ assert_equal number_of_clients + 1, companies(:first_firm, :refresh).clients.size
716
+ assert_equal the_client, companies(:first_firm).clients.find_or_create_by_name("Yet another client")
717
+ assert_equal number_of_clients + 1, companies(:first_firm, :refresh).clients.size
718
+ end
719
+
720
+ def test_deleting
721
+ force_signal37_to_load_all_clients_of_firm
722
+ companies(:first_firm).clients_of_firm.delete(companies(:first_firm).clients_of_firm.first)
723
+ assert_equal 0, companies(:first_firm).clients_of_firm.size
724
+ assert_equal 0, companies(:first_firm).clients_of_firm(true).size
725
+ end
726
+
727
+ def test_deleting_before_save
728
+ new_firm = Firm.new("name" => "A New Firm, Inc.")
729
+ new_client = new_firm.clients_of_firm.build("name" => "Another Client")
730
+ assert_equal 1, new_firm.clients_of_firm.size
731
+ new_firm.clients_of_firm.delete(new_client)
732
+ assert_equal 0, new_firm.clients_of_firm.size
733
+ end
734
+
735
+ def test_deleting_a_collection
736
+ force_signal37_to_load_all_clients_of_firm
737
+ companies(:first_firm).clients_of_firm.create("name" => "Another Client")
738
+ assert_equal 2, companies(:first_firm).clients_of_firm.size
739
+ companies(:first_firm).clients_of_firm.delete([companies(:first_firm).clients_of_firm[0], companies(:first_firm).clients_of_firm[1]])
740
+ assert_equal 0, companies(:first_firm).clients_of_firm.size
741
+ assert_equal 0, companies(:first_firm).clients_of_firm(true).size
742
+ end
743
+
744
+ def test_delete_all
745
+ force_signal37_to_load_all_clients_of_firm
746
+ companies(:first_firm).clients_of_firm.create("name" => "Another Client")
747
+ assert_equal 2, companies(:first_firm).clients_of_firm.size
748
+ companies(:first_firm).clients_of_firm.delete_all
749
+ assert_equal 0, companies(:first_firm).clients_of_firm.size
750
+ assert_equal 0, companies(:first_firm).clients_of_firm(true).size
751
+ end
752
+
753
+ def test_delete_all_with_not_yet_loaded_association_collection
754
+ force_signal37_to_load_all_clients_of_firm
755
+ companies(:first_firm).clients_of_firm.create("name" => "Another Client")
756
+ assert_equal 2, companies(:first_firm).clients_of_firm.size
757
+ companies(:first_firm).clients_of_firm.reset
758
+ companies(:first_firm).clients_of_firm.delete_all
759
+ assert_equal 0, companies(:first_firm).clients_of_firm.size
760
+ assert_equal 0, companies(:first_firm).clients_of_firm(true).size
761
+ end
762
+
763
+ def test_clearing_an_association_collection
764
+ firm = companies(:first_firm)
765
+ client_id = firm.clients_of_firm.first.id
766
+ assert_equal 1, firm.clients_of_firm.size
767
+
768
+ firm.clients_of_firm.clear
769
+
770
+ assert_equal 0, firm.clients_of_firm.size
771
+ assert_equal 0, firm.clients_of_firm(true).size
772
+ assert_equal [], Client.destroyed_client_ids[firm.id]
773
+
774
+ # Should not be destroyed since the association is not dependent.
775
+ assert_nothing_raised do
776
+ assert Client.find(client_id).firm.nil?
777
+ end
778
+ end
779
+
780
+ def test_clearing_a_dependent_association_collection
781
+ firm = companies(:first_firm)
782
+ client_id = firm.dependent_clients_of_firm.first.id
783
+ assert_equal 1, firm.dependent_clients_of_firm.size
784
+
785
+ # :dependent means destroy is called on each client
786
+ firm.dependent_clients_of_firm.clear
787
+
788
+ assert_equal 0, firm.dependent_clients_of_firm.size
789
+ assert_equal 0, firm.dependent_clients_of_firm(true).size
790
+ assert_equal [client_id], Client.destroyed_client_ids[firm.id]
791
+
792
+ # Should be destroyed since the association is dependent.
793
+ assert Client.find_by_id(client_id).nil?
794
+ end
795
+
796
+ def test_clearing_an_exclusively_dependent_association_collection
797
+ firm = companies(:first_firm)
798
+ client_id = firm.exclusively_dependent_clients_of_firm.first.id
799
+ assert_equal 1, firm.exclusively_dependent_clients_of_firm.size
800
+
801
+ assert_equal [], Client.destroyed_client_ids[firm.id]
802
+
803
+ # :exclusively_dependent means each client is deleted directly from
804
+ # the database without looping through them calling destroy.
805
+ firm.exclusively_dependent_clients_of_firm.clear
806
+
807
+ assert_equal 0, firm.exclusively_dependent_clients_of_firm.size
808
+ assert_equal 0, firm.exclusively_dependent_clients_of_firm(true).size
809
+ assert_equal [3], Client.destroyed_client_ids[firm.id]
810
+
811
+ # Should be destroyed since the association is exclusively dependent.
812
+ assert Client.find_by_id(client_id).nil?
813
+ end
814
+
815
+ def test_clearing_without_initial_access
816
+ firm = companies(:first_firm)
817
+
818
+ firm.clients_of_firm.clear
819
+
820
+ assert_equal 0, firm.clients_of_firm.size
821
+ assert_equal 0, firm.clients_of_firm(true).size
822
+ end
823
+
824
+ def test_deleting_a_item_which_is_not_in_the_collection
825
+ force_signal37_to_load_all_clients_of_firm
826
+ summit = Client.find_by_name('Summit')
827
+ companies(:first_firm).clients_of_firm.delete(summit)
828
+ assert_equal 1, companies(:first_firm).clients_of_firm.size
829
+ assert_equal 1, companies(:first_firm).clients_of_firm(true).size
830
+ assert_equal 2, summit.client_of
831
+ end
832
+
833
+ def test_deleting_type_mismatch
834
+ david = Developer.find(1)
835
+ david.projects.reload
836
+ assert_raises(ActiveRecord::AssociationTypeMismatch) { david.projects.delete(1) }
837
+ end
838
+
839
+ def test_deleting_self_type_mismatch
840
+ david = Developer.find(1)
841
+ david.projects.reload
842
+ assert_raises(ActiveRecord::AssociationTypeMismatch) { david.projects.delete(Project.find(1).developers) }
843
+ end
844
+
845
+ def test_destroy_all
846
+ force_signal37_to_load_all_clients_of_firm
847
+ assert !companies(:first_firm).clients_of_firm.empty?, "37signals has clients after load"
848
+ companies(:first_firm).clients_of_firm.destroy_all
849
+ assert companies(:first_firm).clients_of_firm.empty?, "37signals has no clients after destroy all"
850
+ assert companies(:first_firm).clients_of_firm(true).empty?, "37signals has no clients after destroy all and refresh"
851
+ end
852
+
853
+ def test_dependence
854
+ firm = companies(:first_firm)
855
+ assert_equal 2, firm.clients.size
856
+ firm.destroy
857
+ assert Client.find(:all, :conditions => "firm_id=#{firm.id}").empty?
858
+ end
859
+
860
+ def test_destroy_dependent_when_deleted_from_association
861
+ firm = Firm.find(:first)
862
+ assert_equal 2, firm.clients.size
863
+
864
+ client = firm.clients.first
865
+ firm.clients.delete(client)
866
+
867
+ assert_raise(ActiveRecord::RecordNotFound) { Client.find(client.id) }
868
+ assert_raise(ActiveRecord::RecordNotFound) { firm.clients.find(client.id) }
869
+ assert_equal 1, firm.clients.size
870
+ end
871
+
872
+ def test_three_levels_of_dependence
873
+ topic = Topic.create "title" => "neat and simple"
874
+ reply = topic.replies.create "title" => "neat and simple", "content" => "still digging it"
875
+ silly_reply = reply.replies.create "title" => "neat and simple", "content" => "ain't complaining"
876
+
877
+ assert_nothing_raised { topic.destroy }
878
+ end
879
+
880
+ uses_transaction :test_dependence_with_transaction_support_on_failure
881
+ def test_dependence_with_transaction_support_on_failure
882
+ firm = companies(:first_firm)
883
+ clients = firm.clients
884
+ assert_equal 2, clients.length
885
+ clients.last.instance_eval { def before_destroy() raise "Trigger rollback" end }
886
+
887
+ firm.destroy rescue "do nothing"
888
+
889
+ assert_equal 2, Client.find(:all, :conditions => "firm_id=#{firm.id}").size
890
+ end
891
+
892
+ def test_dependence_on_account
893
+ num_accounts = Account.count
894
+ companies(:first_firm).destroy
895
+ assert_equal num_accounts - 1, Account.count
896
+ end
897
+
898
+ def test_depends_and_nullify
899
+ num_accounts = Account.count
900
+ num_companies = Company.count
901
+
902
+ core = companies(:rails_core)
903
+ assert_equal accounts(:rails_core_account), core.account
904
+ assert_equal [companies(:leetsoft), companies(:jadedpixel)], core.companies
905
+ core.destroy
906
+ assert_nil accounts(:rails_core_account).reload.firm_id
907
+ assert_nil companies(:leetsoft).reload.client_of
908
+ assert_nil companies(:jadedpixel).reload.client_of
909
+
910
+
911
+ assert_equal num_accounts, Account.count
912
+ end
913
+
914
+ def test_included_in_collection
915
+ assert companies(:first_firm).clients.include?(Client.find(2))
916
+ end
917
+
918
+ def test_adding_array_and_collection
919
+ assert_nothing_raised { Firm.find(:first).clients + Firm.find(:all).last.clients }
920
+ end
921
+
922
+ def test_find_all_without_conditions
923
+ firm = companies(:first_firm)
924
+ assert_equal 2, firm.clients.find(:all).length
925
+ end
926
+
927
+ def test_replace_with_less
928
+ firm = Firm.find(:first)
929
+ firm.clients = [companies(:first_client)]
930
+ assert firm.save, "Could not save firm"
931
+ firm.reload
932
+ assert_equal 1, firm.clients.length
933
+ end
934
+
935
+
936
+ def test_replace_with_new
937
+ firm = Firm.find(:first)
938
+ new_client = Client.new("name" => "New Client")
939
+ firm.clients = [companies(:second_client),new_client]
940
+ firm.save
941
+ firm.reload
942
+ assert_equal 2, firm.clients.length
943
+ assert !firm.clients.include?(:first_client)
944
+ end
945
+
946
+ def test_replace_on_new_object
947
+ firm = Firm.new("name" => "New Firm")
948
+ firm.clients = [companies(:second_client), Client.new("name" => "New Client")]
949
+ assert firm.save
950
+ firm.reload
951
+ assert_equal 2, firm.clients.length
952
+ assert firm.clients.include?(Client.find_by_name("New Client"))
953
+ end
954
+
955
+ def test_get_ids
956
+ assert_equal [companies(:first_client).id, companies(:second_client).id], companies(:first_firm).client_ids
957
+ end
958
+
959
+ def test_assign_ids
960
+ firm = Firm.new("name" => "Apple")
961
+ firm.client_ids = [companies(:first_client).id, companies(:second_client).id]
962
+ firm.save
963
+ firm.reload
964
+ assert_equal 2, firm.clients.length
965
+ assert firm.clients.include?(companies(:second_client))
966
+ end
967
+
968
+ def test_assign_ids_ignoring_blanks
969
+ firm = Firm.new("name" => "Apple")
970
+ firm.client_ids = [companies(:first_client).id, nil, companies(:second_client).id, '']
971
+ firm.save
972
+ firm.reload
973
+ assert_equal 2, firm.clients.length
974
+ assert firm.clients.include?(companies(:second_client))
975
+ end
976
+
977
+ end
978
+
979
+ class BelongsToAssociationsTest < Test::Unit::TestCase
980
+ fixtures :accounts, :companies, :developers, :projects, :topics,
981
+ :developers_projects, :computers, :authors, :posts
982
+
983
+ def test_belongs_to
984
+ Client.find(3).firm.name
985
+ assert_equal companies(:first_firm).name, Client.find(3).firm.name
986
+ assert !Client.find(3).firm.nil?, "Microsoft should have a firm"
987
+ end
988
+
989
+ def test_proxy_assignment
990
+ account = Account.find(1)
991
+ assert_nothing_raised { account.firm = account.firm }
992
+ end
993
+
994
+ def test_triple_equality
995
+ assert Client.find(3).firm === Firm
996
+ assert Firm === Client.find(3).firm
997
+ end
998
+
999
+ def test_type_mismatch
1000
+ assert_raise(ActiveRecord::AssociationTypeMismatch) { Account.find(1).firm = 1 }
1001
+ assert_raise(ActiveRecord::AssociationTypeMismatch) { Account.find(1).firm = Project.find(1) }
1002
+ end
1003
+
1004
+ def test_natural_assignment
1005
+ apple = Firm.create("name" => "Apple")
1006
+ citibank = Account.create("credit_limit" => 10)
1007
+ citibank.firm = apple
1008
+ assert_equal apple.id, citibank.firm_id
1009
+ end
1010
+
1011
+ def test_creating_the_belonging_object
1012
+ citibank = Account.create("credit_limit" => 10)
1013
+ apple = citibank.create_firm("name" => "Apple")
1014
+ assert_equal apple, citibank.firm
1015
+ citibank.save
1016
+ citibank.reload
1017
+ assert_equal apple, citibank.firm
1018
+ end
1019
+
1020
+ def test_building_the_belonging_object
1021
+ citibank = Account.create("credit_limit" => 10)
1022
+ apple = citibank.build_firm("name" => "Apple")
1023
+ citibank.save
1024
+ assert_equal apple.id, citibank.firm_id
1025
+ end
1026
+
1027
+ def test_natural_assignment_to_nil
1028
+ client = Client.find(3)
1029
+ client.firm = nil
1030
+ client.save
1031
+ assert_nil client.firm(true)
1032
+ assert_nil client.client_of
1033
+ end
1034
+
1035
+ def test_with_different_class_name
1036
+ assert_equal Company.find(1).name, Company.find(3).firm_with_other_name.name
1037
+ assert_not_nil Company.find(3).firm_with_other_name, "Microsoft should have a firm"
1038
+ end
1039
+
1040
+ def test_with_condition
1041
+ assert_equal Company.find(1).name, Company.find(3).firm_with_condition.name
1042
+ assert_not_nil Company.find(3).firm_with_condition, "Microsoft should have a firm"
1043
+ end
1044
+
1045
+ def test_belongs_to_counter
1046
+ debate = Topic.create("title" => "debate")
1047
+ assert_equal 0, debate.send(:read_attribute, "replies_count"), "No replies yet"
1048
+
1049
+ trash = debate.replies.create("title" => "blah!", "content" => "world around!")
1050
+ assert_equal 1, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply created"
1051
+
1052
+ trash.destroy
1053
+ assert_equal 0, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply deleted"
1054
+ end
1055
+
1056
+ def test_belongs_to_counter_with_reassigning
1057
+ t1 = Topic.create("title" => "t1")
1058
+ t2 = Topic.create("title" => "t2")
1059
+ r1 = Reply.new("title" => "r1", "content" => "r1")
1060
+ r1.topic = t1
1061
+
1062
+ assert r1.save
1063
+ assert_equal 1, Topic.find(t1.id).replies.size
1064
+ assert_equal 0, Topic.find(t2.id).replies.size
1065
+
1066
+ r1.topic = Topic.find(t2.id)
1067
+
1068
+ assert r1.save
1069
+ assert_equal 0, Topic.find(t1.id).replies.size
1070
+ assert_equal 1, Topic.find(t2.id).replies.size
1071
+
1072
+ r1.topic = nil
1073
+
1074
+ assert_equal 0, Topic.find(t1.id).replies.size
1075
+ assert_equal 0, Topic.find(t2.id).replies.size
1076
+
1077
+ r1.topic = t1
1078
+
1079
+ assert_equal 1, Topic.find(t1.id).replies.size
1080
+ assert_equal 0, Topic.find(t2.id).replies.size
1081
+
1082
+ r1.destroy
1083
+
1084
+ assert_equal 0, Topic.find(t1.id).replies.size
1085
+ assert_equal 0, Topic.find(t2.id).replies.size
1086
+ end
1087
+
1088
+ def test_assignment_before_parent_saved
1089
+ client = Client.find(:first)
1090
+ apple = Firm.new("name" => "Apple")
1091
+ client.firm = apple
1092
+ assert_equal apple, client.firm
1093
+ assert apple.new_record?
1094
+ assert client.save
1095
+ assert apple.save
1096
+ assert !apple.new_record?
1097
+ assert_equal apple, client.firm
1098
+ assert_equal apple, client.firm(true)
1099
+ end
1100
+
1101
+ def test_assignment_before_child_saved
1102
+ final_cut = Client.new("name" => "Final Cut")
1103
+ firm = Firm.find(1)
1104
+ final_cut.firm = firm
1105
+ assert final_cut.new_record?
1106
+ assert final_cut.save
1107
+ assert !final_cut.new_record?
1108
+ assert !firm.new_record?
1109
+ assert_equal firm, final_cut.firm
1110
+ assert_equal firm, final_cut.firm(true)
1111
+ end
1112
+
1113
+ def test_assignment_before_either_saved
1114
+ final_cut = Client.new("name" => "Final Cut")
1115
+ apple = Firm.new("name" => "Apple")
1116
+ final_cut.firm = apple
1117
+ assert final_cut.new_record?
1118
+ assert apple.new_record?
1119
+ assert final_cut.save
1120
+ assert !final_cut.new_record?
1121
+ assert !apple.new_record?
1122
+ assert_equal apple, final_cut.firm
1123
+ assert_equal apple, final_cut.firm(true)
1124
+ end
1125
+
1126
+ def test_new_record_with_foreign_key_but_no_object
1127
+ c = Client.new("firm_id" => 1)
1128
+ assert_equal Firm.find(:first), c.firm_with_basic_id
1129
+ end
1130
+
1131
+ def test_forgetting_the_load_when_foreign_key_enters_late
1132
+ c = Client.new
1133
+ assert_nil c.firm_with_basic_id
1134
+
1135
+ c.firm_id = 1
1136
+ assert_equal Firm.find(:first), c.firm_with_basic_id
1137
+ end
1138
+
1139
+ def test_field_name_same_as_foreign_key
1140
+ computer = Computer.find(1)
1141
+ assert_not_nil computer.developer, ":foreign key == attribute didn't lock up" # '
1142
+ end
1143
+
1144
+ def test_counter_cache
1145
+ topic = Topic.create :title => "Zoom-zoom-zoom"
1146
+ assert_equal 0, topic[:replies_count]
1147
+
1148
+ reply = Reply.create(:title => "re: zoom", :content => "speedy quick!")
1149
+ reply.topic = topic
1150
+
1151
+ assert_equal 1, topic.reload[:replies_count]
1152
+ assert_equal 1, topic.replies.size
1153
+
1154
+ topic[:replies_count] = 15
1155
+ assert_equal 15, topic.replies.size
1156
+ end
1157
+
1158
+ def test_custom_counter_cache
1159
+ reply = Reply.create(:title => "re: zoom", :content => "speedy quick!")
1160
+ assert_equal 0, reply[:replies_count]
1161
+
1162
+ silly = SillyReply.create(:title => "gaga", :content => "boo-boo")
1163
+ silly.reply = reply
1164
+
1165
+ assert_equal 1, reply.reload[:replies_count]
1166
+ assert_equal 1, reply.replies.size
1167
+
1168
+ reply[:replies_count] = 17
1169
+ assert_equal 17, reply.replies.size
1170
+ end
1171
+
1172
+ def test_store_two_association_with_one_save
1173
+ num_orders = Order.count
1174
+ num_customers = Customer.count
1175
+ order = Order.new
1176
+
1177
+ customer1 = order.billing = Customer.new
1178
+ customer2 = order.shipping = Customer.new
1179
+ assert order.save
1180
+ assert_equal customer1, order.billing
1181
+ assert_equal customer2, order.shipping
1182
+
1183
+ order.reload
1184
+
1185
+ assert_equal customer1, order.billing
1186
+ assert_equal customer2, order.shipping
1187
+
1188
+ assert_equal num_orders +1, Order.count
1189
+ assert_equal num_customers +2, Customer.count
1190
+ end
1191
+
1192
+
1193
+ def test_store_association_in_two_relations_with_one_save
1194
+ num_orders = Order.count
1195
+ num_customers = Customer.count
1196
+ order = Order.new
1197
+
1198
+ customer = order.billing = order.shipping = Customer.new
1199
+ assert order.save
1200
+ assert_equal customer, order.billing
1201
+ assert_equal customer, order.shipping
1202
+
1203
+ order.reload
1204
+
1205
+ assert_equal customer, order.billing
1206
+ assert_equal customer, order.shipping
1207
+
1208
+ assert_equal num_orders +1, Order.count
1209
+ assert_equal num_customers +1, Customer.count
1210
+ end
1211
+
1212
+ def test_store_association_in_two_relations_with_one_save_in_existing_object
1213
+ num_orders = Order.count
1214
+ num_customers = Customer.count
1215
+ order = Order.create
1216
+
1217
+ customer = order.billing = order.shipping = Customer.new
1218
+ assert order.save
1219
+ assert_equal customer, order.billing
1220
+ assert_equal customer, order.shipping
1221
+
1222
+ order.reload
1223
+
1224
+ assert_equal customer, order.billing
1225
+ assert_equal customer, order.shipping
1226
+
1227
+ assert_equal num_orders +1, Order.count
1228
+ assert_equal num_customers +1, Customer.count
1229
+ end
1230
+
1231
+ def test_store_association_in_two_relations_with_one_save_in_existing_object_with_values
1232
+ num_orders = Order.count
1233
+ num_customers = Customer.count
1234
+ order = Order.create
1235
+
1236
+ customer = order.billing = order.shipping = Customer.new
1237
+ assert order.save
1238
+ assert_equal customer, order.billing
1239
+ assert_equal customer, order.shipping
1240
+
1241
+ order.reload
1242
+
1243
+ customer = order.billing = order.shipping = Customer.new
1244
+
1245
+ assert order.save
1246
+ order.reload
1247
+
1248
+ assert_equal customer, order.billing
1249
+ assert_equal customer, order.shipping
1250
+
1251
+ assert_equal num_orders +1, Order.count
1252
+ assert_equal num_customers +2, Customer.count
1253
+ end
1254
+
1255
+
1256
+ def test_association_assignment_sticks
1257
+ post = Post.find(:first)
1258
+
1259
+ author1, author2 = Author.find(:all, :limit => 2)
1260
+ assert_not_nil author1
1261
+ assert_not_nil author2
1262
+
1263
+ # make sure the association is loaded
1264
+ post.author
1265
+
1266
+ # set the association by id, directly
1267
+ post.author_id = author2.id
1268
+
1269
+ # save and reload
1270
+ post.save!
1271
+ post.reload
1272
+
1273
+ # the author id of the post should be the id we set
1274
+ assert_equal post.author_id, author2.id
1275
+ end
1276
+
1277
+ end
1278
+
1279
+
1280
+ class ProjectWithAfterCreateHook < ActiveRecord::Base
1281
+ set_table_name 'projects'
1282
+ has_and_belongs_to_many :developers,
1283
+ :class_name => "DeveloperForProjectWithAfterCreateHook",
1284
+ :join_table => "developers_projects",
1285
+ :foreign_key => "project_id",
1286
+ :association_foreign_key => "developer_id"
1287
+
1288
+ after_create :add_david
1289
+
1290
+ def add_david
1291
+ david = DeveloperForProjectWithAfterCreateHook.find_by_name('David')
1292
+ david.projects << self
1293
+ end
1294
+ end
1295
+
1296
+ class DeveloperForProjectWithAfterCreateHook < ActiveRecord::Base
1297
+ set_table_name 'developers'
1298
+ has_and_belongs_to_many :projects,
1299
+ :class_name => "ProjectWithAfterCreateHook",
1300
+ :join_table => "developers_projects",
1301
+ :association_foreign_key => "project_id",
1302
+ :foreign_key => "developer_id"
1303
+ end
1304
+
1305
+
1306
+ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
1307
+ fixtures :accounts, :companies, :categories, :posts, :categories_posts, :developers, :projects, :developers_projects
1308
+
1309
+ def test_has_and_belongs_to_many
1310
+ david = Developer.find(1)
1311
+
1312
+ assert !david.projects.empty?
1313
+ assert_equal 2, david.projects.size
1314
+
1315
+ active_record = Project.find(1)
1316
+ assert !active_record.developers.empty?
1317
+ assert_equal 3, active_record.developers.size
1318
+ assert active_record.developers.include?(david)
1319
+ end
1320
+
1321
+ def test_triple_equality
1322
+ assert !(Array === Developer.find(1).projects)
1323
+ assert Developer.find(1).projects === Array
1324
+ end
1325
+
1326
+ def test_adding_single
1327
+ jamis = Developer.find(2)
1328
+ jamis.projects.reload # causing the collection to load
1329
+ action_controller = Project.find(2)
1330
+ assert_equal 1, jamis.projects.size
1331
+ assert_equal 1, action_controller.developers.size
1332
+
1333
+ jamis.projects << action_controller
1334
+
1335
+ assert_equal 2, jamis.projects.size
1336
+ assert_equal 2, jamis.projects(true).size
1337
+ assert_equal 2, action_controller.developers(true).size
1338
+ end
1339
+
1340
+ def test_adding_type_mismatch
1341
+ jamis = Developer.find(2)
1342
+ assert_raise(ActiveRecord::AssociationTypeMismatch) { jamis.projects << nil }
1343
+ assert_raise(ActiveRecord::AssociationTypeMismatch) { jamis.projects << 1 }
1344
+ end
1345
+
1346
+ def test_adding_from_the_project
1347
+ jamis = Developer.find(2)
1348
+ action_controller = Project.find(2)
1349
+ action_controller.developers.reload
1350
+ assert_equal 1, jamis.projects.size
1351
+ assert_equal 1, action_controller.developers.size
1352
+
1353
+ action_controller.developers << jamis
1354
+
1355
+ assert_equal 2, jamis.projects(true).size
1356
+ assert_equal 2, action_controller.developers.size
1357
+ assert_equal 2, action_controller.developers(true).size
1358
+ end
1359
+
1360
+ def test_adding_from_the_project_fixed_timestamp
1361
+ jamis = Developer.find(2)
1362
+ action_controller = Project.find(2)
1363
+ action_controller.developers.reload
1364
+ assert_equal 1, jamis.projects.size
1365
+ assert_equal 1, action_controller.developers.size
1366
+ updated_at = jamis.updated_at
1367
+
1368
+ action_controller.developers << jamis
1369
+
1370
+ assert_equal updated_at, jamis.updated_at
1371
+ assert_equal 2, jamis.projects(true).size
1372
+ assert_equal 2, action_controller.developers.size
1373
+ assert_equal 2, action_controller.developers(true).size
1374
+ end
1375
+
1376
+ def test_adding_multiple
1377
+ aredridel = Developer.new("name" => "Aredridel")
1378
+ aredridel.save
1379
+ aredridel.projects.reload
1380
+ aredridel.projects.push(Project.find(1), Project.find(2))
1381
+ assert_equal 2, aredridel.projects.size
1382
+ assert_equal 2, aredridel.projects(true).size
1383
+ end
1384
+
1385
+ def test_adding_a_collection
1386
+ aredridel = Developer.new("name" => "Aredridel")
1387
+ aredridel.save
1388
+ aredridel.projects.reload
1389
+ aredridel.projects.concat([Project.find(1), Project.find(2)])
1390
+ assert_equal 2, aredridel.projects.size
1391
+ assert_equal 2, aredridel.projects(true).size
1392
+ end
1393
+
1394
+ def test_adding_uses_default_values_on_join_table
1395
+ ac = projects(:action_controller)
1396
+ assert !developers(:jamis).projects.include?(ac)
1397
+ developers(:jamis).projects << ac
1398
+
1399
+ assert developers(:jamis, :reload).projects.include?(ac)
1400
+ project = developers(:jamis).projects.detect { |p| p == ac }
1401
+ assert_equal 1, project.access_level.to_i
1402
+ end
1403
+
1404
+ def test_adding_uses_explicit_values_on_join_table
1405
+ ac = projects(:action_controller)
1406
+ assert !developers(:jamis).projects.include?(ac)
1407
+ assert_deprecated do
1408
+ developers(:jamis).projects.push_with_attributes(ac, :access_level => 3)
1409
+ end
1410
+
1411
+ assert developers(:jamis, :reload).projects.include?(ac)
1412
+ project = developers(:jamis).projects.detect { |p| p == ac }
1413
+ assert_equal 3, project.access_level.to_i
1414
+ end
1415
+
1416
+ def test_hatbm_attribute_access_and_respond_to
1417
+ project = developers(:jamis).projects[0]
1418
+ assert project.has_attribute?("name")
1419
+ assert project.has_attribute?("joined_on")
1420
+ assert project.has_attribute?("access_level")
1421
+ assert project.respond_to?("name")
1422
+ assert project.respond_to?("name=")
1423
+ assert project.respond_to?("name?")
1424
+ assert project.respond_to?("joined_on")
1425
+ assert project.respond_to?("joined_on=")
1426
+ assert project.respond_to?("joined_on?")
1427
+ assert project.respond_to?("access_level")
1428
+ assert project.respond_to?("access_level=")
1429
+ assert project.respond_to?("access_level?")
1430
+ end
1431
+
1432
+ def test_habtm_adding_before_save
1433
+ no_of_devels = Developer.count
1434
+ no_of_projects = Project.count
1435
+ aredridel = Developer.new("name" => "Aredridel")
1436
+ aredridel.projects.concat([Project.find(1), p = Project.new("name" => "Projekt")])
1437
+ assert aredridel.new_record?
1438
+ assert p.new_record?
1439
+ assert aredridel.save
1440
+ assert !aredridel.new_record?
1441
+ assert_equal no_of_devels+1, Developer.count
1442
+ assert_equal no_of_projects+1, Project.count
1443
+ assert_equal 2, aredridel.projects.size
1444
+ assert_equal 2, aredridel.projects(true).size
1445
+ end
1446
+
1447
+ def test_habtm_adding_before_save_with_join_attributes
1448
+ no_of_devels = Developer.count
1449
+ no_of_projects = Project.count
1450
+ now = Date.today
1451
+ ken = Developer.new("name" => "Ken")
1452
+ assert_deprecated do
1453
+ ken.projects.push_with_attributes( Project.find(1), :joined_on => now )
1454
+ end
1455
+ p = Project.new("name" => "Foomatic")
1456
+ assert_deprecated do
1457
+ ken.projects.push_with_attributes( p, :joined_on => now )
1458
+ end
1459
+ assert ken.new_record?
1460
+ assert p.new_record?
1461
+ assert ken.save
1462
+ assert !ken.new_record?
1463
+ assert_equal no_of_devels+1, Developer.count
1464
+ assert_equal no_of_projects+1, Project.count
1465
+ assert_equal 2, ken.projects.size
1466
+ assert_equal 2, ken.projects(true).size
1467
+
1468
+ kenReloaded = Developer.find_by_name 'Ken'
1469
+ kenReloaded.projects.each {|prj| assert_date_from_db(now, prj.joined_on)}
1470
+ end
1471
+
1472
+ def test_habtm_saving_multiple_relationships
1473
+ new_project = Project.new("name" => "Grimetime")
1474
+ amount_of_developers = 4
1475
+ developers = (0...amount_of_developers).collect {|i| Developer.create(:name => "JME #{i}") }.reverse
1476
+
1477
+ new_project.developer_ids = [developers[0].id, developers[1].id]
1478
+ new_project.developers_with_callback_ids = [developers[2].id, developers[3].id]
1479
+ assert new_project.save
1480
+
1481
+ new_project.reload
1482
+ assert_equal amount_of_developers, new_project.developers.size
1483
+ assert_equal developers, new_project.developers
1484
+ end
1485
+
1486
+ def test_habtm_unique_order_preserved
1487
+ assert_equal [developers(:poor_jamis), developers(:jamis), developers(:david)], projects(:active_record).non_unique_developers
1488
+ assert_equal [developers(:poor_jamis), developers(:jamis), developers(:david)], projects(:active_record).developers
1489
+ end
1490
+
1491
+ def test_build
1492
+ devel = Developer.find(1)
1493
+ proj = devel.projects.build("name" => "Projekt")
1494
+ assert_equal devel.projects.last, proj
1495
+ assert proj.new_record?
1496
+ devel.save
1497
+ assert !proj.new_record?
1498
+ assert_equal devel.projects.last, proj
1499
+ assert_equal Developer.find(1).projects.sort_by(&:id).last, proj # prove join table is updated
1500
+ end
1501
+
1502
+ def test_build_by_new_record
1503
+ devel = Developer.new(:name => "Marcel", :salary => 75000)
1504
+ proj1 = devel.projects.build(:name => "Make bed")
1505
+ proj2 = devel.projects.build(:name => "Lie in it")
1506
+ assert_equal devel.projects.last, proj2
1507
+ assert proj2.new_record?
1508
+ devel.save
1509
+ assert !devel.new_record?
1510
+ assert !proj2.new_record?
1511
+ assert_equal devel.projects.last, proj2
1512
+ assert_equal Developer.find_by_name("Marcel").projects.last, proj2 # prove join table is updated
1513
+ end
1514
+
1515
+ def test_create
1516
+ devel = Developer.find(1)
1517
+ proj = devel.projects.create("name" => "Projekt")
1518
+ assert_equal devel.projects.last, proj
1519
+ assert !proj.new_record?
1520
+ assert_equal Developer.find(1).projects.sort_by(&:id).last, proj # prove join table is updated
1521
+ end
1522
+
1523
+ def test_create_by_new_record
1524
+ devel = Developer.new(:name => "Marcel", :salary => 75000)
1525
+ proj1 = devel.projects.create(:name => "Make bed")
1526
+ proj2 = devel.projects.create(:name => "Lie in it")
1527
+ assert_equal devel.projects.last, proj2
1528
+ assert proj2.new_record?
1529
+ devel.save
1530
+ assert !devel.new_record?
1531
+ assert !proj2.new_record?
1532
+ assert_equal devel.projects.last, proj2
1533
+ assert_equal Developer.find_by_name("Marcel").projects.last, proj2 # prove join table is updated
1534
+ end
1535
+
1536
+ def test_uniq_after_the_fact
1537
+ developers(:jamis).projects << projects(:active_record)
1538
+ developers(:jamis).projects << projects(:active_record)
1539
+ assert_equal 3, developers(:jamis).projects.size
1540
+ assert_equal 1, developers(:jamis).projects.uniq.size
1541
+ end
1542
+
1543
+ def test_uniq_before_the_fact
1544
+ projects(:active_record).developers << developers(:jamis)
1545
+ projects(:active_record).developers << developers(:david)
1546
+ assert_equal 3, projects(:active_record, :reload).developers.size
1547
+ end
1548
+
1549
+ def test_deleting
1550
+ david = Developer.find(1)
1551
+ active_record = Project.find(1)
1552
+ david.projects.reload
1553
+ assert_equal 2, david.projects.size
1554
+ assert_equal 3, active_record.developers.size
1555
+
1556
+ david.projects.delete(active_record)
1557
+
1558
+ assert_equal 1, david.projects.size
1559
+ assert_equal 1, david.projects(true).size
1560
+ assert_equal 2, active_record.developers(true).size
1561
+ end
1562
+
1563
+ def test_deleting_array
1564
+ david = Developer.find(1)
1565
+ david.projects.reload
1566
+ david.projects.delete(Project.find(:all))
1567
+ assert_equal 0, david.projects.size
1568
+ assert_equal 0, david.projects(true).size
1569
+ end
1570
+
1571
+ def test_deleting_with_sql
1572
+ david = Developer.find(1)
1573
+ active_record = Project.find(1)
1574
+ active_record.developers.reload
1575
+ assert_equal 3, active_record.developers_by_sql.size
1576
+
1577
+ active_record.developers_by_sql.delete(david)
1578
+ assert_equal 2, active_record.developers_by_sql(true).size
1579
+ end
1580
+
1581
+ def test_deleting_array_with_sql
1582
+ active_record = Project.find(1)
1583
+ active_record.developers.reload
1584
+ assert_equal 3, active_record.developers_by_sql.size
1585
+
1586
+ active_record.developers_by_sql.delete(Developer.find(:all))
1587
+ assert_equal 0, active_record.developers_by_sql(true).size
1588
+ end
1589
+
1590
+ def test_deleting_all
1591
+ david = Developer.find(1)
1592
+ david.projects.reload
1593
+ david.projects.clear
1594
+ assert_equal 0, david.projects.size
1595
+ assert_equal 0, david.projects(true).size
1596
+ end
1597
+
1598
+ def test_removing_associations_on_destroy
1599
+ david = DeveloperWithBeforeDestroyRaise.find(1)
1600
+ assert !david.projects.empty?
1601
+ assert_nothing_raised { david.destroy }
1602
+ assert david.projects.empty?
1603
+ assert DeveloperWithBeforeDestroyRaise.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = 1").empty?
1604
+ end
1605
+
1606
+ def test_additional_columns_from_join_table
1607
+ assert_date_from_db Date.new(2004, 10, 10), Developer.find(1).projects.first.joined_on
1608
+ end
1609
+
1610
+ def test_destroy_all
1611
+ david = Developer.find(1)
1612
+ david.projects.reload
1613
+ assert !david.projects.empty?
1614
+ david.projects.destroy_all
1615
+ assert david.projects.empty?
1616
+ assert david.projects(true).empty?
1617
+ end
1618
+
1619
+ def test_rich_association
1620
+ jamis = developers(:jamis)
1621
+ assert_deprecated 'push_with_attributes' do
1622
+ jamis.projects.push_with_attributes(projects(:action_controller), :joined_on => Date.today)
1623
+ end
1624
+
1625
+ assert_date_from_db Date.today, jamis.projects.select { |p| p.name == projects(:action_controller).name }.first.joined_on
1626
+ assert_date_from_db Date.today, developers(:jamis).projects.select { |p| p.name == projects(:action_controller).name }.first.joined_on
1627
+ end
1628
+
1629
+ def test_associations_with_conditions
1630
+ assert_equal 3, projects(:active_record).developers.size
1631
+ assert_equal 1, projects(:active_record).developers_named_david.size
1632
+ assert_equal 1, projects(:active_record).developers_named_david_with_hash_conditions.size
1633
+
1634
+ assert_equal developers(:david), projects(:active_record).developers_named_david.find(developers(:david).id)
1635
+ assert_equal developers(:david), projects(:active_record).developers_named_david_with_hash_conditions.find(developers(:david).id)
1636
+ assert_equal developers(:david), projects(:active_record).salaried_developers.find(developers(:david).id)
1637
+
1638
+ projects(:active_record).developers_named_david.clear
1639
+ assert_equal 2, projects(:active_record, :reload).developers.size
1640
+ end
1641
+
1642
+ def test_find_in_association
1643
+ # Using sql
1644
+ assert_equal developers(:david), projects(:active_record).developers.find(developers(:david).id), "SQL find"
1645
+
1646
+ # Using ruby
1647
+ active_record = projects(:active_record)
1648
+ active_record.developers.reload
1649
+ assert_equal developers(:david), active_record.developers.find(developers(:david).id), "Ruby find"
1650
+ end
1651
+
1652
+ def test_find_in_association_with_custom_finder_sql
1653
+ assert_equal developers(:david), projects(:active_record).developers_with_finder_sql.find(developers(:david).id), "SQL find"
1654
+
1655
+ active_record = projects(:active_record)
1656
+ active_record.developers_with_finder_sql.reload
1657
+ assert_equal developers(:david), active_record.developers_with_finder_sql.find(developers(:david).id), "Ruby find"
1658
+ end
1659
+
1660
+ def test_find_in_association_with_custom_finder_sql_and_string_id
1661
+ assert_equal developers(:david), projects(:active_record).developers_with_finder_sql.find(developers(:david).id.to_s), "SQL find"
1662
+ end
1663
+
1664
+ def test_find_with_merged_options
1665
+ assert_equal 1, projects(:active_record).limited_developers.size
1666
+ assert_equal 1, projects(:active_record).limited_developers.find(:all).size
1667
+ assert_equal 3, projects(:active_record).limited_developers.find(:all, :limit => nil).size
1668
+ end
1669
+
1670
+ def test_new_with_values_in_collection
1671
+ jamis = DeveloperForProjectWithAfterCreateHook.find_by_name('Jamis')
1672
+ david = DeveloperForProjectWithAfterCreateHook.find_by_name('David')
1673
+ project = ProjectWithAfterCreateHook.new(:name => "Cooking with Bertie")
1674
+ project.developers << jamis
1675
+ project.save!
1676
+ project.reload
1677
+
1678
+ assert project.developers.include?(jamis)
1679
+ assert project.developers.include?(david)
1680
+ end
1681
+
1682
+ def test_find_in_association_with_options
1683
+ developers = projects(:active_record).developers.find(:all)
1684
+ assert_equal 3, developers.size
1685
+
1686
+ assert_equal developers(:poor_jamis), projects(:active_record).developers.find(:first, :conditions => "salary < 10000")
1687
+ assert_equal developers(:jamis), projects(:active_record).developers.find(:first, :order => "salary DESC")
1688
+ end
1689
+
1690
+ def test_replace_with_less
1691
+ david = developers(:david)
1692
+ david.projects = [projects(:action_controller)]
1693
+ assert david.save
1694
+ assert_equal 1, david.projects.length
1695
+ end
1696
+
1697
+ def test_replace_with_new
1698
+ david = developers(:david)
1699
+ david.projects = [projects(:action_controller), Project.new("name" => "ActionWebSearch")]
1700
+ david.save
1701
+ assert_equal 2, david.projects.length
1702
+ assert !david.projects.include?(projects(:active_record))
1703
+ end
1704
+
1705
+ def test_replace_on_new_object
1706
+ new_developer = Developer.new("name" => "Matz")
1707
+ new_developer.projects = [projects(:action_controller), Project.new("name" => "ActionWebSearch")]
1708
+ new_developer.save
1709
+ assert_equal 2, new_developer.projects.length
1710
+ end
1711
+
1712
+ def test_consider_type
1713
+ developer = Developer.find(:first)
1714
+ special_project = SpecialProject.create("name" => "Special Project")
1715
+
1716
+ other_project = developer.projects.first
1717
+ developer.special_projects << special_project
1718
+ developer.reload
1719
+
1720
+ assert developer.projects.include?(special_project)
1721
+ assert developer.special_projects.include?(special_project)
1722
+ assert !developer.special_projects.include?(other_project)
1723
+ end
1724
+
1725
+ def test_update_attributes_after_push_without_duplicate_join_table_rows
1726
+ developer = Developer.new("name" => "Kano")
1727
+ project = SpecialProject.create("name" => "Special Project")
1728
+ assert developer.save
1729
+ developer.projects << project
1730
+ developer.update_attribute("name", "Bruza")
1731
+ assert_equal 1, Developer.connection.select_value(<<-end_sql).to_i
1732
+ SELECT count(*) FROM developers_projects
1733
+ WHERE project_id = #{project.id}
1734
+ AND developer_id = #{developer.id}
1735
+ end_sql
1736
+ end
1737
+
1738
+ def test_updating_attributes_on_non_rich_associations
1739
+ welcome = categories(:technology).posts.first
1740
+ welcome.title = "Something else"
1741
+ assert welcome.save!
1742
+ end
1743
+
1744
+ def test_updating_attributes_on_rich_associations
1745
+ david = projects(:action_controller).developers.first
1746
+ david.name = "DHH"
1747
+ assert_raises(ActiveRecord::ReadOnlyRecord) { david.save! }
1748
+ end
1749
+
1750
+
1751
+ def test_updating_attributes_on_rich_associations_with_limited_find
1752
+ david = projects(:action_controller).developers.find(:all, :select => "developers.*").first
1753
+ david.name = "DHH"
1754
+ assert david.save!
1755
+ end
1756
+
1757
+ def test_join_table_alias
1758
+ assert_equal 3, Developer.find(:all, :include => {:projects => :developers}, :conditions => 'developers_projects_join.joined_on IS NOT NULL').size
1759
+ end
1760
+
1761
+ def test_join_with_group
1762
+ group = Developer.columns.inject([]) do |g, c|
1763
+ g << "developers.#{c.name}"
1764
+ g << "developers_projects_2.#{c.name}"
1765
+ end
1766
+ Project.columns.each { |c| group << "projects.#{c.name}" }
1767
+
1768
+ assert_equal 3, Developer.find(:all, :include => {:projects => :developers}, :conditions => 'developers_projects_join.joined_on IS NOT NULL', :group => group.join(",")).size
1769
+ end
1770
+
1771
+ def test_get_ids
1772
+ assert_equal [projects(:active_record).id, projects(:action_controller).id], developers(:david).project_ids
1773
+ assert_equal [projects(:active_record).id], developers(:jamis).project_ids
1774
+ end
1775
+
1776
+ def test_assign_ids
1777
+ developer = Developer.new("name" => "Joe")
1778
+ developer.project_ids = [projects(:active_record).id, projects(:action_controller).id]
1779
+ developer.save
1780
+ developer.reload
1781
+ assert_equal 2, developer.projects.length
1782
+ assert_equal projects(:active_record), developer.projects[0]
1783
+ assert_equal projects(:action_controller), developer.projects[1]
1784
+ end
1785
+
1786
+ def test_assign_ids_ignoring_blanks
1787
+ developer = Developer.new("name" => "Joe")
1788
+ developer.project_ids = [projects(:active_record).id, nil, projects(:action_controller).id, '']
1789
+ developer.save
1790
+ developer.reload
1791
+ assert_equal 2, developer.projects.length
1792
+ assert_equal projects(:active_record), developer.projects[0]
1793
+ assert_equal projects(:action_controller), developer.projects[1]
1794
+ end
1795
+
1796
+ def test_select_limited_ids_list
1797
+ # Set timestamps
1798
+ Developer.transaction do
1799
+ Developer.find(:all, :order => 'id').each_with_index do |record, i|
1800
+ record.update_attributes(:created_at => 5.years.ago + (i * 5.minutes))
1801
+ end
1802
+ end
1803
+
1804
+ join_base = ActiveRecord::Associations::ClassMethods::JoinDependency::JoinBase.new(Project)
1805
+ join_dep = ActiveRecord::Associations::ClassMethods::JoinDependency.new(join_base, :developers, nil)
1806
+ unless current_adapter?(:IBM_DBAdapter)
1807
+ projects = Project.send(:select_limited_ids_list, {:order => 'developers.created_at'}, join_dep)
1808
+ assert_equal %w(1 2), projects.scan(/\d/).sort
1809
+ else
1810
+ # LUW: [IBM][CLI Driver][DB2/LINUX] SQL0214N
1811
+ # An expression in the ORDER BY clause in the following position,
1812
+ # or starting with "DEVELOPERS" in the "ORDER BY" clause is not valid.
1813
+ # Reason code = "2". SQLSTATE=42822 SQLCODE=-214:
1814
+ # SELECT DISTINCT projects.id FROM projects
1815
+ # LEFT OUTER JOIN developers_projects ON developers_projects.project_id = projects.id
1816
+ # LEFT OUTER JOIN developers ON developers.id = developers_projects.developer_id
1817
+ # ORDER BY developers.created_at
1818
+ #
1819
+ # i5: [IBM][CLI Driver][AS] SQL0214N
1820
+ # An expression in the ORDER BY clause in the following position,
1821
+ # or starting with "1" in the "CREATED_AT" clause is not valid.
1822
+ # Reason code = "2". SQLSTATE=42822 SQLCODE=-214:
1823
+ # SELECT DISTINCT projects.id FROM projects
1824
+ # LEFT OUTER JOIN developers_projects ON developers_projects.project_id = projects.id
1825
+ # LEFT OUTER JOIN developers ON developers.id = developers_projects.developer_id
1826
+ # ORDER BY developers.created_at
1827
+ #
1828
+ # zOS 9:[IBM][CLI Driver][DB2] SQL0214N
1829
+ # An expression in the ORDER BY clause in the following position,
1830
+ # or starting with "CREATED_AT" in the "ORDER BY" clause is not valid.
1831
+ # Reason code = "2". SQLSTATE=42822 SQLCODE=-214:
1832
+ # SELECT DISTINCT projects.id FROM projects
1833
+ # LEFT OUTER JOIN developers_projects ON developers_projects.project_id = projects.id
1834
+ # LEFT OUTER JOIN developers ON developers.id = developers_projects.developer_id
1835
+ # ORDER BY developers.created_at
1836
+ #
1837
+ end
1838
+ end
1839
+ end