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 self.use_transactional_fixtures = false fixtures :posts, :authors, :categories, :categorizations, :comments, :tags, :taggings, :author_favorites, :vertices, :items, :books def test_has_many assert authors(:david).categories.include?(categories(:general)) end def test_has_many_inherited assert authors(:mary).categories.include?(categories(:sti_test)) end def test_inherited_has_many assert categories(:sti_test).authors.include?(authors(:mary)) end def test_has_many_uniq_through_join_model 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? assert_queries(1) { assert_equal 1, author.unique_categorized_posts.count } assert_queries(1) { assert_equal 1, author.unique_categorized_posts.count(:title) } assert_queries(1) { assert_equal 0, author.unique_categorized_posts.count(:title, :conditions => "title is NULL") } assert !authors(:mary).unique_categorized_posts.loaded? end def test_polymorphic_has_many assert posts(:welcome).taggings.include?(taggings(:welcome_general)) end def test_polymorphic_has_one assert_equal taggings(:welcome_general), posts(:welcome).tagging end def test_polymorphic_belongs_to assert_equal posts(:welcome), posts(:welcome).taggings.first.taggable end def test_polymorphic_has_many_going_through_join_model assert_equal tags(:general), tag = posts(:welcome).tags.first assert_no_queries do tag.tagging end end def test_count_polymorphic_has_many assert_equal 1, posts(:welcome).taggings.count assert_equal 1, posts(:welcome).tags.count end def test_polymorphic_has_many_going_through_join_model_with_find assert_equal tags(:general), tag = posts(:welcome).tags.find(:first) assert_no_queries do tag.tagging end end def test_polymorphic_has_many_going_through_join_model_with_include_on_source_reflection assert_equal tags(:general), tag = posts(:welcome).funky_tags.first assert_no_queries do tag.tagging end end def test_polymorphic_has_many_going_through_join_model_with_include_on_source_reflection_with_find assert_equal tags(:general), tag = posts(:welcome).funky_tags.find(:first) assert_no_queries do tag.tagging end end def test_polymorphic_has_many_going_through_join_model_with_disabled_include assert_equal tags(:general), tag = posts(:welcome).tags.add_joins_and_select.first assert_queries 1 do tag.tagging end end def test_polymorphic_has_many_going_through_join_model_with_custom_select_and_joins assert_equal tags(:general), tag = posts(:welcome).tags.add_joins_and_select.first tag.author_id end def test_polymorphic_has_many_going_through_join_model_with_custom_foreign_key assert_equal tags(:misc), taggings(:welcome_general).super_tag assert_equal tags(:misc), posts(:welcome).super_tags.first end 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 def test_polymorphic_has_many_going_through_join_model_with_inheritance assert_equal tags(:general), posts(:thinking).tags.first end def test_polymorphic_has_many_going_through_join_model_with_inheritance_with_custom_class_name assert_equal tags(:general), posts(:thinking).funky_tags.first end 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 def test_polymorphic_has_one_create_model_with_inheritance tagging = tags(:misc).create_tagging(:taggable => posts(:thinking)) assert_equal "Post", tagging.taggable_type end def test_set_polymorphic_has_many tagging = tags(:misc).taggings.create posts(:thinking).taggings << tagging assert_equal "Post", tagging.taggable_type end def test_set_polymorphic_has_one tagging = tags(:misc).taggings.create posts(:thinking).tagging = tagging assert_equal "Post", tagging.taggable_type end def test_create_polymorphic_has_many_with_scope old_count = posts(:welcome).taggings.count tagging = posts(:welcome).taggings.create(:tag => tags(:misc)) 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)) assert_equal "Post", tagging.taggable_type assert_equal old_count+1, posts(:welcome).taggings.count end def test_create_polymorphic_has_one_with_scope old_count = Tagging.count tagging = posts(:welcome).tagging.create(:tag => tags(:misc)) assert_equal "Post", tagging.taggable_type assert_equal old_count+1, Tagging.count end def test_delete_polymorphic_has_many_with_delete_all assert_equal 1, posts(:welcome).taggings.count posts(:welcome).taggings.first.update_attribute :taggable_type, 'PostWithHasManyDeleteAll' post = find_post_with_dependency(1, :has_many, :taggings, :delete_all) old_count = Tagging.count post.destroy assert_equal old_count-1, Tagging.count assert_equal 0, posts(:welcome).taggings.count end def test_delete_polymorphic_has_many_with_destroy assert_equal 1, posts(:welcome).taggings.count posts(:welcome).taggings.first.update_attribute :taggable_type, 'PostWithHasManyDestroy' post = find_post_with_dependency(1, :has_many, :taggings, :destroy) old_count = Tagging.count post.destroy assert_equal old_count-1, Tagging.count assert_equal 0, posts(:welcome).taggings.count end def test_delete_polymorphic_has_many_with_nullify assert_equal 1, posts(:welcome).taggings.count posts(:welcome).taggings.first.update_attribute :taggable_type, 'PostWithHasManyNullify' post = find_post_with_dependency(1, :has_many, :taggings, :nullify) old_count = Tagging.count post.destroy assert_equal old_count, Tagging.count assert_equal 0, posts(:welcome).taggings.count end def test_delete_polymorphic_has_one_with_destroy assert posts(:welcome).tagging posts(:welcome).tagging.update_attribute :taggable_type, 'PostWithHasOneDestroy' post = find_post_with_dependency(1, :has_one, :tagging, :destroy) old_count = Tagging.count post.destroy assert_equal old_count-1, Tagging.count assert_nil posts(:welcome).tagging(true) end def test_delete_polymorphic_has_one_with_nullify assert posts(:welcome).tagging posts(:welcome).tagging.update_attribute :taggable_type, 'PostWithHasOneNullify' post = find_post_with_dependency(1, :has_one, :tagging, :nullify) old_count = Tagging.count post.destroy assert_equal old_count, Tagging.count assert_nil posts(:welcome).tagging(true) end def test_has_many_with_piggyback assert_equal "2", categories(:sti_test).authors.first.post_id.to_s end def test_include_has_many_through posts = Post.find(:all, :order => 'posts.id') posts_with_authors = Post.find(:all, :include => :authors, :order => 'posts.id') assert_equal posts.length, posts_with_authors.length posts.length.times do |i| assert_equal posts[i].authors.length, assert_no_queries { posts_with_authors[i].authors.length } end end def test_include_polymorphic_has_one post = Post.find_by_id(posts(:welcome).id, :include => :tagging) tagging = taggings(:welcome_general) assert_no_queries do 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) assert_no_queries do 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') 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_include_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_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 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'") end def test_has_many_class_methods_called_by_method_missing assert_equal categories(:general), authors(:david).categories.find_all_by_name('General').first assert_equal nil, authors(:david).categories.find_by_name('Technology') 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_belongs_to_polymorphic_with_counter_cache assert_equal 0, posts(:welcome)[:taggings_count] tagging = posts(:welcome).taggings.create(:tag => tags(:general)) assert_equal 1, posts(:welcome, :reload)[:taggings_count] tagging.destroy assert posts(:welcome, :reload)[:taggings_count].zero? end def test_unavailable_through_reflection assert_raises (ActiveRecord::HasManyThroughAssociationNotFoundError) { authors(:david).nothings } end def test_has_many_through_join_model_with_conditions assert_equal [], posts(:welcome).invalid_taggings assert_equal [], posts(:welcome).invalid_tags end def test_has_many_polymorphic assert_raises ActiveRecord::HasManyThroughAssociationPolymorphicError do assert_equal posts(:welcome, :thinking), tags(:general).taggables end assert_raises ActiveRecord::EagerLoadPolymorphicError do assert_equal posts(:welcome, :thinking), tags(:general).taggings.find(:all, :include => :taggable) end end def test_has_many_polymorphic_with_source_type assert_equal posts(:welcome, :thinking), tags(:general).tagged_posts end def test_eager_has_many_polymorphic_with_source_type tag_with_include = Tag.find(tags(:general).id, :include => :tagged_posts) desired = posts(:welcome, :thinking) assert_no_queries do assert_equal desired, tag_with_include.tagged_posts end end def test_has_many_through_has_many_find_all assert_equal comments(:greetings), authors(:david).comments.find(:all, :order => 'comments.id').first end def test_has_many_through_has_many_find_all_with_custom_class assert_equal comments(:greetings), authors(:david).funky_comments.find(:all, :order => 'comments.id').first end def test_has_many_through_has_many_find_first assert_equal comments(:greetings), authors(:david).comments.find(:first, :order => 'comments.id') end def test_has_many_through_has_many_find_conditions options = { :conditions => "comments.#{QUOTED_TYPE}='SpecialComment'", :order => 'comments.id' } assert_equal comments(:does_it_hurt), authors(:david).comments.find(:first, options) end def test_has_many_through_has_many_find_by_id assert_equal comments(:more_greetings), authors(:david).comments.find(2) end def test_has_many_through_polymorphic_has_one assert_raise(ActiveRecord::HasManyThroughSourceAssociationMacroError) { authors(:david).tagging } end def test_has_many_through_polymorphic_has_many assert_equal taggings(:welcome_general, :thinking_general), authors(:david).taggings.uniq.sort_by { |t| t.id } end def test_include_has_many_through_polymorphic_has_many author = Author.find_by_id(authors(:david).id, :include => :taggings) expected_taggings = taggings(:welcome_general, :thinking_general) assert_no_queries do assert_equal expected_taggings, author.taggings.uniq.sort_by { |t| t.id } end end def test_has_many_through_has_many_through assert_raise(ActiveRecord::HasManyThroughSourceAssociationMacroError) { authors(:david).tags } end def test_has_many_through_habtm assert_raise(ActiveRecord::HasManyThroughSourceAssociationMacroError) { authors(:david).post_categories } end def test_eager_load_has_many_through_has_many author = Author.find :first, :conditions => ['name = ?', 'David'], :include => :comments, :order => 'comments.id' SpecialComment.new; VerySpecialComment.new assert_no_queries do 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 post.invalid_tags end end def test_eager_belongs_to_and_has_one_not_singularized assert_nothing_raised do Author.find(:first, :include => :author_address) AuthorAddress.find(:first, :include => :author) end end def test_self_referential_has_many_through assert_equal [authors(:mary)], authors(:david).favorite_authors assert_equal [], authors(:mary).favorite_authors end def test_add_to_self_referential_has_many_through new_author = Author.create(:name => "Bob") 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? assert author.nonexistant_comments.blank? end def test_has_many_through_uses_correct_attributes 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 } end def test_create_associate_when_adding_to_has_many_through count = posts(:thinking).tags.count push = Tag.create!(:name => 'pushme') post_thinking = posts(:thinking) assert_nothing_raised { post_thinking.tags << push } assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag }, message = "Expected a Tag in tags collection, got #{wrong.class}.") assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging }, message = "Expected a Tagging in taggings collection, got #{wrong.class}.") assert_equal(count + 1, post_thinking.tags.size) assert_equal(count + 1, post_thinking.tags(true).size) assert_kind_of Tag, post_thinking.tags.create!(:name => 'foo') assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag }, message = "Expected a Tag in tags collection, got #{wrong.class}.") assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging }, message = "Expected a Tagging in taggings collection, got #{wrong.class}.") assert_equal(count + 2, post_thinking.tags.size) assert_equal(count + 2, post_thinking.tags(true).size) assert_nothing_raised { post_thinking.tags.concat(Tag.create!(:name => 'abc'), Tag.create!(:name => 'def')) } assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag }, message = "Expected a Tag in tags collection, got #{wrong.class}.") assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging }, message = "Expected a Tagging in taggings collection, got #{wrong.class}.") assert_equal(count + 4, post_thinking.tags.size) assert_equal(count + 4, post_thinking.tags(true).size) # Raises if the wrong reflection name is used to set the Edge belongs_to assert_nothing_raised { vertices(:vertex_1).sinks << vertices(:vertex_5) } end def test_has_many_through_collection_size_doesnt_load_target_if_not_loaded author = authors(:david) assert_equal 9, author.comments.size assert !author.comments.loaded? end uses_mocha('has_many_through_collection_size_uses_counter_cache_if_it_exists') do def test_has_many_through_collection_size_uses_counter_cache_if_it_exists author = authors(:david) author.stubs(:read_attribute).with('comments_count').returns(100) assert_equal 100, author.comments.size assert !author.comments.loaded? end end def test_adding_junk_to_has_many_through_should_raise_type_mismatch assert_raise(ActiveRecord::AssociationTypeMismatch) { posts(:thinking).tags << "Uhh what now?" } end def test_adding_to_has_many_through_should_return_self tags = posts(:thinking).tags assert_equal tags, posts(:thinking).tags.push(tags(:general)) end def test_delete_associate_when_deleting_from_has_many_through_with_nonstandard_id count = books(:awdr).references.count references_before = books(:awdr).references book = Book.create!(:name => 'Getting Real') book_awdr = books(:awdr) book_awdr.references << book assert_equal(count + 1, book_awdr.references(true).size) assert_nothing_raised { book_awdr.references.delete(book) } assert_equal(count, book_awdr.references.size) assert_equal(count, book_awdr.references(true).size) assert_equal(references_before.sort, book_awdr.references.sort) end def test_delete_associate_when_deleting_from_has_many_through count = posts(:thinking).tags.count tags_before = posts(:thinking).tags tag = Tag.create!(:name => 'doomed') post_thinking = posts(:thinking) post_thinking.tags << tag assert_equal(count + 1, post_thinking.tags(true).size) 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(tags_before.sort, post_thinking.tags.sort) end def test_delete_associate_when_deleting_from_has_many_through_with_multiple_tags count = posts(:thinking).tags.count tags_before = posts(:thinking).tags doomed = Tag.create!(:name => 'doomed') doomed2 = Tag.create!(:name => 'doomed2') quaked = Tag.create!(:name => 'quaked') post_thinking = posts(:thinking) 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_equal(count, post_thinking.tags.size) assert_equal(count, post_thinking.tags(true).size) assert_equal(tags_before.sort, post_thinking.tags.sort) end def test_deleting_junk_from_has_many_through_should_raise_type_mismatch assert_raise(ActiveRecord::AssociationTypeMismatch) { posts(:thinking).tags.delete("Uhh what now?") } end def test_has_many_through_sum_uses_calculations assert_nothing_raised { authors(:david).comments.sum(:post_id) } end 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 private # create dynamic Post models to allow different dependency options def find_post_with_dependency(post_id, association, association_name, dependency) class_name = "PostWith#{association.to_s.classify}#{dependency.to_s.classify}" Post.find(post_id).update_attribute :type, class_name klass = Object.const_set(class_name, Class.new(ActiveRecord::Base)) klass.set_table_name 'posts' klass.send(association, association_name, :as => :taggable, :dependent => dependency) klass.find(post_id) end end