activerecord 1.10.1 → 1.11.0

data/test/associations_test.rb

@@ -17,10 +17,8 @@ raise "ActiveRecord should have barked on bad collection keys" unless bad_collec
 
 
 class AssociationsTest < Test::Unit::TestCase
-  def setup
-    create_fixtures "accounts", "companies", "developers", "projects", "developers_projects", "computers"
-    @signals37 = Firm.find(1)
-  end
+  fixtures :accounts, :companies, :developers, :projects, :developers_projects,
+           :computers
   
   def test_force_reload
     firm = Firm.new("name" => "A New Firm, Inc")
@@ -63,23 +61,20 @@ class AssociationsTest < Test::Unit::TestCase
 end
 
 class HasOneAssociationsTest < Test::Unit::TestCase
-  def setup
-    create_fixtures "accounts", "companies", "developers", "projects", "developers_projects"
-    @signals37 = Firm.find(1)
-  end
+  fixtures :accounts, :companies, :developers, :projects, :developers_projects
   
   def test_has_one
-    assert_equal @signals37.account, Account.find(1)
-    assert_equal Account.find(1).credit_limit, @signals37.account.credit_limit
+    assert_equal companies(:first_firm).account, Account.find(1)
+    assert_equal Account.find(1).credit_limit, companies(:first_firm).account.credit_limit
   end
 
   def test_triple_equality
-    assert Account === @signals37.account
+    assert Account === companies(:first_firm).account
   end
 
   def test_type_mismatch
-    assert_raises(ActiveRecord::AssociationTypeMismatch) { @signals37.account = 1 }
-    assert_raises(ActiveRecord::AssociationTypeMismatch) { @signals37.account = Project.find(1) }
+    assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).account = 1 }
+    assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).account = Project.find(1) }
   end
 
   def test_natural_assignment
@@ -90,19 +85,48 @@ class HasOneAssociationsTest < Test::Unit::TestCase
   end
   
   def test_natural_assignment_to_nil
-    old_account_id = @signals37.account.id
-    @signals37.account = nil
-    @signals37.save
-    assert_nil @signals37.account
+    old_account_id = companies(:first_firm).account.id
+    companies(:first_firm).account = nil
+    companies(:first_firm).save
+    assert_nil companies(:first_firm).account
     # account is dependent, therefore is destroyed when reference to owner is lost
     assert_raises(ActiveRecord::RecordNotFound) { Account.find(old_account_id) } 
   end
+  
+  def test_assignment_without_replacement
+    apple = Firm.create("name" => "Apple")
+    citibank = Account.create("credit_limit" => 10)
+    apple.account = citibank
+    assert_equal apple.id, citibank.firm_id
+    
+    hsbc = apple.build_account({ :credit_limit => 20}, false)
+    assert_equal apple.id, hsbc.firm_id
+    hsbc.save
+    assert_equal apple.id, citibank.firm_id
+
+    nykredit = apple.create_account({ :credit_limit => 30}, false)
+    assert_equal apple.id, nykredit.firm_id
+    assert_equal apple.id, citibank.firm_id
+    assert_equal apple.id, hsbc.firm_id
+  end
+
+  def test_assignment_without_replacement_on_create
+    apple = Firm.create("name" => "Apple")
+    citibank = Account.create("credit_limit" => 10)
+    apple.account = citibank
+    assert_equal apple.id, citibank.firm_id
+    
+    hsbc = apple.create_account({:credit_limit => 10}, false)
+    assert_equal apple.id, hsbc.firm_id
+    hsbc.save
+    assert_equal apple.id, citibank.firm_id
+  end
 
   def test_dependence
     firm = Firm.find(1)
     assert !firm.account.nil?
     firm.destroy
-    assert_equal 1, Account.find_all.length
+    assert_equal 1, Account.count
   end
 
   def test_succesful_build_association
@@ -227,56 +251,53 @@ end
 
 
 class HasManyAssociationsTest < Test::Unit::TestCase
-  fixtures :accounts, :companies, :developers, :projects, :developers_projects, :topics
-  
-  def setup
-    @signals37 = Firm.find(1)
-  end
+  fixtures :accounts, :companies, :developers, :projects,
+           :developers_projects, :topics
   
   def force_signal37_to_load_all_clients_of_firm
-    @signals37.clients_of_firm.each {|f| }
+    companies(:first_firm).clients_of_firm.each {|f| }
   end
   
   def test_counting
-    assert_equal 2, Firm.find_first.clients.count
+    assert_equal 2, Firm.find(:first).clients.count
   end
   
   def test_finding
-    assert_equal 2, Firm.find_first.clients.length
+    assert_equal 2, Firm.find(:first).clients.length
   end
 
   def test_finding_default_orders
-    assert_equal "Summit", Firm.find_first.clients.first.name
+    assert_equal "Summit", Firm.find(:first).clients.first.name
   end
 
   def test_finding_with_different_class_name_and_order
-    assert_equal "Microsoft", Firm.find_first.clients_sorted_desc.first.name
+    assert_equal "Microsoft", Firm.find(:first).clients_sorted_desc.first.name
   end
 
   def test_finding_with_foreign_key
-    assert_equal "Microsoft", Firm.find_first.clients_of_firm.first.name
+    assert_equal "Microsoft", Firm.find(:first).clients_of_firm.first.name
   end
 
   def test_finding_with_condition
-    assert_equal "Microsoft", Firm.find_first.clients_like_ms.first.name
+    assert_equal "Microsoft", Firm.find(:first).clients_like_ms.first.name
   end
 
   def test_finding_using_sql
-    firm = Firm.find_first
+    firm = Firm.find(:first)
     first_client = firm.clients_using_sql.first
     assert_not_nil first_client
     assert_equal "Microsoft", first_client.name
     assert_equal 1, firm.clients_using_sql.size
-    assert_equal 1, Firm.find_first.clients_using_sql.size
+    assert_equal 1, Firm.find(:first).clients_using_sql.size
   end
 
   def test_counting_using_sql
-    assert_equal 1, Firm.find_first.clients_using_counter_sql.size
-    assert_equal 0, Firm.find_first.clients_using_zero_counter_sql.size
+    assert_equal 1, Firm.find(:first).clients_using_counter_sql.size
+    assert_equal 0, Firm.find(:first).clients_using_zero_counter_sql.size
   end
 
   def test_counting_non_existant_items_using_sql
-    assert_equal 0, Firm.find_first.no_clients_using_counter_sql.size
+    assert_equal 0, Firm.find(:first).no_clients_using_counter_sql.size
   end
   
   def test_belongs_to_sanity
@@ -295,7 +316,7 @@ class HasManyAssociationsTest < Test::Unit::TestCase
   end
 
   def test_find_ids
-    firm = Firm.find_first
+    firm = Firm.find(:first)
 
     assert_raises(ActiveRecord::RecordNotFound) { firm.clients.find }
 
@@ -324,43 +345,52 @@ class HasManyAssociationsTest < Test::Unit::TestCase
   def test_find_all_sanitized
     firm = Firm.find_first
     assert_equal firm.clients.find_all("name = 'Summit'"), firm.clients.find_all(["name = '%s'", "Summit"])
+    summit = firm.clients.find(:all, :conditions => "name = 'Summit'")
+    assert_equal summit, firm.clients.find(:all, :conditions => ["name = ?", "Summit"])
+    assert_equal summit, firm.clients.find(:all, :conditions => ["name = :name", { :name => "Summit" }])
   end
 
   def test_find_first
     firm = Firm.find_first
+    client2 = Client.find(2)
     assert_equal firm.clients.first, firm.clients.find_first
-    assert_equal Client.find(2), firm.clients.find_first("type = 'Client'")
+    assert_equal client2, firm.clients.find_first("type = 'Client'")
+    assert_equal client2, firm.clients.find(:first, :conditions => "type = 'Client'")
   end
 
   def test_find_first_sanitized
-    assert_equal Client.find(2), Firm.find_first.clients.find_first(["type = ?", "Client"])
+    firm = Firm.find_first
+    client2 = Client.find(2)
+    assert_equal client2, firm.clients.find_first(["type = ?", "Client"])
+    assert_equal client2, firm.clients.find(:first, :conditions => ['type = ?', 'Client'])
+    assert_equal client2, firm.clients.find(:first, :conditions => ['type = :type', { :type => 'Client' }])
   end
 
   def test_find_in_collection
-    assert_equal Client.find(2).name, @signals37.clients.find(2).name
-    assert_raises(ActiveRecord::RecordNotFound) { @signals37.clients.find(6) }
+    assert_equal Client.find(2).name, companies(:first_firm).clients.find(2).name
+    assert_raises(ActiveRecord::RecordNotFound) { companies(:first_firm).clients.find(6) }
   end
 
   def test_adding
     force_signal37_to_load_all_clients_of_firm
     natural = Client.new("name" => "Natural Company")
-    @signals37.clients_of_firm << natural
-    assert_equal 2, @signals37.clients_of_firm.size # checking via the collection
-    assert_equal 2, @signals37.clients_of_firm(true).size # checking using the db
-    assert_equal natural, @signals37.clients_of_firm.last
+    companies(:first_firm).clients_of_firm << natural
+    assert_equal 2, companies(:first_firm).clients_of_firm.size # checking via the collection
+    assert_equal 2, companies(:first_firm).clients_of_firm(true).size # checking using the db
+    assert_equal natural, companies(:first_firm).clients_of_firm.last
   end
   
   def test_adding_a_mismatch_class
-    assert_raises(ActiveRecord::AssociationTypeMismatch) { @signals37.clients_of_firm << nil }
-    assert_raises(ActiveRecord::AssociationTypeMismatch) { @signals37.clients_of_firm << 1 }
-    assert_raises(ActiveRecord::AssociationTypeMismatch) { @signals37.clients_of_firm << Topic.find(1) }
+    assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).clients_of_firm << nil }
+    assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).clients_of_firm << 1 }
+    assert_raises(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).clients_of_firm << Topic.find(1) }
   end
   
   def test_adding_a_collection
     force_signal37_to_load_all_clients_of_firm
-    @signals37.clients_of_firm.concat([Client.new("name" => "Natural Company"), Client.new("name" => "Apple")])
-    assert_equal 3, @signals37.clients_of_firm.size
-    assert_equal 3, @signals37.clients_of_firm(true).size
+    companies(:first_firm).clients_of_firm.concat([Client.new("name" => "Natural Company"), Client.new("name" => "Apple")])
+    assert_equal 3, companies(:first_firm).clients_of_firm.size
+    assert_equal 3, companies(:first_firm).clients_of_firm(true).size
   end
 
   def test_adding_before_save
@@ -406,51 +436,51 @@ class HasManyAssociationsTest < Test::Unit::TestCase
   end
 
   def test_build
-    new_client = @signals37.clients_of_firm.build("name" => "Another Client")
+    new_client = companies(:first_firm).clients_of_firm.build("name" => "Another Client")
     assert_equal "Another Client", new_client.name
     assert new_client.new_record?
-    assert_equal new_client, @signals37.clients_of_firm.last
-    assert @signals37.save
+    assert_equal new_client, companies(:first_firm).clients_of_firm.last
+    assert companies(:first_firm).save
     assert !new_client.new_record?
-    assert_equal 2, @signals37.clients_of_firm(true).size
+    assert_equal 2, companies(:first_firm).clients_of_firm(true).size
   end
 
   def test_build_many
-    new_clients = @signals37.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}])
+    new_clients = companies(:first_firm).clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}])
     assert_equal 2, new_clients.size
 
-    assert @signals37.save
-    assert_equal 3, @signals37.clients_of_firm(true).size
+    assert companies(:first_firm).save
+    assert_equal 3, companies(:first_firm).clients_of_firm(true).size
   end
 
   def test_invalid_build
-    new_client = @signals37.clients_of_firm.build
+    new_client = companies(:first_firm).clients_of_firm.build
     assert new_client.new_record?
     assert !new_client.valid?
-    assert_equal new_client, @signals37.clients_of_firm.last
-    assert !@signals37.save
+    assert_equal new_client, companies(:first_firm).clients_of_firm.last
+    assert !companies(:first_firm).save
     assert new_client.new_record?
-    assert_equal 1, @signals37.clients_of_firm(true).size
+    assert_equal 1, companies(:first_firm).clients_of_firm(true).size
   end
   
   def test_create
     force_signal37_to_load_all_clients_of_firm
-    new_client = @signals37.clients_of_firm.create("name" => "Another Client")
+    new_client = companies(:first_firm).clients_of_firm.create("name" => "Another Client")
     assert !new_client.new_record?
-    assert_equal new_client, @signals37.clients_of_firm.last
-    assert_equal new_client, @signals37.clients_of_firm(true).last
+    assert_equal new_client, companies(:first_firm).clients_of_firm.last
+    assert_equal new_client, companies(:first_firm).clients_of_firm(true).last
   end
   
   def test_create_many
-    @signals37.clients_of_firm.create([{"name" => "Another Client"}, {"name" => "Another Client II"}])
-    assert_equal 3, @signals37.clients_of_firm(true).size
+    companies(:first_firm).clients_of_firm.create([{"name" => "Another Client"}, {"name" => "Another Client II"}])
+    assert_equal 3, companies(:first_firm).clients_of_firm(true).size
   end
 
   def test_deleting
     force_signal37_to_load_all_clients_of_firm
-    @signals37.clients_of_firm.delete(@signals37.clients_of_firm.first)
-    assert_equal 0, @signals37.clients_of_firm.size
-    assert_equal 0, @signals37.clients_of_firm(true).size
+    companies(:first_firm).clients_of_firm.delete(companies(:first_firm).clients_of_firm.first)
+    assert_equal 0, companies(:first_firm).clients_of_firm.size
+    assert_equal 0, companies(:first_firm).clients_of_firm(true).size
   end
 
   def test_deleting_before_save
@@ -463,29 +493,29 @@ class HasManyAssociationsTest < Test::Unit::TestCase
 
   def test_deleting_a_collection
     force_signal37_to_load_all_clients_of_firm
-    @signals37.clients_of_firm.create("name" => "Another Client")
-    assert_equal 2, @signals37.clients_of_firm.size
-    #@signals37.clients_of_firm.clear
-    @signals37.clients_of_firm.delete([@signals37.clients_of_firm[0], @signals37.clients_of_firm[1]])
-    assert_equal 0, @signals37.clients_of_firm.size
-    assert_equal 0, @signals37.clients_of_firm(true).size
+    companies(:first_firm).clients_of_firm.create("name" => "Another Client")
+    assert_equal 2, companies(:first_firm).clients_of_firm.size
+    #companies(:first_firm).clients_of_firm.clear
+    companies(:first_firm).clients_of_firm.delete([companies(:first_firm).clients_of_firm[0], companies(:first_firm).clients_of_firm[1]])
+    assert_equal 0, companies(:first_firm).clients_of_firm.size
+    assert_equal 0, companies(:first_firm).clients_of_firm(true).size
   end
 
   def test_deleting_a_association_collection
     force_signal37_to_load_all_clients_of_firm
-    @signals37.clients_of_firm.create("name" => "Another Client")
-    assert_equal 2, @signals37.clients_of_firm.size
-    @signals37.clients_of_firm.clear
-    assert_equal 0, @signals37.clients_of_firm.size
-    assert_equal 0, @signals37.clients_of_firm(true).size
+    companies(:first_firm).clients_of_firm.create("name" => "Another Client")
+    assert_equal 2, companies(:first_firm).clients_of_firm.size
+    companies(:first_firm).clients_of_firm.clear
+    assert_equal 0, companies(:first_firm).clients_of_firm.size
+    assert_equal 0, companies(:first_firm).clients_of_firm(true).size
   end
 
   def test_deleting_a_item_which_is_not_in_the_collection
     force_signal37_to_load_all_clients_of_firm
     summit = Client.find_first("name = 'Summit'")
-    @signals37.clients_of_firm.delete(summit)
-    assert_equal 1, @signals37.clients_of_firm.size
-    assert_equal 1, @signals37.clients_of_firm(true).size
+    companies(:first_firm).clients_of_firm.delete(summit)
+    assert_equal 1, companies(:first_firm).clients_of_firm.size
+    assert_equal 1, companies(:first_firm).clients_of_firm(true).size
     assert_equal 2, summit.client_of
   end
 
@@ -503,20 +533,21 @@ class HasManyAssociationsTest < Test::Unit::TestCase
 
   def test_destroy_all
     force_signal37_to_load_all_clients_of_firm
-    assert !@signals37.clients_of_firm.empty?, "37signals has clients after load"
-    @signals37.clients_of_firm.destroy_all
-    assert @signals37.clients_of_firm.empty?, "37signals has no clients after destroy all"
-    assert @signals37.clients_of_firm(true).empty?, "37signals has no clients after destroy all and refresh"
+    assert !companies(:first_firm).clients_of_firm.empty?, "37signals has clients after load"
+    companies(:first_firm).clients_of_firm.destroy_all
+    assert companies(:first_firm).clients_of_firm.empty?, "37signals has no clients after destroy all"
+    assert companies(:first_firm).clients_of_firm(true).empty?, "37signals has no clients after destroy all and refresh"
   end
 
   def test_dependence
-    assert_equal 2, Client.find_all.size
-    Firm.find_first.destroy
-    assert Client.find_all.empty?
+    firm = companies(:first_firm)
+    assert_equal 2, firm.clients.size
+    firm.destroy
+    assert Client.find(:all, :conditions => "firm_id=#{firm.id}").empty?
   end
 
   def test_destroy_dependent_when_deleted_from_association
-    firm = Firm.find_first
+    firm = Firm.find(:first)
     assert_equal 2, firm.clients.size
 
     client = firm.clients.first
@@ -535,43 +566,81 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     assert_nothing_raised { topic.destroy }
   end
 
+  uses_transaction :test_dependence_with_transaction_support_on_failure
   def test_dependence_with_transaction_support_on_failure
-    assert_equal 2, Client.find_all.length
-    firm = Firm.find_first
+    firm = companies(:first_firm)
     clients = firm.clients
+    assert_equal 2, clients.length
     clients.last.instance_eval { def before_destroy() raise "Trigger rollback" end }
 
     firm.destroy rescue "do nothing"
 
-    assert_equal 2, Client.find_all.length
+    assert_equal 2, Client.find(:all, :conditions => "firm_id=#{firm.id}").size
   end
 
   def test_dependence_on_account
-    assert_equal 2, Account.find_all.length
-    @signals37.destroy
-    assert_equal 1, Account.find_all.length
+    assert_equal 2, Account.count
+    companies(:first_firm).destroy
+    assert_equal 1, Account.count
   end
 
   def test_included_in_collection
-    assert @signals37.clients.include?(Client.find(2))
+    assert companies(:first_firm).clients.include?(Client.find(2))
   end
 
   def test_adding_array_and_collection
-    assert_nothing_raised { Firm.find_first.clients + Firm.find_all.last.clients }
+    assert_nothing_raised { Firm.find(:first).clients + Firm.find(:all).last.clients }
   end
-end
 
-class BelongsToAssociationsTest < Test::Unit::TestCase
-  fixtures :accounts, :companies, :developers, :projects, :topics
+  def test_find_all_without_conditions
+    firm = companies(:first_firm)
+    assert_equal 2, firm.clients.find(:all).length
+  end
+
+  def test_replace_with_less
+    firm = Firm.find(:first)
+    firm.clients = [companies(:first_client)]
+    assert firm.save, "Could not save firm"
+    firm.reload
+    assert_equal 1, firm.clients.length
+  end
+  
+  def test_replace_with_new
+    firm = Firm.find(:first)
+    new_client = Client.new("name" => "New Client")
+    firm.clients = [companies(:second_client),new_client]
+    firm.save
+    firm.reload
+    assert_equal 2, firm.clients.length
+    assert !firm.clients.include?(:first_client)
+  end
   
-  def setup
-    create_fixtures "developers_projects"
-    @signals37 = Firm.find(1)
+  def test_replace_on_new_object
+    firm = Firm.new("name" => "New Firm")
+    firm.clients = [companies(:second_client), Client.new("name" => "New Client")]
+    assert firm.save
+    firm.reload
+    assert_equal 2, firm.clients.length
+    assert firm.clients.include?(Client.find_by_name("New Client"))
   end
+  
+  def test_assign_ids
+    firm = Firm.new("name" => "Apple")
+    firm.client_ids = [companies(:first_client).id, companies(:second_client).id]
+    firm.save
+    firm.reload
+    assert_equal 2, firm.clients.length
+    assert firm.clients.include?(companies(:second_client))
+  end
+end
 
+class BelongsToAssociationsTest < Test::Unit::TestCase
+  fixtures :accounts, :companies, :developers, :projects, :topics,
+           :developers_projects
+  
   def test_belongs_to
     Client.find(3).firm.name
-    assert_equal @signals37.name, Client.find(3).firm.name
+    assert_equal companies(:first_firm).name, Client.find(3).firm.name
     assert !Client.find(3).firm.nil?, "Microsoft should have a firm"   
   end
 
@@ -630,7 +699,7 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
   end
 
   def test_assignment_before_parent_saved
-    client = Client.find_first
+    client = Client.find(:first)
     apple = Firm.new("name" => "Apple")
     client.firm = apple
     assert_equal apple, client.firm
@@ -669,7 +738,7 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
 
   def test_new_record_with_foreign_key_but_no_object
     c = Client.new("firm_id" => 1)
-    assert_equal Firm.find_first, c.firm_with_basic_id
+    assert_equal Firm.find(:first), c.firm_with_basic_id
   end
 
   def test_forgetting_the_load_when_foreign_key_enters_late
@@ -677,7 +746,7 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
     assert_nil c.firm_with_basic_id
 
     c.firm_id = 1
-    assert_equal Firm.find_first, c.firm_with_basic_id
+    assert_equal Firm.find(:first), c.firm_with_basic_id
   end
 
   def test_field_name_same_as_foreign_key
@@ -695,12 +764,39 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
     apple.companies_count = 2
     apple.save
 
-    apple = Firm.find_first("name = 'Apple'")
+    apple = Firm.find(:first, :conditions => "name = 'Apple'")
     assert_equal 2, apple.clients.size, "Should use the new cached number"
 
     apple.clients.to_s 
     assert_equal 1, apple.clients.size, "Should not use the cached number, but go to the database"
   end
+  
+end
+
+
+class ProjectWithAfterCreateHook < ActiveRecord::Base
+  set_table_name 'projects'
+  has_and_belongs_to_many :developers,
+    :class_name => "DeveloperForProjectWithAfterCreateHook",
+    :join_table => "developers_projects",
+    :foreign_key => "project_id",
+    :association_foreign_key => "developer_id"
+
+  after_create :add_david
+
+  def add_david
+    david = DeveloperForProjectWithAfterCreateHook.find_by_name('David')
+    david.projects << self
+  end
+end
+
+class DeveloperForProjectWithAfterCreateHook < ActiveRecord::Base
+  set_table_name 'developers'
+  has_and_belongs_to_many :projects,
+    :class_name => "ProjectWithAfterCreateHook",
+    :join_table => "developers_projects",
+    :association_foreign_key => "project_id",
+    :foreign_key => "developer_id"
 end
 
 
@@ -716,9 +812,9 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     active_record = Project.find(1)
     assert !active_record.developers.empty?
     assert_equal 2, active_record.developers.size
-    assert_equal david.name, active_record.developers.first.name
+    assert active_record.developers.include?(david)
   end
-  
+
   def test_adding_single
     jamis = Developer.find(2)
     jamis.projects.reload # causing the collection to load 
@@ -753,8 +849,24 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     assert_equal 2, action_controller.developers(true).size
   end
 
+  def test_adding_from_the_project_fixed_timestamp
+    jamis = Developer.find(2)
+    action_controller = Project.find(2)
+    action_controller.developers.reload
+    assert_equal 1, jamis.projects.size
+    assert_equal 1, action_controller.developers.size
+    updated_at = jamis.updated_at
+
+    action_controller.developers << jamis
+
+    assert_equal updated_at, jamis.updated_at
+    assert_equal 2, jamis.projects(true).size
+    assert_equal 2, action_controller.developers.size
+    assert_equal 2, action_controller.developers(true).size
+  end
+
   def test_adding_multiple
-    aredridel = Developer.new("name" => "Aridridel")
+    aredridel = Developer.new("name" => "Aredridel")
     aredridel.save
     aredridel.projects.reload
     aredridel.projects.push(Project.find(1), Project.find(2))
@@ -763,7 +875,7 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
   end
 
   def test_adding_a_collection
-    aredridel = Developer.new("name" => "Aridridel")
+    aredridel = Developer.new("name" => "Aredridel")
     aredridel.save
     aredridel.projects.reload
     aredridel.projects.concat([Project.find(1), Project.find(2)])
@@ -774,7 +886,7 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
   def test_habtm_adding_before_save
     no_of_devels = Developer.count
     no_of_projects = Project.count
-    aredridel = Developer.new("name" => "Aridridel")
+    aredridel = Developer.new("name" => "Aredridel")
     aredridel.projects.concat([Project.find(1), p = Project.new("name" => "Projekt")])
     assert aredridel.new_record?
     assert p.new_record?
@@ -790,6 +902,7 @@ 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")
@@ -804,7 +917,13 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     assert_equal 2, ken.projects(true).size
 
     kenReloaded = Developer.find_by_name 'Ken'
-    kenReloaded.projects.each { |prj| assert_equal(now.to_s, prj.joined_on.to_s) }
+    # SQL Server doesn't have a separate column type just for dates, 
+    # so the time is in the string and incorrectly formatted
+    if ActiveRecord::ConnectionAdapters.const_defined? :SQLServerAdapter and ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::SQLServerAdapter)
+      kenReloaded.projects.each { |prj| assert_equal(sqlnow, prj.joined_on.to_s) }
+    else
+      kenReloaded.projects.each { |prj| assert_equal(now.to_s, prj.joined_on.to_s) }
+    end
   end
 
   def test_build
@@ -825,16 +944,16 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
   end
   
   def test_uniq_after_the_fact
-    @developers["jamis"].find.projects << @projects["active_record"].find
-    @developers["jamis"].find.projects << @projects["active_record"].find
-    assert_equal 3, @developers["jamis"].find.projects.size
-    assert_equal 1, @developers["jamis"].find.projects.uniq.size
+    developers(:jamis).projects << projects(:active_record)
+    developers(:jamis).projects << projects(:active_record)
+    assert_equal 3, developers(:jamis).projects.size
+    assert_equal 1, developers(:jamis).projects.uniq.size
   end
 
   def test_uniq_before_the_fact
-    @projects["active_record"].find.developers << @developers["jamis"].find
-    @projects["active_record"].find.developers << @developers["david"].find
-    assert_equal 2, @projects["active_record"].find.developers.size
+    projects(:active_record).developers << developers(:jamis)
+    projects(:active_record).developers << developers(:david)
+    assert_equal 2, projects(:active_record, :reload).developers.size
   end
   
   def test_deleting
@@ -854,11 +973,30 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
   def test_deleting_array
     david = Developer.find(1)
     david.projects.reload
-    david.projects.delete(Project.find_all)
+    david.projects.delete(Project.find(:all))
     assert_equal 0, david.projects.size
     assert_equal 0, david.projects(true).size
   end
 
+  def test_deleting_with_sql
+    david = Developer.find(1)
+    active_record = Project.find(1)
+    active_record.developers.reload
+    assert_equal 2, active_record.developers_by_sql.size
+    
+    active_record.developers_by_sql.delete(david)
+    assert_equal 1, 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
+    
+    active_record.developers_by_sql.delete(Developer.find(:all))
+    assert_equal 0, active_record.developers_by_sql(true).size
+  end
+
   def test_deleting_all
     david = Developer.find(1)
     david.projects.reload
@@ -873,7 +1011,13 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
   end
   
   def test_additional_columns_from_join_table
-    assert_equal Date.new(2004, 10, 10).to_s, Developer.find(1).projects.first.joined_on.to_s
+    # SQL Server doesn't have a separate column type just for dates, 
+    # so the time is in the string and incorrectly formatted
+    if ActiveRecord::ConnectionAdapters.const_defined? :SQLServerAdapter and ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::SQLServerAdapter)
+      assert_equal Time.mktime(2004, 10, 10).strftime("%Y/%m/%d 00:00:00"), Developer.find(1).projects.first.joined_on.to_s
+    else
+      assert_equal Date.new(2004, 10, 10).to_s, Developer.find(1).projects.first.joined_on.to_s
+    end
   end
   
   def test_destroy_all
@@ -886,35 +1030,93 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
   end
 
   def test_rich_association
-    @jamis = @developers["jamis"].find
-    @jamis.projects.push_with_attributes(@projects["action_controller"].find, :joined_on => Date.today)
-    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"].find.projects.select { |p| p.name == @projects["action_controller"]["name"] }.first.joined_on.to_s
+    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 ActiveRecord::ConnectionAdapters.const_defined? :SQLServerAdapter and ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::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.to_s
+      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.to_s
+    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
   end
 
   def test_associations_with_conditions
-    assert_equal 2, @projects["active_record"].find.developers.size
-    assert_equal 1, @projects["active_record"].find.developers_named_david.size
-    
-    @projects["active_record"].find.developers_named_david.clear
-    assert_equal 1, @projects["active_record"].find.developers.size
+    assert_equal 2, 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
   end
   
   def test_find_in_association
     # Using sql
-    assert_equal @developers["david"].find, @projects["active_record"].find.developers.find(@developers["david"]["id"]), "SQL find"
+    assert_equal developers(:david), projects(:active_record).developers.find(developers(:david).id), "SQL find"
     
     # Using ruby
-    @active_record = @projects["active_record"].find
-    @active_record.developers.reload
-    assert_equal @developers["david"].find, @active_record.developers.find(@developers["david"]["id"]), "Ruby find"
+    active_record = projects(:active_record)
+    active_record.developers.reload
+    assert_equal developers(:david), active_record.developers.find(developers(:david).id), "Ruby find"
+  end
+
+  def test_new_with_values_in_collection
+    jamis = DeveloperForProjectWithAfterCreateHook.find_by_name('Jamis')
+    david = DeveloperForProjectWithAfterCreateHook.find_by_name('David')
+    project = ProjectWithAfterCreateHook.new(:name => "Cooking with Bertie")
+    project.developers << jamis
+    project.save!
+    project.reload
+
+    assert project.developers.include?(jamis)
+    assert project.developers.include?(david)
   end
 
   def xtest_find_in_association_with_options
-    developers = @active_record.developers.find(:all)
+    developers = projects(:active_record).developers.find(:all)
     assert_equal 2, developers.size
     
-    assert_equal @david, @active_record.developers.find(:first, :conditions => "salary < 10000")
-    assert_equal @jamis, @active_record.developers.find(:first, :order => "salary DESC")
+    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")
   end
-end
+  
+  def test_replace_with_less
+    david = developers(:david)
+    david.projects = [projects(:action_controller)]
+    assert david.save
+    assert_equal 1, david.projects.length
+  end
+
+  def test_replace_with_new
+    david = developers(:david)
+    david.projects = [projects(:action_controller), Project.new("name" => "ActionWebSearch")]
+    david.save
+    assert_equal 2, david.projects.length
+    assert !david.projects.include?(projects(:active_record))
+  end
+  
+  def test_replace_on_new_object
+    new_developer = Developer.new("name" => "Matz")
+    new_developer.projects = [projects(:action_controller), Project.new("name" => "ActionWebSearch")]
+    new_developer.save
+    assert_equal 2, new_developer.projects.length
+  end
+
+  def test_consider_type
+    developer = Developer.find(:first)
+    special_project = SpecialProject.create("name" => "Special Project")
+  
+    other_project = developer.projects.first
+    developer.special_projects << special_project
+    developer.reload
+  
+    assert developer.projects.include?(special_project)
+    assert developer.special_projects.include?(special_project)
+    assert !developer.special_projects.include?(other_project)
+  end
+
+end