activerecord 2.0.5 → 2.1.0

data/test/cases/associations_test.rb

@@ -0,0 +1,262 @@
+require "cases/helper"
+require 'models/developer'
+require 'models/project'
+require 'models/company'
+require 'models/topic'
+require 'models/reply'
+require 'models/computer'
+require 'models/customer'
+require 'models/order'
+require 'models/categorization'
+require 'models/category'
+require 'models/post'
+require 'models/author'
+require 'models/comment'
+require 'models/tag'
+require 'models/tagging'
+require 'models/person'
+require 'models/reader'
+require 'models/parrot'
+require 'models/pirate'
+require 'models/treasure'
+require 'models/price_estimate'
+require 'models/club'
+require 'models/member'
+require 'models/membership'
+require 'models/sponsor'
+
+class AssociationsTest < ActiveRecord::TestCase
+  fixtures :accounts, :companies, :developers, :projects, :developers_projects,
+           :computers
+
+  def test_include_with_order_works
+    assert_nothing_raised {Account.find(:first, :order => 'id', :include => :firm)}
+    assert_nothing_raised {Account.find(:first, :order => :id, :include => :firm)}
+  end
+
+  def test_bad_collection_keys
+    assert_raise(ArgumentError, 'ActiveRecord should have barked on bad collection keys') do
+      Class.new(ActiveRecord::Base).has_many(:wheels, :name => 'wheels')
+    end
+  end
+
+  def test_should_construct_new_finder_sql_after_create
+    person = Person.new :first_name => 'clark'
+    assert_equal [], person.readers.find(:all)
+    person.save!
+    reader = Reader.create! :person => person, :post => Post.new(:title => "foo", :body => "bar")
+    assert_equal [reader], person.readers.find(:all)
+  end
+
+  def test_force_reload
+    firm = Firm.new("name" => "A New Firm, Inc")
+    firm.save
+    firm.clients.each {|c|} # forcing to load all clients
+    assert firm.clients.empty?, "New firm shouldn't have client objects"
+    assert_equal 0, firm.clients.size, "New firm should have 0 clients"
+
+    client = Client.new("name" => "TheClient.com", "firm_id" => firm.id)
+    client.save
+
+    assert firm.clients.empty?, "New firm should have cached no client objects"
+    assert_equal 0, firm.clients.size, "New firm should have cached 0 clients count"
+
+    assert !firm.clients(true).empty?, "New firm should have reloaded client objects"
+    assert_equal 1, firm.clients(true).size, "New firm should have reloaded clients count"
+  end
+
+  def test_storing_in_pstore
+    require "tmpdir"
+    store_filename = File.join(Dir.tmpdir, "ar-pstore-association-test")
+    File.delete(store_filename) if File.exist?(store_filename)
+    require "pstore"
+    apple = Firm.create("name" => "Apple")
+    natural = Client.new("name" => "Natural Company")
+    apple.clients << natural
+
+    db = PStore.new(store_filename)
+    db.transaction do
+      db["apple"] = apple
+    end
+
+    db = PStore.new(store_filename)
+    db.transaction do
+      assert_equal "Natural Company", db["apple"].clients.first.name
+    end
+  end
+end
+
+class AssociationProxyTest < ActiveRecord::TestCase
+  fixtures :authors, :posts, :categorizations, :categories, :developers, :projects, :developers_projects
+
+  def test_proxy_accessors
+    welcome = posts(:welcome)
+    assert_equal  welcome, welcome.author.proxy_owner
+    assert_equal  welcome.class.reflect_on_association(:author), welcome.author.proxy_reflection
+    welcome.author.class  # force load target
+    assert_equal  welcome.author, welcome.author.proxy_target
+
+    david = authors(:david)
+    assert_equal  david, david.posts.proxy_owner
+    assert_equal  david.class.reflect_on_association(:posts), david.posts.proxy_reflection
+    david.posts.class   # force load target
+    assert_equal  david.posts, david.posts.proxy_target
+
+    assert_equal  david, david.posts_with_extension.testing_proxy_owner
+    assert_equal  david.class.reflect_on_association(:posts_with_extension), david.posts_with_extension.testing_proxy_reflection
+    david.posts_with_extension.class   # force load target
+    assert_equal  david.posts_with_extension, david.posts_with_extension.testing_proxy_target
+  end
+
+  def test_push_does_not_load_target
+    david = authors(:david)
+
+    david.posts << (post = Post.new(:title => "New on Edge", :body => "More cool stuff!"))
+    assert !david.posts.loaded?
+    assert david.posts.include?(post)
+  end
+
+  def test_push_has_many_through_does_not_load_target
+    david = authors(:david)
+
+    david.categories << categories(:technology)
+    assert !david.categories.loaded?
+    assert david.categories.include?(categories(:technology))
+  end
+
+  def test_push_followed_by_save_does_not_load_target
+    david = authors(:david)
+
+    david.posts << (post = Post.new(:title => "New on Edge", :body => "More cool stuff!"))
+    assert !david.posts.loaded?
+    david.save
+    assert !david.posts.loaded?
+    assert david.posts.include?(post)
+  end
+
+  def test_push_does_not_lose_additions_to_new_record
+    josh = Author.new(:name => "Josh")
+    josh.posts << Post.new(:title => "New on Edge", :body => "More cool stuff!")
+    assert josh.posts.loaded?
+    assert_equal 1, josh.posts.size
+  end
+
+  def test_save_on_parent_does_not_load_target
+    david = developers(:david)
+
+    assert !david.projects.loaded?
+    david.update_attribute(:created_at, Time.now)
+    assert !david.projects.loaded?
+  end
+
+  def test_inspect_does_not_reload_a_not_yet_loaded_target
+    andreas = Developer.new :name => 'Andreas', :log => 'new developer added'
+    assert !andreas.audit_logs.loaded?
+    assert_match(/message: "new developer added"/, andreas.audit_logs.inspect)
+  end
+
+  def test_save_on_parent_saves_children
+    developer = Developer.create :name => "Bryan", :salary => 50_000
+    assert_equal 1, developer.reload.audit_logs.size
+  end
+
+  def test_create_via_association_with_block
+    post = authors(:david).posts.create(:title => "New on Edge") {|p| p.body = "More cool stuff!"}
+    assert_equal post.title, "New on Edge"
+    assert_equal post.body, "More cool stuff!"
+  end
+
+  def test_create_with_bang_via_association_with_block
+    post = authors(:david).posts.create!(:title => "New on Edge") {|p| p.body = "More cool stuff!"}
+    assert_equal post.title, "New on Edge"
+    assert_equal post.body, "More cool stuff!"
+  end
+
+  def test_failed_reload_returns_nil
+    p = setup_dangling_association
+    assert_nil p.author.reload
+  end
+
+  def test_failed_reset_returns_nil
+    p = setup_dangling_association
+    assert_nil p.author.reset
+  end
+
+  def test_reload_returns_assocition
+    david = developers(:david)
+    assert_nothing_raised do
+      assert_equal david.projects, david.projects.reload.reload
+    end
+  end
+
+  def setup_dangling_association
+    josh = Author.create(:name => "Josh")
+    p = Post.create(:title => "New on Edge", :body => "More cool stuff!", :author => josh)
+    josh.destroy
+    p
+  end
+end
+
+class OverridingAssociationsTest < ActiveRecord::TestCase
+  class Person < ActiveRecord::Base; end
+  class DifferentPerson < ActiveRecord::Base; end
+
+  class PeopleList < ActiveRecord::Base
+    has_and_belongs_to_many :has_and_belongs_to_many, :before_add => :enlist
+    has_many :has_many, :before_add => :enlist
+    belongs_to :belongs_to
+    has_one :has_one
+  end
+
+  class DifferentPeopleList < PeopleList
+    # Different association with the same name, callbacks should be omitted here.
+    has_and_belongs_to_many :has_and_belongs_to_many, :class_name => 'DifferentPerson'
+    has_many :has_many, :class_name => 'DifferentPerson'
+    belongs_to :belongs_to, :class_name => 'DifferentPerson'
+    has_one :has_one, :class_name => 'DifferentPerson'
+  end
+
+  def test_habtm_association_redefinition_callbacks_should_differ_and_not_inherited
+    # redeclared association on AR descendant should not inherit callbacks from superclass
+    callbacks = PeopleList.read_inheritable_attribute(:before_add_for_has_and_belongs_to_many)
+    assert_equal([:enlist], callbacks)
+    callbacks = DifferentPeopleList.read_inheritable_attribute(:before_add_for_has_and_belongs_to_many)
+    assert_equal([], callbacks)
+  end
+
+  def test_has_many_association_redefinition_callbacks_should_differ_and_not_inherited
+    # redeclared association on AR descendant should not inherit callbacks from superclass
+    callbacks = PeopleList.read_inheritable_attribute(:before_add_for_has_many)
+    assert_equal([:enlist], callbacks)
+    callbacks = DifferentPeopleList.read_inheritable_attribute(:before_add_for_has_many)
+    assert_equal([], callbacks)
+  end
+
+  def test_habtm_association_redefinition_reflections_should_differ_and_not_inherited
+    assert_not_equal(
+      PeopleList.reflect_on_association(:has_and_belongs_to_many),
+      DifferentPeopleList.reflect_on_association(:has_and_belongs_to_many)
+    )
+  end
+
+  def test_has_many_association_redefinition_reflections_should_differ_and_not_inherited
+    assert_not_equal(
+      PeopleList.reflect_on_association(:has_many),
+      DifferentPeopleList.reflect_on_association(:has_many)
+    )
+  end
+
+  def test_belongs_to_association_redefinition_reflections_should_differ_and_not_inherited
+    assert_not_equal(
+      PeopleList.reflect_on_association(:belongs_to),
+      DifferentPeopleList.reflect_on_association(:belongs_to)
+    )
+  end
+
+  def test_has_one_association_redefinition_reflections_should_differ_and_not_inherited
+    assert_not_equal(
+      PeopleList.reflect_on_association(:has_one),
+      DifferentPeopleList.reflect_on_association(:has_one)
+    )
+  end
+end

data/test/{attribute_methods_test.rb → cases/attribute_methods_test.rb}

@@ -1,7 +1,7 @@
-require 'abstract_unit'
-require 'fixtures/topic'
+require "cases/helper"
+require 'models/topic'
 
-class AttributeMethodsTest < Test::Unit::TestCase
+class AttributeMethodsTest < ActiveRecord::TestCase
   fixtures :topics
   def setup
     @old_suffixes = ActiveRecord::Base.send(:attribute_method_suffixes).dup
@@ -14,7 +14,6 @@ class AttributeMethodsTest < Test::Unit::TestCase
     ActiveRecord::Base.attribute_method_suffix *@old_suffixes
   end
 
-
   def test_match_attribute_method_query_returns_match_data
     assert_not_nil md = @target.match_attribute_method?('title=')
     assert_equal 'title', md.pre_match
@@ -48,24 +47,24 @@ class AttributeMethodsTest < Test::Unit::TestCase
       assert_equal ['title', 1, 2, 3], topic.send(meth, 1, 2, 3)
     end
   end
-  
+
   def test_should_unserialize_attributes_for_frozen_records
     myobj = {:value1 => :value2}
     topic = Topic.create("content" => myobj)
     topic.freeze
     assert_equal myobj, topic.content
   end
-  
+
   def test_kernel_methods_not_implemented_in_activerecord
     %w(test name display y).each do |method|
       assert_equal false, ActiveRecord::Base.instance_method_already_implemented?(method), "##{method} is defined"
     end
   end
-  
+
   def test_primary_key_implemented
     assert_equal true, Class.new(ActiveRecord::Base).instance_method_already_implemented?('id')
   end
-  
+
   def test_defined_kernel_methods_implemented_in_model
     %w(test name display y).each do |method|
       klass = Class.new ActiveRecord::Base
@@ -73,7 +72,7 @@ class AttributeMethodsTest < Test::Unit::TestCase
       assert_equal true, klass.instance_method_already_implemented?(method), "##{method} is not defined"
     end
   end
-  
+
   def test_defined_kernel_methods_implemented_in_model_abstract_subclass
     %w(test name display y).each do |method|
       abstract = Class.new ActiveRecord::Base
@@ -83,7 +82,7 @@ class AttributeMethodsTest < Test::Unit::TestCase
       assert_equal true, klass.instance_method_already_implemented?(method), "##{method} is not defined"
     end
   end
-  
+
   def test_raises_dangerous_attribute_error_when_defining_activerecord_method_in_model
     %w(save create_or_update).each do |method|
       klass = Class.new ActiveRecord::Base
@@ -97,7 +96,7 @@ class AttributeMethodsTest < Test::Unit::TestCase
   def test_only_time_related_columns_are_meant_to_be_cached_by_default
     expected = %w(datetime timestamp time date).sort
     assert_equal expected, ActiveRecord::Base.attribute_types_cached_by_default.map(&:to_s).sort
-end
+  end
 
   def test_declaring_attributes_as_cached_adds_them_to_the_attributes_cached_by_default
     default_attributes = Topic.cached_attributes
@@ -138,9 +137,102 @@ end
       end
     end
   end
+  
+  def test_time_attributes_are_retrieved_in_current_time_zone
+    in_time_zone "Pacific Time (US & Canada)" do
+      utc_time = Time.utc(2008, 1, 1)
+      record   = @target.new
+      record[:written_on] = utc_time
+      assert_equal utc_time, record.written_on # record.written on is equal to (i.e., simultaneous with) utc_time
+      assert_kind_of ActiveSupport::TimeWithZone, record.written_on # but is a TimeWithZone
+      assert_equal TimeZone["Pacific Time (US & Canada)"], record.written_on.time_zone # and is in the current Time.zone
+      assert_equal Time.utc(2007, 12, 31, 16), record.written_on.time # and represents time values adjusted accordingly
+    end
+  end
+
+  def test_setting_time_zone_aware_attribute_to_utc
+    in_time_zone "Pacific Time (US & Canada)" do
+      utc_time = Time.utc(2008, 1, 1)
+      record   = @target.new
+      record.written_on = utc_time
+      assert_equal utc_time, record.written_on
+      assert_equal TimeZone["Pacific Time (US & Canada)"], record.written_on.time_zone
+      assert_equal Time.utc(2007, 12, 31, 16), record.written_on.time
+    end
+  end
+
+  def test_setting_time_zone_aware_attribute_in_other_time_zone
+    utc_time = Time.utc(2008, 1, 1)
+    cst_time = utc_time.in_time_zone("Central Time (US & Canada)")
+    in_time_zone "Pacific Time (US & Canada)" do
+      record   = @target.new
+      record.written_on = cst_time
+      assert_equal utc_time, record.written_on
+      assert_equal TimeZone["Pacific Time (US & Canada)"], record.written_on.time_zone
+      assert_equal Time.utc(2007, 12, 31, 16), record.written_on.time
+    end
+  end
+
+  def test_setting_time_zone_aware_attribute_with_string
+    utc_time = Time.utc(2008, 1, 1)
+    (-11..13).each do |timezone_offset|
+      time_string = utc_time.in_time_zone(timezone_offset).to_s
+      in_time_zone "Pacific Time (US & Canada)" do
+        record   = @target.new
+        record.written_on = time_string
+        assert_equal Time.zone.parse(time_string), record.written_on
+        assert_equal TimeZone["Pacific Time (US & Canada)"], record.written_on.time_zone
+        assert_equal Time.utc(2007, 12, 31, 16), record.written_on.time
+      end
+    end
+  end
+  
+  def test_setting_time_zone_aware_attribute_to_blank_string_returns_nil
+    in_time_zone "Pacific Time (US & Canada)" do
+      record   = @target.new
+      record.written_on = ' '
+      assert_nil record.written_on
+    end
+  end
+
+  def test_setting_time_zone_aware_attribute_interprets_time_zone_unaware_string_in_time_zone
+    time_string = 'Tue Jan 01 00:00:00 2008'
+    (-11..13).each do |timezone_offset|
+      in_time_zone timezone_offset do
+        record   = @target.new
+        record.written_on = time_string
+        assert_equal Time.zone.parse(time_string), record.written_on
+        assert_equal TimeZone[timezone_offset], record.written_on.time_zone
+        assert_equal Time.utc(2008, 1, 1), record.written_on.time
+      end
+    end
+  end
+
+  def test_setting_time_zone_aware_attribute_in_current_time_zone
+    utc_time = Time.utc(2008, 1, 1)
+    in_time_zone "Pacific Time (US & Canada)" do
+      record   = @target.new
+      record.written_on = utc_time.in_time_zone
+      assert_equal utc_time, record.written_on
+      assert_equal TimeZone["Pacific Time (US & Canada)"], record.written_on.time_zone
+      assert_equal Time.utc(2007, 12, 31, 16), record.written_on.time
+    end
+  end
 
   private
   def time_related_columns_on_topic
     Topic.columns.select{|c| [:time, :date, :datetime, :timestamp].include?(c.type)}.map(&:name)
   end
+  
+  def in_time_zone(zone)
+    old_zone  = Time.zone
+    old_tz    = ActiveRecord::Base.time_zone_aware_attributes
+
+    Time.zone = zone ? TimeZone[zone] : nil
+    ActiveRecord::Base.time_zone_aware_attributes = !zone.nil?
+    yield
+  ensure
+    Time.zone = old_zone
+    ActiveRecord::Base.time_zone_aware_attributes = old_tz
+  end
 end

data/test/{base_test.rb → cases/base_test.rb}

@@ -1,17 +1,21 @@
-require 'abstract_unit'
-require 'fixtures/topic'
-require 'fixtures/reply'
-require 'fixtures/company'
-require 'fixtures/customer'
-require 'fixtures/developer'
-require 'fixtures/project'
-require 'fixtures/default'
-require 'fixtures/auto_id'
-require 'fixtures/column_name'
-require 'fixtures/subscriber'
-require 'fixtures/keyboard'
-require 'fixtures/post'
-require 'fixtures/minimalistic'
+require "cases/helper"
+require 'models/author'
+require 'models/topic'
+require 'models/reply'
+require 'models/category'
+require 'models/company'
+require 'models/customer'
+require 'models/developer'
+require 'models/project'
+require 'models/default'
+require 'models/auto_id'
+require 'models/column_name'
+require 'models/subscriber'
+require 'models/keyboard'
+require 'models/post'
+require 'models/comment'
+require 'models/minimalistic'
+require 'models/warehouse_thing'
 require 'rexml/document'
 
 class Category < ActiveRecord::Base; end
@@ -64,20 +68,20 @@ class Task < ActiveRecord::Base
   attr_protected :starting
 end
 
-class TopicWithProtectedContentAndAccessibleAuthorName < ActiveRecord::Base 
-  self.table_name = 'topics' 
+class TopicWithProtectedContentAndAccessibleAuthorName < ActiveRecord::Base
+  self.table_name = 'topics'
   attr_accessible :author_name
   attr_protected  :content
 end
 
-class BasicsTest < Test::Unit::TestCase
-  fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics
+class BasicsTest < ActiveRecord::TestCase
+  fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, 'warehouse-things', :authors
 
   def test_table_exists
     assert !NonExistentTable.table_exists?
     assert Topic.table_exists?
   end
-  
+
   def test_set_attributes
     topic = Topic.find(1)
     topic.attributes = { "title" => "Budget", "author_name" => "Jason" }
@@ -91,7 +95,7 @@ class BasicsTest < Test::Unit::TestCase
     test = AutoId.create('value' => '')
     assert_nil AutoId.find(test.id).value
   end
-  
+
   def test_set_attributes_with_block
     topic = Topic.new do |t|
       t.title       = "Budget"
@@ -101,7 +105,7 @@ class BasicsTest < Test::Unit::TestCase
     assert_equal("Budget", topic.title)
     assert_equal("Jason", topic.author_name)
   end
-  
+
   def test_respond_to?
     topic = Topic.find(1)
     assert topic.respond_to?("title")
@@ -115,7 +119,7 @@ class BasicsTest < Test::Unit::TestCase
     assert !topic.respond_to?("nothingness")
     assert !topic.respond_to?(:nothingness)
   end
-  
+
   def test_array_content
     topic = Topic.new
     topic.content = %w( one two three )
@@ -124,19 +128,38 @@ class BasicsTest < Test::Unit::TestCase
     assert_equal(%w( one two three ), Topic.find(topic.id).content)
   end
 
+  def test_read_attributes_before_type_cast
+    category = Category.new({:name=>"Test categoty", :type => nil})
+    category_attrs = {"name"=>"Test categoty", "type" => nil}
+    assert_equal category_attrs , category.attributes_before_type_cast
+  end
+  
+  if current_adapter?(:MysqlAdapter)
+    def test_read_attributes_before_type_cast_on_boolean
+      bool = Booleantest.create({ "value" => false })
+      assert_equal 0, bool.attributes_before_type_cast["value"]
+    end
+  end
+  
+  def test_read_attributes_before_type_cast_on_datetime
+    developer = Developer.find(:first)
+    assert_equal developer.created_at.to_s(:db) , developer.attributes_before_type_cast["created_at"]
+  end
+  
   def test_hash_content
     topic = Topic.new
     topic.content = { "one" => 1, "two" => 2 }
     topic.save
 
     assert_equal 2, Topic.find(topic.id).content["two"]
-    
+
+    topic.content_will_change!
     topic.content["three"] = 3
     topic.save
 
     assert_equal 3, Topic.find(topic.id).content["three"]
   end
-  
+
   def test_update_array_content
     topic = Topic.new
     topic.content = %w( one two three )
@@ -145,12 +168,12 @@ class BasicsTest < Test::Unit::TestCase
     assert_equal(%w( one two three four ), topic.content)
 
     topic.save
-    
+
     topic = Topic.find(topic.id)
     topic.content << "five"
     assert_equal(%w( one two three four five ), topic.content)
   end
- 
+
   def test_case_sensitive_attributes_hash
     # DB2 is not case-sensitive
     return true if current_adapter?(:DB2Adapter)
@@ -165,11 +188,11 @@ class BasicsTest < Test::Unit::TestCase
     topic_reloaded = Topic.find(topic.id)
     assert_equal("New Topic", topic_reloaded.title)
   end
-  
+
   def test_save!
     topic = Topic.new(:title => "New Topic")
     assert topic.save!
-    
+
     reply = Reply.new
     assert_raise(ActiveRecord::RecordInvalid) { reply.save! }
   end
@@ -210,7 +233,7 @@ class BasicsTest < Test::Unit::TestCase
     topic.attributes= new_topic_values
     assert_equal new_topic_values[:title], topic.title
   end
-  
+
   def test_create_many
     topics = Topic.create([ { "title" => "first" }, { "title" => "second" }])
     assert_equal 2, topics.size
@@ -228,6 +251,27 @@ class BasicsTest < Test::Unit::TestCase
     topic = Topic.create("title" => "New Topic")
     topicReloaded = Topic.find(topic.id)
     assert_equal(topic, topicReloaded)
+  end  
+
+  def test_create_through_factory_with_block
+    topic = Topic.create("title" => "New Topic") do |t|
+      t.author_name = "David"
+    end
+    topicReloaded = Topic.find(topic.id)
+    assert_equal("New Topic", topic.title)
+    assert_equal("David", topic.author_name)
+  end
+
+  def test_create_many_through_factory_with_block
+    topics = Topic.create([ { "title" => "first" }, { "title" => "second" }]) do |t|
+      t.author_name = "David"
+    end
+    assert_equal 2, topics.size
+    topic1, topic2 = Topic.find(topics[0].id), Topic.find(topics[1].id)
+    assert_equal "first", topic1.title
+    assert_equal "David", topic1.author_name
+    assert_equal "second", topic2.title
+    assert_equal "David", topic2.author_name
   end
 
   def test_update
@@ -240,9 +284,9 @@ class BasicsTest < Test::Unit::TestCase
 
     topicReloaded.title = "Updated topic"
     topicReloaded.save
-    
+
     topicReloadedAgain = Topic.find(topic.id)
-    
+
     assert_equal("Updated topic", topicReloadedAgain.title)
   end
 
@@ -250,7 +294,7 @@ class BasicsTest < Test::Unit::TestCase
     topic = Topic.new
     topic.title = "Still another topic"
     topic.save
-    
+
     topicReloaded = Topic.find(topic.id)
     topicReloaded.title = "A New Topic"
     topicReloaded.send :write_attribute, 'does_not_exist', 'test'
@@ -261,7 +305,7 @@ class BasicsTest < Test::Unit::TestCase
     minimalistic = minimalistics(:first)
     assert_nothing_raised { minimalistic.save }
   end
-  
+
   def test_write_attribute
     topic = Topic.new
     topic.send(:write_attribute, :title, "Still another topic")
@@ -320,29 +364,29 @@ class BasicsTest < Test::Unit::TestCase
     assert topic.approved?, "approved should be true"
     # puts ""
   end
-  
+
   def test_query_attribute_string
     [nil, "", " "].each do |value|
       assert_equal false, Topic.new(:author_name => value).author_name?
     end
-    
+
     assert_equal true, Topic.new(:author_name => "Name").author_name?
   end
-  
+
   def test_query_attribute_number
     [nil, 0, "0"].each do |value|
       assert_equal false, Developer.new(:salary => value).salary?
     end
-    
+
     assert_equal true, Developer.new(:salary => 1).salary?
     assert_equal true, Developer.new(:salary => "1").salary?
   end
-  
+
   def test_query_attribute_boolean
     [nil, "", false, "false", "f", 0].each do |value|
       assert_equal false, Topic.new(:approved => value).approved?
     end
-    
+
     [true, "true", "1", 1].each do |value|
       assert_equal true, Topic.new(:approved => value).approved?
     end
@@ -390,12 +434,12 @@ class BasicsTest < Test::Unit::TestCase
       # Sybase ctlib does not (yet?) support the date type; use datetime instead.
       # Oracle treats all dates/times as Time.
       assert_kind_of(
-        Time, Topic.find(1).last_read, 
+        Time, Topic.find(1).last_read,
         "The last_read attribute should be of the Time class"
       )
     else
       assert_kind_of(
-        Date, Topic.find(1).last_read, 
+        Date, Topic.find(1).last_read,
         "The last_read attribute should be of the Date class"
       )
     end
@@ -419,7 +463,7 @@ class BasicsTest < Test::Unit::TestCase
       assert_equal 9900, Topic.find(2).written_on.usec
     end
   end
-  
+
   def test_custom_mutator
     topic = Topic.find(1)
     # This mutator is protected in the class definition
@@ -437,34 +481,34 @@ class BasicsTest < Test::Unit::TestCase
   def test_record_not_found_exception
     assert_raises(ActiveRecord::RecordNotFound) { topicReloaded = Topic.find(99999) }
   end
-  
+
   def test_initialize_with_attributes
-    topic = Topic.new({ 
+    topic = Topic.new({
       "title" => "initialized from attributes", "written_on" => "2003-12-12 23:23"
     })
-    
+
     assert_equal("initialized from attributes", topic.title)
   end
-  
+
   def test_initialize_with_invalid_attribute
     begin
-      topic = Topic.new({ "title" => "test", 
+      topic = Topic.new({ "title" => "test",
         "last_read(1i)" => "2005", "last_read(2i)" => "2", "last_read(3i)" => "31"})
     rescue ActiveRecord::MultiparameterAssignmentErrors => ex
       assert_equal(1, ex.errors.size)
       assert_equal("last_read", ex.errors[0].attribute)
     end
   end
-  
+
   def test_load
-    topics = Topic.find(:all, :order => 'id')    
-    assert_equal(2, topics.size)
+    topics = Topic.find(:all, :order => 'id')
+    assert_equal(4, topics.size)
     assert_equal(topics(:first).title, topics.first.title)
   end
-  
+
   def test_load_with_condition
     topics = Topic.find(:all, :conditions => "author_name = 'Mary'")
-    
+
     assert_equal(1, topics.size)
     assert_equal(topics(:second).title, topics.first.title)
   end
@@ -528,12 +572,13 @@ class BasicsTest < Test::Unit::TestCase
     ActiveRecord::Base.pluralize_table_names = true
     classes.each(&:reset_table_name)
   end
-  
-  def test_destroy_all
-    assert_equal 2, Topic.count
 
-    Topic.destroy_all "author_name = 'Mary'"
-    assert_equal 1, Topic.count
+  def test_destroy_all
+    original_count = Topic.count
+    topics_by_mary = Topic.count(:conditions => mary = "author_name = 'Mary'")
+    
+    Topic.destroy_all mary
+    assert_equal original_count - topics_by_mary, Topic.count
   end
 
   def test_destroy_many
@@ -543,15 +588,16 @@ class BasicsTest < Test::Unit::TestCase
   end
 
   def test_delete_many
-    Topic.delete([1, 2])
-    assert_equal 0, Topic.count
+    original_count = Topic.count
+    Topic.delete(deleting = [1, 2])
+    assert_equal original_count - deleting.size, Topic.count
   end
 
   def test_boolean_attributes
     assert ! Topic.find(1).approved?
     assert Topic.find(2).approved?
   end
-  
+
   def test_increment_counter
     Topic.increment_counter("replies_count", 1)
     assert_equal 2, Topic.find(1).replies_count
@@ -559,7 +605,7 @@ class BasicsTest < Test::Unit::TestCase
     Topic.increment_counter("replies_count", 1)
     assert_equal 3, Topic.find(1).replies_count
   end
-  
+
   def test_decrement_counter
     Topic.decrement_counter("replies_count", 2)
     assert_equal -1, Topic.find(2).replies_count
@@ -569,27 +615,32 @@ class BasicsTest < Test::Unit::TestCase
   end
 
   def test_update_all
-    assert_equal 2, Topic.update_all("content = 'bulk updated!'")
+    assert_equal Topic.count, Topic.update_all("content = 'bulk updated!'")
     assert_equal "bulk updated!", Topic.find(1).content
     assert_equal "bulk updated!", Topic.find(2).content
 
-    assert_equal 2, Topic.update_all(['content = ?', 'bulk updated again!'])
+    assert_equal Topic.count, Topic.update_all(['content = ?', 'bulk updated again!'])
     assert_equal "bulk updated again!", Topic.find(1).content
     assert_equal "bulk updated again!", Topic.find(2).content
 
-    assert_equal 2, Topic.update_all(['content = ?', nil])
+    assert_equal Topic.count, Topic.update_all(['content = ?', nil])
     assert_nil Topic.find(1).content
   end
 
   def test_update_all_with_hash
     assert_not_nil Topic.find(1).last_read
-    assert_equal 2, Topic.update_all(:content => 'bulk updated with hash!', :last_read => nil)
+    assert_equal Topic.count, Topic.update_all(:content => 'bulk updated with hash!', :last_read => nil)
     assert_equal "bulk updated with hash!", Topic.find(1).content
     assert_equal "bulk updated with hash!", Topic.find(2).content
     assert_nil Topic.find(1).last_read
     assert_nil Topic.find(2).last_read
   end
 
+  def test_update_all_with_non_standard_table_name
+    assert_equal 1, WarehouseThing.update_all(['value = ?', 0], ['id = ?', 1])
+    assert_equal 0, WarehouseThing.find(1).value
+  end
+
   if current_adapter?(:MysqlAdapter)
     def test_update_all_with_order_and_limit
       assert_equal 1, Topic.update_all("content = 'bulk updated!'", nil, :limit => 1, :order => 'id DESC')
@@ -613,7 +664,9 @@ class BasicsTest < Test::Unit::TestCase
   end
 
   def test_delete_all
-    assert_equal 2, Topic.delete_all
+    assert Topic.count > 0
+    
+    assert_equal Topic.count, Topic.delete_all
   end
 
   def test_update_by_condition
@@ -621,7 +674,7 @@ class BasicsTest < Test::Unit::TestCase
     assert_equal "Have a nice day", Topic.find(1).content
     assert_equal "bulk updated!", Topic.find(2).content
   end
-    
+
   def test_attribute_present
     t = Topic.new
     t.title = "hello there!"
@@ -630,13 +683,13 @@ class BasicsTest < Test::Unit::TestCase
     assert t.attribute_present?("written_on")
     assert !t.attribute_present?("content")
   end
-  
+
   def test_attribute_keys_on_new_instance
     t = Topic.new
     assert_equal nil, t.title, "The topics table has a title column, so it should be nil"
     assert_raise(NoMethodError) { t.title2 }
   end
-  
+
   def test_class_name
     assert_equal "Firm", ActiveRecord::Base.class_name("firms")
     assert_equal "Category", ActiveRecord::Base.class_name("categories")
@@ -655,26 +708,26 @@ class BasicsTest < Test::Unit::TestCase
     ActiveRecord::Base.table_name_suffix = ""
     assert_equal "Firm", ActiveRecord::Base.class_name( "firms" )
   end
-  
+
   def test_null_fields
     assert_nil Topic.find(1).parent_id
     assert_nil Topic.create("title" => "Hey you").parent_id
   end
-  
+
   def test_default_values
     topic = Topic.new
     assert topic.approved?
     assert_nil topic.written_on
     assert_nil topic.bonus_time
     assert_nil topic.last_read
-    
+
     topic.save
 
     topic = Topic.find(topic.id)
     assert topic.approved?
     assert_nil topic.last_read
 
-    # Oracle has some funky default handling, so it requires a bit of 
+    # Oracle has some funky default handling, so it requires a bit of
     # extra testing. See ticket #2788.
     if current_adapter?(:OracleAdapter)
       test = TestOracleDefault.new
@@ -730,29 +783,29 @@ class BasicsTest < Test::Unit::TestCase
   def test_equality
     assert_equal Topic.find(1), Topic.find(2).topic
   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).topic ] & [ Topic.find(1) ]
   end
-  
+
   def test_destroy_new_record
     client = Client.new
     client.destroy
     assert client.frozen?
   end
-  
+
   def test_destroy_record_with_associations
     client = Client.find(3)
     client.destroy
     assert client.frozen?
     assert_kind_of Firm, client.firm
-    assert_raises(TypeError) { client.name = "something else" }
+    assert_raises(ActiveSupport::FrozenObjectError) { client.name = "something else" }
   end
-  
+
   def test_update_attribute
     assert !Topic.find(1).approved?
     Topic.find(1).update_attribute("approved", true)
@@ -761,12 +814,12 @@ class BasicsTest < Test::Unit::TestCase
     Topic.find(1).update_attribute(:approved, false)
     assert !Topic.find(1).approved?
   end
-  
+
   def test_update_attributes
     topic = Topic.find(1)
     assert !topic.approved?
     assert_equal "The First Topic", topic.title
-    
+
     topic.update_attributes("approved" => true, "title" => "The First Topic Updated")
     topic.reload
     assert topic.approved?
@@ -777,37 +830,37 @@ class BasicsTest < Test::Unit::TestCase
     assert !topic.approved?
     assert_equal "The First Topic", topic.title
   end
-  
+
   def test_update_attributes!
     reply = Reply.find(2)
-    assert_equal "The Second Topic's of the day", reply.title
+    assert_equal "The Second Topic of the day", reply.title
     assert_equal "Have a nice day", reply.content
-    
-    reply.update_attributes!("title" => "The Second Topic's of the day updated", "content" => "Have a nice evening")
+
+    reply.update_attributes!("title" => "The Second Topic of the day updated", "content" => "Have a nice evening")
     reply.reload
-    assert_equal "The Second Topic's of the day updated", reply.title
+    assert_equal "The Second Topic of the day updated", reply.title
     assert_equal "Have a nice evening", reply.content
-    
-    reply.update_attributes!(:title => "The Second Topic's of the day", :content => "Have a nice day")
+
+    reply.update_attributes!(:title => "The Second Topic of the day", :content => "Have a nice day")
     reply.reload
-    assert_equal "The Second Topic's of the day", reply.title
+    assert_equal "The Second Topic of the day", reply.title
     assert_equal "Have a nice day", reply.content
-    
+
     assert_raise(ActiveRecord::RecordInvalid) { reply.update_attributes!(:title => nil, :content => "Have a nice evening") }
   end
-  
+
   def test_mass_assignment_should_raise_exception_if_accessible_and_protected_attribute_writers_are_both_used
     topic = TopicWithProtectedContentAndAccessibleAuthorName.new
     assert_raises(RuntimeError) { topic.attributes = { "author_name" => "me" } }
     assert_raises(RuntimeError) { topic.attributes = { "content" => "stuff" } }
   end
-  
+
   def test_mass_assignment_protection
     firm = Firm.new
     firm.attributes = { "name" => "Next Angle", "rating" => 5 }
     assert_equal 1, firm.rating
   end
-  
+
   def test_mass_assignment_protection_against_class_attribute_writers
     [:logger, :configurations, :primary_key_prefix_type, :table_name_prefix, :table_name_suffix, :pluralize_table_names, :colorize_logging,
       :default_timezone, :allow_concurrency, :schema_format, :verification_timeout, :lock_optimistically, :record_timestamps].each do |method|
@@ -833,26 +886,26 @@ class BasicsTest < Test::Unit::TestCase
     keyboard = Keyboard.new(:id => 9, :name => 'nice try')
     assert_nil keyboard.id
   end
-  
+
   def test_mass_assignment_protection_on_defaults
     firm = Firm.new
     firm.attributes = { "id" => 5, "type" => "Client" }
     assert_nil firm.id
     assert_equal "Firm", firm[:type]
   end
-  
+
   def test_mass_assignment_accessible
     reply = Reply.new("title" => "hello", "content" => "world", "approved" => true)
     reply.save
 
     assert reply.approved?
-    
+
     reply.approved = false
     reply.save
 
     assert !reply.approved?
   end
-  
+
   def test_mass_assignment_protection_inheritance
     assert_nil LoosePerson.accessible_attributes
     assert_equal Set.new([ 'credit_rating', 'administrator' ]), LoosePerson.protected_attributes
@@ -869,14 +922,14 @@ class BasicsTest < Test::Unit::TestCase
     assert_nil TightDescendant.protected_attributes
     assert_equal Set.new([ 'name', 'address', 'phone_number' ]), TightDescendant.accessible_attributes
   end
-  
+
   def test_readonly_attributes
-    assert_equal Set.new([ 'title' ]), ReadonlyTitlePost.readonly_attributes
-    
+    assert_equal Set.new([ 'title' , 'comments_count' ]), ReadonlyTitlePost.readonly_attributes
+
     post = ReadonlyTitlePost.create(:title => "cannot change this", :body => "changeable")
     post.reload
     assert_equal "cannot change this", post.title
-    
+
     post.update_attributes(:title => "try to change", :body => "changed")
     post.reload
     assert_equal "cannot change this", post.title
@@ -887,7 +940,7 @@ class BasicsTest < Test::Unit::TestCase
     attributes = { "last_read(1i)" => "2004", "last_read(2i)" => "6", "last_read(3i)" => "24" }
     topic = Topic.find(1)
     topic.attributes = attributes
-    # note that extra #to_date call allows test to pass for Oracle, which 
+    # note that extra #to_date call allows test to pass for Oracle, which
     # treats dates/times the same
     assert_date_from_db Date.new(2004, 6, 24), topic.last_read.to_date
   end
@@ -896,7 +949,7 @@ class BasicsTest < Test::Unit::TestCase
     attributes = { "last_read(1i)" => "2004", "last_read(2i)" => "6", "last_read(3i)" => "" }
     topic = Topic.find(1)
     topic.attributes = attributes
-    # note that extra #to_date call allows test to pass for Oracle, which 
+    # note that extra #to_date call allows test to pass for Oracle, which
     # treats dates/times the same
     assert_date_from_db Date.new(2004, 6, 1), topic.last_read.to_date
   end
@@ -909,18 +962,96 @@ class BasicsTest < Test::Unit::TestCase
   end
 
   def test_multiparameter_attributes_on_time
-    attributes = { 
-      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24", 
+    attributes = {
+      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24",
       "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00"
     }
     topic = Topic.find(1)
     topic.attributes = attributes
     assert_equal Time.local(2004, 6, 24, 16, 24, 0), topic.written_on
   end
+  
+  def test_multiparameter_attributes_on_time_with_old_date
+    attributes = {
+      "written_on(1i)" => "1850", "written_on(2i)" => "6", "written_on(3i)" => "24",
+      "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00"
+    }
+    topic = Topic.find(1)
+    topic.attributes = attributes
+    # testing against to_s(:db) representation because either a Time or a DateTime might be returned, depending on platform
+    assert_equal "1850-06-24 16:24:00", topic.written_on.to_s(:db)
+  end
+
+  def test_multiparameter_attributes_on_time_with_utc
+    ActiveRecord::Base.default_timezone = :utc
+    attributes = {
+      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24",
+      "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00"
+    }
+    topic = Topic.find(1)
+    topic.attributes = attributes
+    assert_equal Time.utc(2004, 6, 24, 16, 24, 0), topic.written_on
+  ensure
+    ActiveRecord::Base.default_timezone = :local
+  end
+
+  def test_multiparameter_attributes_on_time_with_time_zone_aware_attributes
+    ActiveRecord::Base.time_zone_aware_attributes = true
+    ActiveRecord::Base.default_timezone = :utc
+    Time.zone = TimeZone[-28800]
+    attributes = {
+      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24",
+      "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00"
+    }
+    topic = Topic.find(1)
+    topic.attributes = attributes
+    assert_equal Time.utc(2004, 6, 24, 23, 24, 0), topic.written_on
+    assert_equal Time.utc(2004, 6, 24, 16, 24, 0), topic.written_on.time
+    assert_equal Time.zone, topic.written_on.time_zone
+  ensure
+    ActiveRecord::Base.time_zone_aware_attributes = false
+    ActiveRecord::Base.default_timezone = :local
+    Time.zone = nil
+  end
+
+  def test_multiparameter_attributes_on_time_with_time_zone_aware_attributes_false
+    ActiveRecord::Base.time_zone_aware_attributes = false
+    Time.zone = TimeZone[-28800]
+    attributes = {
+      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24",
+      "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00"
+    }
+    topic = Topic.find(1)
+    topic.attributes = attributes
+    assert_equal Time.local(2004, 6, 24, 16, 24, 0), topic.written_on
+    assert_equal false, topic.written_on.respond_to?(:time_zone)
+  ensure
+    Time.zone = nil
+  end
+
+  def test_multiparameter_attributes_on_time_with_skip_time_zone_conversion_for_attributes
+    ActiveRecord::Base.time_zone_aware_attributes = true
+    ActiveRecord::Base.default_timezone = :utc
+    Time.zone = TimeZone[-28800]
+    Topic.skip_time_zone_conversion_for_attributes = [:written_on]
+    attributes = {
+      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24",
+      "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => "00"
+    }
+    topic = Topic.find(1)
+    topic.attributes = attributes
+    assert_equal Time.utc(2004, 6, 24, 16, 24, 0), topic.written_on
+    assert_equal false, topic.written_on.respond_to?(:time_zone)
+  ensure
+    ActiveRecord::Base.time_zone_aware_attributes = false
+    ActiveRecord::Base.default_timezone = :local
+    Time.zone = nil
+    Topic.skip_time_zone_conversion_for_attributes = []
+  end
 
   def test_multiparameter_attributes_on_time_with_empty_seconds
-    attributes = { 
-      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24", 
+    attributes = {
+      "written_on(1i)" => "2004", "written_on(2i)" => "6", "written_on(3i)" => "24",
       "written_on(4i)" => "16", "written_on(5i)" => "24", "written_on(6i)" => ""
     }
     topic = Topic.find(1)
@@ -931,12 +1062,12 @@ class BasicsTest < Test::Unit::TestCase
   def test_multiparameter_mass_assignment_protector
     task = Task.new
     time = Time.mktime(2000, 1, 1, 1)
-    task.starting = time 
+    task.starting = time
     attributes = { "starting(1i)" => "2004", "starting(2i)" => "6", "starting(3i)" => "24" }
     task.attributes = attributes
     assert_equal time, task.starting
   end
-  
+
   def test_multiparameter_assignment_of_aggregation
     customer = Customer.new
     address = Address.new("The Street", "The City", "The Country")
@@ -978,9 +1109,9 @@ class BasicsTest < Test::Unit::TestCase
     b_false = Booleantest.find(false_id)
     assert !b_false.value?
     b_true = Booleantest.find(true_id)
-    assert b_true.value?    
+    assert b_true.value?
   end
-  
+
   def test_clone
     topic = Topic.find(1)
     cloned_topic = nil
@@ -989,15 +1120,15 @@ class BasicsTest < Test::Unit::TestCase
     assert cloned_topic.new_record?
 
     # test if the attributes have been cloned
-    topic.title = "a" 
-    cloned_topic.title = "b" 
+    topic.title = "a"
+    cloned_topic.title = "b"
     assert_equal "a", topic.title
     assert_equal "b", cloned_topic.title
 
     # test if the attribute values have been cloned
     topic.title = {"a" => "b"}
     cloned_topic = topic.clone
-    cloned_topic.title["a"] = "c" 
+    cloned_topic.title["a"] = "c"
     assert_equal "b", topic.title["a"]
 
     #test if attributes set as part of after_initialize are cloned correctly
@@ -1047,11 +1178,11 @@ class BasicsTest < Test::Unit::TestCase
   if current_adapter?(:PostgreSQLAdapter)
     def test_default
       default = Default.new
-  
+
       # fixed dates / times
       assert_equal Date.new(2004, 1, 1), default.fixed_date
       assert_equal Time.local(2004, 1,1,0,0,0,0), default.fixed_time
-  
+
       # char types
       assert_equal 'Y', default.char1
       assert_equal 'a varchar field', default.char2
@@ -1074,7 +1205,7 @@ class BasicsTest < Test::Unit::TestCase
         :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.
@@ -1092,7 +1223,7 @@ class BasicsTest < Test::Unit::TestCase
       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
@@ -1107,7 +1238,7 @@ class BasicsTest < Test::Unit::TestCase
 
       # 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
@@ -1197,10 +1328,10 @@ class BasicsTest < Test::Unit::TestCase
   end
 
   MyObject = Struct.new :attribute1, :attribute2
-  
+
   def test_serialized_attribute
     myobj = MyObject.new('value1', 'value2')
-    topic = Topic.create("content" => myobj)  
+    topic = Topic.create("content" => myobj)
     Topic.serialize("content", MyObject)
     assert_equal(myobj, topic.content)
   end
@@ -1236,19 +1367,21 @@ class BasicsTest < Test::Unit::TestCase
     topic = Topic.create('author_name' => author_name)
     assert_equal author_name, Topic.find(topic.id).author_name
   end
-  
-  def test_quote_chars
-    str = 'The Narrator'
-    topic = Topic.create(:author_name => str)
-    assert_equal str, topic.author_name
-    
-    assert_kind_of ActiveSupport::Multibyte::Chars, str.chars
-    topic = Topic.find_by_author_name(str.chars)
-    
-    assert_kind_of Topic, topic
-    assert_equal str, topic.author_name, "The right topic should have been found by name even with name passed as Chars"
+
+  if RUBY_VERSION < '1.9'
+    def test_quote_chars
+      str = 'The Narrator'
+      topic = Topic.create(:author_name => str)
+      assert_equal str, topic.author_name
+
+      assert_kind_of ActiveSupport::Multibyte::Chars, str.chars
+      topic = Topic.find_by_author_name(str.chars)
+
+      assert_kind_of Topic, topic
+      assert_equal str, topic.author_name, "The right topic should have been found by name even with name passed as Chars"
+    end
   end
-  
+
   def test_class_level_destroy
     should_be_destroyed_reply = Reply.create("title" => "hello", "content" => "world")
     Topic.find(1).replies << should_be_destroyed_reply
@@ -1270,46 +1403,46 @@ class BasicsTest < Test::Unit::TestCase
   def test_increment_attribute
     assert_equal 50, accounts(:signals37).credit_limit
     accounts(:signals37).increment! :credit_limit
-    assert_equal 51, accounts(:signals37, :reload).credit_limit    
+    assert_equal 51, accounts(:signals37, :reload).credit_limit
 
     accounts(:signals37).increment(:credit_limit).increment!(:credit_limit)
     assert_equal 53, accounts(:signals37, :reload).credit_limit
   end
-  
+
   def test_increment_nil_attribute
     assert_nil topics(:first).parent_id
     topics(:first).increment! :parent_id
     assert_equal 1, topics(:first).parent_id
   end
-  
+
   def test_increment_attribute_by
     assert_equal 50, accounts(:signals37).credit_limit
     accounts(:signals37).increment! :credit_limit, 5
-    assert_equal 55, accounts(:signals37, :reload).credit_limit    
+    assert_equal 55, accounts(:signals37, :reload).credit_limit
 
     accounts(:signals37).increment(:credit_limit, 1).increment!(:credit_limit, 3)
     assert_equal 59, accounts(:signals37, :reload).credit_limit
   end
-  
+
   def test_decrement_attribute
     assert_equal 50, accounts(:signals37).credit_limit
 
     accounts(:signals37).decrement!(:credit_limit)
     assert_equal 49, accounts(:signals37, :reload).credit_limit
-  
+
     accounts(:signals37).decrement(:credit_limit).decrement!(:credit_limit)
     assert_equal 47, accounts(:signals37, :reload).credit_limit
   end
-  
+
   def test_decrement_attribute_by
     assert_equal 50, accounts(:signals37).credit_limit
     accounts(:signals37).decrement! :credit_limit, 5
-    assert_equal 45, accounts(:signals37, :reload).credit_limit    
+    assert_equal 45, accounts(:signals37, :reload).credit_limit
 
     accounts(:signals37).decrement(:credit_limit, 1).decrement!(:credit_limit, 3)
     assert_equal 41, accounts(:signals37, :reload).credit_limit
   end
-  
+
   def test_toggle_attribute
     assert !topics(:first).approved?
     topics(:first).toggle!(:approved)
@@ -1386,17 +1519,17 @@ class BasicsTest < Test::Unit::TestCase
 
   def test_count_with_join
     res = Post.count_by_sql "SELECT COUNT(*) FROM posts LEFT JOIN comments ON posts.id=comments.post_id WHERE posts.#{QUOTED_TYPE} = 'Post'"
-    
+
     res2 = Post.count(:conditions => "posts.#{QUOTED_TYPE} = 'Post'", :joins => "LEFT JOIN comments ON posts.id=comments.post_id")
     assert_equal res, res2
-    
+
     res3 = nil
     assert_nothing_raised do
       res3 = Post.count(:conditions => "posts.#{QUOTED_TYPE} = 'Post'",
                         :joins => "LEFT JOIN comments ON posts.id=comments.post_id")
     end
     assert_equal res, res3
-    
+
     res4 = Post.count_by_sql "SELECT COUNT(p.id) FROM posts p, comments co WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id"
     res5 = nil
     assert_nothing_raised do
@@ -1405,7 +1538,7 @@ class BasicsTest < Test::Unit::TestCase
                         :select => "p.id")
     end
 
-    assert_equal res4, res5 
+    assert_equal res4, res5
 
     unless current_adapter?(:SQLite2Adapter, :DeprecatedSQLiteAdapter)
       res6 = Post.count_by_sql "SELECT COUNT(DISTINCT p.id) FROM posts p, comments co WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id"
@@ -1419,15 +1552,15 @@ class BasicsTest < Test::Unit::TestCase
       assert_equal res6, res7
     end
   end
-  
-  def test_clear_association_cache_stored     
+
+  def test_clear_association_cache_stored
     firm = Firm.find(1)
     assert_kind_of Firm, firm
 
     firm.clear_association_cache
     assert_equal Firm.find(1).clients.collect{ |x| x.name }.sort, firm.clients.collect{ |x| x.name }.sort
   end
-  
+
   def test_clear_association_cache_new_record
      firm            = Firm.new
      client_stored   = Client.find(3)
@@ -1455,31 +1588,31 @@ class BasicsTest < Test::Unit::TestCase
     assert !scoped_developers.include?(developers(:david)) # David's salary is less than 90,000
     assert_equal 3, scoped_developers.size
   end
-  
+
   def test_scoped_find_limit_offset
     scoped_developers = Developer.with_scope(:find => { :limit => 3, :offset => 2 }) do
       Developer.find(:all, :order => 'id')
-    end    
+    end
     assert !scoped_developers.include?(developers(:david))
     assert !scoped_developers.include?(developers(:jamis))
     assert_equal 3, scoped_developers.size
-    
+
     # Test without scoped find conditions to ensure we get the whole thing
     developers = Developer.find(:all, :order => 'id')
     assert_equal Developer.count, developers.size
   end
 
-  def test_scoped_find_order   
-    # Test order in scope   
+  def test_scoped_find_order
+    # Test order in scope
     scoped_developers = Developer.with_scope(:find => { :limit => 1, :order => 'salary DESC' }) do
       Developer.find(:all)
-    end   
+    end
     assert_equal 'Jamis', scoped_developers.first.name
     assert scoped_developers.include?(developers(:jamis))
     # Test scope without order and order in find
     scoped_developers = Developer.with_scope(:find => { :limit => 1 }) do
       Developer.find(:all, :order => 'salary DESC')
-    end   
+    end
     # Test scope order + find order, find has priority
     scoped_developers = Developer.with_scope(:find => { :limit => 3, :order => 'id DESC' }) do
       Developer.find(:all, :order => 'salary ASC')
@@ -1510,6 +1643,41 @@ class BasicsTest < Test::Unit::TestCase
     end
   end
 
+  def test_find_last
+    last  = Developer.find :last
+    assert_equal last, Developer.find(:first, :order => 'id desc')
+  end
+  
+  def test_last
+    assert_equal Developer.find(:first, :order => 'id desc'), Developer.last
+  end
+
+  def test_all_with_conditions
+    assert_equal Developer.find(:all, :order => 'id desc'), Developer.all(:order => 'id desc')
+  end
+  
+  def test_find_ordered_last
+    last  = Developer.find :last, :order => 'developers.salary ASC'
+    assert_equal last, Developer.find(:all, :order => 'developers.salary ASC').last
+  end
+
+  def test_find_reverse_ordered_last
+    last  = Developer.find :last, :order => 'developers.salary DESC'
+    assert_equal last, Developer.find(:all, :order => 'developers.salary DESC').last
+  end
+
+  def test_find_multiple_ordered_last
+    last  = Developer.find :last, :order => 'developers.name, developers.salary DESC'
+    assert_equal last, Developer.find(:all, :order => 'developers.name, developers.salary DESC').last
+  end
+  
+  def test_find_scoped_ordered_last
+    last_developer = Developer.with_scope(:find => { :order => 'developers.salary ASC' }) do
+      Developer.find(:last)
+    end
+    assert_equal last_developer, Developer.find(:all, :order => 'developers.salary ASC').last
+  end
+  
   def test_abstract_class
     assert !ActiveRecord::Base.abstract_class?
     assert LoosePerson.abstract_class?
@@ -1561,7 +1729,7 @@ class BasicsTest < Test::Unit::TestCase
     old_class = LooseDescendant
     Object.send :remove_const, :LooseDescendant
 
-    descendant = old_class.create!
+    descendant = old_class.create! :first_name => 'bob'
     assert_not_nil LoosePerson.find(descendant.id), "Should have found instance of LooseDescendant when finding abstract LoosePerson: #{descendant.inspect}"
   ensure
     unless Object.const_defined?(:LooseDescendant)
@@ -1626,18 +1794,18 @@ class BasicsTest < Test::Unit::TestCase
     xml = topics(:first).to_xml(:indent => 0, :skip_instruct => true, :except => [:title, :replies_count])
     assert_equal "<topic>", xml.first(7)
     assert !xml.include?(%(<title>The First Topic</title>))
-    assert xml.include?(%(<author-name>David</author-name>))    
+    assert xml.include?(%(<author-name>David</author-name>))
 
     xml = topics(:first).to_xml(:indent => 0, :skip_instruct => true, :except => [:title, :author_name, :replies_count])
     assert !xml.include?(%(<title>The First Topic</title>))
-    assert !xml.include?(%(<author-name>David</author-name>))    
+    assert !xml.include?(%(<author-name>David</author-name>))
   end
 
   def test_to_xml_including_has_many_association
     xml = topics(:first).to_xml(:indent => 0, :skip_instruct => true, :include => :replies, :except => :replies_count)
     assert_equal "<topic>", xml.first(7)
     assert xml.include?(%(<replies type="array"><reply>))
-    assert xml.include?(%(<title>The Second Topic's of the day</title>))
+    assert xml.include?(%(<title>The Second Topic of the day</title>))
   end
 
   def test_array_to_xml_including_has_many_association
@@ -1650,7 +1818,7 @@ class BasicsTest < Test::Unit::TestCase
     assert xml.include?(%(<topic-id type="integer">#{topics(:first).topic_id}</topic-id>)), xml
     assert xml.include?(%(<topic-id type="integer">#{topics(:second).topic_id}</topic-id>)), xml
   end
-  
+
   def test_array_to_xml_including_has_one_association
     xml = [ companies(:first_firm), companies(:rails_core) ].to_xml(:indent => 0, :skip_instruct => true, :include => :account)
     assert xml.include?(companies(:first_firm).account.to_xml(:indent => 0, :skip_instruct => true))
@@ -1671,7 +1839,7 @@ class BasicsTest < Test::Unit::TestCase
     xml = companies(:second_client).to_xml(:indent => 0, :skip_instruct => true, :include => :firm)
     assert xml.include?("<firm>")
   end
-  
+
   def test_to_xml_including_multiple_associations
     xml = companies(:first_firm).to_xml(:indent => 0, :skip_instruct => true, :include => [ :clients, :account ])
     assert_equal "<firm>", xml.first(6)
@@ -1681,21 +1849,21 @@ class BasicsTest < Test::Unit::TestCase
 
   def test_to_xml_including_multiple_associations_with_options
     xml = companies(:first_firm).to_xml(
-      :indent  => 0, :skip_instruct => true, 
+      :indent  => 0, :skip_instruct => true,
       :include => { :clients => { :only => :name } }
     )
-    
+
     assert_equal "<firm>", xml.first(6)
     assert xml.include?(%(<client><name>Summit</name></client>))
     assert xml.include?(%(<clients type="array"><client>))
   end
-  
+
   def test_to_xml_including_methods
     xml = Company.new.to_xml(:methods => :arbitrary_method, :skip_instruct => true)
     assert_equal "<company>", xml.first(9)
     assert xml.include?(%(<arbitrary-method>I am Jack's profound disappointment</arbitrary-method>))
   end
-  
+
   def test_to_xml_with_block
     value = "Rockin' the block"
     xml = Company.new.to_xml(:skip_instruct => true) do |xml|
@@ -1704,37 +1872,16 @@ class BasicsTest < Test::Unit::TestCase
     assert_equal "<company>", xml.first(9)
     assert xml.include?(%(<arbitrary-element>#{value}</arbitrary-element>))
   end
-  
-  def test_except_attributes
-    assert_deprecated do
-      assert_equal(
-        %w( author_name type id approved replies_count bonus_time written_on content author_email_address parent_id last_read),
-        topics(:first).attributes(:except => :title).keys
-      )
 
-      assert_equal(
-        %w( replies_count bonus_time written_on content author_email_address parent_id last_read),
-        topics(:first).attributes(:except => [ :title, :id, :type, :approved, :author_name ]).keys
-      )
-    end
-  end
-  
-  def test_include_attributes
-    assert_deprecated do
-      assert_equal(%w( title ), topics(:first).attributes(:only => :title).keys)
-      assert_equal(%w( title author_name type id approved ), topics(:first).attributes(:only => [ :title, :id, :type, :approved, :author_name ]).keys)
-    end
-  end
-  
   def test_type_name_with_module_should_handle_beginning
     assert_equal 'ActiveRecord::Person', ActiveRecord::Base.send(:type_name_with_module, 'Person')
     assert_equal '::Person', ActiveRecord::Base.send(:type_name_with_module, '::Person')
   end
-  
+
   def test_to_param_should_return_string
     assert_kind_of String, Client.find(:first).to_param
   end
-  
+
   def test_inspect_class
     assert_equal 'ActiveRecord::Base', ActiveRecord::Base.inspect
     assert_equal 'LoosePerson(abstract)', LoosePerson.inspect
@@ -1754,7 +1901,7 @@ class BasicsTest < Test::Unit::TestCase
     assert_equal %(#<Topic id: 1>), Topic.find(:first, :select => 'id', :conditions => 'id = 1').inspect
     assert_equal %(#<Topic id: 1, title: "The First Topic">), Topic.find(:first, :select => 'id, title', :conditions => 'id = 1').inspect
   end
-  
+
   def test_inspect_class_without_table
     assert_equal "NonExistentTable(Table doesn't exist)", NonExistentTable.inspect
   end
@@ -1766,7 +1913,7 @@ class BasicsTest < Test::Unit::TestCase
     assert_equal %("#{t.written_on.to_s(:db)}"), t.attribute_for_inspect(:written_on)
     assert_equal '"The First Topic Now Has A Title With\nNewlines And M..."', t.attribute_for_inspect(:title)
   end
-  
+
   def test_becomes
     assert_kind_of Reply, topics(:first).becomes(Reply)
     assert_equal "The First Topic", topics(:first).becomes(Reply).title