activerecord 1.13.2 → 1.14.0

data/test/associations_join_model_test.rb

@@ -0,0 +1,338 @@
+require 'abstract_unit'
+require 'fixtures/tag'
+require 'fixtures/tagging'
+require 'fixtures/post'
+require 'fixtures/comment'
+require 'fixtures/author'
+require 'fixtures/category'
+require 'fixtures/categorization'
+
+class AssociationsJoinModelTest < Test::Unit::TestCase
+  self.use_transactional_fixtures = false
+  fixtures :posts, :authors, :categories, :categorizations, :comments, :tags, :taggings, :author_favorites
+
+  def test_has_many
+    assert_equal categories(:general), authors(:david).categories.first
+  end
+  
+  def test_has_many_inherited
+    assert_equal categories(:sti_test), authors(:mary).categories.first
+  end
+
+  def test_inherited_has_many
+    assert_equal authors(:mary), categories(:sti_test).authors.first
+  end
+  
+  def test_polymorphic_has_many
+    assert_equal taggings(:welcome_general), posts(:welcome).taggings.first
+  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_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_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_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), posts(:thinking)], tags(:general).taggables
+    end
+    assert_raises ActiveRecord::EagerLoadPolymorphicError do
+      assert_equal [posts(:welcome), posts(:thinking)], tags(:general).taggings.find(:all, :include => :taggable)
+    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
+    assert_equal comments(:does_it_hurt), authors(:david).comments.find(:first, :conditions => "comments.type='SpecialComment'", :order => 'comments.id')
+  end
+
+  def test_has_many_through_has_many_find_by_id
+    assert_equal comments(:more_greetings), authors(:david).comments.find(2)
+  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_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_correct_attributes
+    assert_nil posts(:thinking).tags.find_by_name("General").attributes["tag_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

data/test/associations_test.rb

@@ -79,6 +79,7 @@ class HasOneAssociationsTest < Test::Unit::TestCase
 
   def test_triple_equality
     assert Account === companies(:first_firm).account
+    assert companies(:first_firm).account === Account
   end
 
   def test_type_mismatch
@@ -157,6 +158,15 @@ class HasOneAssociationsTest < Test::Unit::TestCase
     assert_equal "can't be empty", account.errors.on("credit_limit")
   end
 
+  def test_build_association_twice_without_saving_affects_nothing
+    count_of_account = Account.count
+    firm = Firm.find(:first)
+    account1 = firm.build_account("credit_limit" => 1000)
+    account2 = firm.build_account("credit_limit" => 2000)
+
+    assert_equal count_of_account, Account.count
+  end
+
   def test_create_association
     firm = Firm.new("name" => "GlobalMegaCorp")
     firm.save
@@ -280,6 +290,17 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     assert_equal 2, Firm.find(:first).clients.length
   end
 
+  def test_find_many_with_merged_options
+    assert_equal 1, companies(:first_firm).limited_clients.size
+    assert_equal 1, companies(:first_firm).limited_clients.find(:all).size
+    assert_equal 2, companies(:first_firm).limited_clients.find(:all, :limit => nil).size
+  end
+
+  def test_triple_equality
+    assert !(Array === Firm.find(:first).clients)
+    assert Firm.find(:first).clients === Array
+  end
+
   def test_finding_default_orders
     assert_equal "Summit", Firm.find(:first).clients.first.name
   end
@@ -641,7 +662,7 @@ class HasManyAssociationsTest < Test::Unit::TestCase
   def test_three_levels_of_dependence
     topic = Topic.create "title" => "neat and simple"
     reply = topic.replies.create "title" => "neat and simple", "content" => "still digging it"
-    silly_reply = reply.silly_replies.create "title" => "neat and simple", "content" => "ain't complaining"
+    silly_reply = reply.replies.create "title" => "neat and simple", "content" => "ain't complaining"
     
     assert_nothing_raised { topic.destroy }
   end
@@ -664,7 +685,6 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     assert_equal num_accounts - 1, Account.count
   end
 
-
   def test_depends_and_nullify
     num_accounts = Account.count
     num_companies = Company.count
@@ -747,6 +767,11 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
     assert_nothing_raised { account.firm = account.firm }
   end
 
+  def test_triple_equality
+    assert Client.find(3).firm === Firm
+    assert Firm === Client.find(3).firm
+  end
+
   def test_type_mismatch
     assert_raise(ActiveRecord::AssociationTypeMismatch) { Account.find(1).firm = 1 }
     assert_raise(ActiveRecord::AssociationTypeMismatch) { Account.find(1).firm = Project.find(1) }
@@ -804,6 +829,38 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
     assert_equal 0, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply deleted"
   end
 
+  def test_belongs_to_counter_with_reassigning
+    t1 = Topic.create("title" => "t1")
+    t2 = Topic.create("title" => "t2")
+    r1 = Reply.new("title" => "r1", "content" => "r1")
+    r1.topic = t1
+
+    assert r1.save
+    assert_equal 1, Topic.find(t1.id).replies.size
+    assert_equal 0, Topic.find(t2.id).replies.size
+
+    r1.topic = Topic.find(t2.id)
+
+    assert r1.save
+    assert_equal 0, Topic.find(t1.id).replies.size
+    assert_equal 1, Topic.find(t2.id).replies.size
+
+    r1.topic = nil
+
+    assert_equal 0, Topic.find(t1.id).replies.size
+    assert_equal 0, Topic.find(t2.id).replies.size
+
+    r1.topic = t1
+
+    assert_equal 1, Topic.find(t1.id).replies.size
+    assert_equal 0, Topic.find(t2.id).replies.size
+
+    r1.destroy
+
+    assert_equal 0, Topic.find(t1.id).replies.size
+    assert_equal 0, Topic.find(t2.id).replies.size
+  end
+
   def test_assignment_before_parent_saved
     client = Client.find(:first)
     apple = Firm.new("name" => "Apple")
@@ -860,21 +917,32 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
     assert_not_nil computer.developer, ":foreign key == attribute didn't lock up" # '
   end
 
-  def xtest_counter_cache
-    apple = Firm.create("name" => "Apple")
-    final_cut = apple.clients.create("name" => "Final Cut")
-
-    apple.clients.to_s
-    assert_equal 1, apple.clients.size, "Created one client"
+  def test_counter_cache
+    topic = Topic.create :title => "Zoom-zoom-zoom"
+    assert_equal 0, topic[:replies_count]
     
-    apple.companies_count = 2
-    apple.save
+    reply = Reply.create(:title => "re: zoom", :content => "speedy quick!")
+    reply.topic = topic
+
+    assert_equal 1, topic.reload[:replies_count]
+    assert_equal 1, topic.replies.size
+
+    topic[:replies_count] = 15
+    assert_equal 15, topic.replies.size
+  end
+
+  def test_custom_counter_cache
+    reply = Reply.create(:title => "re: zoom", :content => "speedy quick!")
+    assert_equal 0, reply[:replies_count]
+
+    silly = SillyReply.create(:title => "gaga", :content => "boo-boo")
+    silly.reply = reply
 
-    apple = Firm.find(:first, :conditions => "name = 'Apple'")
-    assert_equal 2, apple.clients.size, "Should use the new cached number"
+    assert_equal 1, reply.reload[:replies_count]
+    assert_equal 1, reply.replies.size
 
-    apple.clients.to_s 
-    assert_equal 1, apple.clients.size, "Should not use the cached number, but go to the database"
+    reply[:replies_count] = 17
+    assert_equal 17, reply.replies.size
   end
 
   def test_store_two_association_with_one_save
@@ -1022,10 +1090,15 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
 
     active_record = Project.find(1)
     assert !active_record.developers.empty?
-    assert_equal 2, active_record.developers.size
+    assert_equal 3, active_record.developers.size
     assert active_record.developers.include?(david)
   end
 
+  def test_triple_equality
+    assert !(Array === Developer.find(1).projects)
+    assert Developer.find(1).projects === Array
+  end
+
   def test_adding_single
     jamis = Developer.find(2)
     jamis.projects.reload # causing the collection to load 
@@ -1149,7 +1222,6 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     no_of_devels = Developer.count
     no_of_projects = Project.count
     now = Date.today
-    sqlnow = Time.now.strftime("%Y/%m/%d 00:00:00")
     ken = Developer.new("name" => "Ken")
     ken.projects.push_with_attributes( Project.find(1), :joined_on => now )
     p = Project.new("name" => "Foomatic")
@@ -1164,12 +1236,22 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     assert_equal 2, ken.projects(true).size
 
     kenReloaded = Developer.find_by_name 'Ken'
-    # SQL Server doesn't have a separate column type just for dates, 
-    # so the time is in the string and incorrectly formatted
-    if current_adapter?(:SQLServerAdapter)
-      kenReloaded.projects.each { |prj| assert_equal(sqlnow, prj.joined_on.strftime("%Y/%m/%d 00:00:00")) }
-    else
-      kenReloaded.projects.each { |prj| assert_equal(now.to_s, prj.joined_on.to_s) }
+    kenReloaded.projects.each {|prj| assert_date_from_db(now, prj.joined_on)}
+  end
+
+  def test_habtm_saving_multiple_relationships
+    new_project = Project.new("name" => "Grimetime")
+    amount_of_developers = 4
+    developers = (0..amount_of_developers).collect {|i| Developer.create(:name => "JME #{i}") }
+  
+    new_project.developer_ids = [developers[0].id, developers[1].id]
+    new_project.developers_with_callback_ids = [developers[2].id, developers[3].id]
+    assert new_project.save
+    
+    new_project.reload
+    assert_equal amount_of_developers, new_project.developers.size
+    amount_of_developers.times do |i|
+      assert_equal developers[i].name, new_project.developers[i].name
     end
   end
 
@@ -1200,7 +1282,7 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
   def test_uniq_before_the_fact
     projects(:active_record).developers << developers(:jamis)
     projects(:active_record).developers << developers(:david)
-    assert_equal 2, projects(:active_record, :reload).developers.size
+    assert_equal 3, projects(:active_record, :reload).developers.size
   end
   
   def test_deleting
@@ -1208,13 +1290,13 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     active_record = Project.find(1)
     david.projects.reload
     assert_equal 2, david.projects.size
-    assert_equal 2, active_record.developers.size
+    assert_equal 3, active_record.developers.size
 
     david.projects.delete(active_record)
     
     assert_equal 1, david.projects.size
     assert_equal 1, david.projects(true).size
-    assert_equal 1, active_record.developers(true).size
+    assert_equal 2, active_record.developers(true).size
   end
 
   def test_deleting_array
@@ -1229,16 +1311,16 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     david = Developer.find(1)
     active_record = Project.find(1)
     active_record.developers.reload
-    assert_equal 2, active_record.developers_by_sql.size
+    assert_equal 3, active_record.developers_by_sql.size
     
     active_record.developers_by_sql.delete(david)
-    assert_equal 1, active_record.developers_by_sql(true).size
+    assert_equal 2, active_record.developers_by_sql(true).size
   end
 
   def test_deleting_array_with_sql
     active_record = Project.find(1)
     active_record.developers.reload
-    assert_equal 2, active_record.developers_by_sql.size
+    assert_equal 3, active_record.developers_by_sql.size
     
     active_record.developers_by_sql.delete(Developer.find(:all))
     assert_equal 0, active_record.developers_by_sql(true).size
@@ -1261,13 +1343,7 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
   end
 
   def test_additional_columns_from_join_table
-    # SQL Server doesn't have a separate column type just for dates, 
-    # so the time is in the string and incorrectly formatted
-    if current_adapter?(:SQLServerAdapter)
-      assert_equal Time.mktime(2004, 10, 10).strftime("%Y/%m/%d 00:00:00"), Developer.find(1).projects.first.joined_on.strftime("%Y/%m/%d 00:00:00")
-    else
-      assert_equal Date.new(2004, 10, 10).to_s, Developer.find(1).projects.first.joined_on.to_s
-    end
+    assert_date_from_db Date.new(2004, 10, 10), Developer.find(1).projects.first.joined_on
   end
   
   def test_destroy_all
@@ -1282,26 +1358,20 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
   def test_rich_association
     jamis = developers(:jamis)
     jamis.projects.push_with_attributes(projects(:action_controller), :joined_on => Date.today)
-    # SQL Server doesn't have a separate column type just for dates, 
-    # so the time is in the string and incorrectly formatted
-    if current_adapter?(:SQLServerAdapter)
-      assert_equal Time.now.strftime("%Y/%m/%d 00:00:00"), jamis.projects.select { |p| p.name == projects(:action_controller).name }.first.joined_on.strftime("%Y/%m/%d 00:00:00")
-      assert_equal Time.now.strftime("%Y/%m/%d 00:00:00"), developers(:jamis).projects.select { |p| p.name == projects(:action_controller).name }.first.joined_on.strftime("%Y/%m/%d 00:00:00")
-    else
-      assert_equal Date.today.to_s, jamis.projects.select { |p| p.name == projects(:action_controller).name }.first.joined_on.to_s
-      assert_equal Date.today.to_s, developers(:jamis).projects.select { |p| p.name == projects(:action_controller).name }.first.joined_on.to_s
-    end
+    
+    assert_date_from_db Date.today, jamis.projects.select { |p| p.name == projects(:action_controller).name }.first.joined_on
+    assert_date_from_db Date.today, developers(:jamis).projects.select { |p| p.name == projects(:action_controller).name }.first.joined_on
   end
 
   def test_associations_with_conditions
-    assert_equal 2, projects(:active_record).developers.size
+    assert_equal 3, projects(:active_record).developers.size
     assert_equal 1, projects(:active_record).developers_named_david.size
 
     assert_equal developers(:david), projects(:active_record).developers_named_david.find(developers(:david).id)
     assert_equal developers(:david), projects(:active_record).salaried_developers.find(developers(:david).id)
 
     projects(:active_record).developers_named_david.clear
-    assert_equal 1, projects(:active_record, :reload).developers.size
+    assert_equal 2, projects(:active_record, :reload).developers.size
   end
   
   def test_find_in_association
@@ -1326,6 +1396,11 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     assert_equal developers(:david), projects(:active_record).developers_with_finder_sql.find(developers(:david).id.to_s), "SQL find"
   end
 
+  def test_find_with_merged_options
+    assert_equal 1, projects(:active_record).limited_developers.size
+    assert_equal 1, projects(:active_record).limited_developers.find(:all).size
+    assert_equal 3, projects(:active_record).limited_developers.find(:all, :limit => nil).size
+  end
 
   def test_new_with_values_in_collection
     jamis = DeveloperForProjectWithAfterCreateHook.find_by_name('Jamis')
@@ -1339,12 +1414,12 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     assert project.developers.include?(david)
   end
 
-  def xtest_find_in_association_with_options
+  def test_find_in_association_with_options
     developers = projects(:active_record).developers.find(:all)
-    assert_equal 2, developers.size
+    assert_equal 3, developers.size
     
-    assert_equal developers(:david), projects(:active_record).developers.find(:first, :conditions => "salary < 10000")
-    assert_equal developers(:jamis), projects(:active_record).developers.find(:first, :order => "salary DESC")
+    assert_equal developers(:poor_jamis), projects(:active_record).developers.find(:first, :conditions => "salary < 10000")
+    assert_equal developers(:jamis),      projects(:active_record).developers.find(:first, :order => "salary DESC")
   end
   
   def test_replace_with_less
@@ -1394,4 +1469,8 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
       AND developer_id = #{developer.id}
     end_sql
   end
+
+  def test_join_table_alias
+    assert_equal 3, Developer.find(:all, :include => {:projects => :developers}, :conditions => 'developers_projects_join.joined_on IS NOT NULL').size
+  end
 end