vendor/rails/activerecord/test/cases/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 AssociationsTest < ActiveRecord::TestCase
  29   fixtures :accounts, :companies, :developers, :projects, :developers_projects,
  30            :computers, :people, :readers
  31
  32   def test_include_with_order_works
  33     assert_nothing_raised {Account.find(:first, :order => 'id', :include => :firm)}
  34     assert_nothing_raised {Account.find(:first, :order => :id, :include => :firm)}
  35   end
  36
  37   def test_bad_collection_keys
  38     assert_raise(ArgumentError, 'ActiveRecord should have barked on bad collection keys') do
  39       Class.new(ActiveRecord::Base).has_many(:wheels, :name => 'wheels')
  40     end
  41   end
  42
  43   def test_should_construct_new_finder_sql_after_create
  44     person = Person.new :first_name => 'clark'
  45     assert_equal [], person.readers.find(:all)
  46     person.save!
  47     reader = Reader.create! :person => person, :post => Post.new(:title => "foo", :body => "bar")
  48     assert person.readers.find(reader.id)
  49   end
  50
  51   def test_force_reload
  52     firm = Firm.new("name" => "A New Firm, Inc")
  53     firm.save
  54     firm.clients.each {|c|} # forcing to load all clients
  55     assert firm.clients.empty?, "New firm shouldn't have client objects"
  56     assert_equal 0, firm.clients.size, "New firm should have 0 clients"
  57
  58     client = Client.new("name" => "TheClient.com", "firm_id" => firm.id)
  59     client.save
  60
  61     assert firm.clients.empty?, "New firm should have cached no client objects"
  62     assert_equal 0, firm.clients.size, "New firm should have cached 0 clients count"
  63
  64     assert !firm.clients(true).empty?, "New firm should have reloaded client objects"
  65     assert_equal 1, firm.clients(true).size, "New firm should have reloaded clients count"
  66   end
  67
  68   def test_storing_in_pstore
  69     require "tmpdir"
  70     store_filename = File.join(Dir.tmpdir, "ar-pstore-association-test")
  71     File.delete(store_filename) if File.exist?(store_filename)
  72     require "pstore"
  73     apple = Firm.create("name" => "Apple")
  74     natural = Client.new("name" => "Natural Company")
  75     apple.clients << natural
  76
  77     db = PStore.new(store_filename)
  78     db.transaction do
  79       db["apple"] = apple
  80     end
  81
  82     db = PStore.new(store_filename)
  83     db.transaction do
  84       assert_equal "Natural Company", db["apple"].clients.first.name
  85     end
  86   end
  87 end
  88
  89 class AssociationProxyTest < ActiveRecord::TestCase
  90   fixtures :authors, :posts, :categorizations, :categories, :developers, :projects, :developers_projects
  91
  92   def test_proxy_accessors
  93     welcome = posts(:welcome)
  94     assert_equal  welcome, welcome.author.proxy_owner
  95     assert_equal  welcome.class.reflect_on_association(:author), welcome.author.proxy_reflection
  96     welcome.author.class  # force load target
  97     assert_equal  welcome.author, welcome.author.proxy_target
  98
  99     david = authors(:david)
 100     assert_equal  david, david.posts.proxy_owner
 101     assert_equal  david.class.reflect_on_association(:posts), david.posts.proxy_reflection
 102     david.posts.class   # force load target
 103     assert_equal  david.posts, david.posts.proxy_target
 104
 105     assert_equal  david, david.posts_with_extension.testing_proxy_owner
 106     assert_equal  david.class.reflect_on_association(:posts_with_extension), david.posts_with_extension.testing_proxy_reflection
 107     david.posts_with_extension.class   # force load target
 108     assert_equal  david.posts_with_extension, david.posts_with_extension.testing_proxy_target
 109   end
 110
 111   def test_push_does_not_load_target
 112     david = authors(:david)
 113
 114     david.posts << (post = Post.new(:title => "New on Edge", :body => "More cool stuff!"))
 115     assert !david.posts.loaded?
 116     assert david.posts.include?(post)
 117   end
 118
 119   def test_push_has_many_through_does_not_load_target
 120     david = authors(:david)
 121
 122     david.categories << categories(:technology)
 123     assert !david.categories.loaded?
 124     assert david.categories.include?(categories(:technology))
 125   end
 126
 127   def test_push_followed_by_save_does_not_load_target
 128     david = authors(:david)
 129
 130     david.posts << (post = Post.new(:title => "New on Edge", :body => "More cool stuff!"))
 131     assert !david.posts.loaded?
 132     david.save
 133     assert !david.posts.loaded?
 134     assert david.posts.include?(post)
 135   end
 136
 137   def test_push_does_not_lose_additions_to_new_record
 138     josh = Author.new(:name => "Josh")
 139     josh.posts << Post.new(:title => "New on Edge", :body => "More cool stuff!")
 140     assert josh.posts.loaded?
 141     assert_equal 1, josh.posts.size
 142   end
 143
 144   def test_save_on_parent_does_not_load_target
 145     david = developers(:david)
 146
 147     assert !david.projects.loaded?
 148     david.update_attribute(:created_at, Time.now)
 149     assert !david.projects.loaded?
 150   end
 151
 152   def test_inspect_does_not_reload_a_not_yet_loaded_target
 153     andreas = Developer.new :name => 'Andreas', :log => 'new developer added'
 154     assert !andreas.audit_logs.loaded?
 155     assert_match(/message: "new developer added"/, andreas.audit_logs.inspect)
 156   end
 157
 158   def test_save_on_parent_saves_children
 159     developer = Developer.create :name => "Bryan", :salary => 50_000
 160     assert_equal 1, developer.reload.audit_logs.size
 161   end
 162
 163   def test_create_via_association_with_block
 164     post = authors(:david).posts.create(:title => "New on Edge") {|p| p.body = "More cool stuff!"}
 165     assert_equal post.title, "New on Edge"
 166     assert_equal post.body, "More cool stuff!"
 167   end
 168
 169   def test_create_with_bang_via_association_with_block
 170     post = authors(:david).posts.create!(:title => "New on Edge") {|p| p.body = "More cool stuff!"}
 171     assert_equal post.title, "New on Edge"
 172     assert_equal post.body, "More cool stuff!"
 173   end
 174
 175   def test_failed_reload_returns_nil
 176     p = setup_dangling_association
 177     assert_nil p.author.reload
 178   end
 179
 180   def test_failed_reset_returns_nil
 181     p = setup_dangling_association
 182     assert_nil p.author.reset
 183   end
 184
 185   def test_reload_returns_assocition
 186     david = developers(:david)
 187     assert_nothing_raised do
 188       assert_equal david.projects, david.projects.reload.reload
 189     end
 190   end
 191
 192   def setup_dangling_association
 193     josh = Author.create(:name => "Josh")
 194     p = Post.create(:title => "New on Edge", :body => "More cool stuff!", :author => josh)
 195     josh.destroy
 196     p
 197   end
 198 end
 199
 200 class OverridingAssociationsTest < ActiveRecord::TestCase
 201   class Person < ActiveRecord::Base; end
 202   class DifferentPerson < ActiveRecord::Base; end
 203
 204   class PeopleList < ActiveRecord::Base
 205     has_and_belongs_to_many :has_and_belongs_to_many, :before_add => :enlist
 206     has_many :has_many, :before_add => :enlist
 207     belongs_to :belongs_to
 208     has_one :has_one
 209   end
 210
 211   class DifferentPeopleList < PeopleList
 212     # Different association with the same name, callbacks should be omitted here.
 213     has_and_belongs_to_many :has_and_belongs_to_many, :class_name => 'DifferentPerson'
 214     has_many :has_many, :class_name => 'DifferentPerson'
 215     belongs_to :belongs_to, :class_name => 'DifferentPerson'
 216     has_one :has_one, :class_name => 'DifferentPerson'
 217   end
 218
 219   def test_habtm_association_redefinition_callbacks_should_differ_and_not_inherited
 220     # redeclared association on AR descendant should not inherit callbacks from superclass
 221     callbacks = PeopleList.read_inheritable_attribute(:before_add_for_has_and_belongs_to_many)
 222     assert_equal([:enlist], callbacks)
 223     callbacks = DifferentPeopleList.read_inheritable_attribute(:before_add_for_has_and_belongs_to_many)
 224     assert_equal([], callbacks)
 225   end
 226
 227   def test_has_many_association_redefinition_callbacks_should_differ_and_not_inherited
 228     # redeclared association on AR descendant should not inherit callbacks from superclass
 229     callbacks = PeopleList.read_inheritable_attribute(:before_add_for_has_many)
 230     assert_equal([:enlist], callbacks)
 231     callbacks = DifferentPeopleList.read_inheritable_attribute(:before_add_for_has_many)
 232     assert_equal([], callbacks)
 233   end
 234
 235   def test_habtm_association_redefinition_reflections_should_differ_and_not_inherited
 236     assert_not_equal(
 237       PeopleList.reflect_on_association(:has_and_belongs_to_many),
 238       DifferentPeopleList.reflect_on_association(:has_and_belongs_to_many)
 239     )
 240   end
 241
 242   def test_has_many_association_redefinition_reflections_should_differ_and_not_inherited
 243     assert_not_equal(
 244       PeopleList.reflect_on_association(:has_many),
 245       DifferentPeopleList.reflect_on_association(:has_many)
 246     )
 247   end
 248
 249   def test_belongs_to_association_redefinition_reflections_should_differ_and_not_inherited
 250     assert_not_equal(
 251       PeopleList.reflect_on_association(:belongs_to),
 252       DifferentPeopleList.reflect_on_association(:belongs_to)
 253     )
 254   end
 255
 256   def test_has_one_association_redefinition_reflections_should_differ_and_not_inherited
 257     assert_not_equal(
 258       PeopleList.reflect_on_association(:has_one),
 259       DifferentPeopleList.reflect_on_association(:has_one)
 260     )
 261   end
 262 end