activerecord 2.0.5 → 2.1.0

data/test/cases/associations/has_one_through_associations_test.rb

@@ -0,0 +1,74 @@
+require "cases/helper"
+require 'models/club'
+require 'models/member'
+require 'models/membership'
+require 'models/sponsor'
+
+class HasOneThroughAssociationsTest < ActiveRecord::TestCase
+  fixtures :members, :clubs, :memberships, :sponsors
+  
+  def setup
+    @member = members(:groucho)
+  end
+
+  def test_has_one_through_with_has_one
+    assert_equal clubs(:boring_club), @member.club
+  end
+
+  def test_has_one_through_with_has_many
+    assert_equal clubs(:moustache_club), @member.favourite_club
+  end
+  
+  def test_creating_association_creates_through_record
+    new_member = Member.create(:name => "Chris")
+    new_member.club = Club.create(:name => "LRUG")
+    assert_not_nil new_member.current_membership
+    assert_not_nil new_member.club
+  end
+  
+  def test_replace_target_record
+    new_club = Club.create(:name => "Marx Bros")
+    @member.club = new_club
+    @member.reload
+    assert_equal new_club, @member.club
+  end
+  
+  def test_replacing_target_record_deletes_old_association
+    assert_no_difference "Membership.count" do
+      new_club = Club.create(:name => "Bananarama")
+      @member.club = new_club
+      @member.reload      
+    end
+  end
+  
+  def test_has_one_through_polymorphic
+    assert_equal clubs(:moustache_club), @member.sponsor_club
+  end
+  
+  def has_one_through_to_has_many
+    assert_equal 2, @member.fellow_members.size
+  end
+  
+  def test_has_one_through_eager_loading
+    members = Member.find(:all, :include => :club, :conditions => ["name = ?", "Groucho Marx"])
+    assert_equal 1, members.size
+    assert_not_nil assert_no_queries {members[0].club}
+  end
+  
+  def test_has_one_through_eager_loading_through_polymorphic
+    members = Member.find(:all, :include => :sponsor_club, :conditions => ["name = ?", "Groucho Marx"])
+    assert_equal 1, members.size
+    assert_not_nil assert_no_queries {members[0].sponsor_club}    
+  end
+
+  def test_has_one_through_polymorphic_with_source_type
+    assert_equal members(:groucho), clubs(:moustache_club).sponsored_member
+  end
+
+  def test_eager_has_one_through_polymorphic_with_source_type
+    clubs = Club.find(:all, :include => :sponsored_member, :conditions => ["name = ?","Moustache and Eyebrow Fancier Club"])
+    # Only the eyebrow fanciers club has a sponsored_member
+    assert_not_nil assert_no_queries {clubs[0].sponsored_member}
+  end
+
+end

data/test/{associations → cases/associations}/inner_join_association_test.rb

@@ -1,39 +1,39 @@
-require 'abstract_unit'
-require 'fixtures/post'
-require 'fixtures/comment'
-require 'fixtures/author'
-require 'fixtures/category'
-require 'fixtures/categorization'
+require "cases/helper"
+require 'models/post'
+require 'models/comment'
+require 'models/author'
+require 'models/category'
+require 'models/categorization'
 
-class InnerJoinAssociationTest < Test::Unit::TestCase
+class InnerJoinAssociationTest < ActiveRecord::TestCase
   fixtures :authors, :posts, :comments, :categories, :categories_posts, :categorizations
 
   def test_construct_finder_sql_creates_inner_joins
     sql = Author.send(:construct_finder_sql, :joins => :posts)
-    assert_match /INNER JOIN `?posts`? ON `?posts`?.author_id = authors.id/, sql
+    assert_match /INNER JOIN .?posts.? ON .?posts.?.author_id = authors.id/, sql
   end
-  
+
   def test_construct_finder_sql_cascades_inner_joins
     sql = Author.send(:construct_finder_sql, :joins => {:posts => :comments})
-    assert_match /INNER JOIN `?posts`? ON `?posts`?.author_id = authors.id/, sql
-    assert_match /INNER JOIN `?comments`? ON `?comments`?.post_id = posts.id/, sql
+    assert_match /INNER JOIN .?posts.? ON .?posts.?.author_id = authors.id/, sql
+    assert_match /INNER JOIN .?comments.? ON .?comments.?.post_id = posts.id/, sql
   end
-  
+
   def test_construct_finder_sql_inner_joins_through_associations
     sql = Author.send(:construct_finder_sql, :joins => :categorized_posts)
-    assert_match /INNER JOIN `?categorizations`?.*INNER JOIN `?posts`?/, sql
+    assert_match /INNER JOIN .?categorizations.?.*INNER JOIN .?posts.?/, sql
   end
-  
+
   def test_construct_finder_sql_applies_association_conditions
     sql = Author.send(:construct_finder_sql, :joins => :categories_like_general, :conditions => "TERMINATING_MARKER")
-    assert_match /INNER JOIN `?categories`? ON.*AND.*`?General`?.*TERMINATING_MARKER/, sql
+    assert_match /INNER JOIN .?categories.? ON.*AND.*.?General.?.*TERMINATING_MARKER/, sql
   end
 
   def test_construct_finder_sql_unpacks_nested_joins
     sql = Author.send(:construct_finder_sql, :joins => {:posts => [[:comments]]})
     assert_no_match /inner join.*inner join.*inner join/i, sql, "only two join clauses should be present"
-    assert_match /INNER JOIN `?posts`? ON `?posts`?.author_id = authors.id/, sql
-    assert_match /INNER JOIN `?comments`? ON `?comments`?.post_id = `?posts`?.id/, sql
+    assert_match /INNER JOIN .?posts.? ON .?posts.?.author_id = authors.id/, sql
+    assert_match /INNER JOIN .?comments.? ON .?comments.?.post_id = .?posts.?.id/, sql
   end
 
   def test_construct_finder_sql_ignores_empty_joins_hash
@@ -51,7 +51,7 @@ class InnerJoinAssociationTest < Test::Unit::TestCase
     assert !authors.empty?, "expected authors to be non-empty"
     assert authors.all? {|a| a.readonly? }, "expected all authors to be readonly"
   end
-  
+
   def test_find_with_implicit_inner_joins_honors_readonly_with_select
     authors = Author.find(:all, :select => 'authors.*', :joins => :posts)
     assert !authors.empty?, "expected authors to be non-empty"
@@ -67,9 +67,9 @@ class InnerJoinAssociationTest < Test::Unit::TestCase
   def test_find_with_implicit_inner_joins_does_not_set_associations
     authors = Author.find(:all, :select => 'authors.*', :joins => :posts)
     assert !authors.empty?, "expected authors to be non-empty"
-    assert authors.all? {|a| !a.send(:instance_variables).include?("@posts")}, "expected no authors to have the @posts association loaded"
+    assert authors.all? {|a| !a.send(:instance_variable_names).include?("@posts")}, "expected no authors to have the @posts association loaded"
   end
-  
+
   def test_count_honors_implicit_inner_joins
     real_count = Author.find(:all).sum{|a| a.posts.count }
     assert_equal real_count, Author.count(:joins => :posts), "plain inner join count should match the number of referenced posts records"

data/test/{associations → cases/associations}/join_model_test.rb

@@ -1,18 +1,18 @@
-require 'abstract_unit'
-require 'fixtures/tag'
-require 'fixtures/tagging'
-require 'fixtures/post'
-require 'fixtures/item'
-require 'fixtures/comment'
-require 'fixtures/author'
-require 'fixtures/category'
-require 'fixtures/categorization'
-require 'fixtures/vertex'
-require 'fixtures/edge'
-require 'fixtures/book'
-require 'fixtures/citation'
-
-class AssociationsJoinModelTest < Test::Unit::TestCase
+require "cases/helper"
+require 'models/tag'
+require 'models/tagging'
+require 'models/post'
+require 'models/item'
+require 'models/comment'
+require 'models/author'
+require 'models/category'
+require 'models/categorization'
+require 'models/vertex'
+require 'models/edge'
+require 'models/book'
+require 'models/citation'
+
+class AssociationsJoinModelTest < ActiveRecord::TestCase
   self.use_transactional_fixtures = false
   fixtures :posts, :authors, :categories, :categorizations, :comments, :tags, :taggings, :author_favorites, :vertices, :items, :books
 
@@ -32,7 +32,7 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
     assert_equal 2, authors(:mary).categorized_posts.size
     assert_equal 1, authors(:mary).unique_categorized_posts.size
   end
-  
+
   def test_has_many_uniq_through_count
     author = authors(:mary)
     assert !authors(:mary).unique_categorized_posts.loaded?
@@ -42,6 +42,14 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
     assert !authors(:mary).unique_categorized_posts.loaded?
   end
   
+  def test_has_many_uniq_through_find
+    assert_equal 1, authors(:mary).unique_categorized_posts.find(:all).size
+  end
+  
+  def test_has_many_uniq_through_dynamic_find
+    assert_equal 1, authors(:mary).unique_categorized_posts.find_all_by_title("So I was thinking").size
+  end
+
   def test_polymorphic_has_many
     assert posts(:welcome).taggings.include?(taggings(:welcome_general))
   end
@@ -107,7 +115,7 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
   def test_polymorphic_has_many_create_model_with_inheritance_and_custom_base_class
     post = SubStiPost.create :title => 'SubStiPost', :body => 'SubStiPost body'
     assert_instance_of SubStiPost, post
-    
+
     tagging = tags(:misc).taggings.create(:taggable => post)
     assert_equal "SubStiPost", tagging.taggable_type
   end
@@ -123,7 +131,7 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
   def test_polymorphic_has_many_create_model_with_inheritance
     post = posts(:thinking)
     assert_instance_of SpecialPost, post
-    
+
     tagging = tags(:misc).taggings.create(:taggable => post)
     assert_equal "Post", tagging.taggable_type
   end
@@ -151,7 +159,7 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
     assert_equal "Post", tagging.taggable_type
     assert_equal old_count+1, posts(:welcome).taggings.count
   end
-  
+
   def test_create_bang_polymorphic_with_has_many_scope
     old_count = posts(:welcome).taggings.count
     tagging = posts(:welcome).taggings.create!(:tag => tags(:misc))
@@ -241,7 +249,7 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
       assert_equal tagging, post.tagging
     end
   end
-  
+
   def test_include_polymorphic_has_one_defined_in_abstract_parent
     item    = Item.find_by_id(items(:dvd).id, :include => :tagging)
     tagging = taggings(:godfather)
@@ -249,7 +257,7 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
       assert_equal tagging, item.tagging
     end
   end
-  
+
   def test_include_polymorphic_has_many_through
     posts           = Post.find(:all, :order => 'posts.id')
     posts_with_tags = Post.find(:all, :include => :tags, :order => 'posts.id')
@@ -271,7 +279,7 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
   def test_has_many_find_all
     assert_equal [categories(:general)], authors(:david).categories.find(:all)
   end
-  
+
   def test_has_many_find_first
     assert_equal categories(:general), authors(:david).categories.find(:first)
   end
@@ -279,7 +287,7 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
   def test_has_many_with_hash_conditions
     assert_equal categories(:general), authors(:david).categories_like_general.find(:first)
   end
-  
+
   def test_has_many_find_conditions
     assert_equal categories(:general), authors(:david).categories.find(:first, :conditions => "categories.name = 'General'")
     assert_equal nil, authors(:david).categories.find(:first, :conditions => "categories.name = 'Technology'")
@@ -290,10 +298,23 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
     assert_equal nil, authors(:david).categories.find_by_name('Technology')
   end
 
+  def test_has_many_array_methods_called_by_method_missing
+    assert true, authors(:david).categories.any? { |category| category.name == 'General' }
+    assert_nothing_raised { authors(:david).categories.sort }
+  end
+
   def test_has_many_going_through_join_model_with_custom_foreign_key
     assert_equal [], posts(:thinking).authors
     assert_equal [authors(:mary)], posts(:authorless).authors
   end
+  
+  def test_both_scoped_and_explicit_joins_should_be_respected
+    assert_nothing_raised do
+      Post.send(:with_scope, :find => {:joins => "left outer join comments on comments.id = posts.id"}) do
+        Post.find :all, :select => "comments.id, authors.id", :joins => "left outer join authors on authors.id = posts.author_id"
+      end
+    end
+  end
 
   def test_belongs_to_polymorphic_with_counter_cache
     assert_equal 0, posts(:welcome)[:taggings_count]
@@ -317,10 +338,10 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
       assert_equal posts(:welcome, :thinking), tags(:general).taggables
     end
     assert_raise ActiveRecord::EagerLoadPolymorphicError do
-      assert_equal posts(:welcome, :thinking), tags(:general).taggings.find(:all, :include => :taggable)
+      assert_equal posts(:welcome, :thinking), tags(:general).taggings.find(:all, :include => :taggable, :conditions => 'bogus_table.column = 1')
     end
   end
-  
+
   def test_has_many_polymorphic_with_source_type
     assert_equal posts(:welcome, :thinking), tags(:general).tagged_posts
   end
@@ -331,6 +352,7 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
     assert_no_queries do
       assert_equal desired, tag_with_include.tagged_posts
     end
+    assert_equal 5, tag_with_include.taggings.length
   end
 
   def test_has_many_through_has_many_find_all
@@ -385,7 +407,7 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
       assert_equal [1,2,3,5,6,7,8,9,10], author.comments.collect(&:id)
     end
   end
-  
+
   def test_eager_load_has_many_through_has_many_with_conditions
     post = Post.find(:first, :include => :invalid_tags)
     assert_no_queries do
@@ -410,7 +432,7 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
     authors(:david).author_favorites.create :favorite_author => new_author
     assert_equal new_author, authors(:david).reload.favorite_authors.first
   end
-  
+
   def test_has_many_through_uses_conditions_specified_on_the_has_many_association
     author = Author.find(:first)
     assert !author.comments.blank?
@@ -421,11 +443,33 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
     assert_nil posts(:thinking).tags.find_by_name("General").attributes["tag_id"]
   end
 
-  def test_raise_error_when_adding_new_record_to_has_many_through
-    assert_raise(ActiveRecord::HasManyThroughCantAssociateNewRecords) { posts(:thinking).tags << tags(:general).clone }
-    assert_raise(ActiveRecord::HasManyThroughCantAssociateNewRecords) { posts(:thinking).clone.tags << tags(:general) }
-    assert_raise(ActiveRecord::HasManyThroughCantAssociateNewRecords) { posts(:thinking).tags.build }
-    assert_raise(ActiveRecord::HasManyThroughCantAssociateNewRecords) { posts(:thinking).tags.new }
+  def test_associating_unsaved_records_with_has_many_through
+    saved_post = posts(:thinking)
+    new_tag = Tag.new(:name => "new")
+
+    saved_post.tags << new_tag
+    assert !new_tag.new_record? #consistent with habtm!
+    assert !saved_post.new_record?
+    assert saved_post.tags.include?(new_tag)
+
+    assert !new_tag.new_record?
+    assert saved_post.reload.tags(true).include?(new_tag)
+
+
+    new_post = Post.new(:title => "Association replacmenet works!", :body => "You best believe it.")
+    saved_tag = tags(:general)
+
+    new_post.tags << saved_tag
+    assert new_post.new_record?
+    assert !saved_tag.new_record?
+    assert new_post.tags.include?(saved_tag)
+
+    new_post.save!
+    assert !new_post.new_record?
+    assert new_post.reload.tags(true).include?(saved_tag)
+
+    assert posts(:thinking).tags.build.new_record?
+    assert posts(:thinking).tags.new.new_record?
   end
 
   def test_create_associate_when_adding_to_has_many_through
@@ -504,11 +548,13 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
     tag = Tag.create!(:name => 'doomed')
     post_thinking = posts(:thinking)
     post_thinking.tags << tag
+    assert_equal(count + 1, post_thinking.taggings(true).size)
     assert_equal(count + 1, post_thinking.tags(true).size)
 
-    assert_nothing_raised { post_thinking.tags.delete(tag) }    
+    assert_nothing_raised { post_thinking.tags.delete(tag) }
     assert_equal(count, post_thinking.tags.size)
     assert_equal(count, post_thinking.tags(true).size)
+    assert_equal(count, post_thinking.taggings(true).size)
     assert_equal(tags_before.sort, post_thinking.tags.sort)
   end
 
@@ -522,7 +568,7 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
     post_thinking.tags << doomed << doomed2
     assert_equal(count + 2, post_thinking.tags(true).size)
 
-    assert_nothing_raised { post_thinking.tags.delete(doomed, doomed2, quaked) }    
+    assert_nothing_raised { post_thinking.tags.delete(doomed, doomed2, quaked) }
     assert_equal(count, post_thinking.tags.size)
     assert_equal(count, post_thinking.tags(true).size)
     assert_equal(tags_before.sort, post_thinking.tags.sort)
@@ -547,13 +593,107 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
   def test_has_many_through_has_many_with_sti
     assert_equal [comments(:does_it_hurt)], authors(:david).special_post_comments
   end
-  
+
   def test_uniq_has_many_through_should_retain_order
     comment_ids = authors(:david).comments.map(&:id)
     assert_equal comment_ids.sort, authors(:david).ordered_uniq_comments.map(&:id)
     assert_equal comment_ids.sort.reverse, authors(:david).ordered_uniq_comments_desc.map(&:id)
   end
 
+  def test_polymorphic_has_many
+    expected = taggings(:welcome_general)
+    p = Post.find(posts(:welcome).id, :include => :taggings)
+    assert_no_queries {assert p.taggings.include?(expected)}
+    assert posts(:welcome).taggings.include?(taggings(:welcome_general))
+  end
+
+  def test_polymorphic_has_one
+    expected = posts(:welcome)
+
+    tagging  = Tagging.find(taggings(:welcome_general).id, :include => :taggable)
+    assert_no_queries { assert_equal expected, tagging.taggable}
+  end
+
+  def test_polymorphic_belongs_to
+    p = Post.find(posts(:welcome).id, :include => {:taggings => :taggable})
+    assert_no_queries {assert_equal posts(:welcome), p.taggings.first.taggable}
+  end
+
+  def test_preload_polymorphic_has_many_through
+    posts           = Post.find(:all, :order => 'posts.id')
+    posts_with_tags = Post.find(:all, :include => :tags, :order => 'posts.id')
+    assert_equal posts.length, posts_with_tags.length
+    posts.length.times do |i|
+      assert_equal posts[i].tags.length, assert_no_queries { posts_with_tags[i].tags.length }
+    end
+  end
+
+  def test_preload_polymorph_many_types
+    taggings = Tagging.find :all, :include => :taggable, :conditions => ['taggable_type != ?', 'FakeModel']
+    assert_no_queries do
+      taggings.first.taggable.id
+      taggings[1].taggable.id
+    end
+
+    taggables = taggings.map(&:taggable)
+    assert taggables.include?(items(:dvd))
+    assert taggables.include?(posts(:welcome))
+  end
+
+  def test_preload_nil_polymorphic_belongs_to
+    assert_nothing_raised do
+      taggings = Tagging.find(:all, :include => :taggable, :conditions => ['taggable_type IS NULL'])
+    end
+  end
+
+  def test_preload_polymorphic_has_many
+    posts               = Post.find(:all, :order => 'posts.id')
+    posts_with_taggings = Post.find(:all, :include => :taggings, :order => 'posts.id')
+    assert_equal posts.length, posts_with_taggings.length
+    posts.length.times do |i|
+      assert_equal posts[i].taggings.length, assert_no_queries { posts_with_taggings[i].taggings.length }
+    end
+  end
+
+  def test_belongs_to_shared_parent
+    comments = Comment.find(:all, :include => :post, :conditions => 'post_id = 1')
+    assert_no_queries do
+      assert_equal comments.first.post, comments[1].post
+    end
+  end
+
+  def test_has_many_through_include_uses_array_include_after_loaded
+    david = authors(:david)
+    david.categories.class # force load target
+
+    category = david.categories.first
+
+    assert_no_queries do
+      assert david.categories.loaded?
+      assert david.categories.include?(category)
+    end
+  end
+
+  def test_has_many_through_include_checks_if_record_exists_if_target_not_loaded
+    david = authors(:david)
+    category = david.categories.first
+
+    david.reload
+    assert ! david.categories.loaded?
+    assert_queries(1) do
+      assert david.categories.include?(category)
+    end
+    assert ! david.categories.loaded?
+  end
+  
+  def test_has_many_through_include_returns_false_for_non_matching_record_to_verify_scoping
+    david = authors(:david)
+    category = Category.create!(:name => 'Not Associated')
+
+    assert ! david.categories.loaded?
+    assert ! david.categories.include?(category)
+  end
+
   private
     # create dynamic Post models to allow different dependency options
     def find_post_with_dependency(post_id, association, association_name, dependency)