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_raise(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).account = 1 }
  63     assert_raise(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_raise(ActiveRecord::RecordNotFound) { Account.find(old_account_id) }
  80   end
  81
  82   def test_nullification_on_association_change
  83     firm = companies(:rails_core)
  84     old_account_id = firm.account.id
  85     firm.account = Account.new
  86     # account is dependent with nullify, therefore its firm_id should be nil
  87     assert_nil Account.find(old_account_id).firm_id
  88   end
  89
  90   def test_association_changecalls_delete
  91     companies(:first_firm).deletable_account = Account.new
  92     assert_equal [], Account.destroyed_account_ids[companies(:first_firm).id]
  93   end
  94
  95   def test_association_change_calls_destroy
  96     companies(:first_firm).account = Account.new
  97     assert_equal [companies(:first_firm).id], Account.destroyed_account_ids[companies(:first_firm).id]
  98   end
  99
 100   def test_natural_assignment_to_already_associated_record
 101     company = companies(:first_firm)
 102     account = accounts(:signals37)
 103     assert_equal company.account, account
 104     company.account = account
 105     company.reload
 106     account.reload
 107     assert_equal company.account, account
 108   end
 109
 110   def test_assignment_without_replacement
 111     apple = Firm.create("name" => "Apple")
 112     citibank = Account.create("credit_limit" => 10)
 113     apple.account = citibank
 114     assert_equal apple.id, citibank.firm_id
 115
 116     hsbc = apple.build_account({ :credit_limit => 20}, false)
 117     assert_equal apple.id, hsbc.firm_id
 118     hsbc.save
 119     assert_equal apple.id, citibank.firm_id
 120
 121     nykredit = apple.create_account({ :credit_limit => 30}, false)
 122     assert_equal apple.id, nykredit.firm_id
 123     assert_equal apple.id, citibank.firm_id
 124     assert_equal apple.id, hsbc.firm_id
 125   end
 126
 127   def test_assignment_without_replacement_on_create
 128     apple = Firm.create("name" => "Apple")
 129     citibank = Account.create("credit_limit" => 10)
 130     apple.account = citibank
 131     assert_equal apple.id, citibank.firm_id
 132
 133     hsbc = apple.create_account({:credit_limit => 10}, false)
 134     assert_equal apple.id, hsbc.firm_id
 135     hsbc.save
 136     assert_equal apple.id, citibank.firm_id
 137   end
 138
 139   def test_dependence
 140     num_accounts = Account.count
 141
 142     firm = Firm.find(1)
 143     assert !firm.account.nil?
 144     account_id = firm.account.id
 145     assert_equal [], Account.destroyed_account_ids[firm.id]
 146
 147     firm.destroy
 148     assert_equal num_accounts - 1, Account.count
 149     assert_equal [account_id], Account.destroyed_account_ids[firm.id]
 150   end
 151
 152   def test_exclusive_dependence
 153     num_accounts = Account.count
 154
 155     firm = ExclusivelyDependentFirm.find(9)
 156     assert !firm.account.nil?
 157     account_id = firm.account.id
 158     assert_equal [], Account.destroyed_account_ids[firm.id]
 159
 160     firm.destroy
 161     assert_equal num_accounts - 1, Account.count
 162     assert_equal [], Account.destroyed_account_ids[firm.id]
 163   end
 164
 165   def test_dependence_with_nil_associate
 166     firm = DependentFirm.new(:name => 'nullify')
 167     firm.save!
 168     assert_nothing_raised { firm.destroy }
 169   end
 170
 171   def test_succesful_build_association
 172     firm = Firm.new("name" => "GlobalMegaCorp")
 173     firm.save
 174
 175     account = firm.build_account("credit_limit" => 1000)
 176     assert account.save
 177     assert_equal account, firm.account
 178   end
 179
 180   def test_failing_build_association
 181     firm = Firm.new("name" => "GlobalMegaCorp")
 182     firm.save
 183
 184     account = firm.build_account
 185     assert !account.save
 186     assert_equal "can't be empty", account.errors.on("credit_limit")
 187   end
 188
 189   def test_build_association_twice_without_saving_affects_nothing
 190     count_of_account = Account.count
 191     firm = Firm.find(:first)
 192     account1 = firm.build_account("credit_limit" => 1000)
 193     account2 = firm.build_account("credit_limit" => 2000)
 194
 195     assert_equal count_of_account, Account.count
 196   end
 197
 198   def test_create_association
 199     firm = Firm.create(:name => "GlobalMegaCorp")
 200     account = firm.create_account(:credit_limit => 1000)
 201     assert_equal account, firm.reload.account
 202   end
 203
 204   def test_build
 205     firm = Firm.new("name" => "GlobalMegaCorp")
 206     firm.save
 207
 208     firm.account = account = Account.new("credit_limit" => 1000)
 209     assert_equal account, firm.account
 210     assert account.save
 211     assert_equal account, firm.account
 212   end
 213
 214   def test_failing_build_association
 215     firm = Firm.new("name" => "GlobalMegaCorp")
 216     firm.save
 217
 218     firm.account = account = Account.new
 219     assert_equal account, firm.account
 220     assert !account.save
 221     assert_equal account, firm.account
 222     assert_equal "can't be empty", account.errors.on("credit_limit")
 223   end
 224
 225   def test_create
 226     firm = Firm.new("name" => "GlobalMegaCorp")
 227     firm.save
 228     firm.account = account = Account.create("credit_limit" => 1000)
 229     assert_equal account, firm.account
 230   end
 231
 232   def test_create_before_save
 233     firm = Firm.new("name" => "GlobalMegaCorp")
 234     firm.account = account = Account.create("credit_limit" => 1000)
 235     assert_equal account, firm.account
 236   end
 237
 238   def test_dependence_with_missing_association
 239     Account.destroy_all
 240     firm = Firm.find(1)
 241     assert firm.account.nil?
 242     firm.destroy
 243   end
 244
 245   def test_dependence_with_missing_association_and_nullify
 246     Account.destroy_all
 247     firm = DependentFirm.find(:first)
 248     assert firm.account.nil?
 249     firm.destroy
 250   end
 251
 252   def test_finding_with_interpolated_condition
 253     firm = Firm.find(:first)
 254     superior = firm.clients.create(:name => 'SuperiorCo')
 255     superior.rating = 10
 256     superior.save
 257     assert_equal 10, firm.clients_with_interpolated_conditions.first.rating
 258   end
 259
 260   def test_assignment_before_child_saved
 261     firm = Firm.find(1)
 262     firm.account = a = Account.new("credit_limit" => 1000)
 263     assert !a.new_record?
 264     assert_equal a, firm.account
 265     assert_equal a, firm.account
 266     assert_equal a, firm.account(true)
 267   end
 268
 269   def test_save_still_works_after_accessing_nil_has_one
 270     jp = Company.new :name => 'Jaded Pixel'
 271     jp.dummy_account.nil?
 272
 273     assert_nothing_raised do
 274       jp.save!
 275     end
 276   end
 277
 278   def test_cant_save_readonly_association
 279     assert_raise(ActiveRecord::ReadOnlyRecord) { companies(:first_firm).readonly_account.save!  }
 280     assert companies(:first_firm).readonly_account.readonly?
 281   end
 282
 283   def test_has_one_proxy_should_not_respond_to_private_methods
 284     assert_raise(NoMethodError) { accounts(:signals37).private_method }
 285     assert_raise(NoMethodError) { companies(:first_firm).account.private_method }
 286   end
 287
 288   def test_has_one_proxy_should_respond_to_private_methods_via_send
 289     accounts(:signals37).send(:private_method)
 290     companies(:first_firm).account.send(:private_method)
 291   end
 292
 293   def test_save_of_record_with_loaded_has_one
 294     @firm = companies(:first_firm)
 295     assert_not_nil @firm.account
 296
 297     assert_nothing_raised do
 298       Firm.find(@firm.id).save!
 299       Firm.find(@firm.id, :include => :account).save!
 300     end
 301
 302     @firm.account.destroy
 303
 304     assert_nothing_raised do
 305       Firm.find(@firm.id).save!
 306       Firm.find(@firm.id, :include => :account).save!
 307     end
 308   end
 309 end