activerecord 1.11.1 → 1.12.1

data/test/associations_test.rb

@@ -5,12 +5,16 @@ require 'fixtures/company'
 require 'fixtures/topic'
 require 'fixtures/reply'
 require 'fixtures/computer'
+require 'fixtures/customer'
+require 'fixtures/order'
+require 'fixtures/post'
+require 'fixtures/author'
 
 # Can't declare new classes in test case methods, so tests before that
 bad_collection_keys = false
 begin
   class Car < ActiveRecord::Base; has_many :wheels, :name => "wheels"; end
-rescue ActiveRecord::ActiveRecordError
+rescue ArgumentError
   bad_collection_keys = true
 end
 raise "ActiveRecord should have barked on bad collection keys" unless bad_collection_keys
@@ -19,7 +23,7 @@ raise "ActiveRecord should have barked on bad collection keys" unless bad_collec
 class AssociationsTest < Test::Unit::TestCase
   fixtures :accounts, :companies, :developers, :projects, :developers_projects,
            :computers
-  
+
   def test_force_reload
     firm = Firm.new("name" => "A New Firm, Inc")
     firm.save
@@ -68,6 +72,11 @@ class HasOneAssociationsTest < Test::Unit::TestCase
     assert_equal Account.find(1).credit_limit, companies(:first_firm).account.credit_limit
   end
 
+  def test_proxy_assignment
+    company = companies(:first_firm)
+    assert_nothing_raised { company.account = company.account }
+  end
+
   def test_triple_equality
     assert Account === companies(:first_firm).account
   end
@@ -123,10 +132,11 @@ class HasOneAssociationsTest < Test::Unit::TestCase
   end
 
   def test_dependence
+    num_accounts = Account.count
     firm = Firm.find(1)
     assert !firm.account.nil?
-    firm.destroy
-    assert_equal 1, Account.count
+    firm.destroy                
+    assert_equal num_accounts - 1, Account.count
   end
 
   def test_succesful_build_association
@@ -253,11 +263,15 @@ end
 class HasManyAssociationsTest < Test::Unit::TestCase
   fixtures :accounts, :companies, :developers, :projects,
            :developers_projects, :topics
-  
+
+  def setup
+    Client.destroyed_client_ids.clear
+  end
+
   def force_signal37_to_load_all_clients_of_firm
     companies(:first_firm).clients_of_firm.each {|f| }
   end
-  
+
   def test_counting
     assert_equal 2, Firm.find(:first).clients.count
   end
@@ -312,7 +326,6 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     else
       assert false,  "belongs_to failed unless check"
     end
-        
   end
 
   def test_find_ids
@@ -418,6 +431,7 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     firm = Firm.find(1)
     assert !(firm.clients_of_firm << c = Client.new)
     assert c.new_record?
+    assert !firm.valid?
     assert !firm.save
     assert c.new_record?
   end
@@ -429,7 +443,7 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     new_firm.clients_of_firm.concat([c = Client.new, Client.new("name" => "Apple")])
     assert c.new_record?
     assert !c.valid?
-    assert new_firm.valid?
+    assert !new_firm.valid?
     assert !new_firm.save
     assert c.new_record?
     assert new_firm.new_record?
@@ -495,21 +509,63 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     force_signal37_to_load_all_clients_of_firm
     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
-    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
+  def test_clearing_an_association_collection
+    firm = companies(:first_firm)
+    client_id = firm.clients_of_firm.first.id
+    assert_equal 1, firm.clients_of_firm.size
+
+    firm.clients_of_firm.clear
+
+    assert_equal 0, firm.clients_of_firm.size
+    assert_equal 0, firm.clients_of_firm(true).size
+    assert_equal [], Client.destroyed_client_ids[firm.id]
+
+    # Should not be destroyed since the association is not dependent.
+    assert_nothing_raised do
+      assert Client.find(client_id).firm.nil?
+    end
+  end
+
+  def test_clearing_a_dependent_association_collection
+    firm = companies(:first_firm)
+    client_id = firm.dependent_clients_of_firm.first.id
+    assert_equal 1, firm.dependent_clients_of_firm.size
+
+    # :dependent means destroy is called on each client
+    firm.dependent_clients_of_firm.clear
+
+    assert_equal 0, firm.dependent_clients_of_firm.size
+    assert_equal 0, firm.dependent_clients_of_firm(true).size
+    assert_equal [client_id], Client.destroyed_client_ids[firm.id]
+
+    # Should be destroyed since the association is dependent.
+    assert Client.find_by_id(client_id).nil?
   end
 
+  def test_clearing_an_exclusively_dependent_association_collection
+    firm = companies(:first_firm)
+    client_id = firm.exclusively_dependent_clients_of_firm.first.id
+    assert_equal 1, firm.exclusively_dependent_clients_of_firm.size
+
+    assert_equal [], Client.destroyed_client_ids[firm.id]
+
+    # :exclusively_dependent means each client is deleted directly from
+    # the database without looping through them calling destroy.
+    firm.exclusively_dependent_clients_of_firm.clear
+
+    assert_equal 0, firm.exclusively_dependent_clients_of_firm.size
+    assert_equal 0, firm.exclusively_dependent_clients_of_firm(true).size
+    assert_equal [3], Client.destroyed_client_ids[firm.id]
+
+    # Should be destroyed since the association is exclusively dependent.
+    assert Client.find_by_id(client_id).nil?
+  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'")
@@ -579,9 +635,26 @@ class HasManyAssociationsTest < Test::Unit::TestCase
   end
 
   def test_dependence_on_account
-    assert_equal 2, Account.count
+    num_accounts = Account.count
     companies(:first_firm).destroy
-    assert_equal 1, Account.count
+    assert_equal num_accounts - 1, Account.count
+  end
+
+
+  def test_depends_and_nullify
+    num_accounts = Account.count
+    num_companies = Company.count
+    
+    core = companies(:rails_core)
+    assert_equal accounts(:rails_core_account), core.account
+    assert_equal [companies(:leetsoft), companies(:jadedpixel)], core.companies
+    core.destroy                                         
+    assert_nil accounts(:rails_core_account).reload.firm_id
+    assert_nil companies(:leetsoft).reload.client_of
+    assert_nil companies(:jadedpixel).reload.client_of
+    
+    
+    assert_equal num_accounts, Account.count
   end
 
   def test_included_in_collection
@@ -603,7 +676,8 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     assert firm.save, "Could not save firm"
     firm.reload
     assert_equal 1, firm.clients.length
-  end
+  end 
+  
   
   def test_replace_with_new
     firm = Firm.find(:first)
@@ -636,7 +710,7 @@ end
 
 class BelongsToAssociationsTest < Test::Unit::TestCase
   fixtures :accounts, :companies, :developers, :projects, :topics,
-           :developers_projects
+           :developers_projects, :computers, :authors, :posts
   
   def test_belongs_to
     Client.find(3).firm.name
@@ -644,6 +718,11 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
     assert !Client.find(3).firm.nil?, "Microsoft should have a firm"   
   end
 
+  def test_proxy_assignment
+    account = Account.find(1)
+    assert_nothing_raised { account.firm = account.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) }
@@ -660,6 +739,9 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
     citibank = Account.create("credit_limit" => 10)
     apple    = citibank.create_firm("name" => "Apple")
     assert_equal apple, citibank.firm
+    citibank.save
+    citibank.reload
+    assert_equal apple, citibank.firm
   end
 
   def test_building_the_belonging_object
@@ -750,7 +832,7 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
   end
 
   def test_field_name_same_as_foreign_key
-    computer = Computer.find 1
+    computer = Computer.find(1)
     assert_not_nil computer.developer, ":foreign key == attribute didn't lock up" # '
   end
 
@@ -770,6 +852,111 @@ class BelongsToAssociationsTest < Test::Unit::TestCase
     apple.clients.to_s 
     assert_equal 1, apple.clients.size, "Should not use the cached number, but go to the database"
   end
+
+  def test_store_two_association_with_one_save
+    num_orders = Order.count
+    num_customers = Customer.count
+    order = Order.new 
+
+    customer1 = order.billing = Customer.new
+    customer2 = order.shipping = Customer.new 
+    assert order.save
+    assert_equal customer1, order.billing
+    assert_equal customer2, order.shipping
+
+    order.reload
+
+    assert_equal customer1, order.billing
+    assert_equal customer2, order.shipping        
+
+    assert_equal num_orders +1, Order.count
+    assert_equal num_customers +2, Customer.count
+  end
+
+  
+  def test_store_association_in_two_relations_with_one_save
+    num_orders = Order.count
+    num_customers = Customer.count
+    order = Order.new 
+    
+    customer = order.billing = order.shipping = Customer.new 
+    assert order.save
+    assert_equal customer, order.billing
+    assert_equal customer, order.shipping
+    
+    order.reload
+    
+    assert_equal customer, order.billing
+    assert_equal customer, order.shipping        
+    
+    assert_equal num_orders +1, Order.count
+    assert_equal num_customers +1, Customer.count
+  end
+
+  def test_store_association_in_two_relations_with_one_save_in_existing_object
+    num_orders = Order.count
+    num_customers = Customer.count
+    order = Order.create
+    
+    customer = order.billing = order.shipping = Customer.new 
+    assert order.save
+    assert_equal customer, order.billing
+    assert_equal customer, order.shipping
+    
+    order.reload
+    
+    assert_equal customer, order.billing
+    assert_equal customer, order.shipping        
+    
+    assert_equal num_orders +1, Order.count
+    assert_equal num_customers +1, Customer.count
+  end
+  
+  def test_store_association_in_two_relations_with_one_save_in_existing_object_with_values
+    num_orders = Order.count
+    num_customers = Customer.count
+    order = Order.create
+    
+    customer = order.billing = order.shipping = Customer.new 
+    assert order.save
+    assert_equal customer, order.billing
+    assert_equal customer, order.shipping
+    
+    order.reload
+    
+    customer = order.billing = order.shipping = Customer.new 
+    
+    assert order.save
+    order.reload    
+    
+    assert_equal customer, order.billing
+    assert_equal customer, order.shipping        
+    
+    assert_equal num_orders +1, Order.count
+    assert_equal num_customers +2, Customer.count
+  end
+  
+  
+  def test_association_assignment_sticks
+    post = Post.find(:first)
+
+    author1, author2 = Author.find(:all, :limit => 2)
+    assert_not_nil author1
+    assert_not_nil author2
+
+    # make sure the association is loaded
+    post.author
+
+    # set the association by id, directly
+    post.author_id = author2.id
+
+    # save and reload
+    post.save!
+    post.reload
+
+    # the author id of the post should be the id we set
+    assert_equal post.author_id, author2.id
+  end
   
 end
 
@@ -883,6 +1070,26 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     assert_equal 2, aredridel.projects(true).size
   end
 
+  def test_adding_uses_default_values_on_join_table
+    ac = projects(:action_controller)
+    assert !developers(:jamis).projects.include?(ac)
+    developers(:jamis).projects << ac
+
+    assert developers(:jamis, :reload).projects.include?(ac)
+    project = developers(:jamis).projects.detect { |p| p == ac }
+    assert_equal 1, project.access_level.to_i
+  end
+
+  def test_adding_uses_explicit_values_on_join_table
+    ac = projects(:action_controller)
+    assert !developers(:jamis).projects.include?(ac)
+    developers(:jamis).projects.push_with_attributes(ac, :access_level => 3)
+
+    assert developers(:jamis, :reload).projects.include?(ac)
+    project = developers(:jamis).projects.detect { |p| p == ac }
+    assert_equal 3, project.access_level.to_i
+  end
+
   def test_habtm_adding_before_save
     no_of_devels = Developer.count
     no_of_projects = Project.count
@@ -920,7 +1127,7 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     # 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) }
+      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) }
     end
@@ -1014,7 +1221,7 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     # 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
+      assert_equal Time.mktime(2004, 10, 10).strftime("%Y/%m/%d 00:00:00"), Time.parse(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
@@ -1035,8 +1242,8 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     # 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
+      assert_equal Time.now.strftime("%Y/%m/%d 00:00:00"), Time.parse(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"), Time.parse(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
@@ -1064,6 +1271,19 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     assert_equal developers(:david), active_record.developers.find(developers(:david).id), "Ruby find"
   end
 
+  def test_find_in_association_with_custom_finder_sql
+    assert_equal developers(:david), projects(:active_record).developers_with_finder_sql.find(developers(:david).id), "SQL find"
+   
+    active_record = projects(:active_record)
+    active_record.developers_with_finder_sql.reload
+    assert_equal developers(:david), active_record.developers_with_finder_sql.find(developers(:david).id), "Ruby find"
+  end
+
+  def test_find_in_association_with_custom_finder_sql_and_string_id
+    assert_equal developers(:david), projects(:active_record).developers_with_finder_sql.find(developers(:david).id.to_s), "SQL find"
+  end
+
+
   def test_new_with_values_in_collection
     jamis = DeveloperForProjectWithAfterCreateHook.find_by_name('Jamis')
     david = DeveloperForProjectWithAfterCreateHook.find_by_name('David')

data/test/base_test.rb

@@ -1,5 +1,3 @@
-require 'abstract_unit'
-require 'fixtures/topic'
 require 'fixtures/reply'
 require 'fixtures/company'
 require 'fixtures/developer'
@@ -7,6 +5,8 @@ require 'fixtures/project'
 require 'fixtures/default'
 require 'fixtures/auto_id'
 require 'fixtures/column_name'
+require 'fixtures/subscriber'
+require 'fixtures/keyboard'
 
 class Category < ActiveRecord::Base; end
 class Smarts < ActiveRecord::Base; end
@@ -50,8 +50,8 @@ class BasicsTest < Test::Unit::TestCase
   end
   
   def test_integers_as_nil
-    Topic.update(1, "approved" => "")
-    assert_nil Topic.find(1).approved
+    test = AutoId.create('value' => '')
+    assert_nil AutoId.find(test.id).value
   end
   
   def test_set_attributes_with_block
@@ -180,10 +180,33 @@ class BasicsTest < Test::Unit::TestCase
     assert_equal "Still another topic: part 2", topic.title
   end
 
+  def test_read_attribute
+    topic = Topic.new
+    topic.title = "Don't change the topic"
+    assert_equal "Don't change the topic", topic.send(:read_attribute, "title")
+    assert_equal "Don't change the topic", topic["title"]
+
+    assert_equal "Don't change the topic", topic.send(:read_attribute, :title)
+    assert_equal "Don't change the topic", topic[:title]
+  end
+
   def test_read_attribute_when_false
     topic = topics(:first)
     topic.approved = false
-    assert_equal 0, topic.approved, "approved should be 0"
+    assert !topic.approved?, "approved should be false"
+  end
+
+  def test_reader_generation
+    Topic.find(:first).title
+    Firm.find(:first).name
+    Client.find(:first).name
+    if ActiveRecord::Base.generate_read_methods
+      assert_readers(Topic,  %w(type replies_count))
+      assert_readers(Firm,   %w(type))
+      assert_readers(Client, %w(type))
+    else
+      [Topic, Firm, Client].each {|klass| assert_equal klass.read_methods, {}}
+    end
   end
 
   def test_preserving_date_objects
@@ -223,6 +246,12 @@ class BasicsTest < Test::Unit::TestCase
     assert_raise(ActiveRecord::RecordNotFound) { Topic.find(topic.id) }
   end
   
+  def test_destroy_returns_self
+    topic = Topic.new("title" => "Yet Another Title")
+    assert topic.save
+    assert_equal topic, topic.destroy, "destroy did not return destroyed object"
+  end
+  
   def test_record_not_found_exception
     assert_raises(ActiveRecord::RecordNotFound) { topicReloaded = Topic.find(99999) }
   end
@@ -267,31 +296,42 @@ class BasicsTest < Test::Unit::TestCase
     assert_equal "master_credit_cards", MasterCreditCard.table_name
 
     ActiveRecord::Base.pluralize_table_names = false
+    [Category, Smarts, CreditCard, MasterCreditCard].each{|c| c.reset_table_name}
     assert_equal "category", Category.table_name
     assert_equal "smarts", Smarts.table_name
     assert_equal "credit_card", CreditCard.table_name
     assert_equal "master_credit_card", MasterCreditCard.table_name
     ActiveRecord::Base.pluralize_table_names = true
+    [Category, Smarts, CreditCard, MasterCreditCard].each{|c| c.reset_table_name}
 
     ActiveRecord::Base.table_name_prefix = "test_"
+    Category.reset_table_name
     assert_equal "test_categories", Category.table_name
     ActiveRecord::Base.table_name_suffix = "_test"
+    Category.reset_table_name
     assert_equal "test_categories_test", Category.table_name
     ActiveRecord::Base.table_name_prefix = ""
+    Category.reset_table_name
     assert_equal "categories_test", Category.table_name
     ActiveRecord::Base.table_name_suffix = ""
+    Category.reset_table_name
     assert_equal "categories", Category.table_name
 
     ActiveRecord::Base.pluralize_table_names = false
     ActiveRecord::Base.table_name_prefix = "test_"
+    Category.reset_table_name
     assert_equal "test_category", Category.table_name
     ActiveRecord::Base.table_name_suffix = "_test"
+    Category.reset_table_name
     assert_equal "test_category_test", Category.table_name
     ActiveRecord::Base.table_name_prefix = ""
+    Category.reset_table_name
     assert_equal "category_test", Category.table_name
     ActiveRecord::Base.table_name_suffix = ""
+    Category.reset_table_name
     assert_equal "category", Category.table_name
     ActiveRecord::Base.pluralize_table_names = true
+    [Category, Smarts, CreditCard, MasterCreditCard].each{|c| c.reset_table_name}
   end
   
   def test_destroy_all
@@ -347,7 +387,7 @@ class BasicsTest < Test::Unit::TestCase
   end
 
   def test_update_many
-    topic_data = { "1" => { "content" => "1 updated" }, "2" => { "content" => "2 updated" } }
+    topic_data = { 1 => { "content" => "1 updated" }, 2 => { "content" => "2 updated" } }
     updated = Topic.update(topic_data.keys, topic_data.values)
 
     assert_equal 2, updated.size
@@ -364,7 +404,7 @@ class BasicsTest < Test::Unit::TestCase
   end
 
   def test_update_by_condition
-    Topic.update_all "content = 'bulk updated!'", "approved = 1"
+    Topic.update_all "content = 'bulk updated!'", ["approved = ?", true]
     assert_equal "Have a nice day", Topic.find(1).content
     assert_equal "bulk updated!", Topic.find(2).content
   end
@@ -410,7 +450,7 @@ class BasicsTest < Test::Unit::TestCase
   
   def test_default_values
     topic = Topic.new
-    assert_equal 1, topic.approved
+    assert topic.approved?
     assert_nil topic.written_on
     assert_nil topic.bonus_time
     assert_nil topic.last_read
@@ -418,22 +458,20 @@ class BasicsTest < Test::Unit::TestCase
     topic.save
 
     topic = Topic.find(topic.id)
-    assert_equal 1, topic.approved
+    assert topic.approved?
     assert_nil topic.last_read
   end
 
-  def test_utc_as_time_zone
-    # Oracle does not have a TIME datatype.
-    if ActiveRecord::ConnectionAdapters.const_defined? :OracleAdapter
-      return true if ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::OracleAdapter)
+  # Oracle and SQLServer do not have a TIME datatype.
+  unless 'OCI' == ActiveRecord::Base.connection.adapter_name or ActiveRecord::ConnectionAdapters.const_defined?(:SQLServerAdapter)
+    def test_utc_as_time_zone
+      Topic.default_timezone = :utc
+      attributes = { "bonus_time" => "5:42:00AM" }
+      topic = Topic.find(1)
+      topic.attributes = attributes
+      assert_equal Time.utc(2000, 1, 1, 5, 42, 0), topic.bonus_time
+      Topic.default_timezone = :local
     end
-
-    Topic.default_timezone = :utc
-    attributes = { "bonus_time" => "5:42:00AM" }
-    topic = Topic.find(1)
-    topic.attributes = attributes
-    assert_equal Time.utc(2000, 1, 1, 5, 42, 0), topic.bonus_time
-    Topic.default_timezone = :local
   end
 
   def test_default_values_on_empty_strings
@@ -452,6 +490,10 @@ class BasicsTest < Test::Unit::TestCase
     assert_equal Topic.find(1), Topic.find(2).parent
   end
   
+  def test_equality_of_new_records
+    assert_not_equal Topic.new, Topic.new
+  end
+  
   def test_hashing
     assert_equal [ Topic.find(1) ], [ Topic.find(2).parent ] & [ Topic.find(1) ]
   end
@@ -484,6 +526,22 @@ class BasicsTest < Test::Unit::TestCase
     firm.attributes = { "name" => "Next Angle", "rating" => 5 }
     assert_equal 1, firm.rating
   end
+
+  def test_customized_primary_key_remains_protected
+    subscriber = Subscriber.new(:nick => 'webster123', :name => 'nice try')
+    assert_nil subscriber.id
+
+    keyboard = Keyboard.new(:key_number => 9, :name => 'nice try')
+    assert_nil keyboard.id
+  end
+
+  def test_customized_primary_key_remains_protected_when_refered_to_as_id
+    subscriber = Subscriber.new(:id => 'webster123', :name => 'nice try')
+    assert_nil subscriber.id
+
+    keyboard = Keyboard.new(:id => 9, :name => 'nice try')
+    assert_nil keyboard.id
+  end
   
   def test_mass_assignment_protection_on_defaults
     firm = Firm.new
@@ -493,15 +551,15 @@ class BasicsTest < Test::Unit::TestCase
   end
   
   def test_mass_assignment_accessible
-    reply = Reply.new("title" => "hello", "content" => "world", "approved" => 0)
+    reply = Reply.new("title" => "hello", "content" => "world", "approved" => true)
     reply.save
+
+    assert reply.approved?
     
-    assert_equal 1, reply.approved
-    
-    reply.approved = 0
+    reply.approved = false
     reply.save
 
-    assert_equal 0, reply.approved
+    assert !reply.approved?
   end
   
   def test_mass_assignment_protection_inheritance
@@ -571,7 +629,7 @@ class BasicsTest < Test::Unit::TestCase
 
   def test_multiparameter_mass_assignment_protector
     task = Task.new
-    time = Time.mktime(0)
+    time = Time.mktime(2000, 1, 1, 1)
     task.starting = time 
     attributes = { "starting(1i)" => "2004", "starting(2i)" => "6", "starting(3i)" => "24" }
     task.attributes = attributes
@@ -583,6 +641,10 @@ class BasicsTest < Test::Unit::TestCase
     if ActiveRecord::ConnectionAdapters.const_defined? :OracleAdapter
       return true if ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::OracleAdapter)
     end
+    # Sqlserver doesn't either .
+    if ActiveRecord::ConnectionAdapters.const_defined? :SQLServerAdapter
+      return true if ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::SQLServerAdapter)
+    end
 
     attributes = {
       "bonus_time" => "5:42:00AM"
@@ -662,14 +724,21 @@ class BasicsTest < Test::Unit::TestCase
     assert_equal 2147483647, company.rating
   end
 
-  def test_default
-    if Default.connection.class.name == 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter'
+  # TODO: extend defaults tests to other databases!
+  if 'PostgreSQL' == ActiveRecord::Base.connection.adapter_name
+    def test_default
       default = Default.new
   
-      # dates / timestamps
+      # CURRENT_TIMESTAMP and NOW() timestamps
       time_format = "%m/%d/%Y %H:%M"
-      assert_equal Time.now.strftime(time_format), default.modified_time.strftime(time_format)
-      assert_equal Date.today, default.modified_date
+      now = Time.now.strftime(time_format)
+      assert_equal now, default.modified_time.strftime(time_format)
+      assert_equal now, default.modified_time_function.strftime(time_format)
+
+      # CURRENT_DATE and NOW() dates
+      today = Date.today
+      assert_equal today, default.modified_date
+      assert_equal today, default.modified_date_function
   
       # fixed dates / times
       assert_equal Date.new(2004, 1, 1), default.fixed_date
@@ -680,6 +749,68 @@ class BasicsTest < Test::Unit::TestCase
       assert_equal 'a varchar field', default.char2
       assert_equal 'a text field', default.char3
     end
+
+    class Geometric < ActiveRecord::Base; end
+    def test_geometric_content
+
+      # accepted format notes:
+      # ()'s aren't required
+      # values can be a mix of float or integer
+
+      g = Geometric.new(
+        :a_point        => '(5.0, 6.1)',
+        #:a_line         => '((2.0, 3), (5.5, 7.0))' # line type is currently unsupported in postgresql
+        :a_line_segment => '(2.0, 3), (5.5, 7.0)',
+        :a_box          => '2.0, 3, 5.5, 7.0',
+        :a_path         => '[(2.0, 3), (5.5, 7.0), (8.5, 11.0)]',  # [ ] is an open path
+        :a_polygon      => '((2.0, 3), (5.5, 7.0), (8.5, 11.0))',
+        :a_circle       => '<(5.3, 10.4), 2>'
+      )
+        
+      assert g.save
+
+      # Reload and check that we have all the geometric attributes.
+      h = Geometric.find(g.id)
+
+      assert_equal '(5,6.1)', h.a_point
+      assert_equal '[(2,3),(5.5,7)]', h.a_line_segment
+      assert_equal '(5.5,7),(2,3)', h.a_box   # reordered to store upper right corner then bottom left corner
+      assert_equal '[(2,3),(5.5,7),(8.5,11)]', h.a_path
+      assert_equal '((2,3),(5.5,7),(8.5,11))', h.a_polygon
+      assert_equal '<(5.3,10.4),2>', h.a_circle
+
+      # use a geometric function to test for an open path
+      objs = Geometric.find_by_sql ["select isopen(a_path) from geometrics where id = ?", g.id]
+      assert_equal objs[0].isopen, 't'
+
+      # test alternate formats when defining the geometric types
+      
+      g = Geometric.new(
+        :a_point        => '5.0, 6.1',
+        #:a_line         => '((2.0, 3), (5.5, 7.0))' # line type is currently unsupported in postgresql
+        :a_line_segment => '((2.0, 3), (5.5, 7.0))',
+        :a_box          => '(2.0, 3), (5.5, 7.0)',
+        :a_path         => '((2.0, 3), (5.5, 7.0), (8.5, 11.0))',  # ( ) is a closed path
+        :a_polygon      => '2.0, 3, 5.5, 7.0, 8.5, 11.0',
+        :a_circle       => '((5.3, 10.4), 2)'
+      )
+
+      assert g.save
+
+      # Reload and check that we have all the geometric attributes.
+      h = Geometric.find(g.id)
+      
+      assert_equal '(5,6.1)', h.a_point
+      assert_equal '[(2,3),(5.5,7)]', h.a_line_segment
+      assert_equal '(5.5,7),(2,3)', h.a_box   # reordered to store upper right corner then bottom left corner
+      assert_equal '((2,3),(5.5,7),(8.5,11))', h.a_path
+      assert_equal '((2,3),(5.5,7),(8.5,11))', h.a_polygon
+      assert_equal '<(5.3,10.4),2>', h.a_circle
+
+      # use a geometric function to test for an closed path
+      objs = Geometric.find_by_sql ["select isclosed(a_path) from geometrics where id = ?", g.id]
+      assert_equal objs[0].isclosed, 't'
+    end
   end
 
   def test_auto_id
@@ -734,9 +865,9 @@ class BasicsTest < Test::Unit::TestCase
   end
 
   def test_quote
-    content = "\\ \001 ' \n \\n \""
-    topic = Topic.create('content' => content)
-    assert_equal content, Topic.find(topic.id).content
+    author_name = "\\ \001 ' \n \\n \""
+    topic = Topic.create('author_name' => author_name)
+    assert_equal author_name, Topic.find(topic.id).author_name
   end
   
   def test_class_level_destroy
@@ -787,6 +918,11 @@ class BasicsTest < Test::Unit::TestCase
     assert !topics(:first).approved?
     topics(:first).toggle!(:approved)
     assert topics(:first).approved?
+    topic = topics(:first)
+    topic.toggle(:approved)
+    assert !topic.approved?
+    topic.reload
+    assert topic.approved?
   end
 
   def test_reload
@@ -883,4 +1019,39 @@ class BasicsTest < Test::Unit::TestCase
 
      assert_equal    firm.clients.collect{ |x| x.name }.sort, clients.collect{ |x| x.name }.sort
   end
+
+  def test_interpolate_sql
+    assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo@bar') }
+    assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo bar) baz') }
+    assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo bar} baz') }
+  end
+
+  # FIXME: this test ought to run, but it needs to run sandboxed so that it
+  # doesn't b0rk the current test environment by undefing everything.
+  #
+  #def test_dev_mode_memory_leak
+  #  counts = []
+  #  2.times do
+  #    require_dependency 'fixtures/company'
+  #    Firm.find(:first)
+  #    Dependencies.clear
+  #    ActiveRecord::Base.reset_subclasses
+  #    Dependencies.remove_subclasses_for(ActiveRecord::Base)
+  #
+  #    GC.start
+  #    
+  #    count = 0
+  #    ObjectSpace.each_object(Proc) { count += 1 }
+  #    counts << count
+  #  end
+  #  assert counts.last <= counts.first,
+  #    "expected last count (#{counts.last}) to be <= first count (#{counts.first})"
+  #end
+  
+  private
+
+    def assert_readers(model, exceptions)
+      expected_readers = model.column_names - (model.serialized_attributes.keys + exceptions + ['id'])
+      assert_equal expected_readers.sort, model.read_methods.keys.sort
+    end
 end