vendor/rails/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb

   1 require "cases/helper"
   2 require 'models/developer'
   3 require 'models/project'
   4 require 'models/company'
   5 require 'models/topic'
   6 require 'models/reply'
   7 require 'models/computer'
   8 require 'models/customer'
   9 require 'models/order'
  10 require 'models/categorization'
  11 require 'models/category'
  12 require 'models/post'
  13 require 'models/author'
  14 require 'models/comment'
  15 require 'models/tag'
  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'
  23 require 'models/club'
  24 require 'models/member'
  25 require 'models/membership'
  26 require 'models/sponsor'
  27
  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"
  35
  36   after_create :add_david
  37
  38   def add_david
  39     david = DeveloperForProjectWithAfterCreateHook.find_by_name('David')
  40     david.projects << self
  41   end
  42 end
  43
  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"
  51 end
  52
  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"
  60 end
  61
  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"
  69 end
  70
  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}'
  79 end
  80
  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
  84
  85   def test_has_and_belongs_to_many
  86     david = Developer.find(1)
  87
  88     assert !david.projects.empty?
  89     assert_equal 2, david.projects.size
  90
  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)
  95   end
  96
  97   def test_triple_equality
  98     assert !(Array === Developer.find(1).projects)
  99     assert Developer.find(1).projects === Array
 100   end
 101
 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
 108
 109     jamis.projects << action_controller
 110
 111     assert_equal 2, jamis.projects.size
 112     assert_equal 2, jamis.projects(true).size
 113     assert_equal 2, action_controller.developers(true).size
 114   end
 115
 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 }
 120   end
 121
 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
 128
 129     action_controller.developers << jamis
 130
 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
 134   end
 135
 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
 143
 144     action_controller.developers << jamis
 145
 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
 150   end
 151
 152   def test_adding_multiple
 153     aredridel = Developer.new("name" => "Aredridel")
 154     aredridel.save
 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
 159   end
 160
 161   def test_adding_a_collection
 162     aredridel = Developer.new("name" => "Aredridel")
 163     aredridel.save
 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
 168   end
 169
 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
 174
 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
 178   end
 179
 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?")
 196   end
 197
 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?
 204     assert p.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
 211   end
 212
 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
 217
 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
 221
 222     new_project.reload
 223     assert_equal amount_of_developers, new_project.developers.size
 224     assert_equal developers, new_project.developers
 225   end
 226
 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
 230   end
 231
 232   def test_build
 233     devel = Developer.find(1)
 234     proj = assert_no_queries { devel.projects.build("name" => "Projekt") }
 235     assert !devel.projects.loaded?
 236
 237     assert_equal devel.projects.last, proj
 238     assert devel.projects.loaded?
 239
 240     assert proj.new_record?
 241     devel.save
 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
 245   end
 246
 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?
 253     devel.save
 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
 258   end
 259
 260   def test_create
 261     devel = Developer.find(1)
 262     proj = devel.projects.create("name" => "Projekt")
 263     assert !devel.projects.loaded?
 264
 265     assert_equal devel.projects.last, proj
 266     assert !devel.projects.loaded?
 267
 268     assert !proj.new_record?
 269     assert_equal Developer.find(1).projects.sort_by(&:id).last, proj  # prove join table is updated
 270   end
 271
 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?
 278     devel.save
 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
 283   end
 284
 285   def test_creation_respects_hash_condition
 286     post = categories(:general).post_with_conditions.build(:body => '')
 287
 288     assert        post.save
 289     assert_equal  'Yet Another Testing Title', post.title
 290
 291     another_post = categories(:general).post_with_conditions.create(:body => '')
 292
 293     assert        !another_post.new_record?
 294     assert_equal  'Yet Another Testing Title', another_post.title
 295   end
 296
 297   def test_uniq_after_the_fact
 298     dev = developers(:jamis)
 299     dev.projects << projects(:active_record)
 300     dev.projects << projects(:active_record)
 301
 302     assert_equal 3, dev.projects.size
 303     assert_equal 1, dev.projects.uniq.size
 304   end
 305
 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
 310   end
 311
 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
 317
 318     project.developers << developers(:david)
 319     project.developers << developers(:jamis)
 320     assert_equal 3, project.developers.size
 321   end
 322
 323   def test_deleting
 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
 329
 330     david.projects.delete(active_record)
 331
 332     assert_equal 1, david.projects.size
 333     assert_equal 1, david.projects(true).size
 334     assert_equal 2, active_record.developers(true).size
 335   end
 336
 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
 343   end
 344
 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
 350
 351     active_record.developers_by_sql.delete(david)
 352     assert_equal 2, active_record.developers_by_sql(true).size
 353   end
 354
 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
 359
 360     active_record.developers_by_sql.delete(Developer.find(:all))
 361     assert_equal 0, active_record.developers_by_sql(true).size
 362   end
 363
 364   def test_deleting_all
 365     david = Developer.find(1)
 366     david.projects.reload
 367     david.projects.clear
 368     assert_equal 0, david.projects.size
 369     assert_equal 0, david.projects(true).size
 370   end
 371
 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?
 378   end
 379
 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
 382   end
 383
 384   def test_destroy_all
 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?
 391   end
 392
 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)
 397     end
 398   end
 399
 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
 404
 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)
 408
 409     projects(:active_record).developers_named_david.clear
 410     assert_equal 2, projects(:active_record, :reload).developers.size
 411   end
 412
 413   def test_find_in_association
 414     # Using sql
 415     assert_equal developers(:david), projects(:active_record).developers.find(developers(:david).id), "SQL find"
 416
 417     # Using ruby
 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"
 421   end
 422
 423   def test_include_uses_array_include_after_loaded
 424     project = projects(:active_record)
 425     project.developers.class # force load target
 426
 427     developer = project.developers.first
 428
 429     assert_no_queries do
 430       assert project.developers.loaded?
 431       assert project.developers.include?(developer)
 432     end
 433   end
 434
 435   def test_include_checks_if_record_exists_if_target_not_loaded
 436     project = projects(:active_record)
 437     developer = project.developers.first
 438
 439     project.reload
 440     assert ! project.developers.loaded?
 441     assert_queries(1) do
 442       assert project.developers.include?(developer)
 443     end
 444     assert ! project.developers.loaded?
 445   end
 446
 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
 450
 451     assert ! project.developers.loaded?
 452     assert ! project.developers.include?(developer)
 453   end
 454
 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"
 457
 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"
 461   end
 462
 463   def test_find_in_association_with_custom_finder_sql_and_multiple_interpolations
 464     # interpolate once:
 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"
 468   end
 469
 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"
 472   end
 473
 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
 478   end
 479
 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')
 485
 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')
 488   end
 489
 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')
 495
 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')
 498   end
 499
 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')
 505
 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')
 508   end
 509
 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')
 515
 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')
 518   end
 519
 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
 523   end
 524
 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
 528   end
 529
 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? }
 533   end
 534
 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
 540     project.save!
 541     project.reload
 542
 543     assert project.developers.include?(jamis)
 544     assert project.developers.include?(david)
 545   end
 546
 547   def test_find_in_association_with_options
 548     developers = projects(:active_record).developers.find(:all)
 549     assert_equal 3, developers.size
 550
 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")
 553   end
 554
 555   def test_replace_with_less
 556     david = developers(:david)
 557     david.projects = [projects(:action_controller)]
 558     assert david.save
 559     assert_equal 1, david.projects.length
 560   end
 561
 562   def test_replace_with_new
 563     david = developers(:david)
 564     david.projects = [projects(:action_controller), Project.new("name" => "ActionWebSearch")]
 565     david.save
 566     assert_equal 2, david.projects.length
 567     assert !david.projects.include?(projects(:active_record))
 568   end
 569
 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")]
 573     new_developer.save
 574     assert_equal 2, new_developer.projects.length
 575   end
 576
 577   def test_consider_type
 578     developer = Developer.find(:first)
 579     special_project = SpecialProject.create("name" => "Special Project")
 580
 581     other_project = developer.projects.first
 582     developer.special_projects << special_project
 583     developer.reload
 584
 585     assert developer.projects.include?(special_project)
 586     assert developer.special_projects.include?(special_project)
 587     assert !developer.special_projects.include?(other_project)
 588   end
 589
 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}
 600     end_sql
 601   end
 602
 603   def test_updating_attributes_on_non_rich_associations
 604     welcome = categories(:technology).posts.first
 605     welcome.title = "Something else"
 606     assert welcome.save!
 607   end
 608
 609   def test_habtm_respects_select
 610     categories(:technology).select_testing_posts(true).each do |o|
 611       assert_respond_to o, :correctness_marker
 612     end
 613     assert_respond_to categories(:technology).select_testing_posts.find(:first), :correctness_marker
 614   end
 615
 616   def test_updating_attributes_on_rich_associations
 617     david = projects(:action_controller).developers.first
 618     david.name = "DHH"
 619     assert_raises(ActiveRecord::ReadOnlyRecord) { david.save! }
 620   end
 621
 622   def test_updating_attributes_on_rich_associations_with_limited_find_from_reflection
 623     david = projects(:action_controller).selected_developers.first
 624     david.name = "DHH"
 625     assert_nothing_raised { david.save! }
 626   end
 627
 628
 629   def test_updating_attributes_on_rich_associations_with_limited_find
 630     david = projects(:action_controller).developers.find(:all, :select => "developers.*").first
 631     david.name = "DHH"
 632     assert david.save!
 633   end
 634
 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
 637   end
 638
 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}"
 643     end
 644     Project.columns.each { |c| group << "projects.#{c.name}" }
 645
 646     assert_equal 3, Developer.find(:all, :include => {:projects => :developers}, :conditions => 'developers_projects_join.joined_on IS NOT NULL', :group => group.join(",")).size
 647   end
 648
 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
 654   end
 655
 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
 659   end
 660
 661   def test_get_ids
 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
 664   end
 665
 666   def test_get_ids_for_loaded_associations
 667     developer = developers(:david)
 668     developer.projects(true)
 669     assert_queries(0) do
 670       developer.project_ids
 671       developer.project_ids
 672     end
 673   end
 674
 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?
 680   end
 681
 682   def test_assign_ids
 683     developer = Developer.new("name" => "Joe")
 684     developer.project_ids = projects(:active_record, :action_controller).map(&:id)
 685     developer.save
 686     developer.reload
 687     assert_equal 2, developer.projects.length
 688     assert_equal [projects(:active_record), projects(:action_controller)].map(&:id).sort, developer.project_ids.sort
 689   end
 690
 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, '']
 694     developer.save
 695     developer.reload
 696     assert_equal 2, developer.projects.length
 697     assert_equal [projects(:active_record), projects(:action_controller)].map(&:id).sort, developer.project_ids.sort
 698   end
 699
 700   def test_select_limited_ids_list
 701     # Set timestamps
 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))
 705       end
 706     end
 707
 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
 713   end
 714
 715   def test_scoped_find_on_through_association_doesnt_return_read_only_records
 716     tag = Post.find(1).tags.find_by_name("General")
 717
 718     assert_nothing_raised do
 719       tag.save!
 720     end
 721   end
 722
 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
 725   end
 726
 727   def test_symbols_as_keys
 728     developer = DeveloperWithSymbolsForKeys.new(:name => 'David')
 729     project = ProjectWithSymbolsForKeys.new(:name => 'Rails Testing')
 730     project.developers << developer
 731     project.save!
 732
 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)
 737   end
 738
 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')
 743   end
 744
 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') }
 750   end
 751
 752   def test_count
 753     david = Developer.find(1)
 754     assert_equal 2, david.projects.count
 755   end
 756
 757   def test_count_with_counter_sql
 758     developer  = DeveloperWithCounterSQL.create(:name => 'tekin')
 759     developer.project_ids = [projects(:active_record).id]
 760     developer.save
 761     developer.reload
 762     assert_equal 1, developer.projects.count
 763   end
 764
 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
 769         # nothing
 770       end
 771     end
 772   end
 773 end