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

   1 require "cases/helper"
   2 require 'models/developer'
   3 require 'models/project'
   4 require 'models/company'
   5
   6 class HasOneAssociationsTest < ActiveRecord::TestCase
   7   fixtures :accounts, :companies, :developers, :projects, :developers_projects
   8
   9   def setup
  10     Account.destroyed_account_ids.clear
  11   end
  12
  13   def test_has_one
  14     assert_equal companies(:first_firm).account, Account.find(1)
  15     assert_equal Account.find(1).credit_limit, companies(:first_firm).account.credit_limit
  16   end
  17
  18   def test_has_one_cache_nils
  19     firm = companies(:another_firm)
  20     assert_queries(1) { assert_nil firm.account }
  21     assert_queries(0) { assert_nil firm.account }
  22
  23     firms = Firm.find(:all, :include => :account)
  24     assert_queries(0) { firms.each(&:account) }
  25   end
  26
  27   def test_with_select
  28     assert_equal Firm.find(1).account_with_select.attributes.size, 2
  29     assert_equal Firm.find(1, :include => :account_with_select).account_with_select.attributes.size, 2
  30   end
  31
  32   def test_finding_using_primary_key
  33     firm = companies(:first_firm)
  34     assert_equal Account.find_by_firm_id(firm.id), firm.account
  35     firm.firm_id = companies(:rails_core).id
  36     assert_equal accounts(:rails_core_account), firm.account_using_primary_key
  37   end
  38
  39   def test_can_marshal_has_one_association_with_nil_target
  40     firm = Firm.new
  41     assert_nothing_raised do
  42       assert_equal firm.attributes, Marshal.load(Marshal.dump(firm)).attributes
  43     end
  44
  45     firm.account
  46     assert_nothing_raised do
  47       assert_equal firm.attributes, Marshal.load(Marshal.dump(firm)).attributes
  48     end
  49   end
  50
  51   def test_proxy_assignment
  52     company = companies(:first_firm)
  53     assert_nothing_raised { company.account = company.account }
  54   end
  55
  56   def test_triple_equality
  57     assert Account === companies(:first_firm).account
  58     assert companies(:first_firm).account === Account
  59   end
  60
  61   def test_type_mismatch
  62     assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).account = 1 }
  63     assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).account = Project.find(1) }
  64   end
  65
  66   def test_natural_assignment
  67     apple = Firm.create("name" => "Apple")
  68     citibank = Account.create("credit_limit" => 10)
  69     apple.account = citibank
  70     assert_equal apple.id, citibank.firm_id
  71   end
  72
  73   def test_natural_assignment_to_nil
  74     old_account_id = companies(:first_firm).account.id
  75     companies(:first_firm).account = nil
  76     companies(:first_firm).save
  77     assert_nil companies(:first_firm).account
  78     # account is dependent, therefore is destroyed when reference to owner is lost
  79     assert_raises(ActiveRecord::RecordNotFound) { Account.find(old_account_id) }
  80   end
  81
  82   def test_natural_assignment_to_already_associated_record
  83     company = companies(:first_firm)
  84     account = accounts(:signals37)
  85     assert_equal company.account, account
  86     company.account = account
  87     company.reload
  88     account.reload
  89     assert_equal company.account, account
  90   end
  91
  92   def test_assignment_without_replacement
  93     apple = Firm.create("name" => "Apple")
  94     citibank = Account.create("credit_limit" => 10)
  95     apple.account = citibank
  96     assert_equal apple.id, citibank.firm_id
  97
  98     hsbc = apple.build_account({ :credit_limit => 20}, false)
  99     assert_equal apple.id, hsbc.firm_id
 100     hsbc.save
 101     assert_equal apple.id, citibank.firm_id
 102
 103     nykredit = apple.create_account({ :credit_limit => 30}, false)
 104     assert_equal apple.id, nykredit.firm_id
 105     assert_equal apple.id, citibank.firm_id
 106     assert_equal apple.id, hsbc.firm_id
 107   end
 108
 109   def test_assignment_without_replacement_on_create
 110     apple = Firm.create("name" => "Apple")
 111     citibank = Account.create("credit_limit" => 10)
 112     apple.account = citibank
 113     assert_equal apple.id, citibank.firm_id
 114
 115     hsbc = apple.create_account({:credit_limit => 10}, false)
 116     assert_equal apple.id, hsbc.firm_id
 117     hsbc.save
 118     assert_equal apple.id, citibank.firm_id
 119   end
 120
 121   def test_dependence
 122     num_accounts = Account.count
 123
 124     firm = Firm.find(1)
 125     assert !firm.account.nil?
 126     account_id = firm.account.id
 127     assert_equal [], Account.destroyed_account_ids[firm.id]
 128
 129     firm.destroy
 130     assert_equal num_accounts - 1, Account.count
 131     assert_equal [account_id], Account.destroyed_account_ids[firm.id]
 132   end
 133
 134   def test_exclusive_dependence
 135     num_accounts = Account.count
 136
 137     firm = ExclusivelyDependentFirm.find(9)
 138     assert !firm.account.nil?
 139     account_id = firm.account.id
 140     assert_equal [], Account.destroyed_account_ids[firm.id]
 141
 142     firm.destroy
 143     assert_equal num_accounts - 1, Account.count
 144     assert_equal [], Account.destroyed_account_ids[firm.id]
 145   end
 146
 147   def test_dependence_with_nil_associate
 148     firm = DependentFirm.new(:name => 'nullify')
 149     firm.save!
 150     assert_nothing_raised { firm.destroy }
 151   end
 152
 153   def test_succesful_build_association
 154     firm = Firm.new("name" => "GlobalMegaCorp")
 155     firm.save
 156
 157     account = firm.build_account("credit_limit" => 1000)
 158     assert account.save
 159     assert_equal account, firm.account
 160   end
 161
 162   def test_failing_build_association
 163     firm = Firm.new("name" => "GlobalMegaCorp")
 164     firm.save
 165
 166     account = firm.build_account
 167     assert !account.save
 168     assert_equal "can't be empty", account.errors.on("credit_limit")
 169   end
 170
 171   def test_build_association_twice_without_saving_affects_nothing
 172     count_of_account = Account.count
 173     firm = Firm.find(:first)
 174     account1 = firm.build_account("credit_limit" => 1000)
 175     account2 = firm.build_account("credit_limit" => 2000)
 176
 177     assert_equal count_of_account, Account.count
 178   end
 179
 180   def test_create_association
 181     firm = Firm.create(:name => "GlobalMegaCorp")
 182     account = firm.create_account(:credit_limit => 1000)
 183     assert_equal account, firm.reload.account
 184   end
 185
 186   def test_build
 187     firm = Firm.new("name" => "GlobalMegaCorp")
 188     firm.save
 189
 190     firm.account = account = Account.new("credit_limit" => 1000)
 191     assert_equal account, firm.account
 192     assert account.save
 193     assert_equal account, firm.account
 194   end
 195
 196   def test_build_before_child_saved
 197     firm = Firm.find(1)
 198
 199     account = firm.account.build("credit_limit" => 1000)
 200     assert_equal account, firm.account
 201     assert account.new_record?
 202     assert firm.save
 203     assert_equal account, firm.account
 204     assert !account.new_record?
 205   end
 206
 207   def test_build_before_either_saved
 208     firm = Firm.new("name" => "GlobalMegaCorp")
 209
 210     firm.account = account = Account.new("credit_limit" => 1000)
 211     assert_equal account, firm.account
 212     assert account.new_record?
 213     assert firm.save
 214     assert_equal account, firm.account
 215     assert !account.new_record?
 216   end
 217
 218   def test_failing_build_association
 219     firm = Firm.new("name" => "GlobalMegaCorp")
 220     firm.save
 221
 222     firm.account = account = Account.new
 223     assert_equal account, firm.account
 224     assert !account.save
 225     assert_equal account, firm.account
 226     assert_equal "can't be empty", account.errors.on("credit_limit")
 227   end
 228
 229   def test_create
 230     firm = Firm.new("name" => "GlobalMegaCorp")
 231     firm.save
 232     firm.account = account = Account.create("credit_limit" => 1000)
 233     assert_equal account, firm.account
 234   end
 235
 236   def test_create_before_save
 237     firm = Firm.new("name" => "GlobalMegaCorp")
 238     firm.account = account = Account.create("credit_limit" => 1000)
 239     assert_equal account, firm.account
 240   end
 241
 242   def test_dependence_with_missing_association
 243     Account.destroy_all
 244     firm = Firm.find(1)
 245     assert firm.account.nil?
 246     firm.destroy
 247   end
 248
 249   def test_dependence_with_missing_association_and_nullify
 250     Account.destroy_all
 251     firm = DependentFirm.find(:first)
 252     assert firm.account.nil?
 253     firm.destroy
 254   end
 255
 256   def test_assignment_before_parent_saved
 257     firm = Firm.new("name" => "GlobalMegaCorp")
 258     firm.account = a = Account.find(1)
 259     assert firm.new_record?
 260     assert_equal a, firm.account
 261     assert firm.save
 262     assert_equal a, firm.account
 263     assert_equal a, firm.account(true)
 264   end
 265
 266   def test_finding_with_interpolated_condition
 267     firm = Firm.find(:first)
 268     superior = firm.clients.create(:name => 'SuperiorCo')
 269     superior.rating = 10
 270     superior.save
 271     assert_equal 10, firm.clients_with_interpolated_conditions.first.rating
 272   end
 273
 274   def test_assignment_before_child_saved
 275     firm = Firm.find(1)
 276     firm.account = a = Account.new("credit_limit" => 1000)
 277     assert !a.new_record?
 278     assert_equal a, firm.account
 279     assert_equal a, firm.account
 280     assert_equal a, firm.account(true)
 281   end
 282
 283   def test_save_fails_for_invalid_has_one
 284     firm = Firm.find(:first)
 285     assert firm.valid?
 286
 287     firm.account = Account.new
 288
 289     assert !firm.account.valid?
 290     assert !firm.valid?
 291     assert !firm.save
 292     assert_equal "is invalid", firm.errors.on("account")
 293   end
 294
 295
 296   def test_save_succeeds_for_invalid_has_one_with_validate_false
 297     firm = Firm.find(:first)
 298     assert firm.valid?
 299
 300     firm.unvalidated_account = Account.new
 301
 302     assert !firm.unvalidated_account.valid?
 303     assert firm.valid?
 304     assert firm.save
 305   end
 306
 307   def test_assignment_before_either_saved
 308     firm = Firm.new("name" => "GlobalMegaCorp")
 309     firm.account = a = Account.new("credit_limit" => 1000)
 310     assert firm.new_record?
 311     assert a.new_record?
 312     assert_equal a, firm.account
 313     assert firm.save
 314     assert !firm.new_record?
 315     assert !a.new_record?
 316     assert_equal a, firm.account
 317     assert_equal a, firm.account(true)
 318   end
 319
 320   def test_not_resaved_when_unchanged
 321     firm = Firm.find(:first, :include => :account)
 322     firm.name += '-changed'
 323     assert_queries(1) { firm.save! }
 324
 325     firm = Firm.find(:first)
 326     firm.account = Account.find(:first)
 327     assert_queries(Firm.partial_updates? ? 0 : 1) { firm.save! }
 328
 329     firm = Firm.find(:first).clone
 330     firm.account = Account.find(:first)
 331     assert_queries(2) { firm.save! }
 332
 333     firm = Firm.find(:first).clone
 334     firm.account = Account.find(:first).clone
 335     assert_queries(2) { firm.save! }
 336   end
 337
 338   def test_save_still_works_after_accessing_nil_has_one
 339     jp = Company.new :name => 'Jaded Pixel'
 340     jp.dummy_account.nil?
 341
 342     assert_nothing_raised do
 343       jp.save!
 344     end
 345   end
 346
 347   def test_cant_save_readonly_association
 348     assert_raise(ActiveRecord::ReadOnlyRecord) { companies(:first_firm).readonly_account.save!  }
 349     assert companies(:first_firm).readonly_account.readonly?
 350   end
 351
 352   def test_has_one_proxy_should_not_respond_to_private_methods
 353     assert_raises(NoMethodError) { accounts(:signals37).private_method }
 354     assert_raises(NoMethodError) { companies(:first_firm).account.private_method }
 355   end
 356
 357   def test_has_one_proxy_should_respond_to_private_methods_via_send
 358     accounts(:signals37).send(:private_method)
 359     companies(:first_firm).account.send(:private_method)
 360   end
 361
 362 end